transpec 1.7.0 → 1.8.0

data/lib/transpec/syntax/method_stub.rb

@@ -55,6 +55,10 @@ module Transpec
         check_syntax_availability(__method__)
       end
 
+      def hash_arg?
+        arg_node.hash_type?
+      end
+
       def allowize!(rspec_version)
         # There's no way of unstubbing in #allow syntax.
         return unless [:stub, :stub!, :stub_chain].include?(method_name)
@@ -90,7 +94,7 @@ module Transpec
         if method_name == :stub_chain
           [build_allow_to(:receive_message_chain), :allow_to_receive_message_chain]
         else
-          if arg_node.hash_type?
+          if hash_arg?
             if rspec_version.receive_messages_available?
               [build_allow_to(:receive_messages), :allow_to_receive_messages]
             else
@@ -181,7 +185,7 @@ module Transpec
           if @method_stub.method_name == :stub_chain
             syntax << '(:message1, :message2)'
           else
-            syntax << (@method_stub.arg_node.hash_type? ? '(:message => value)' : '(:message)')
+            syntax << (@method_stub.hash_arg? ? '(:message => value)' : '(:message)')
           end
         end
 
@@ -192,7 +196,7 @@ module Transpec
           case @conversion_type
           when :allow_to_receive
             syntax << 'receive(:message)'
-            syntax << '.and_return(value)' if @method_stub.arg_node.hash_type?
+            syntax << '.and_return(value)' if @method_stub.hash_arg?
           when :allow_to_receive_messages
             syntax << 'receive_messages(:message => value)'
           when :allow_to_receive_message_chain
@@ -219,20 +223,6 @@ module Transpec
           syntax << '(:message)'
         end
       end
-
-      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
 end

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

@@ -28,6 +28,20 @@ module Transpec
             return node if node.block_type?
           end
         end
+
+        class AnyInstanceBlockRecord < Record
+          def initialize(host, *)
+            @host = host
+          end
+
+          def original_syntax
+            "Klass.any_instance.#{@host.method_name}(:message) { |arg| }"
+          end
+
+          def converted_syntax
+            "Klass.any_instance.#{@host.method_name}(:message) { |instance, arg| }"
+          end
+        end
       end
     end
   end

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

@@ -0,0 +1,27 @@
+# coding: utf-8
+
+require 'active_support/concern'
+
+module Transpec
+  class Syntax
+    module Mixin
+      module OwnedMatcher
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          def standalone?
+            false
+          end
+        end
+
+        def initialize(node, expectation, source_rewriter = nil, runtime_data = nil, report = nil)
+          @node = node
+          @expectation = expectation
+          @source_rewriter = source_rewriter
+          @runtime_data = runtime_data
+          @report = report || Report.new
+        end
+      end
+    end
+  end
+end

data/lib/transpec/syntax/receive.rb

@@ -2,31 +2,20 @@
 
 require 'transpec/syntax'
 require 'transpec/syntax/mixin/send'
+require 'transpec/syntax/mixin/owned_matcher'
 require 'transpec/syntax/mixin/any_instance_block'
 
 module Transpec
   class Syntax
     class Receive < Syntax
-      include Mixin::Send, Mixin::AnyInstanceBlock
+      include Mixin::Send, Mixin::OwnedMatcher, Mixin::AnyInstanceBlock
 
       attr_reader :expectation
 
-      def self.standalone?
-        false
-      end
-
       def self.target_method?(receiver_node, method_name)
         receiver_node.nil? && method_name == :receive
       end
 
-      def initialize(node, expectation, source_rewriter = nil, runtime_data = nil, report = nil)
-        @node = node
-        @expectation = expectation
-        @source_rewriter = source_rewriter
-        @runtime_data = runtime_data
-        @report = report || Report.new
-      end
-
       def add_receiver_arg_to_any_instance_implementation_block!
         added = super
         return unless added

data/lib/transpec/syntax/rspec_configure.rb

@@ -9,6 +9,8 @@ module Transpec
       require 'transpec/syntax/rspec_configure/expectations'
       require 'transpec/syntax/rspec_configure/mocks'
 
+      include Util
+
       def self.target_node?(node, runtime_data = nil)
         return false unless node && node.block_type?
         send_node = node.children.first
@@ -17,11 +19,15 @@ module Transpec
       end
 
       def expectations
-        @expectations ||= Expectations.new(node, source_rewriter)
+        @expectations ||= Expectations.new(self, source_rewriter)
       end
 
       def mocks
