transpec 1.10.3 → 1.10.4

data/lib/transpec/syntax/expect.rb

@@ -13,8 +13,8 @@ module Transpec
       add_matcher Have
       add_matcher RaiseError
 
-      def self.target_method?(receiver_node, method_name)
-        receiver_node.nil? && [:expect, :expect_any_instance_of].include?(method_name)
+      def dynamic_analysis_target?
+        super && receiver_node.nil? && [:expect, :expect_any_instance_of].include?(method_name)
       end
 
       def method_name_for_instance

data/lib/transpec/syntax/have.rb

@@ -7,11 +7,11 @@ require 'transpec/syntax/mixin/owned_matcher'
 module Transpec
   class Syntax
     class Have < Syntax
-      require 'transpec/syntax/have/dynamic_inspector'
+      require 'transpec/syntax/have/dynamic_analysis'
       require 'transpec/syntax/have/source_builder'
       require 'transpec/syntax/have/have_record'
 
-      include Mixin::Send, Mixin::OwnedMatcher
+      include Mixin::Send, Mixin::OwnedMatcher, DynamicAnalysis
 
       # String#count is not query method, and there's no way to determine
       # whether a method is query method.
@@ -22,15 +22,12 @@ module Transpec
       # for String (String responds to #size).
       QUERY_METHOD_PRIORITIES = [:size, :count, :length].freeze
 
-      def self.target_method?(receiver_node, method_name)
-        receiver_node.nil? &&
+      def dynamic_analysis_target?
+        super &&
+          receiver_node.nil? &&
           [:have, :have_exactly, :have_at_least, :have_at_most].include?(method_name)
       end
 
-      define_dynamic_analysis_request do |rewriter|
-        DynamicInspector.register_request(self, rewriter)
-      end
-
       def convert_to_standard_expectation!(parenthesize_matcher_arg = true)
         return if project_requires_collection_matcher?
 

data/lib/transpec/syntax/have/{dynamic_inspector.rb → dynamic_analysis.rb}

@@ -5,62 +5,41 @@ require 'transpec/syntax/have'
 module Transpec
   class Syntax
     class Have
-      class DynamicInspector
-        def self.register_request(have, rewriter)
-          new(have, rewriter).register_request
-        end
-
-        attr_reader :have, :rewriter
-
-        def initialize(have, rewriter)
-          @have = have
-          @rewriter = rewriter
-        end
+      module DynamicAnalysis
+        extend ActiveSupport::Concern
 
-        def target_node
-          if have.explicit_subject?
-            have.expectation.subject_node
-          else
-            have.expectation.node
-          end
-        end
+        included do
+          define_dynamic_analysis do |rewriter|
+            target_node = explicit_subject? ? expectation.subject_node : expectation.node
+            target_type = explicit_subject? ? :object : :context
 
-        def target_type
-          if have.explicit_subject?
-            :object
-          else
-            :context
-          end
-        end
+            key = :collection_accessor
+            code = collection_accessor_inspection_code
+            rewriter.register_request(target_node, key, code, target_type)
 
-        def register_request
-          key = :collection_accessor
-          code = collection_accessor_inspection_code
-          rewriter.register_request(target_node, key, code, target_type)
+            # Give up inspecting query methods of collection accessor with arguments
+            # (e.g. have(2).errors_on(variable)) since this is a context of #instance_eval.
+            unless items_method_has_arguments?
+              key = :available_query_methods
+              code = available_query_methods_inspection_code
+              rewriter.register_request(target_node, key, code, target_type)
+            end
 
-          # Give up inspecting query methods of collection accessor with arguments
-          # (e.g. have(2).errors_on(variable)) since this is a context of #instance_eval.
-          unless have.items_method_has_arguments?
-            key = :available_query_methods
-            code = available_query_methods_inspection_code
+            key = :collection_accessor_is_private?
+            code = "#{subject_code}.private_methods.include?(#{items_name.inspect})"
             rewriter.register_request(target_node, key, code, target_type)
-          end
-
-          key = :collection_accessor_is_private?
-          code = "#{subject_code}.private_methods.include?(#{have.items_name.inspect})"
-          rewriter.register_request(target_node, key, code, target_type)
 
-          key = :project_requires_collection_matcher?
-          code = 'defined?(RSpec::Rails) || defined?(RSpec::CollectionMatchers)'
-          rewriter.register_request(target_node, key, code, :context)
+            key = :project_requires_collection_matcher?
+            code = 'defined?(RSpec::Rails) || defined?(RSpec::CollectionMatchers)'
+            rewriter.register_request(target_node, key, code, :context)
+          end
         end
 
         def subject_code
