transpec 1.6.1 → 1.7.0

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

@@ -1,13 +1,19 @@
 # coding: utf-8
 
+require 'active_support/concern'
+require 'transpec/syntax/mixin/send'
+require 'transpec/syntax/mixin/have_matcher_owner'
 require 'transpec/syntax/operator_matcher'
 
 module Transpec
   class Syntax
     module Mixin
       module ShouldBase
-        def self.included(syntax)
-          syntax.add_dynamic_analysis_request do |rewriter|
+        extend ActiveSupport::Concern
+        include Send, HaveMatcherOwner
+
+        included do
+          add_dynamic_analysis_request do |rewriter|
             if OperatorMatcher.dynamic_analysis_target_node?(matcher_node)
               create_operator_matcher.register_request_for_dynamic_analysis(rewriter)
             end

data/lib/transpec/syntax/oneliner_should.rb

@@ -2,8 +2,6 @@
 
 require 'transpec/syntax'
 require 'transpec/syntax/mixin/should_base'
-require 'transpec/syntax/mixin/send'
-require 'transpec/syntax/mixin/have_matcher_owner'
 require 'transpec/rspec_dsl'
 require 'transpec/util'
 require 'active_support/inflector/methods'
@@ -11,7 +9,7 @@ require 'active_support/inflector/methods'
 module Transpec
   class Syntax
     class OnelinerShould < Syntax
-      include Mixin::ShouldBase, Mixin::Send, Mixin::HaveMatcherOwner, RSpecDSL, Util
+      include Mixin::ShouldBase, RSpecDSL, Util
 
       attr_reader :current_syntax_type
 
@@ -114,7 +112,7 @@ module Transpec
         return @example_block_node if instance_variable_defined?(:@example_block_node)
 
         @example_block_node = @node.each_ancestor_node.find do |node|
-          next false unless node.type == :block
+          next false unless node.block_type?
           send_node = node.children.first
           receiver_node, method_name, = *send_node
           next false if receiver_node

data/lib/transpec/syntax/operator_matcher.rb

@@ -93,7 +93,7 @@ module Transpec
       end
 
       def arg_is_enumerable?
-        return true if arg_node.type == :array
+        return true if arg_node.array_type?
         node_data = runtime_node_data(arg_node)
         node_data && node_data[:arg_is_enumerable?].result
       end
@@ -101,7 +101,7 @@ module Transpec
       def parenthesize_single_line!(always)
         if in_explicit_parentheses?(arg_node)
           remove(range_in_between_selector_and_arg)
-        elsif always || arg_node.type == :hash
+        elsif always || arg_node.hash_type?
           replace(range_in_between_selector_and_arg, '(')
           insert_after(expression_range, ')')
         elsif range_in_between_selector_and_arg.source.empty?

data/lib/transpec/syntax/raise_error.rb

@@ -25,7 +25,7 @@ module Transpec
 
       def positive?
         @node.each_ancestor_node do |ancestor_node|
-          next unless ancestor_node.type == :send
+          next unless ancestor_node.send_type?
           expectation_method_name = ancestor_node.children[1]
           return [:should, :to].include?(expectation_method_name)
         end
@@ -38,7 +38,7 @@ module Transpec
       def register_record
         original_syntax = 'expect { }.not_to raise_error('
 
-        if arg_nodes.first.type == :const
+        if arg_nodes.first.const_type?
           original_syntax << 'SpecificErrorClass'
           original_syntax << ', message' if arg_nodes.count >= 2
         else

data/lib/transpec/syntax/receive.rb

@@ -0,0 +1,49 @@
+# coding: utf-8
+
+require 'transpec/syntax'
+require 'transpec/syntax/mixin/send'
+require 'transpec/syntax/mixin/any_instance_block'
+
+module Transpec
+  class Syntax
+    class Receive < Syntax
+      include Mixin::Send, 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
+        @report.records << Record.new(
+          "#{@expectation.method_name}(Klass).to receive(:message) { |arg| }",
+          "#{@expectation.method_name}(Klass).to receive(:message) { |instance, arg| }"
+        )
+      end
+
+      def any_instance?
+        @expectation.any_instance?
+      end
+
+      def any_instance_block_node
+        return unless any_instance?
+        super || @expectation.block_node
+      end
+    end
+  end
+end

data/lib/transpec/syntax/rspec_configure.rb

@@ -2,115 +2,27 @@
 
 require 'transpec/syntax'
 require 'transpec/util'
-require 'ast'
 
 module Transpec
   class Syntax
     class RSpecConfigure < Syntax
+      require 'transpec/syntax/rspec_configure/expectations'
+      require 'transpec/syntax/rspec_configure/mocks'
+
       def self.target_node?(node, runtime_data = nil)
