transpec 1.10.4 → 1.11.0

data/lib/transpec/syntax/method_stub.rb

@@ -29,7 +29,7 @@ module Transpec
 
       def dynamic_analysis_target?
         super &&
-          !receiver_node.nil? &&
+          receiver_node &&
           [:stub, :stub!, :stub_chain, :unstub, :unstub!].include?(method_name)
       end
 
@@ -55,9 +55,11 @@ module Transpec
         arg_node.hash_type?
       end
 
+      def unstub?
+        [:unstub, :unstub!].include?(method_name)
+      end
+
       def allowize!(rspec_version)
-        # There's no way of unstubbing in #allow syntax.
-        return unless [:stub, :stub!, :stub_chain].include?(method_name)
         return if method_name == :stub_chain && !rspec_version.receive_message_chain_available?
 
         unless allow_to_receive_available?
@@ -133,6 +135,7 @@ module Transpec
         expression << message_source(message_node)
         expression << (keep_form_around_arg ? range_after_arg.source : ')')
         expression << ".and_return(#{value_node.loc.expression.source})" if value_node
+        expression << '.and_call_original' if unstub?
         expression
       end
 
@@ -168,16 +171,11 @@ module Transpec
 
       def register_record(conversion_type)
         record_class = case conversion_type
-                       when :deprecated
-                         DeprecatedMethodRecord
-                       when :no_message_allowance
-                         NoMessageAllowanceRecord
-                       when :useless_and_return
-                         MonkeyPatchUselessAndReturnRecord
-                       when :any_instance_block
-                         MonkeyPatchAnyInstanceBlockRecord
-                       else
-                         AllowRecord
+                       when :deprecated           then DeprecatedMethodRecord
+                       when :no_message_allowance then NoMessageAllowanceRecord
+                       when :useless_and_return   then MonkeyPatchUselessAndReturnRecord
+                       when :any_instance_block   then MonkeyPatchAnyInstanceBlockRecord
+                       else                            AllowRecord
                        end
         report.records << record_class.new(self, conversion_type)
       end
@@ -207,6 +205,7 @@ module Transpec
           when :allow_to_receive
             syntax << 'receive(:message)'
             syntax << '.and_return(value)' if @method_stub.hash_arg?
+            syntax << '.and_call_original' if @method_stub.unstub?
           when :allow_to_receive_messages
             syntax << 'receive_messages(:message => value)'
           when :allow_to_receive_message_chain

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

@@ -11,18 +11,26 @@ module Transpec
         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
+        def need_to_add_receiver_arg_to_any_instance_implementation_block?
+          first_arg_node = any_instance_block_first_arg_node
+          return false 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, ')
+          first_arg_name != :instance
+        end
+
+        def add_receiver_arg_to_any_instance_implementation_block!
+          return unless need_to_add_receiver_arg_to_any_instance_implementation_block?
+          insert_before(any_instance_block_first_arg_node.loc.expression, 'instance, ')
           true
         end
 
         private
 
+        def any_instance_block_first_arg_node
+          return nil unless any_instance_block_node
+          any_instance_block_node.children[1].children[0]
+        end
+
         def any_instance_block_node
           return unless any_instance?
           Util.each_backward_chained_node(node).find(&:block_type?)

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

@@ -0,0 +1,41 @@
+# coding: utf-8
+
+require 'active_support/concern'
+require 'transpec/syntax/mixin/send'
+
+module Transpec
+  class Syntax
+    module Mixin
+      module ContextSensitive
+        extend ActiveSupport::Concern
+        include Send
+
+        included do
+          define_dynamic_analysis do |rewriter|
+            code = "is_a?(Class) && ancestors.any? { |a| a.name == 'RSpec::Core::ExampleGroup' }"
+            rewriter.register_request(node, :example_group_context?, code, :context)
+          end
+        end
+
+        def conversion_target?
+          return false unless dynamic_analysis_target?
+
+          in_example_group_context = if runtime_data.run?(node)
+                                       # If we have runtime data, check with it.
+                                       return false unless defined_by_rspec?
+                                       runtime_data[node, :example_group_context?]
+                                     else
+                                       # Otherwise check statically.
+                                       static_context_inspector.scopes.last == :example_group
+                                     end
+
+          in_example_group_context == should_be_in_example_group_context?
+        end
+
+        def should_be_in_example_group_context?
+          fail NotImplementedError
+        end
+      end
+    end
+  end
+end

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

@@ -9,37 +9,27 @@ module Transpec
         extend ActiveSupport::Concern
 
         module ClassMethods
