transpec 0.2.6 → 1.0.0

data/lib/transpec/syntax/method_stub.rb

@@ -1,28 +1,39 @@
 # coding: utf-8
 
 require 'transpec/syntax'
-require 'transpec/syntax/able_to_allow_no_message'
-require 'transpec/syntax/able_to_target_any_instance'
+require 'transpec/syntax/mixin/send'
+require 'transpec/syntax/mixin/monkey_patch'
+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 AbleToAllowNoMessage, AbleToTargetAnyInstance, Util
+      include Mixin::Send, Mixin::MonkeyPatch, Mixin::AllowNoMessage, Mixin::AnyInstance, Util
 
-      CLASSES_DEFINING_OWN_STUB_METHOD = [
-        'Typhoeus', # https://github.com/typhoeus/typhoeus/blob/6a59c62/lib/typhoeus.rb#L66-L85
-        'Excon'     # https://github.com/geemus/excon/blob/6af4f9c/lib/excon.rb#L143-L178
-      ]
+      def self.target_method?(receiver_node, method_name)
+        !receiver_node.nil? && [:stub, :unstub, :stub!, :unstub!].include?(method_name)
+      end
+
+      def register_request_for_dynamic_analysis(rewriter)
+        register_request_of_syntax_availability_inspection(
+          rewriter,
+          :allow_to_receive_available?,
+          [:allow, :receive]
+        )
+      end
+
+      def allow_to_receive_available?
+        check_syntax_availability(__method__)
+      end
 
       def allowize!
         # There's no way of unstubbing in #allow syntax.
         return unless [:stub, :stub!].include?(method_name)
 
-        fail 'Already replaced deprecated method, cannot allowize.' if @replaced_deprecated_method
-
-        unless context.allow_to_receive_available?
+        unless allow_to_receive_available?
           fail InvalidContextError.new(selector_range, "##{method_name}", '#allow')
         end
 
@@ -35,34 +46,18 @@ module Transpec
         end
 
         register_record(:allow)
-
-        @allowized = true
       end
 
-      def replace_deprecated_method!
+      def convert_deprecated_method!
         return unless replacement_method_for_deprecated_method
 
-        fail 'Already allowized, cannot replace deprecated method.' if @allowized
-
         replace(selector_range, replacement_method_for_deprecated_method)
 
         register_record(:deprecated)
-
-        @replaced_deprecated_method = true
       end
 
       private
 
-      def self.target_receiver_node?(node)
-        return false if node.nil?
-        const_name = Util.const_name(node)
-        !CLASSES_DEFINING_OWN_STUB_METHOD.include?(const_name)
-      end
-
-      def self.target_method_names
-        [:stub, :unstub, :stub!, :unstub!]
-      end
-
       def build_allow_expressions_from_hash_node(hash_node)
         expressions = []
 

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

@@ -0,0 +1,73 @@
+# coding: utf-8
+
+module Transpec
+  class Syntax
+    module Mixin
+      module AllowNoMessage
+        include ::AST::Sexp
+
+        def allow_no_message?
+          any_number_of_times? || at_least_zero?
+        end
+
+        def remove_allowance_for_no_message!
+          remove_any_number_of_times!
+          remove_at_least_zero!
+        end
+
+        private
+
+        def any_number_of_times?
+          !any_number_of_times_node.nil?
+        end
+
+        def at_least_zero?
+          !at_least_zero_node.nil?
+        end
+
+        def remove_any_number_of_times!
+          return unless any_number_of_times?
+          remove_dot_and_method!(any_number_of_times_node)
+        end
+
+        def remove_at_least_zero!
+          return unless at_least_zero?
+          remove_dot_and_method!(at_least_zero_node)
+        end
+
+        def remove_dot_and_method!(send_node)
+          map = send_node.loc
+          dot_and_method_range = map.dot.join(map.expression.end)
+          remove(dot_and_method_range)
+        end
+
+        def any_number_of_times_node
+          each_following_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|
+            _, 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?
+
+          @ancestor_nodes.reverse.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
+end

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

