transpec 1.9.3 → 1.10.0

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

@@ -17,14 +17,12 @@ module Transpec
             code << " && respond_to?(#{method.inspect})"
           end
 
-          rewriter.register_request(@node, key, code, :context)
+          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
+          if runtime_data.present?(node, key)
+            runtime_data[node, key]
           else
             static_context_inspector.send(key)
           end

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

@@ -32,9 +32,7 @@ module Transpec
 
         def any_instance?
           return true unless any_instance_target_node.nil?
-          node_data = runtime_node_data(subject_node)
-          return false unless node_data && node_data[:any_instance_target_class_name]
-          !node_data[:any_instance_target_class_name].result.nil?
+          !runtime_data[subject_node, :any_instance_target_class_name].nil?
         end
 
         private
@@ -45,7 +43,7 @@ module Transpec
           if any_instance_target_node
             any_instance_target_node.loc.expression.source
           else
-            runtime_node_data(subject_node)[:any_instance_target_class_name].result
+            runtime_data[subject_node, :any_instance_target_class_name]
           end
         end
 

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

@@ -19,11 +19,8 @@ module Transpec
         end
 
         def initialize(node, expectation, source_rewriter = nil, runtime_data = nil, report = nil)
-          @node = node
+          super(node, source_rewriter, runtime_data, report)
           @expectation = expectation
-          @source_rewriter = source_rewriter
-          @runtime_data = runtime_data
-          @report = report || Report.new
         end
       end
     end

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

@@ -34,9 +34,7 @@ module Transpec
             return unless runtime_data
             receiver_node, method_name, *_ = *node
             target_node = receiver_node ? receiver_node : node
-            return unless (node_data = runtime_data[target_node])
-            return unless (eval_data = node_data[source_location_key(method_name)])
-            eval_data.result
+            runtime_data[target_node, source_location_key(method_name)]
           end
 
           def source_location_key(method_name)
@@ -50,7 +48,7 @@ module Transpec
               target_node = receiver_node
               target_object_type = :object
             else
-              target_node = @node
+              target_node = node
               target_object_type = :context
             end
 
@@ -61,23 +59,23 @@ module Transpec
         end
 
         def receiver_node
-          @node.children[0]
+          node.children[0]
         end
 
         def method_name
-          @node.children[1]
+          node.children[1]
         end
 
         def arg_node
-          @node.children[2]
+          node.children[2]
         end
 
         def arg_nodes
-          @node.children[2..-1]
+          node.children[2..-1]
         end
 
         def selector_range
-          @node.loc.selector
+          node.loc.selector
         end
 
         def receiver_range

data/lib/transpec/syntax/oneliner_should.rb

@@ -43,7 +43,7 @@ module Transpec
 
         have_matcher.convert_to_standard_expectation!
 
-        @report.records << OnelinerShouldHaveRecord.new(self, have_matcher)
+        report.records << OnelinerShouldHaveRecord.new(self, have_matcher)
       end
 
       # rubocop:disable LineLength
@@ -61,7 +61,7 @@ module Transpec
         @current_syntax_type = :expect
         have_matcher.convert_to_standard_expectation!
 
-        @report.records << OnelinerShouldHaveRecord.new(self, have_matcher, negative_form)
+        report.records << OnelinerShouldHaveRecord.new(self, have_matcher, negative_form)
       end
 
       def example_has_description?
@@ -111,7 +111,7 @@ module Transpec
       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|
+        @example_block_node = node.each_ancestor_node.find do |node|
           next false unless node.block_type?
           send_node = node.children.first
           receiver_node, method_name, = *send_node
@@ -157,7 +157,7 @@ module Transpec
           syntax << ' ... }'
         end
 
-        @report.records << Record.new(original_syntax, converted_syntax)
+        report.records << Record.new(original_syntax, converted_syntax)
       end
 
       class OnelinerShouldHaveRecord < Have::HaveRecord

data/lib/transpec/syntax/operator.rb

@@ -19,12 +19,12 @@ module Transpec
         false
       end
 
-      def self.target_node?(node, runtime_data = nil)
+      def self.check_target_node_statically(node)
         node = node.parent_node if node == BE_NODE
+        return false unless node && node.send_type?
         receiver_node, method_name, *_ = *node
         return false if receiver_node.nil?
-        return false unless OPERATORS.include?(method_name)
-        check_target_node_dynamically(node, runtime_data)
+        OPERATORS.include?(method_name)
       end
 
       define_dynamic_analysis_request do |rewriter|
@@ -94,10 +94,12 @@ module Transpec
 
         # Need to register record after all source rewrites are done
         # to avoid false record when failed with overlapped rewrite.
+        accurate = !arg_is_enumerable?.nil?
+
         if arg_is_enumerable?
-          register_record('=~ [1, 2]', 'match_array([1, 2])')
+          register_record('=~ [1, 2]', 'match_array([1, 2])', accurate)
         else
-          register_record('=~ /pattern/', 'match(/pattern/)')
+          register_record('=~ /pattern/', 'match(/pattern/)', accurate)
         end
       end
 