-        @mocks ||= Mocks.new(node, source_rewriter)
+        @mocks ||= Mocks.new(self, source_rewriter)
+      end
+
+      def block_arg_name
+        first_block_arg_name(node)
       end
     end
   end

data/lib/transpec/syntax/rspec_configure/expectations.rb

@@ -6,7 +6,7 @@ module Transpec
   class Syntax
     class RSpecConfigure
       class Expectations < Framework
-        def framework_block_method_name
+        def block_method_name
           :expect_with
         end
       end

data/lib/transpec/syntax/rspec_configure/framework.rb

@@ -7,65 +7,18 @@ module Transpec
   class Syntax
     class RSpecConfigure
       class Framework
-        module SyntaxConfiguration
-          def syntaxes
-            return [] unless syntaxes_node
-
-            case syntaxes_node.type
-            when :sym
-              [syntaxes_node.children.first]
-            when :array
-              syntaxes_node.children.map do |child_node|
-                child_node.children.first
-              end
-            else
-              fail UnknownSyntaxError, "Unknown syntax specification: #{syntaxes_node}"
-            end
-          end
-
-          def syntaxes=(syntaxes)
-            unless [Array, Symbol].include?(syntaxes.class)
-              fail ArgumentError, 'Syntaxes must be either an array or a symbol.'
-            end
-
-            set_configuration!(:syntax, syntaxes.inspect)
-          end
-
-          private
-
-          def syntaxes_node
-            return @syntaxes_node if instance_variable_defined?(:@syntaxes_node)
-
-            syntax_setter_node = find_configuration_node(:syntax=)
-
-            @syntaxes_node = if syntax_setter_node
-                               syntax_setter_node.children[2]
-                             else
-                               nil
-                             end
-          end
+        include Util, ::AST::Sexp
 
-          class UnknownSyntaxError < StandardError; end
-        end
-      end
-    end
-  end
-end
+        attr_reader :rspec_configure
 
-module Transpec
-  class Syntax
-    class RSpecConfigure
-      class Framework
-        include SyntaxConfiguration, Util, ::AST::Sexp
-
-        def initialize(rspec_configure_node, source_rewriter)
-          @rspec_configure_node = rspec_configure_node
+        def initialize(rspec_configure, source_rewriter)
+          @rspec_configure = rspec_configure
           @source_rewriter = source_rewriter
         end
 
         private
 
-        def framework_block_method_name
+        def block_method_name
           fail NotImplementedError
         end
 
@@ -80,86 +33,142 @@ module Transpec
           end
         end
 
-        def add_configuration!(config_name, value)
-          block_arg_name = framework_block_arg_name || new_framework_block_arg_name
-
-          lines = [framework_indentation + "#{block_arg_name}.#{config_name} = #{value}"]
-
-          unless framework_block_node
-            indentation = indentation_of_line(@rspec_configure_node) + '  '
-            block_invocation = format(
-              '%s.%s :rspec do |%s|',
-              rspec_configure_block_arg_name, framework_block_method_name, block_arg_name
-            )
-            lines.unshift(indentation + block_invocation)
-            lines << indentation + 'end'
-          end
-
-          block_node = framework_block_node || @rspec_configure_node
-          insertion_position = beginning_of_line_range(block_node.loc.end)
-
-          lines.unshift('') unless (block_node.loc.end.line - block_node.loc.begin.line) <= 1
-          lines.map! { |line| line + "\n" }
-
-          @source_rewriter.insert_before(insertion_position, lines.join(''))
-        end
-
         def find_configuration_node(configuration_method_name)
-          return nil unless framework_block_node
+          return nil unless block_node
 
           configuration_method_name = configuration_method_name.to_sym
 
-          framework_block_node.each_descendent_node.find do |node|
+          block_node.each_descendent_node.find do |node|
             next unless node.send_type?
             receiver_node, method_name, = *node
-            next unless receiver_node == s(:lvar, framework_block_arg_name)
+            next unless receiver_node == s(:lvar, block_arg_name)
             method_name == configuration_method_name
           end
         end
 
-        def framework_block_arg_name
-          return nil unless framework_block_node
-          first_block_arg_name(framework_block_node)
+        def block_arg_name
+          return nil unless block_node
+          first_block_arg_name(block_node)
         end
 
-        def framework_block_node
-          return @framework_block_node if instance_variable_defined?(:@framework_block_node)
+        def block_node
+          return @block_node if instance_variable_defined?(:@block_node)
 