-          have.explicit_subject? ? 'self' : 'subject'
+          explicit_subject? ? 'self' : 'subject'
         end
 
-        # rubocop:disable MethodLength
-        def collection_accessor_inspection_code
+        def collection_accessor_inspection_code # rubocop:disable MethodLength
           # `expect(owner).to have(n).things` invokes private owner#things with Object#__send__
           # if the owner does not respond to any of #size, #count and #length.
           #
@@ -69,7 +48,7 @@ module Transpec
           # rubocop:enable LineLength
           @collection_accessor_inspection_code ||= <<-END.gsub(/^\s+\|/, '').chomp
             |begin
-            |  exact_name = #{have.items_name.inspect}
+            |  exact_name = #{items_name.inspect}
             |
             |  inflector = if defined?(ActiveSupport::Inflector) &&
             |                   ActiveSupport::Inflector.respond_to?(:pluralize)
@@ -100,7 +79,6 @@ module Transpec
             |end
           END
         end
-        # rubocop:enable MethodLength
 
         def available_query_methods_inspection_code
           <<-END.gsub(/^\s+\|/, '').chomp

data/lib/transpec/syntax/have/have_record.rb

@@ -12,22 +12,6 @@ module Transpec
           @have = have
         end
 
-        def original_syntax
-          @original_syntax ||= begin
-            type = have.expectation.class.snake_case_name.to_sym
-            syntax = build_expectation(original_subject, type)
-            syntax << " #{have.method_name}(n).#{original_items}"
-          end
-        end
-
-        def converted_syntax
-          @converted_syntax ||= begin
-            type = have.expectation.current_syntax_type
-            syntax = build_expectation(converted_subject, type)
-            syntax << " #{source_builder.replacement_matcher_source}"
-          end
-        end
-
         def annotation
           return @annotation if instance_variable_defined?(:@annotation)
 
@@ -40,6 +24,18 @@ module Transpec
 
         private
 
+        def build_original_syntax
+          type = have.expectation.class.snake_case_name.to_sym
+          syntax = build_expectation(original_subject, type)
+          syntax << " #{have.method_name}(n).#{original_items}"
+        end
+
+        def build_converted_syntax
+          type = have.expectation.current_syntax_type
+          syntax = build_expectation(converted_subject, type)
+          syntax << " #{source_builder.replacement_matcher_source}"
+        end
+
         def build_expectation(subject, type)
           case type
           when :should

data/lib/transpec/syntax/its.rb

@@ -9,16 +9,16 @@ module Transpec
     class Its < Syntax
       include Mixin::Send, Util
 
-      def self.target_method?(receiver_node, method_name)
-        receiver_node.nil? && method_name == :its
-      end
-
-      define_dynamic_analysis_request do |rewriter|
+      define_dynamic_analysis do |rewriter|
         key = :project_requires_its?
         code = 'defined?(RSpec::Its)'
         rewriter.register_request(node, key, code, :context)
       end
 
+      def dynamic_analysis_target?
+        super && receiver_node.nil? && method_name == :its
+      end
+
       def convert_to_describe_subject_it!
         return if project_requires_its?
 

data/lib/transpec/syntax/matcher_definition.rb

@@ -15,8 +15,8 @@ module Transpec
         failure_message_for_should_not: :failure_message_when_negated
       }
 
-      def self.target_method?(receiver_node, method_name)
-        receiver_node.nil? && CONVERSION_CORRESPONDENCE.keys.include?(method_name)
+      def dynamic_analysis_target?
+        super && receiver_node.nil? && CONVERSION_CORRESPONDENCE.keys.include?(method_name)
       end
 
       def convert_deprecated_method!

data/lib/transpec/syntax/method_stub.rb

@@ -19,35 +19,36 @@ module Transpec
       ]
       # rubocop:enable LineLength
 
-      def self.conversion_target_node?(node, runtime_data = nil)
-        return false unless check_target_node_statically(node)
+      define_dynamic_analysis do |rewriter|
+        register_syntax_availability_analysis_request(
+          rewriter,
+          :allow_to_receive_available?,
+          [:allow, :receive]
+        )
+      end
+
+      def dynamic_analysis_target?
+        super &&
+          !receiver_node.nil? &&
+          [:stub, :stub!, :stub_chain, :unstub, :unstub!].include?(method_name)
+      end
+
+      def conversion_target?
+        return false unless dynamic_analysis_target?
 
         # Check if the method is RSpec's one or not.
-        if source_location(node, runtime_data)
-          # If we have a source location runtime data, check with it.
-          check_target_node_dynamically(node, runtime_data)
+        if runtime_data.run?(send_analysis_target_node)
+          # If we have runtime data, check with it.
+          defined_by_rspec?
         else
           # Otherwise check with a static whitelist.