@@ -110,9 +112,14 @@ module Transpec
       end
 
       def arg_is_enumerable?
-        return true if arg_node.array_type?
-        node_data = runtime_node_data(arg_node)
-        node_data && node_data[:arg_is_enumerable?].result
+        case arg_node.type
+        when :array
+          true
+        when :regexp
+          false
+        else
+          runtime_data[arg_node, :arg_is_enumerable?]
+        end
       end
 
       def parenthesize_single_line!(always)
@@ -128,7 +135,7 @@ module Transpec
 
       def parenthesize_multi_line!(linefeed)
         insert_before(range_in_between_selector_and_arg, '(')
-        matcher_line_indentation = indentation_of_line(@node)
+        matcher_line_indentation = indentation_of_line(node)
         right_parenthesis = "#{linefeed}#{matcher_line_indentation})"
         insert_after(expression_range, right_parenthesis)
       end
@@ -150,9 +157,18 @@ module Transpec
         end
       end
 
-      def register_record(original_syntax, converted_syntax)
+      def matcher_range
+        if be_node
+          expression_range
+        else
+          selector_range.join(expression_range.end)
+        end
+      end
+
+      def register_record(original_syntax, converted_syntax, accurate = true)
         original_syntax ||= "#{method_name} expected"
-        @report.records << Record.new(original_syntax, converted_syntax)
+        annotation = AccuracyAnnotation.new(matcher_range) unless accurate
+        report.records << Record.new(original_syntax, converted_syntax, annotation)
       end
     end
   end

data/lib/transpec/syntax/pending.rb

@@ -0,0 +1,110 @@
+# coding: utf-8
+
+require 'transpec/syntax'
+require 'transpec/syntax/mixin/send'
+require 'transpec/util'
+
+module Transpec
+  class Syntax
+    class Pending < Syntax
+      include Mixin::Send, Util
+
+      def self.conversion_target_node?(node, runtime_data = nil)
+        return false unless target_node?(node, runtime_data)
+
+        # 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 && runtime_data.run?(node)
+          # If we have runtime data, check with it.
+          runtime_data[node, :example_context?]
+        else
+          # Otherwise check statically.
+          inspector = StaticContextInspector.new(node)
+          inspector.scopes.last == :example
+        end
+      end
+
+      def self.target_method?(receiver_node, method_name)
+        receiver_node.nil? && method_name == :pending
+      end
+
+      define_dynamic_analysis_request do |rewriter|
+        code = 'is_a?(RSpec::Core::ExampleGroup)'
+        rewriter.register_request(node, :example_context?, code, :context)
+      end
+
+      def convert_deprecated_syntax!
+        if block_node
+          unblock!
+        else
+          convert_to_skip!
+        end
+      end
+
+      private
+
+      def convert_to_skip!
+        replace(selector_range, 'skip')
+        register_record('pending', 'skip')
+      end
+
+      def unblock!
+        if block_beginning_line == block_body_line
+          range_between_pending_and_body =
+            expression_range.end.join(block_body_node.loc.expression.begin)
+          replace(range_between_pending_and_body, "\n" + indentation_of_line(node))
+        else
+          remove(expression_range.end.join(block_node.loc.begin))
+          outdent!(block_body_node, node)
+        end
+
+        if block_body_line == block_end_line
+          remove(block_body_node.loc.expression.end.join(block_node.loc.end))
+        else
+          remove(line_range(block_node.loc.end))
+        end
+
+        register_record('pending { do_something_fail }', 'pending; do_something_fail')
+      end
+
+      def outdent!(target_node, base_node)
+        indentation_width = indentation_width(target_node, base_node)
+
+        return unless indentation_width > 0
+
+        each_line_range(target_node) do |line_range|
+          remove(line_range.resize(indentation_width))
+        end
+      end
+
+      def indentation_width(target, base)
+        indentation_of_line(target).size - indentation_of_line(base).size
+      end
+
+      def block_node
+        block_node_taken_by_method(node)
+      end
+
+      def block_body_node
+        block_node.children[2]
+      end
+
+      def block_beginning_line
+        block_node.loc.begin.line
+      end
+
+      def block_body_line
+        block_body_node.loc.expression.line
+      end
+
+      def block_end_line
+        block_node.loc.end.line
+      end
+
+      def register_record(original_syntax, converted_syntax)
+        report.records << Record.new(original_syntax, converted_syntax)
+      end
+    end
+  end
+end

data/lib/transpec/syntax/raise_error.rb

@@ -38,7 +38,7 @@ module Transpec
 
         original_syntax << ')'
 
-        @report.records << Record.new(original_syntax, 'expect { }.not_to raise_error')
+        report.records << Record.new(original_syntax, 'expect { }.not_to raise_error')
       end
     end
   end

data/lib/transpec/syntax/receive.rb

@@ -17,22 +17,22 @@ module Transpec
       def remove_useless_and_return!
         removed = super
         return unless removed
-        @report.records << ReceiveUselessAndReturnRecord.new(self)
+        report.records << ReceiveUselessAndReturnRecord.new(self)
       end
 
       def add_receiver_arg_to_any_instance_implementation_block!
         added = super
         return unless added
