transpec 1.3.1 → 1.4.0

data/lib/transpec/syntax/method_stub.rb

@@ -14,7 +14,7 @@ module Transpec
       include Mixin::Send, Mixin::MonkeyPatch, Mixin::AllowNoMessage, Mixin::AnyInstance, Util
 
       def self.target_method?(receiver_node, method_name)
-        !receiver_node.nil? && [:stub, :unstub, :stub!, :unstub!].include?(method_name)
+        !receiver_node.nil? && [:stub, :stub!, :stub_chain, :unstub, :unstub!].include?(method_name)
       end
 
       def register_request_for_dynamic_analysis(rewriter)
@@ -30,23 +30,17 @@ module Transpec
         check_syntax_availability(__method__)
       end
 
-      def allowize!(receive_messages_available = false)
+      def allowize!(rspec_version)
         # There's no way of unstubbing in #allow syntax.
-        return unless [:stub, :stub!].include?(method_name)
+        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?
           fail InvalidContextError.new(selector_range, "##{method_name}", '#allow')
         end
 
-        source, type = if arg_node.type == :hash
-                         if receive_messages_available
-                           [build_allow_to_receive_messages_expression, :allow_to_receive_messages]
-                         else
-                           [build_allow_expressions_from_hash_node(arg_node), :allow_to_receive]
-                         end
-                       else
-                         [build_allow_expression(arg_node), :allow_to_receive]
-                       end
+        source, type = replacement_source_and_conversion_type(rspec_version)
+        return unless source
 
         replace(expression_range, source)
 
@@ -63,12 +57,28 @@ module Transpec
 
       private
 
-      def build_allow_expressions_from_hash_node(hash_node)
+      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 rspec_version.receive_messages_available?
+              [build_allow_to(:receive_messages), :allow_to_receive_messages]
+            else
+              [build_multiple_allow_to_receive_with_hash(arg_node), :allow_to_receive]
+            end
+          else
+            [build_allow_to_receive(arg_node), :allow_to_receive]
+          end
+        end
+      end
+
+      def build_multiple_allow_to_receive_with_hash(hash_node)
         expressions = []
 
         hash_node.children.each_with_index do |pair_node, index|
           key_node, value_node = *pair_node
-          expression = build_allow_expression(key_node, value_node, false)
+          expression = build_allow_to_receive(key_node, value_node, false)
           expression.prepend(indentation_of_line(@node)) if index > 0
           expressions << expression
         end
@@ -76,26 +86,21 @@ module Transpec
         expressions.join($RS)
       end
 
-      def build_allow_expression(message_node, return_value_node = nil, keep_form_around_arg = true)
+      def build_allow_to_receive(message_node, value_node = nil, keep_form_around_arg = true)
         expression =  allow_source
         expression << range_in_between_receiver_and_selector.source
         expression << 'to receive'
         expression << (keep_form_around_arg ? range_in_between_selector_and_arg.source : '(')
         expression << message_source(message_node)
         expression << (keep_form_around_arg ? range_after_arg.source : ')')
-
-        if return_value_node
-          return_value_source = return_value_node.loc.expression.source
-          expression << ".and_return(#{return_value_source})"
-        end
-
+        expression << ".and_return(#{value_node.loc.expression.source})" if value_node
         expression
       end
 
-      def build_allow_to_receive_messages_expression
+      def build_allow_to(method)
         expression =  allow_source
         expression << range_in_between_receiver_and_selector.source
-        expression << 'to receive_messages'
+        expression << "to #{method}"
         expression << parentheses_range.source
         expression
       end
@@ -129,28 +134,44 @@ module Transpec
       def original_syntax
         syntax = any_instance? ? 'Klass.any_instance' : 'obj'
         syntax << ".#{method_name}"
-        syntax << (arg_node.type == :hash ? '(:message => value)' : '(:message)')
+
+        if method_name == :stub_chain
+          syntax << '(:message1, :message2)'
+        else
+          syntax << (arg_node.type == :hash ? '(:message => value)' : '(:message)')
+        end
       end
 
       def converted_syntax(conversion_type)
+        if conversion_type == :deprecated
+          converted_syntax_from_deprecated
+        else
+          allowized_syntax(conversion_type)
+        end
+      end
+
+      def allowized_syntax(conversion_type)
+        syntax = any_instance? ? 'allow_any_instance_of(Klass)' : 'allow(obj)'
+        syntax << '.to '
+
         case conversion_type
-        when :allow_to_receive, :allow_to_receive_messages
-          syntax = any_instance? ? 'allow_any_instance_of(Klass)' : 'allow(obj)'
-          syntax << '.to '
-          if conversion_type == :allow_to_receive
-            syntax << 'receive(:message)'
-            syntax << '.and_return(value)' if arg_node.type == :hash
-          else
-            syntax << 'receive_messages(:message => value)'
-          end
-        when :deprecated
-          syntax = 'obj.'
-          syntax << replacement_method_for_deprecated_method
-          syntax << '(:message)'
+        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)'
         end
 
         syntax
       end