-          receiver_node = node.children.first
-          const_name = Util.const_name(receiver_node)
+          const_name = const_name(receiver_node)
           !CLASSES_DEFINING_OWN_STUB_METHOD.include?(const_name)
         end
       end
 
-      def self.target_method?(receiver_node, method_name)
-        !receiver_node.nil? && [:stub, :stub!, :stub_chain, :unstub, :unstub!].include?(method_name)
-      end
-
-      define_dynamic_analysis_request do |rewriter|
-        register_request_of_syntax_availability_inspection(
-          rewriter,
-          :allow_to_receive_available?,
-          [:allow, :receive]
-        )
-      end
-
       def allow_to_receive_available?
-        check_syntax_availability(__method__)
+        syntax_available?(__method__)
       end
 
       def hash_arg?
@@ -187,7 +188,7 @@ module Transpec
           @conversion_type = conversion_type
         end
 
-        def original_syntax
+        def build_original_syntax
           syntax = @method_stub.any_instance? ? 'Klass.any_instance' : 'obj'
           syntax << ".#{@method_stub.method_name}"
 
@@ -198,7 +199,7 @@ module Transpec
           end
         end
 
-        def converted_syntax
+        def build_converted_syntax
           syntax = @method_stub.any_instance? ? 'allow_any_instance_of(Klass)' : 'allow(obj)'
           syntax << '.to '
 
@@ -221,12 +222,12 @@ module Transpec
           @method_stub = method_stub
         end
 
-        def original_syntax
+        def build_original_syntax
           syntax = @method_stub.any_instance? ? 'Klass.any_instance' : 'obj'
           syntax << ".#{@method_stub.method_name}(:message)"
         end
 
-        def converted_syntax
+        def build_converted_syntax
           syntax = 'obj.'
           syntax << @method_stub.send(:replacement_method_for_deprecated_method)
           syntax << '(:message)'
@@ -238,19 +239,19 @@ module Transpec
           @method_stub = method_stub
         end
 
-        def original_syntax
+        private
+
+        def build_original_syntax
           syntax = base_syntax
           syntax << '.any_number_of_times' if @method_stub.any_number_of_times?
           syntax << '.at_least(0)' if @method_stub.at_least_zero?
           syntax
         end
 
-        def converted_syntax
+        def build_converted_syntax
           base_syntax
         end
 
-        private
-
         def base_syntax
           "obj.#{@method_stub.method_name}(:message)"
         end

data/lib/transpec/syntax/mixin/any_instance_block.rb

@@ -33,11 +33,11 @@ module Transpec
             @host = host
           end
 
-          def original_syntax
+          def build_original_syntax
             "#{base_syntax} { |arg| }"
           end
 
-          def converted_syntax
+          def build_converted_syntax
             "#{base_syntax} { |instance, arg| }"
           end
 

data/lib/transpec/syntax/mixin/matcher_owner.rb

@@ -10,29 +10,32 @@ module Transpec
 
         module ClassMethods
           def add_matcher(matcher_class) # rubocop:disable MethodLength
-            matcher_accessor_name = "#{matcher_class.snake_case_name}_matcher"
-            matcher_ivar_name = "@#{matcher_accessor_name}"
-            matcher_creator_name = "create_#{matcher_class.snake_case_name}"
+            matcher_accessor = "#{matcher_class.snake_case_name}_matcher"
+            matcher_ivar = "@#{matcher_accessor}"
+            matcher_creator = "create_#{matcher_class.snake_case_name}"
 
-            define_dynamic_analysis_request do |rewriter|
-              if matcher_class.dynamic_analysis_target_node?(matcher_node)
-                send(matcher_creator_name).register_request_for_dynamic_analysis(rewriter)
+            define_dynamic_analysis do |rewriter|
+              matcher = send(matcher_creator)
+              if matcher.dynamic_analysis_target?
+                matcher.register_dynamic_analysis_request(rewriter)
               end
             end
 
-            define_method(matcher_accessor_name) do
-              if instance_variable_defined?(matcher_ivar_name)
-                return instance_variable_get(matcher_ivar_name)
+            define_method(matcher_accessor) do
+              if instance_variable_defined?(matcher_ivar)
+                return instance_variable_get(matcher_ivar)
               end
 
-              if matcher_class.conversion_target_node?(matcher_node, runtime_data)
-                instance_variable_set(matcher_ivar_name, send(matcher_creator_name))
+              matcher = send(matcher_creator)
+
+              if matcher.conversion_target?
+                instance_variable_set(matcher_ivar, matcher)
               else
-                instance_variable_set(matcher_ivar_name, nil)
+                instance_variable_set(matcher_ivar, nil)
               end
             end
 