-        @report.records << ReceiveAnyInstanceBlockRecord.new(self)
+        report.records << ReceiveAnyInstanceBlockRecord.new(self)
       end
 
       def any_instance?
-        @expectation.any_instance?
+        expectation.any_instance?
       end
 
       def any_instance_block_node
         return unless any_instance?
-        super || @expectation.block_node
+        super || expectation.block_node
       end
 
       class ReceiveAnyInstanceBlockRecord < AnyInstanceBlockRecord

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

@@ -9,7 +9,7 @@ module Transpec
       class Framework
         include Util, ::AST::Sexp
 
-        attr_reader :rspec_configure
+        attr_reader :rspec_configure, :source_rewriter
 
         def initialize(rspec_configure, source_rewriter)
           @rspec_configure = rspec_configure
@@ -27,7 +27,7 @@ module Transpec
 
           if setter_node
             arg_node = setter_node.children[2]
-            @source_rewriter.replace(arg_node.loc.expression, value.to_s)
+            source_rewriter.replace(arg_node.loc.expression, value.to_s)
           else
             add_configuration!(config_name, value)
           end
@@ -77,7 +77,7 @@ module Transpec
             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(''))
+            source_rewriter.insert_before(insertion_position, lines.join(''))
           end
 
           def config_variable_name

data/lib/transpec/syntax/should.rb

@@ -35,7 +35,7 @@ module Transpec
       end
 
       def expectize!(negative_form = 'not_to', parenthesize_matcher_arg = true)
-        fail ContextError.new(selector_range, "##{method_name}", '#expect') unless expect_available?
+        fail ContextError.new("##{method_name}", '#expect', selector_range) unless expect_available?
 
         if proc_literal?(subject_node)
           replace(range_of_subject_method_taking_block, 'expect')
@@ -74,7 +74,7 @@ module Transpec
           converted_syntax << negative_form_of_to
         end
 
-        @report.records << Record.new(original_syntax, converted_syntax)
+        report.records << Record.new(original_syntax, converted_syntax)
       end
     end
   end

data/lib/transpec/syntax/should_receive.rb

@@ -45,7 +45,7 @@ module Transpec
 
       def expectize!(negative_form = 'not_to')
         unless expect_to_receive_available?
-          fail ContextError.new(selector_range, "##{method_name}", '#expect')
+          fail ContextError.new("##{method_name}", '#expect', selector_range)
         end
 
         convert_to_syntax!('expect', negative_form)
@@ -56,7 +56,7 @@ module Transpec
         return unless useless_expectation?
 
         unless allow_to_receive_available?
-          fail ContextError.new(selector_range, "##{method_name}", '#allow')
+          fail ContextError.new("##{method_name}", '#allow', selector_range)
         end
 
         convert_to_syntax!('allow', negative_form)
@@ -157,7 +157,7 @@ module Transpec
       end
 
       def register_record(record_class, negative_form_of_to = nil)
-        @report.records << record_class.new(self, negative_form_of_to)
+        report.records << record_class.new(self, negative_form_of_to)
       end
 
       class ExpectBaseRecord < Record

data/lib/transpec/util.rb

@@ -12,6 +12,14 @@ module Transpec
 
     module_function
 
+    def node_id(node)
+      source_range = node.loc.expression
+      source_buffer = source_range.source_buffer
+      absolute_path = File.expand_path(source_buffer.name)
+      relative_path = Pathname.new(absolute_path).relative_path_from(Pathname.pwd).to_s
+      [relative_path, source_range.begin_pos, source_range.end_pos].join('_')
+    end
+
     def proc_literal?(node)
       return false unless node.block_type?
 
@@ -133,16 +141,40 @@ module Transpec
     end
 
     def beginning_of_line_range(arg)
-      range = case arg
-              when AST::Node             then arg.loc.expression
-              when Parser::Source::Range then arg
-              else fail ArgumentError, "Invalid argument #{arg}"
-              end
-
+      range = range_from_arg(arg)
       begin_pos = range.begin_pos - range.column
       Parser::Source::Range.new(range.source_buffer, begin_pos, begin_pos)
     end
 
+    def end_of_line_range(arg)
+      range = range_from_arg(arg)
+      begin_pos = beginning_of_line_range(range).begin_pos + range.source_line.size
+      Parser::Source::Range.new(range.source_buffer, begin_pos, begin_pos)
+    end
+
+    def line_range(arg)
+      range = range_from_arg(arg)
+      beginning_of_line_range(range).resize(range.source_line.size + 1)
+    end
+
+    def each_line_range(arg)
+      multiline_range = range_from_arg(arg)
+      range = line_range(multiline_range)
+
+      while range.line <= multiline_range.end.line
+        yield range
+        range = line_range(range.end)
+      end
+    end
+
+    def range_from_arg(arg)
+      case arg
+      when AST::Node             then arg.loc.expression
+      when Parser::Source::Range then arg
+      else fail ArgumentError, "Invalid argument #{arg}"
+      end
+    end
+
     def literal?(node)
       case node.type
       when *LITERAL_TYPES