-          def add_matcher(matcher_class) # rubocop:disable MethodLength
-            matcher_accessor = "#{matcher_class.snake_case_name}_matcher"
-            matcher_ivar = "@#{matcher_accessor}"
-            matcher_creator = "create_#{matcher_class.snake_case_name}"
-
-            define_dynamic_analysis do |rewriter|
-              matcher = send(matcher_creator)
-              if matcher.dynamic_analysis_target?
-                matcher.register_dynamic_analysis_request(rewriter)
-              end
+          def add_matcher(matcher_class)
+            accessor = "#{matcher_class.snake_case_name}_matcher"
+            ivar = "@#{accessor}"
+
+            define_method(accessor) do
+              return instance_variable_get(ivar) if instance_variable_defined?(ivar)
+              matcher = matcher_class.new(matcher_node, self, source_rewriter, runtime_data, report)
+              instance_variable_set(ivar, matcher)
             end
 
-            define_method(matcher_accessor) do
-              if instance_variable_defined?(matcher_ivar)
-                return instance_variable_get(matcher_ivar)
-              end
-
-              matcher = send(matcher_creator)
-
-              if matcher.conversion_target?
-                instance_variable_set(matcher_ivar, matcher)
-              else
-                instance_variable_set(matcher_ivar, nil)
-              end
-            end
+            matcher_accessors << accessor
+          end
 
-            define_method(matcher_creator) do
-              matcher_class.new(matcher_node, self, source_rewriter, runtime_data, report)
-            end
+          def matcher_accessors
+            @matcher_accessors ||= []
           end
         end
+
+        def dependent_syntaxes
+          super + self.class.matcher_accessors.map { |accessor| send(accessor) }
+        end
       end
     end
   end

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

@@ -32,7 +32,7 @@ module Transpec
 
         def any_instance?
           return true unless any_instance_target_node.nil?
-          !runtime_data[subject_node, :any_instance_target_class_name].nil?
+          runtime_data[subject_node, :any_instance_target_class_name]
         end
 
         private

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

@@ -22,11 +22,11 @@ module Transpec
         end
 
         def any_number_of_times?
-          !any_number_of_times_node.nil?
+          any_number_of_times_node
         end
 
         def at_least_zero?
-          !at_least_zero_node.nil?
+          at_least_zero_node
         end
 
         private

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

@@ -27,11 +27,11 @@ module Transpec
 
         def and_return_with_block?
           block_node = Util.block_node_taken_by_method(and_return_node)
-          !block_node.nil?
+          block_node
         end
 
         def and_return?
-          !and_return_node.nil?
+          and_return_node
         end
 
         def and_return_node

data/lib/transpec/syntax/oneliner_should.rb

@@ -13,7 +13,7 @@ module Transpec
 
       attr_reader :current_syntax_type
 
-      def initialize(node, source_rewriter = nil, runtime_data = nil, report = nil)
+      def initialize(*)
         super
         @current_syntax_type = :should
       end
@@ -22,34 +22,29 @@ module Transpec
         super && receiver_node.nil? && [:should, :should_not].include?(method_name)
       end
 
-      def expectize!(negative_form = 'not_to', parenthesize_matcher_arg = true)
+      def expectize!(negative_form = 'not_to')
         replacement = 'is_expected.'
         replacement << (positive? ? 'to' : negative_form)
         replace(should_range, replacement)
 
         @current_syntax_type = :expect
-        operator_matcher.convert_operator!(parenthesize_matcher_arg) if operator_matcher
 
         register_record(negative_form)
       end
 
       def convert_have_items_to_standard_should!
-        return if have_matcher.project_requires_collection_matcher?
+        return unless have_matcher.conversion_target?
 
         insert_example_description!
 
         subject_source = have_matcher.replacement_subject_source('subject')
         insert_before(expression_range, "#{subject_source}.")
 
-        have_matcher.convert_to_standard_expectation!
-
         report.records << OnelinerShouldHaveRecord.new(self, have_matcher)
       end
 
-      # rubocop:disable LineLength
-      def convert_have_items_to_standard_expect!(negative_form = 'not_to', parenthesize_matcher_arg = true)
-        # rubocop:enable LineLength
-        return if have_matcher.project_requires_collection_matcher?
+      def convert_have_items_to_standard_expect!(negative_form = 'not_to')
+        return unless have_matcher.conversion_target?
 
         insert_example_description!
 