+
+      def converted_syntax_from_deprecated
+        syntax = 'obj.'
+        syntax << replacement_method_for_deprecated_method
+        syntax << '(:message)'
+      end
     end
   end
 end

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

@@ -1,5 +1,7 @@
 # coding: utf-8
 
+require 'ast'
+
 module Transpec
   class Syntax
     module Mixin

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

@@ -1,5 +1,7 @@
 # coding: utf-8
 
+require 'ast'
+
 module Transpec
   class Syntax
     module Mixin

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

@@ -0,0 +1,39 @@
+# coding: utf-8
+
+require 'transpec/syntax/operator_matcher'
+
+module Transpec
+  class Syntax
+    module Mixin
+      module ShouldBase
+        def positive?
+          method_name == :should
+        end
+
+        def matcher_node
+          arg_node || parent_node
+        end
+
+        def operator_matcher
+          return @operator_matcher if instance_variable_defined?(:@operator_matcher)
+
+          @operator_matcher ||= begin
+            if OperatorMatcher.target_node?(matcher_node, @runtime_data)
+              OperatorMatcher.new(matcher_node, @source_rewriter, @runtime_data, @report)
+            else
+              nil
+            end
+          end
+        end
+
+        def should_range
+          if arg_node
+            selector_range
+          else
+            selector_range.join(expression_range.end)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/transpec/syntax/oneliner_should.rb

@@ -0,0 +1,218 @@
+# coding: utf-8
+
+require 'transpec/syntax'
+require 'transpec/syntax/mixin/should_base'
+require 'transpec/syntax/mixin/send'
+require 'transpec/syntax/mixin/have_matcher'
+require 'transpec/util'
+require 'active_support/inflector/methods'
+
+module Transpec
+  class Syntax
+    class OnelinerShould < Syntax
+      include Mixin::ShouldBase, Mixin::Send, Mixin::HaveMatcher, Util
+
+      attr_reader :current_syntax_type
+
+      def self.target_method?(receiver_node, method_name)
+        receiver_node.nil? && [:should, :should_not].include?(method_name)
+      end
+
+      def initialize(node, source_rewriter = nil, runtime_data = nil, report = nil)
+        super
+        @current_syntax_type = :should
+      end
+
+      def register_request_for_dynamic_analysis(rewriter)
+        operator_matcher.register_request_for_dynamic_analysis(rewriter) if operator_matcher
+        have_matcher.register_request_for_dynamic_analysis(rewriter) if have_matcher
+      end
+
+      def expectize!(negative_form = 'not_to', parenthesize_matcher_arg = true)
+        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?
+
+        insert_example_description!
+
+        subject_source = have_matcher.build_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?
+
+        insert_example_description!
+
+        subject_source = have_matcher.build_replacement_subject_source('subject')
+        expect_to_source = "expect(#{subject_source})."
+        expect_to_source << (positive? ? 'to' : negative_form)
+        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?
+      end
+
+      def build_description(size)
+        description = positive? ? 'has ' : 'does not have '
+
+        case have_matcher.have_method_name
+        when :have_at_least then description << 'at least '
+        when :have_at_most  then description << 'at most '
+        end
+
+        items = have_matcher.items_name
+
+        if positive? && size == '0'
+          size = 'no'
+        elsif size == '1'
+          items = ActiveSupport::Inflector.singularize(have_matcher.items_name)
+        end
+
+        description << "#{size} #{items}"
+      end
+
+      private
+
+      def insert_example_description!
+        fail 'This one-liner #should does not have #have matcher!' unless have_matcher
+
+        unless example_has_description?
+          insert_before(example_block_node.loc.begin, "'#{generated_description}' ")
+        end
+
+        indentation = indentation_of_line(example_block_node)
+
+        unless linefeed_at_beginning_of_block?
+          replace(left_curly_and_whitespaces_range, "do\n#{indentation}  ")
+        end
+
+        unless linefeed_at_end_of_block?
+          replace(whitespaces_and_right_curly_range, "\n#{indentation}end")
+        end
+      end
+
+      def example_block_node
+        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
+          send_node = node.children.first
+          receiver_node, method_name, = *send_node
+          next false if receiver_node
+          EXAMPLE_METHODS.include?(method_name)
+        end
+      end
+
+      def generated_description
+        build_description(have_matcher.size_source)
+      end
+
+      def linefeed_at_beginning_of_block?
+        beginning_to_body_range = example_block_node.loc.begin.join(expression_range.begin)
+        beginning_to_body_range.source.include?("\n")
+      end
+
+      def linefeed_at_end_of_block?
+        body_to_end_range = expression_range.end.join(example_block_node.loc.end)
+        body_to_end_range.source.include?("\n")
+      end
+
+      def left_curly_and_whitespaces_range
+        expand_range_to_adjacent_whitespaces(example_block_node.loc.begin, :end)
+      end
+
+      def whitespaces_and_right_curly_range
+        expand_range_to_adjacent_whitespaces(example_block_node.loc.end, :begin)
+      end
+
+      def register_record(negative_form_of_to)
+        original_syntax = 'it { should'
+        converted_syntax = 'it { is_expected.'
+
+        if positive?
+          converted_syntax << 'to'
+        else
+          original_syntax << '_not'
+          converted_syntax << negative_form_of_to
+        end
+
+        [original_syntax, converted_syntax].each do |syntax|
+          syntax << ' ... }'
+        end
+
+        @report.records << Record.new(original_syntax, converted_syntax)
+      end
+
+      class OnelinerShouldHaveRecord < Have::HaveRecord
+        def initialize(should, have, negative_form_of_to = nil)
+          @should = should
+          @have = have
+          @negative_form_of_to = negative_form_of_to
+        end
+
+        def original_syntax
+          @original_syntax ||= begin
+            syntax = @should.example_has_description? ? "it '...' do" : 'it {'
+            syntax << " #{@should.method_name} #{@have.have_method_name}(n).#{original_items} "
+            syntax << (@should.example_has_description? ? 'end' : '}')
+          end
+        end
+
+        def converted_syntax
+          @converted_syntax ||= begin
+            syntax = converted_description
+            syntax << ' '
+            syntax << converted_expectation
+            syntax << ' '
+            syntax << @have.build_replacement_matcher_source('n')
+            syntax << ' end'
+          end
+        end
+
+        def converted_description
+          if @should.example_has_description?
+            "it '...' do"
+          else
+            "it '#{@should.build_description('n')}' do"
+          end
+        end
+
+        def converted_expectation
+          case @should.current_syntax_type
+          when :should
+            "#{converted_subject}.#{@should.method_name}"
+          when :expect
+            "expect(#{converted_subject})." + (@should.positive? ? 'to' : @negative_form_of_to)
+          end
+        end
+
+        def converted_subject
+          build_converted_subject('subject')
+        end
+      end
+    end
+  end
+end