-          @framework_block_node = @rspec_configure_node.each_descendent_node.find do |node|
+          @block_node = rspec_configure.node.each_descendent_node.find do |node|
             next unless node.block_type?
             send_node = node.children.first
             receiver_node, method_name, *_ = *send_node
-            next unless receiver_node == s(:lvar, rspec_configure_block_arg_name)
-            method_name == framework_block_method_name
+            next unless receiver_node == s(:lvar, rspec_configure.block_arg_name)
+            method_name == block_method_name
             # TODO: Check expectation framework.
           end
         end
 
-        def rspec_configure_block_arg_name
-          first_block_arg_name(@rspec_configure_node)
-        end
+        module ConfigurationAddition
+          def add_configuration!(config_name, value)
+            lines = [body_indentation + "#{config_variable_name}.#{config_name} = #{value}"]
 
-        def framework_indentation
-          if framework_block_node
-            indentation_of_line(framework_block_node) + '  '
-          else
-            indentation_of_line(@rspec_configure_node) + '    '
+            unless block_node
+              lines.unshift(framework_begin_code)
+              lines << framework_end_code
+            end
+
+            lines.unshift('') unless empty_block_body?(block_node_to_insert_code)
+            lines.map! { |line| line + "\n" }
+
+            insertion_position = beginning_of_line_range(block_node_to_insert_code.loc.end)
+            @source_rewriter.insert_before(insertion_position, lines.join(''))
+          end
+
+          def config_variable_name
+            block_arg_name || new_config_variable_name
+          end
+
+          def new_config_variable_name
+            case rspec_configure.block_arg_name
+            when :rspec then self.class.name.split('::').last.downcase
+            when :c     then 'config'
+            else 'c'
+            end
+          end
+
+          def body_indentation
+            if block_node
+              indentation_of_line(block_node) + (' ' * 2)
+            else
+              indentation_of_line(rspec_configure.node) + (' ' * 4)
+            end
+          end
+
+          def framework_begin_code
+            code = format(
+              '%s.%s :rspec do |%s|',
+              rspec_configure.block_arg_name, block_method_name, config_variable_name
+            )
+            rspec_configure_body_indentation + code
           end
-        end
 
-        def new_framework_block_arg_name
-          case rspec_configure_block_arg_name
-          when :rspec then self.class.name.split('::').last.downcase
-          when :c     then 'config'
-          else 'c'
+          def framework_end_code
+            rspec_configure_body_indentation + 'end'
+          end
+
+          def rspec_configure_body_indentation
+            indentation_of_line(rspec_configure.node) + (' ' * 2)
+          end
+
+          def block_node_to_insert_code
+            block_node || rspec_configure.node
+          end
+
+          def empty_block_body?(block_node)
+            (block_node.loc.end.line - block_node.loc.begin.line) <= 1
           end
         end
 
-        def first_block_arg_name(block_node)
-          args_node = block_node.children[1]
-          first_arg_node = args_node.children.first
-          first_arg_node.children.first
+        include ConfigurationAddition
+
+        module SyntaxConfiguration
+          def syntaxes
+            return [] unless syntaxes_node
+
+            case syntaxes_node.type
+            when :sym
+              [syntaxes_node.children.first]
+            when :array
+              syntaxes_node.children.map do |child_node|
+                child_node.children.first
+              end
+            else
+              fail UnknownSyntaxError, "Unknown syntax specification: #{syntaxes_node}"
+            end
+          end
+
+          def syntaxes=(syntaxes)
+            unless [Array, Symbol].include?(syntaxes.class)
+              fail ArgumentError, 'Syntaxes must be either an array or a symbol.'
+            end
+
+            set_configuration!(:syntax, syntaxes.inspect)
+          end
+
+          private
+
+          def syntaxes_node
+            return @syntaxes_node if instance_variable_defined?(:@syntaxes_node)
+
+            syntax_setter_node = find_configuration_node(:syntax=)
+
+            @syntaxes_node = if syntax_setter_node
+                               syntax_setter_node.children[2]
+                             else
+                               nil
+                             end
+          end
+
+          class UnknownSyntaxError < StandardError; end
         end
+
+        include SyntaxConfiguration
       end
     end
   end

data/lib/transpec/syntax/rspec_configure/mocks.rb

@@ -6,7 +6,7 @@ module Transpec
   class Syntax
     class RSpecConfigure
       class Mocks < Framework
-        def framework_block_method_name
+        def block_method_name
           :mock_with
         end