-        return false unless node && node.type == :block
+        return false unless node && node.block_type?
         send_node = node.children.first
         receiver_node, method_name, *_ = *send_node
         Util.const_name(receiver_node) == 'RSpec' && method_name == :configure
       end
 
-      def self.add_framework_configuration(type, config_method_name)
-        class_eval <<-END
-          def #{type}_syntaxes
-            #{type}_framework_configuration.syntaxes
-          end
-
-          def modify_#{type}_syntaxes!(syntaxes)
-            #{type}_framework_configuration.modify_syntaxes!(syntaxes)
-          end
-
-          def #{type}_framework_configuration
-            @#{type}_framework_configuration ||=
-              FrameworkConfiguration.new(node, :#{config_method_name}, source_rewriter)
-          end
-        END
+      def expectations
+        @expectations ||= Expectations.new(node, source_rewriter)
       end
 
-      add_framework_configuration :expectation, :expect_with
-      add_framework_configuration :mock,        :mock_with
-
-      class FrameworkConfiguration
-        include ::AST::Sexp
-
-        def initialize(rspec_configure_node, framework_config_method_name, source_rewriter)
-          @rspec_configure_node = rspec_configure_node
-          @framework_config_method_name = framework_config_method_name
-          @source_rewriter = source_rewriter
-        end
-
-        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 modify_syntaxes!(syntaxes)
-          unless [Array, Symbol].include?(syntaxes.class)
-            fail ArgumentError, 'Syntaxes must be either an array or a symbol.'
-          end
-
-          @source_rewriter.replace(syntaxes_node.loc.expression, syntaxes.inspect)
-        end
-
-        private
-
-        def syntaxes_node
-          return nil unless framework_block_node
-
-          return @syntaxes_node if instance_variable_defined?(:@syntaxes_node)
-
-          framework_config_variable_name = first_block_arg_name(framework_block_node)
-
-          framework_block_node.each_descendent_node do |node|
-            next unless node.type == :send
-            receiver_node, method_name, arg_node, *_ = *node
-            next unless receiver_node == s(:lvar, framework_config_variable_name)
-            next unless method_name == :syntax=
-            return @syntaxes_node = arg_node
-          end
-
-          @syntaxes_node = nil
-        end
-
-        def framework_block_node
-          return @framework_block_node if instance_variable_defined?(:@framework_block_node)
-
-          @framework_block_node = @rspec_configure_node.each_descendent_node.find do |node|
-            next unless node.type == :block
-            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_config_method_name
-            # TODO: Check expectation framework.
-          end
-        end
-
-        def rspec_configure_block_arg_name
-          first_block_arg_name(@rspec_configure_node)
-        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
-        end
+      def mocks
+        @mocks ||= Mocks.new(node, source_rewriter)
       end
-
-      class UnknownSyntaxError < StandardError; end
     end
   end
 end

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

@@ -0,0 +1,15 @@
+# coding: utf-8
+
+require 'transpec/syntax/rspec_configure/framework'
+
+module Transpec
+  class Syntax
+    class RSpecConfigure
+      class Expectations < Framework
+        def framework_block_method_name
+          :expect_with
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,166 @@
+# coding: utf-8
+
+require 'transpec/util'
+require 'ast'
+
+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
+
+          class UnknownSyntaxError < StandardError; end
+        end
+      end
+    end
+  end
+end
+
+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
+          @source_rewriter = source_rewriter
+        end
+
+        private
+
+        def framework_block_method_name
+          fail NotImplementedError
+        end
+
+        def set_configuration!(config_name, value)
+          setter_node = find_configuration_node("#{config_name}=")
+
+          if setter_node
+            arg_node = setter_node.children[2]
+            @source_rewriter.replace(arg_node.loc.expression, value.to_s)
+          else
+            add_configuration!(config_name, value)
+          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
+
+          configuration_method_name = configuration_method_name.to_sym
+
+          framework_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)
+            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)
+        end
+
+        def framework_block_node
+          return @framework_block_node if instance_variable_defined?(:@framework_block_node)
+
+          @framework_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
+            # TODO: Check expectation framework.
+          end
+        end
+
+        def rspec_configure_block_arg_name
+          first_block_arg_name(@rspec_configure_node)
+        end
+
+        def framework_indentation
+          if framework_block_node
+            indentation_of_line(framework_block_node) + '  '
+          else
+            indentation_of_line(@rspec_configure_node) + '    '
+          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'
+          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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# coding: utf-8
+
+require 'transpec/syntax/rspec_configure/framework'
+
+module Transpec
+  class Syntax
+    class RSpecConfigure
+      class Mocks < Framework
+        def framework_block_method_name
+          :mock_with
+        end
+
+        def yield_receiver_to_any_instance_implementation_blocks=(boolean)
+          set_configuration!(:yield_receiver_to_any_instance_implementation_blocks, boolean)
+        end
+      end
+    end
+  end
+end