-            define_method(matcher_creator_name) do
+            define_method(matcher_creator) do
               matcher_class.new(matcher_node, self, source_rewriter, runtime_data, report)
             end
           end

data/lib/transpec/syntax/mixin/monkey_patch.rb

@@ -10,7 +10,7 @@ module Transpec
         extend ActiveSupport::Concern
         include Send
 
-        def register_request_of_syntax_availability_inspection(rewriter, key, methods)
+        def register_syntax_availability_analysis_request(rewriter, key, methods)
           code = "self.class.ancestors.any? { |a| a.name.start_with?('RSpec::') }"
 
           methods.each do |method|
@@ -20,7 +20,7 @@ module Transpec
           rewriter.register_request(node, key, code, :context)
         end
 
-        def check_syntax_availability(key)
+        def syntax_available?(key)
           if runtime_data.present?(node, key)
             runtime_data[node, key]
           else

data/lib/transpec/syntax/mixin/monkey_patch_any_instance.rb

@@ -12,7 +12,7 @@ module Transpec
         include MonkeyPatch, ::AST::Sexp
 
         included do
-          define_dynamic_analysis_request do |rewriter|
+          define_dynamic_analysis do |rewriter|
             code = <<-END.gsub(/^\s+\|/, '').chomp
               |if self.class.name == 'RSpec::Mocks::AnyInstance::Recorder'
               |  if respond_to?(:klass)

data/lib/transpec/syntax/mixin/send.rb

@@ -8,53 +8,65 @@ module Transpec
       module Send
         extend ActiveSupport::Concern
 
-        module ClassMethods
-          def target_node?(node, runtime_data = nil)
-            check_target_node_statically(node) && check_target_node_dynamically(node, runtime_data)
+        module TargetDetection
+          def dynamic_analysis_target?
+            node && node.send_type?
           end
 
-          def check_target_node_statically(node)
-            return false unless node && node.send_type?
-            receiver_node, method_name, *_ = *node
-            target_method?(receiver_node, method_name)
+          def conversion_target?
+            return false unless dynamic_analysis_target?
+            return true unless runtime_data.run?(send_analysis_target_node)
+            defined_by_rspec?
           end
 
-          def target_method?(receiver_node, method_name)
-            fail NotImplementedError
+          private
+
+          def defined_by_rspec?
+            defined_in_rspec_source? && !example_method_defined_by_user?
           end
 
-          def check_target_node_dynamically(node, runtime_data)
-            source_location = source_location(node, runtime_data)
+          def defined_in_rspec_source?
+            source_location = runtime_data[send_analysis_target_node, source_location_key]
             return true unless source_location
-            file_path = source_location.first
-            !file_path.match(%r{/rspec\-[^/]+/lib/rspec/}).nil?
+            source_path = source_location.first
+            return false unless source_path
+            source_path.match(%r{/rspec\-[^/]+/lib/rspec/})
+          end
+
+          def example_method_defined_by_user?
+            runtime_data[send_analysis_target_node, example_method_defined_by_user_key]
           end
 
-          def source_location(node, runtime_data)
-            return unless runtime_data
-            receiver_node, method_name, *_ = *node
-            target_node = receiver_node ? receiver_node : node
-            runtime_data[target_node, source_location_key(method_name)]
+          def send_analysis_target_node
+            receiver_node || node
           end
 
-          def source_location_key(method_name)
+          def source_location_key
             "#{method_name}_source_location".to_sym
           end
+
+          def example_method_defined_by_user_key
+            "#{method_name}_example_method_defined_by_user?".to_sym
+          end
         end
 
+        include TargetDetection
+
         included do
-          define_dynamic_analysis_request do |rewriter|
-            if receiver_node
-              target_node = receiver_node
-              target_object_type = :object
-            else
-              target_node = node
-              target_object_type = :context
-            end
-
-            key = self.class.source_location_key(method_name)
+          define_dynamic_analysis do |rewriter|
+            target_type = receiver_node ? :object : :context
+
+            key = source_location_key
             code = "method(#{method_name.inspect}).source_location"
-            rewriter.register_request(target_node, key, code, target_object_type)
+            rewriter.register_request(send_analysis_target_node, key, code, target_type)
+
+            key = example_method_defined_by_user_key
+            code = <<-END.gsub(/^\s+\|/, '').chomp
+              |owner = method(#{method_name.inspect}).owner
+              |owner != RSpec::Core::ExampleGroup &&
+              |  owner.ancestors.include?(RSpec::Core::ExampleGroup)
+            END
+            rewriter.register_request(send_analysis_target_node, key, code, target_type)
           end
         end