@@ -59,14 +54,13 @@ module Transpec
         replace(should_range, expect_to_source)
 
         @current_syntax_type = :expect
-        have_matcher.convert_to_standard_expectation!
 
         report.records << OnelinerShouldHaveRecord.new(self, have_matcher, negative_form)
       end
 
       def example_has_description?
         send_node = example_block_node.children.first
-        !send_node.children[2].nil?
+        send_node.children[2]
       end
 
       def build_description(size)
@@ -91,7 +85,9 @@ module Transpec
       private
 
       def insert_example_description!
-        fail 'This one-liner #should does not have #have matcher!' unless have_matcher
+        unless have_matcher.conversion_target?
+          fail 'This one-liner #should does not have #have matcher!'
+        end
 
         unless example_has_description?
           insert_before(example_block_node.loc.begin, "'#{generated_description}' ")

data/lib/transpec/syntax/operator.rb

@@ -21,10 +21,6 @@ module Transpec
         end
       end
 
-      def self.standalone?
-        false
-      end
-
       def initialize(node, expectation, source_rewriter = nil, runtime_data = nil, report = nil)
         operator_node = if node == BE_NODE
                           node.parent_node
@@ -36,7 +32,7 @@ module Transpec
       end
 
       def dynamic_analysis_target?
-        super && !receiver_node.nil? && OPERATORS.include?(method_name)
+        super && receiver_node && OPERATORS.include?(method_name)
       end
 
       def convert_operator!(parenthesize_arg = true)
@@ -88,7 +84,7 @@ module Transpec
 
         parenthesize!(parenthesize_arg)
 
-        accurate = !enumerable_arg?.nil?
+        accurate = !enumerable_arg?.nil? # rubocop:disable NonNilCheck
 
         # Need to register record after all source rewrites are done
         # to avoid false record when failed with overlapped rewrite.
@@ -137,7 +133,7 @@ module Transpec
       end
 
       def prefixed_with_be?
-        !be_node.nil?
+        be_node
       end
 
       def remove_be!

data/lib/transpec/syntax/pending.rb

@@ -1,36 +1,20 @@
 # coding: utf-8
 
 require 'transpec/syntax'
-require 'transpec/syntax/mixin/send'
+require 'transpec/syntax/mixin/context_sensitive'
 require 'transpec/util'
 
 module Transpec
   class Syntax
     class Pending < Syntax
-      include Mixin::Send, Util
-
-      define_dynamic_analysis do |rewriter|
-        code = 'is_a?(RSpec::Core::ExampleGroup)'
-        rewriter.register_request(node, :example_context?, code, :context)
-      end
+      include Mixin::ContextSensitive, Util
 
       def dynamic_analysis_target?
         super && receiver_node.nil? && method_name == :pending
       end
 
-      def conversion_target?
-        return false unless dynamic_analysis_target?
-
-        # Check whether the context is example group to differenciate
-        # RSpec::Core::ExampleGroup.pending (a relative of #it) and
-        # RSpec::Core::ExampleGroup#pending (marks the example as pending in #it block).
-        if runtime_data.run?(node)
-          # If we have runtime data, check with it.
-          runtime_data[node, :example_context?]
-        else
-          # Otherwise check statically.
-          static_context_inspector.scopes.last == :example
-        end
+      def should_be_in_example_group_context?
+        false
       end
 
       def convert_deprecated_syntax!

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

@@ -0,0 +1,86 @@
+# coding: utf-8
+
+require 'transpec/util'
+require 'ast'
+
+module Transpec
+  class Syntax
+    class RSpecConfigure
+      module ConfigurationModification
+        include Util, ::AST::Sexp
+
+        def block_node
+          fail NotImplementedError
+        end
+
+        private
+
+        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 find_configuration_node(configuration_method_name)
+          return nil unless block_node
+
+          configuration_method_name = configuration_method_name.to_sym
+
+          block_node.each_descendent_node.find do |node|
+            next unless node.send_type?
+            receiver_node, method_name, = *node
+            next unless receiver_node == s(:lvar, block_arg_name)
+            method_name == configuration_method_name
+          end
+        end
+
+        def block_arg_name
+          return nil unless block_node
+          first_block_arg_name(block_node)
+        end
+
+        module ConfigurationAddition
+          def add_configuration!(config_name, value)
+            lines = generate_configuration_lines(config_name, value)
+            lines.unshift('') unless empty_block_body?
+            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(''))
+
+            block_node_to_insert_code.metadata[:added_configuration] = true
+          end
+
+          def generate_configuration_lines(config_name, value)
+            [body_indentation + "#{config_variable_name}.#{config_name} = #{value}"]
+          end
+
+          def config_variable_name
+            block_arg_name
+          end
+
+          def body_indentation
+            indentation_of_line(block_node) + (' ' * 2)
+          end
+
+          def block_node_to_insert_code
+            block_node
+          end
+
+          def empty_block_body?
+            block_node = block_node_to_insert_code
+            (block_node.loc.end.line - block_node.loc.begin.line <= 1) &&
+              !block_node.metadata[:added_configuration]
+          end
+        end
+
+        include ConfigurationAddition
+      end
+    end
+  end
+end

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

