Workaround JRuby incompatibility

JRuby apparently only supports #arity (and not #parameters) for Java proxy methods (see jruby/jruby#2817), but verifying doubles in RSpec use #parameters to infer required method parameters, and thus doesn't work for Java classes.

This extends the previously existing JRuby workaround that returns an empty list from #parameters so that it fallbacks to the legacy method of using #arity.

In addition, it turns out that the #arity method is broken for Java proxy methods in JRuby 1.7.x. While JRuby 1.7 has been sunset, the test suite still uses it, and thus this introduces another workaround to account for that.

This looks up the corresponding JavaMethod overloads, and if there is only one, retrieves the arity from that one instead. In the presence of multiple overloads, -1 is returned.

While this obviously doesn't cover all cases, it does cover the cases the previous workaround covered, and also allows using verifying doubles for many Java classes in JRuby.

Author: grddev

lib/rspec/support/method_signature_verifier.rb

@@ -154,19 +154,57 @@ def classify_parameters
       INFINITY = 1 / 0.0
     end
 
-    # Some versions of JRuby have a nasty bug we have to work around :(.
-    # https://github.com/jruby/jruby/issues/2816
+    # JRuby has only partial support for UnboundMethod#parameters, so we fall back on using #arity
+    # https://github.com/jruby/jruby/issues/2816 and https://github.com/jruby/jruby/issues/2817
     if RSpec::Support::Ruby.jruby? &&
        RubyFeatures.optional_and_splat_args_supported? &&
-       Class.new { attr_writer :foo }.instance_method(:foo=).parameters == []
+       Java::JavaLang::String.instance_method(:char_at).parameters == []
+      class MethodSignature < remove_const(:MethodSignature)
+      private
+
+        def classify_parameters
+          super
+          if (arity = @method.arity) != 0 && @method.parameters.empty?
+            if arity < 0
+              @min_non_kw_args = ~arity
+              @max_non_kw_args = INFINITY
+            else
+              @min_non_kw_args = arity
+              @max_non_kw_args = arity
+            end
+          end
+        end
+      end
+    end
 
+    if RSpec::Support::Ruby.jruby? &&
+       Java::JavaLang::String.instance_method(:char_at).arity == -1
       class MethodSignature < remove_const(:MethodSignature)
       private
 
         def classify_parameters
           super
-          return unless @method.parameters == [] && @method.arity == 1
-          @max_non_kw_args = @min_non_kw_args = 1
+          if @method.arity == -1 && (arity = java_method_arity)
+            if arity < 0
+              @min_non_kw_args = ~arity
+              @max_non_kw_args = INFINITY
+            else
+              @min_non_kw_args = arity
+              @max_non_kw_args = arity
+            end
+          end
+        end
+
+        def java_method_arity
+          if @method.owner.respond_to?(:java_class)
+            java_instance_methods = @method.owner.java_class.java_instance_methods
+            overloads = java_instance_methods.select do |java_method|
+              @method == @method.owner.instance_method(java_method.name)
+            end
+            if overloads.size == 1
+              overloads.first.arity
+            end
+          end
         end
       end
     end

spec/rspec/support/method_signature_verifier_spec.rb

@@ -719,6 +719,24 @@ def arity_block(_, &block); end
             expect(valid_non_kw_args?(2)).to eq false
           end
         end
+
+        if Ruby.jruby?
+          describe 'a single-argument Java method' do
+            let(:test_method) { Java::JavaLang::String.instance_method(:char_at) }
+
+            it 'validates against a single argument' do
+              expect(valid_non_kw_args?(1)).to eq true
+            end
+
+            it 'fails validation against 0 arguments' do
+              expect(valid_non_kw_args?(0)).to eq false
+            end
+
+            it 'fails validation against 2 arguments' do
+              expect(valid_non_kw_args?(2)).to eq false
+            end
+          end
+        end
       end
 
       let(:fake_matcher) { Object.new }