@@ -0,0 +1,22 @@
+# coding: utf-8
+
+module Transpec
+  class Syntax
+    module Mixin
+      module AnyInstance
+        def any_instance?
+          !class_node_of_any_instance.nil?
+        end
+
+        def class_node_of_any_instance
+          return nil unless subject_node.type == :send
+          return nil unless subject_node.children.count == 2
+          receiver_node, method_name = *subject_node
+          return nil unless method_name == :any_instance
+          return nil unless receiver_node.type == :const
+          receiver_node
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# coding: utf-8
+
+require 'transpec/util'
+
+module Transpec
+  class Syntax
+    module Mixin
+      module Expectizable
+        def wrap_subject_in_expect!
+          wrap_subject_with_method!('expect')
+        end
+
+        private
+
+        def wrap_subject_with_method!(method)
+          if Util.in_parentheses?(subject_node)
+            insert_before(subject_range, method)
+          else
+            insert_before(subject_range, "#{method}(")
+            insert_after(subject_range, ')')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# coding: utf-8
+
+require 'transpec/syntax/have'
+
+module Transpec
+  class Syntax
+    module Mixin
+      module HaveMatcher
+        def have_matcher
+          return @have_matcher if instance_variable_defined?(:@have_matcher)
+
+          @have_matcher ||= begin
+            if Have.target_node?(matcher_node, @runtime_data)
+              Have.new(matcher_node, self, @source_rewriter, @runtime_data, @report)
+            else
+              nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# coding: utf-8
+
+module Transpec
+  class Syntax
+    module Mixin
+      module MonkeyPatch
+        def register_request_of_syntax_availability_inspection(rewriter, key, methods)
+          code = "self.class.name.start_with?('RSpec::')"
+
+          methods.each do |method|
+            code << " && respond_to?(#{method.inspect})"
+          end
+
+          rewriter.register_request(@node, key, code, :context)
+        end
+
+        def check_syntax_availability(key)
+          node_data = runtime_node_data(@node)
+
+          if node_data
+            node_data[key].result
+          else
+            static_context_inspector.send(key)
+          end
+        end
+
+        def subject_node
+          receiver_node
+        end
+
+        def subject_range
+          receiver_range
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+# coding: utf-8
+
+module Transpec
+  class Syntax
+    module Mixin
+      module Send
+        def self.included(klass)
+          klass.extend(ClassMethods)
+        end
+
+        module ClassMethods
+          def register_request_for_dynamic_analysis(node, rewriter)
+            return unless target_node?(node)
+
+            receiver_node, method_name, *_ = *node
+
+            if receiver_node
+              target_node = receiver_node
+              target_object_type = :object
+            else
+              target_node = node
+              target_object_type = :context
+            end
+
+            key = source_location_key(method_name)
+            code = "method(#{method_name.inspect}).source_location"
+            rewriter.register_request(target_node, key, code, target_object_type)
+          end
+
+          def target_node?(node, runtime_data = nil)
+            check_target_node_statically(node) && check_target_node_dynamically(node, runtime_data)
+          end
+
+          def target_method?(receiver_node, method_name)
+            false
+          end
+
+          def check_target_node_statically(node)
+            return false unless node && node.type == :send
+            receiver_node, method_name, *_ = *node
+            target_method?(receiver_node, method_name)
+          end
+
+          def check_target_node_dynamically(node, runtime_data)
+            return true unless runtime_data
+
+            receiver_node, method_name, *_ = *node
+            target_node = receiver_node ? receiver_node : node
+
+            return true unless (node_data = runtime_data[target_node])
+            return true unless (eval_data = node_data[source_location_key(method_name)])
+            return true unless (source_location = eval_data.result)
+
+            file_path = source_location.first
+            !file_path.match(%r{/gems/rspec\-[^/]+/lib/rspec/}).nil?
+          end
+
+          def source_location_key(method_name)
+            "#{method_name}_source_location".to_sym
+          end
+        end
+
+        def receiver_node
+          @node.children[0]
+        end
+
+        def method_name
+          @node.children[1]
+        end
+
+        def arg_node
+          @node.children[2]
+        end
+
+        def arg_nodes
+          @node.children[2..-1]
+        end
+
+        def selector_range
+          @node.loc.selector
+        end
+
+        def receiver_range
+          receiver_node.loc.expression
+        end
+
+        def arg_range
+          arg_node.loc.expression
+        end
+
+        def parentheses_range
+          selector_range.end.join(expression_range.end)
+        end
+
+        def range_in_between_receiver_and_selector
+          receiver_range.end.join(selector_range.begin)
+        end
+
+        def range_in_between_selector_and_arg
+          selector_range.end.join(arg_range.begin)
+        end
+
+        def range_after_arg
+          arg_range.end.join(expression_range.end)
+        end
+      end
+    end
+  end
+end