@@ -1,13 +1,12 @@
 # coding: utf-8
 
-require 'transpec/util'
-require 'ast'
+require 'transpec/syntax/rspec_configure/configuration_modification'
 
 module Transpec
   class Syntax
     class RSpecConfigure
       class Framework
-        include Util, ::AST::Sexp
+        include ConfigurationModification
 
         attr_reader :rspec_configure, :source_rewriter
 
@@ -16,45 +15,10 @@ module Transpec
           @source_rewriter = source_rewriter
         end
 
-        private
-
-        def 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 find_configuration_node(configuration_method_name)
-          return nil unless block_node
-
-          configuration_method_name = configuration_method_name.to_sym
-
-          block_node.each_descendent_node.find do |node|
-            next unless node.send_type?
-            receiver_node, method_name, = *node
-            next unless receiver_node == s(:lvar, block_arg_name)
-            method_name == configuration_method_name
-          end
-        end
-
-        def block_arg_name
-          return nil unless block_node
-          first_block_arg_name(block_node)
-        end
-
         def block_node
           return @block_node if instance_variable_defined?(:@block_node)
 
-          @block_node = rspec_configure.node.each_descendent_node.find do |node|
+          @block_node = rspec_configure.block_node.each_descendent_node.find do |node|
             next unless node.block_type?
             send_node = node.children.first
             receiver_node, method_name, *_ = *send_node
@@ -64,68 +28,63 @@ module Transpec
           end
         end
 
-        module ConfigurationAddition
-          def add_configuration!(config_name, value)
-            lines = [body_indentation + "#{config_variable_name}.#{config_name} = #{value}"]
-
-            unless block_node
-              lines.unshift(framework_begin_code)
-              lines << framework_end_code
-            end
+        private
 
-            lines.unshift('') unless empty_block_body?(block_node_to_insert_code)
-            lines.map! { |line| line + "\n" }
+        def block_method_name
+          fail NotImplementedError
+        end
 
-            insertion_position = beginning_of_line_range(block_node_to_insert_code.loc.end)
-            source_rewriter.insert_before(insertion_position, lines.join(''))
-          end
+        def generate_configuration_lines(config_name, value)
+          lines = super
 
-          def config_variable_name
-            block_arg_name || new_config_variable_name
+          unless block_node
+            lines.unshift(framework_begin_code)
+            lines << framework_end_code
           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
+          lines
+        end
 
-          def body_indentation
-            if block_node
-              indentation_of_line(block_node) + (' ' * 2)
-            else
-              indentation_of_line(rspec_configure.node) + (' ' * 4)
-            end
-          end
+        def config_variable_name
+          super || new_config_variable_name
+        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
+        def new_config_variable_name
+          framework_name = self.class.name.split('::').last.downcase
+          if rspec_configure.block_arg_name.to_s == framework_name
+            'config'
+          else
+            framework_name
           end
+        end
 
-          def framework_end_code
-            rspec_configure_body_indentation + 'end'
+        def body_indentation
+          if block_node
+            super
+          else
+            rspec_configure_body_indentation + (' ' * 2)
           end
+        end
 
-          def rspec_configure_body_indentation
-            indentation_of_line(rspec_configure.node) + (' ' * 2)
-          end
+        def block_node_to_insert_code
+          super || rspec_configure.block_node
+        end
 
-          def block_node_to_insert_code
-            block_node || rspec_configure.node
-          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
 
-          def empty_block_body?(block_node)
-            (block_node.loc.end.line - block_node.loc.begin.line) <= 1
-          end
+        def framework_end_code
+          rspec_configure_body_indentation + 'end'
         end
 
-        include ConfigurationAddition
+        def rspec_configure_body_indentation
+          indentation_of_line(rspec_configure.node) + (' ' * 2)
+        end
 
         module SyntaxConfiguration
           def syntaxes