data/lib/transpec/syntax/operator_matcher.rb

@@ -3,6 +3,7 @@
 require 'transpec/syntax'
 require 'transpec/syntax/mixin/send'
 require 'transpec/util'
+require 'ast'
 
 module Transpec
   class Syntax

data/lib/transpec/syntax/should.rb

@@ -1,17 +1,18 @@
 # coding: utf-8
 
 require 'transpec/syntax'
+require 'transpec/syntax/mixin/should_base'
 require 'transpec/syntax/mixin/send'
 require 'transpec/syntax/mixin/monkey_patch'
 require 'transpec/syntax/mixin/expectizable'
 require 'transpec/syntax/mixin/have_matcher'
 require 'transpec/util'
-require 'transpec/syntax/operator_matcher'
 
 module Transpec
   class Syntax
     class Should < Syntax
-      include Mixin::Send, Mixin::MonkeyPatch, Mixin::Expectizable, Mixin::HaveMatcher, Util
+      include Mixin::ShouldBase, Mixin::Send, Mixin::MonkeyPatch, Mixin::Expectizable,
+              Mixin::HaveMatcher, Util
 
       attr_reader :current_syntax_type
 
@@ -39,10 +40,6 @@ module Transpec
         check_syntax_availability(__method__)
       end
 
-      def positive?
-        method_name == :should
-      end
-
       def expectize!(negative_form = 'not_to', parenthesize_matcher_arg = true)
         unless expect_available?
           fail InvalidContextError.new(selector_range, "##{method_name}", '#expect')
@@ -62,22 +59,6 @@ module Transpec
         operator_matcher.convert_operator!(parenthesize_matcher_arg) if operator_matcher
       end
 
-      def operator_matcher
-        return @operator_matcher if instance_variable_defined?(:@operator_matcher)
-
-        @operator_matcher ||= begin
-          if OperatorMatcher.target_node?(matcher_node, @runtime_data)
-            OperatorMatcher.new(matcher_node, @source_rewriter, @runtime_data, @report)
-          else
-            nil
-          end
-        end
-      end
-
-      def matcher_node
-        arg_node || parent_node
-      end
-
       private
 
       def replace_proc_selector_with_expect!
@@ -86,14 +67,6 @@ module Transpec
         replace(range_of_subject_method_taking_block, 'expect')
       end
 
-      def should_range
-        if arg_node
-          selector_range
-        else
-          selector_range.join(expression_range.end)
-        end
-      end
-
       def register_record(negative_form_of_to)
         if proc_literal?(subject_node)
           original_syntax = 'lambda { }.should'