data/lib/transpec/syntax/{matcher.rb → operator_matcher.rb}

@@ -1,22 +1,34 @@
 # coding: utf-8
 
 require 'transpec/syntax'
-require 'transpec/syntax/send_node_syntax'
+require 'transpec/syntax/mixin/send'
 require 'transpec/util'
 
 module Transpec
   class Syntax
-    class Matcher < Syntax
-      include SendNodeSyntax, Util, ::AST::Sexp
+    class OperatorMatcher < Syntax
+      include Mixin::Send, Util, ::AST::Sexp
 
-      def self.target_node?(node)
+      OPERATORS = [:==, :===, :<, :<=, :>, :>=, :=~].freeze
+
+      def self.standalone?
         false
       end
 
-      def initialize(node, source_rewriter, report = Report.new)
+      def self.target_method?(receiver_node, method_name)
+        !receiver_node.nil? && OPERATORS.include?(method_name)
+      end
+
+      def initialize(node, source_rewriter = nil, runtime_data = nil, report = nil)
         @node = node
         @source_rewriter = source_rewriter
-        @report = report
+        @runtime_data = runtime_data
+        @report = report || Report.new
+      end
+
+      def register_request_for_dynamic_analysis(rewriter)
+        return unless method_name == :=~
+        rewriter.register_request(arg_node, :arg_is_enumerable?, 'is_a?(Enumerable)')
       end
 
       def correct_operator!(parenthesize_arg = true)
@@ -31,7 +43,7 @@ module Transpec
       end
 
       def parenthesize!(always = true)
-        return if argument_is_here_document?
+        return if contain_here_document?(arg_node)
 
         left_of_arg_source = range_in_between_selector_and_arg.source
 
@@ -60,7 +72,7 @@ module Transpec
       def convert_to_match!(parenthesize_arg)
         handle_anterior_of_operator!
 
-        if arg_node.type == :array
+        if arg_is_enumerable?
           replace(selector_range, 'match_array')
         else
           replace(selector_range, 'match')
@@ -70,7 +82,7 @@ module Transpec
 
         # Need to register record after all source rewrites are done
         # to avoid false record when failed with overlapped rewrite.
-        if arg_node.type == :array
+        if arg_is_enumerable?
           register_record('=~ [1, 2]', 'match_array([1, 2])')
         else
           register_record('=~ /pattern/', 'match(/pattern/)')
@@ -85,6 +97,12 @@ module Transpec
         end
       end
 
+      def arg_is_enumerable?
+        return true if arg_node.type == :array
+        node_data = runtime_node_data(arg_node)
+        node_data && node_data[:arg_is_enumerable?].result
+      end
+
       def parenthesize_single_line!(always)
         if in_parentheses?(arg_node)
           remove(range_in_between_selector_and_arg)
@@ -120,11 +138,6 @@ module Transpec
         end
       end
 
-      def argument_is_here_document?
-        here_document?(arg_node) ||
-          arg_node.each_descendent_node.any? { |n| here_document?(n) }
-      end
-
       def register_record(original_syntax, converted_syntax)
         original_syntax ||= "#{method_name} expected"
         @report.records << Record.new(original_syntax, converted_syntax)

