transpec 1.6.1 → 1.7.0

data/lib/transpec/syntax/method_stub.rb

@@ -1,17 +1,16 @@
 # coding: utf-8
 
 require 'transpec/syntax'
-require 'transpec/syntax/mixin/send'
-require 'transpec/syntax/mixin/monkey_patch'
+require 'transpec/syntax/mixin/monkey_patch_any_instance'
+require 'transpec/syntax/mixin/any_instance_block'
 require 'transpec/syntax/mixin/allow_no_message'
-require 'transpec/syntax/mixin/any_instance'
 require 'transpec/util'
 require 'English'
 
 module Transpec
   class Syntax
     class MethodStub < Syntax
-      include Mixin::Send, Mixin::MonkeyPatch, Mixin::AllowNoMessage, Mixin::AnyInstance, Util
+      include Mixin::MonkeyPatchAnyInstance, Mixin::AnyInstanceBlock, Mixin::AllowNoMessage, Util
 
       # rubocop:disable LineLength
       CLASSES_DEFINING_OWN_STUB_METHOD = [
@@ -81,13 +80,17 @@ module Transpec
         register_record(:deprecated)
       end
 
+      def add_receiver_arg_to_any_instance_implementation_block!
+        super && register_record(:any_instance_block)
+      end
+
       private
 
       def replacement_source_and_conversion_type(rspec_version)
         if method_name == :stub_chain
           [build_allow_to(:receive_message_chain), :allow_to_receive_message_chain]
         else
-          if arg_node.type == :hash
+          if arg_node.hash_type?
             if rspec_version.receive_messages_available?
               [build_allow_to(:receive_messages), :allow_to_receive_messages]
             else
@@ -141,7 +144,7 @@ module Transpec
 
       def message_source(node)
         message_source = node.loc.expression.source
-        message_source.prepend(':') if node.type == :sym && !message_source.start_with?(':')
+        message_source.prepend(':') if node.sym_type? && !message_source.start_with?(':')
         message_source
       end
 
@@ -154,49 +157,81 @@ module Transpec
       end
 
       def register_record(conversion_type)
-        @report.records << Record.new(original_syntax, converted_syntax(conversion_type))
-      end
+        record_class = case conversion_type
+                       when :deprecated
+                         DeprecatedRecord
+                       when :any_instance_block
+                         AnyInstanceBlockRecord
+                       else
+                         AllowRecord
+                       end
+        @report.records << record_class.new(self, conversion_type)
+      end
+
+      class AllowRecord < Record
+        def initialize(method_stub, conversion_type)
+          @method_stub = method_stub
+          @conversion_type = conversion_type
+        end
 
-      def original_syntax
-        syntax = any_instance? ? 'Klass.any_instance' : 'obj'
-        syntax << ".#{method_name}"
+        def original_syntax
+          syntax = @method_stub.any_instance? ? 'Klass.any_instance' : 'obj'
+          syntax << ".#{@method_stub.method_name}"
 
-        if method_name == :stub_chain
-          syntax << '(:message1, :message2)'
-        else
-          syntax << (arg_node.type == :hash ? '(:message => value)' : '(:message)')
+          if @method_stub.method_name == :stub_chain
+            syntax << '(:message1, :message2)'
+          else
+            syntax << (@method_stub.arg_node.hash_type? ? '(:message => value)' : '(:message)')
+          end
         end
-      end
 
-      def converted_syntax(conversion_type)
-        if conversion_type == :deprecated
-          converted_syntax_from_deprecated
-        else
-          allowized_syntax(conversion_type)
+        def converted_syntax
+          syntax = @method_stub.any_instance? ? 'allow_any_instance_of(Klass)' : 'allow(obj)'
+          syntax << '.to '
+
+          case @conversion_type
+          when :allow_to_receive
+            syntax << 'receive(:message)'
+            syntax << '.and_return(value)' if @method_stub.arg_node.hash_type?
+          when :allow_to_receive_messages
+            syntax << 'receive_messages(:message => value)'
+          when :allow_to_receive_message_chain
+            syntax << 'receive_message_chain(:message1, :message2)'
+          end
+
+          syntax
         end
       end
 
-      def allowized_syntax(conversion_type)
-        syntax = any_instance? ? 'allow_any_instance_of(Klass)' : 'allow(obj)'
-        syntax << '.to '
+      class DeprecatedRecord < Record
+        def initialize(method_stub, *)
+          @method_stub = method_stub
+        end
 
-        case conversion_type
-        when :allow_to_receive
-          syntax << 'receive(:message)'
-          syntax << '.and_return(value)' if arg_node.type == :hash
-        when :allow_to_receive_messages
-          syntax << 'receive_messages(:message => value)'
-        when :allow_to_receive_message_chain
-          syntax << 'receive_message_chain(:message1, :message2)'
+        def original_syntax
+          syntax = @method_stub.any_instance? ? 'Klass.any_instance' : 'obj'
+          syntax << ".#{@method_stub.method_name}(:message)"
         end
 
-        syntax
+        def converted_syntax
+          syntax = 'obj.'
+          syntax << @method_stub.send(:replacement_method_for_deprecated_method)
+          syntax << '(:message)'
+        end
       end
 
-      def converted_syntax_from_deprecated
-        syntax = 'obj.'
-        syntax << replacement_method_for_deprecated_method
-        syntax << '(:message)'
+      class AnyInstanceBlockRecord < Record
+        def initialize(method_stub, *)
+          @method_stub = method_stub
+        end
+
+        def original_syntax
+          "Klass.any_instance.#{@method_stub.method_name}(:message) { |arg| }"
+        end
+
+        def converted_syntax
+          "Klass.any_instance.#{@method_stub.method_name}(:message) { |instance, arg| }"
+        end
       end
     end
   end

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

@@ -1,12 +1,15 @@
 # coding: utf-8
 
+require 'active_support/concern'
+require 'transpec/syntax/mixin/send'
 require 'ast'
 
 module Transpec
   class Syntax
     module Mixin
       module AllowNoMessage
-        include ::AST::Sexp
+        extend ActiveSupport::Concern
+        include Send, ::AST::Sexp
 
         def allow_no_message?
           any_number_of_times? || at_least_zero?
@@ -17,8 +20,6 @@ module Transpec
           remove_at_least_zero!
         end
 
-        private
-
         def any_number_of_times?
           !any_number_of_times_node.nil?
         end
@@ -27,6 +28,8 @@ module Transpec
           !at_least_zero_node.nil?
         end
 
+        private
+
         def remove_any_number_of_times!
           return unless any_number_of_times?
           remove_dot_and_method!(any_number_of_times_node)
@@ -44,31 +47,19 @@ module Transpec
         end
 
         def any_number_of_times_node
-          each_following_chained_method_node do |chained_node|
+          each_chained_method_node do |chained_node|
             method_name = chained_node.children[1]
             return chained_node if method_name == :any_number_of_times
           end
         end
 
         def at_least_zero_node
-          each_following_chained_method_node do |chained_node|
+          each_chained_method_node do |chained_node|
             _, method_name, arg_node = *chained_node
             next unless method_name == :at_least
             return chained_node if arg_node == s(:int, 0)
           end
         end
-
-        def each_following_chained_method_node
-          return to_enum(__method__) unless block_given?
-
-          @node.each_ancestor_node.reduce(@node) do |child_node, parent_node|
-            return unless [:send, :block].include?(parent_node.type)
-            return unless parent_node.children.first == child_node
-            yield parent_node, child_node
-            parent_node
-          end
-          nil
-        end
       end
     end
   end

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

@@ -0,0 +1,34 @@
+# coding: utf-8
+
+require 'active_support/concern'
+require 'transpec/syntax/mixin/send'
+
+module Transpec
+  class Syntax
+    module Mixin
+      module AnyInstanceBlock
+        extend ActiveSupport::Concern
+        include Send
+
+        def add_receiver_arg_to_any_instance_implementation_block!
+          return unless any_instance_block_node
+          first_arg_node = any_instance_block_node.children[1].children[0]
+          return unless first_arg_node
+          first_arg_name = first_arg_node.children.first
+          return if first_arg_name == :instance
+          insert_before(first_arg_node.loc.expression, 'instance, ')
+          true
+        end
+
+        private
+
+        def any_instance_block_node
+          return unless any_instance?
+          each_chained_method_node do |node, _|
+            return node if node.block_type?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# coding: utf-8
+
+require 'active_support/concern'
+require 'transpec/syntax/mixin/send'
+require 'transpec/syntax/receive'
+require 'transpec/util'
+
+module Transpec
+  class Syntax
+    module Mixin
+      module ExpectBase
+        extend ActiveSupport::Concern
+        include Send
+
+        included do
+          add_dynamic_analysis_request do |rewriter|
+            if Receive.dynamic_analysis_target_node?(matcher_node)
+              create_receive_matcher.register_request_for_dynamic_analysis(rewriter)
+            end
+          end
+
+          alias_method :subject_node, :arg_node
+          alias_method :to_node, :parent_node
+        end
+
+        def current_syntax_type
+          :expect
+        end
+
+        def positive?
+          to_method_name = to_node.children[1]
+          to_method_name == :to
+        end
+
+        def matcher_node
+          to_arg_node = to_node.children[2]
+          if to_arg_node.block_type?
+            to_arg_node.children.first
+          else
+            to_arg_node
+          end
+        end
+
+        def block_node
+          Util.block_node_taken_by_method(to_node)
+        end
+
+        def subject_range
+          subject_node.loc.expression
+        end
+
+        def receive_matcher
+          return @receive_matcher if instance_variable_defined?(:@receive_matcher)
+
+          @receive_matcher ||= if Receive.conversion_target_node?(matcher_node, @runtime_data)
+                                 create_receive_matcher
+                               else
+                                 nil
+                               end
+        end
+
+        private
+
+        def create_receive_matcher
+          Receive.new(matcher_node, self, @source_rewriter, @runtime_data, @report)
+        end
+      end
+    end
+  end
+end

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

@@ -1,11 +1,14 @@
 # coding: utf-8
 
+require 'active_support/concern'
 require 'transpec/util'
 
 module Transpec
   class Syntax
     module Mixin
       module Expectizable
+        extend ActiveSupport::Concern
+
         def wrap_subject_in_expect!
           wrap_subject_with_method!('expect')
         end

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

@@ -1,13 +1,16 @@
 # coding: utf-8
 
+require 'active_support/concern'
 require 'transpec/syntax/have'
 
 module Transpec
   class Syntax
     module Mixin
       module HaveMatcherOwner
-        def self.included(syntax)
-          syntax.add_dynamic_analysis_request do |rewriter|
+        extend ActiveSupport::Concern
+
+        included do
+          add_dynamic_analysis_request do |rewriter|
             if Have.dynamic_analysis_target_node?(matcher_node)
               create_have_matcher.register_request_for_dynamic_analysis(rewriter)
             end

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

@@ -1,9 +1,15 @@
 # coding: utf-8
 
+require 'active_support/concern'
+require 'transpec/syntax/mixin/send'
+
 module Transpec
   class Syntax
     module Mixin
       module MonkeyPatch
+        extend ActiveSupport::Concern
+        include Send
+
         def register_request_of_syntax_availability_inspection(rewriter, key, methods)
           code = "self.class.ancestors.any? { |a| a.name.start_with?('RSpec::') }"
 

data/lib/transpec/syntax/mixin/{any_instance.rb → monkey_patch_any_instance.rb}

@@ -1,16 +1,18 @@
 # coding: utf-8
 
+require 'active_support/concern'
+require 'transpec/syntax/mixin/monkey_patch'
 require 'ast'
 
 module Transpec
   class Syntax
     module Mixin
-      module AnyInstance
-        include ::AST::Sexp
+      module MonkeyPatchAnyInstance
+        extend ActiveSupport::Concern
+        include MonkeyPatch, ::AST::Sexp
 
-        def self.included(syntax)
-          syntax.add_dynamic_analysis_request do |rewriter|
-            key = :any_instance_target_class_name
+        included do
+          add_dynamic_analysis_request do |rewriter|
             code = <<-END.gsub(/^\s+\|/, '').chomp
               |if self.class.name == 'RSpec::Mocks::AnyInstance::Recorder'
               |  if respond_to?(:klass)
@@ -24,7 +26,7 @@ module Transpec
               |  nil
               |end
             END
-            rewriter.register_request(subject_node, key, code)
+            rewriter.register_request(subject_node, :any_instance_target_class_name, code)
           end
         end
 
@@ -35,6 +37,8 @@ module Transpec
           !node_data[:any_instance_target_class_name].result.nil?
         end
 
+        private
+
         def any_instance_target_class_source
           return nil unless any_instance?
 
@@ -46,13 +50,13 @@ module Transpec
         end
 
         def any_instance_target_node
-          return nil unless subject_node.type == :send
+          return nil unless subject_node.send_type?
           return nil unless subject_node.children.count == 2
           receiver_node, method_name = *subject_node
           return nil unless receiver_node
           return nil unless method_name == :any_instance
 
-          if receiver_node.type == :const || receiver_node == s(:send, nil, :described_class)
+          if receiver_node.const_type? || receiver_node == s(:send, nil, :described_class)
             receiver_node
           else
             nil

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

@@ -14,7 +14,7 @@ module Transpec
           end
 
           def check_target_node_statically(node)
-            return false unless node && node.type == :send
+            return false unless node && node.send_type?
             receiver_node, method_name, *_ = *node
             target_method?(receiver_node, method_name)
           end
@@ -44,8 +44,8 @@ module Transpec
           end
         end
 
-        def self.included(syntax)
-          syntax.add_dynamic_analysis_request do |rewriter|
+        included do
+          add_dynamic_analysis_request do |rewriter|
             if receiver_node
               target_node = receiver_node
               target_object_type = :object
@@ -107,6 +107,19 @@ module Transpec
         def range_after_arg
           arg_range.end.join(expression_range.end)
         end
+
+        def each_chained_method_node
+          return to_enum(__method__) unless block_given?
+
+          @node.each_ancestor_node.reduce(@node) do |child_node, parent_node|
+            return unless [:send, :block].include?(parent_node.type)
+            return unless parent_node.children.first == child_node
+            yield parent_node, child_node
+            parent_node
+          end
+
+          nil
+        end
       end
     end
   end