data/lib/transpec/syntax/raise_error.rb

@@ -1,12 +1,16 @@
 # coding: utf-8
 
 require 'transpec/syntax'
-require 'transpec/syntax/send_node_syntax'
+require 'transpec/syntax/mixin/send'
 
 module Transpec
   class Syntax
     class RaiseError < Syntax
-      include SendNodeSyntax
+      include Mixin::Send
+
+      def self.target_method?(receiver_node, method_name)
+        receiver_node.nil? && method_name == :raise_error
+      end
 
       def remove_error_specification_with_negative_expectation!
         return if positive?
@@ -31,14 +35,6 @@ module Transpec
 
       private
 
-      def self.target_receiver_node?(node)
-        node.nil?
-      end
-
-      def self.target_method_names
-        [:raise_error]
-      end
-
       def register_record
         original_syntax = 'expect { }.not_to raise_error('
 

data/lib/transpec/syntax/rspec_configure.rb

@@ -2,11 +2,39 @@
 
 require 'transpec/syntax'
 require 'transpec/util'
-require 'transpec/ast/scanner'
 
 module Transpec
   class Syntax
     class RSpecConfigure < Syntax
+      extend Util
+
+      def self.target_node?(node, runtime_data = nil)
+        return false unless node && node.type == :block
+        send_node = node.children.first
+        receiver_node, method_name, *_ = *send_node
+        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
+      end
+
+      add_framework_configuration :expectation, :expect_with
+      add_framework_configuration :mock,        :mock_with
+
       class FrameworkConfiguration
         include ::AST::Sexp
 
@@ -83,33 +111,6 @@ module Transpec
         end
       end
 
-      def self.target_node?(node)
-        return false unless node.type == :block
-        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
-      end
-
-      add_framework_configuration :expectation, :expect_with
-      add_framework_configuration :mock,        :mock_with
-
       class UnknownSyntaxError < StandardError; end
     end
   end

data/lib/transpec/syntax/should.rb

@@ -1,21 +1,50 @@
 # coding: utf-8
 
 require 'transpec/syntax'
-require 'transpec/syntax/expectizable'
-require 'transpec/syntax/matcher'
+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 Expectizable, Util
+      include Mixin::Send, Mixin::MonkeyPatch, Mixin::Expectizable, 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, ancestor_nodes, source_rewriter = nil, runtime_data = nil, report = nil)
+        super
+        @current_syntax_type = :should
+      end
+
+      def register_request_for_dynamic_analysis(rewriter)
+        register_request_of_syntax_availability_inspection(
+          rewriter,
+          :expect_available?,
+          [:expect]
+        )
+
+        operator_matcher.register_request_for_dynamic_analysis(rewriter) if operator_matcher
+        have_matcher.register_request_for_dynamic_analysis(rewriter) if have_matcher
+      end
+
+      def expect_available?
+        check_syntax_availability(__method__)
+      end
 
       def positive?
         method_name == :should
       end
 
       def expectize!(negative_form = 'not_to', parenthesize_matcher_arg = true)
-        unless context.expect_to_matcher_available?
+        unless expect_available?
           fail InvalidContextError.new(selector_range, "##{method_name}", '#expect')
         end
 
@@ -27,13 +56,22 @@ module Transpec
 
         replace(should_range, positive? ? 'to' : negative_form)
 
+        @current_syntax_type = :expect
         register_record(negative_form)
 
-        matcher.correct_operator!(parenthesize_matcher_arg)
+        operator_matcher.correct_operator!(parenthesize_matcher_arg) if operator_matcher
       end
 
-      def matcher
-        @matcher ||= Matcher.new(matcher_node, @source_rewriter, @report)
+      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
@@ -42,14 +80,6 @@ module Transpec
 
       private
 
-      def self.target_receiver_node?(node)
-        !node.nil?
-      end
-
-      def self.target_method_names
-        [:should, :should_not]
-      end
-
       def replace_proc_selector_with_expect!
         send_node = subject_node.children.first
         range_of_subject_method_taking_block = send_node.loc.expression