transpec 1.9.3 → 1.10.0

data/lib/transpec/syntax/double.rb

@@ -21,7 +21,7 @@ module Transpec
       private
 
       def register_record
-        @report.records << Record.new("#{method_name}('something')", "double('something')")
+        report.records << Record.new("#{method_name}('something')", "double('something')")
       end
     end
   end

data/lib/transpec/syntax/example.rb

@@ -3,89 +3,95 @@
 require 'transpec/syntax'
 require 'transpec/syntax/mixin/send'
 require 'transpec/rspec_dsl'
-require 'transpec/util'
 
 module Transpec
   class Syntax
     class Example < Syntax
-      include Mixin::Send, RSpecDSL, Util
+      include Mixin::Send, RSpecDSL
 
-      METHODS_YIELD_EXAMPLE = (EXAMPLE_METHODS + HOOK_METHODS + HELPER_METHODS).freeze
+      def self.conversion_target_node?(node, runtime_data = nil)
+        return false unless target_node?(node, runtime_data)
 
-      def self.target_node?(node, runtime_data = nil)
-        receiver_node, method_name, *_ = *node
-        return false if receiver_node
-        return false unless [:example, :running_example].include?(method_name)
-        return false if Util.block_node_taken_by_method(node)
-        check_target_node_dynamically(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_group_context?]
+        else
+          # Otherwise check statically.
+          inspector = StaticContextInspector.new(node)
+          inspector.scopes.last == :example_group
+        end
       end
 
       def self.target_method?(receiver_node, method_name)
-        receiver_node.nil? && [:example, :running_example].include?(method_name)
+        receiver_node.nil? && EXAMPLE_METHODS.include?(method_name)
       end
 
-      def convert!
-        if block_node
-          insert_after(block_node.loc.begin, " |#{block_arg_name}|") unless block_has_argument?
-          replace(selector_range, block_arg_name.to_s) unless method_name == block_arg_name
-          block_node.metadata[:added_example_block_arg] = true
-        else
-          replace(selector_range, 'RSpec.current_example')
-        end
-
-        register_record
+      define_dynamic_analysis_request do |rewriter|
+        code = "is_a?(Class) && ancestors.any? { |a| a.name == 'RSpec::Core::ExampleGroup' }"
+        rewriter.register_request(node, :example_group_context?, code, :context)
       end
 
-      private
-
-      def block_has_argument?
-        block_arg_node || block_node.metadata[:added_example_block_arg]
+      def convert_pending_to_skip!
+        convert_pending_selector_to_skip!
+        convert_pending_metadata_to_skip!
       end
 
-      def block_node
-        return @block_node if instance_variable_defined?(:@block_node)
-
-        @block_node ||= @node.each_ancestor_node.find do |ancestor_node|
-          next false unless ancestor_node.block_type?
-          method_name = method_name_of_block_node(ancestor_node)
-          METHODS_YIELD_EXAMPLE.include?(method_name)
+      def metadata_key_nodes
+        metadata_nodes.each_with_object([]) do |node, key_nodes|
+          if node.hash_type?
+            key_nodes.concat(node.children.map { |pair_node| pair_node.children.first })
+          else
+            key_nodes << node
+          end
         end
       end
 
-      def block_method_name
-        method_name_of_block_node(block_node)
-      end
+      private
 
-      def block_arg_node
-        args_node = block_node.children[1]
-        args_node.children.first
+      def convert_pending_selector_to_skip!
+        return unless method_name == :pending
+        replace(selector_range, 'skip')
+        register_record("pending 'is an example' { }", "skip 'is an example' { }")
       end
 
-      def block_arg_name
-        if block_arg_node
-          block_arg_node.children.first
-        else
-          :example
+      def convert_pending_metadata_to_skip!
+        metadata_key_nodes.each do |node|
+          next unless pending_symbol?(node)
+          replace(symbol_range_without_colon(node), 'skip')
+          if node.parent_node.pair_type?
+            register_record("it 'is an example', :pending => value { }",
+                            "it 'is an example', :skip => value { }")
+          else
+            register_record("it 'is an example', :pending { }",
+                            "it 'is an example', :skip { }")
+          end
         end
       end
 
-      def method_name_of_block_node(block_node)
-        send_node = block_node.children.first
-        send_node.children[1]
+      def pending_symbol?(node)
+        return false unless node.sym_type?
+        key = node.children.first
+        key == :pending
       end
 
-      def register_record
-        if block_node
-          prefix = "#{block_method_name}"
-          prefix << '(:name)' if HELPER_METHODS.include?(block_method_name)
-          original_syntax = "#{prefix} { example }"
-          converted_syntax = "#{prefix} { |example| example }"
+      def symbol_range_without_colon(node)
+        range = node.loc.expression
+        if range.source.start_with?(':')
+          Parser::Source::Range.new(range.source_buffer, range.begin_pos + 1, range.end_pos)
         else
-          original_syntax = 'def helper_method example; end'
-          converted_syntax = 'def helper_method RSpec.current_example; end'
+          range
         end
+      end
+
+      def metadata_nodes
+        arg_nodes[1..-1] || []
+      end
 
-        @report.records << Record.new(original_syntax, converted_syntax)
+      def register_record(original_syntax, converted_syntax)
+        report.records << Record.new(original_syntax, converted_syntax)
       end
     end
   end

data/lib/transpec/syntax/have.rb

@@ -60,12 +60,12 @@ module Transpec
       end
 
       def project_requires_collection_matcher?
-        runtime_subject_data && runtime_subject_data[:project_requires_collection_matcher?].result
+        runtime_subject_data(:project_requires_collection_matcher?)
       end
 
       def collection_accessor
-        if runtime_subject_data && runtime_subject_data[:collection_accessor].result
-          runtime_subject_data[:collection_accessor].result.to_sym
+        if runtime_subject_data(:collection_accessor)
+          runtime_subject_data(:collection_accessor).to_sym
         else
           items_name
         end
@@ -73,16 +73,15 @@ module Transpec
 
       def subject_is_owner_of_collection?
         return true if items_method_has_arguments?
-        runtime_subject_data && !runtime_subject_data[:collection_accessor].result.nil?
+        !runtime_subject_data(:collection_accessor).nil?
       end
 
       def collection_accessor_is_private?
-        runtime_subject_data && runtime_subject_data[:collection_accessor_is_private?].result
+        runtime_subject_data(:collection_accessor_is_private?)
       end
 
       def query_method
-        if runtime_subject_data && runtime_subject_data[:available_query_methods]
-          available_query_methods = runtime_subject_data[:available_query_methods].result
+        if (available_query_methods = runtime_subject_data(:available_query_methods))
           (QUERY_METHOD_PRIORITIES & available_query_methods.map(&:to_sym)).first
         else
           default_query_method
@@ -102,24 +101,37 @@ module Transpec
         size_node.loc.expression.source
       end
 
+      def accurate_conversion?
+        !runtime_subject_data.nil?
+      end
+
+      def matcher_range
+        expression_range.join(items_node.loc.expression)
+      end
+
       private
 
       def source_builder
         @source_builder ||= SourceBuilder.new(self, size_source)
       end
 
-      def runtime_subject_data
-        return @runtime_subject_data if instance_variable_defined?(:@runtime_subject_data)
-        node = explicit_subject? ? expectation.subject_node : expectation.node
-        @runtime_subject_data = runtime_node_data(node)
-      end
+      def runtime_subject_data(key = nil)
+        unless instance_variable_defined?(:@runtime_subject_data)
+          node = explicit_subject? ? expectation.subject_node : expectation.node
+          @runtime_subject_data = runtime_data[node]
+        end
 
-      def matcher_range
-        expression_range.join(items_node.loc.expression)
+        return @runtime_subject_data unless key
+
+        if @runtime_subject_data
+          @runtime_subject_data[key]
+        else
+          nil
+        end
       end
 
       def register_record
-        @report.records << HaveRecord.new(self)
+        report.records << HaveRecord.new(self)
       end
     end
   end

data/lib/transpec/syntax/have/have_record.rb

@@ -28,6 +28,18 @@ module Transpec
           end
         end
 
+        def annotation
+          return @annotation if instance_variable_defined?(:@annotation)
+
+          @annotation = if have.accurate_conversion?
+                          nil
+                        else
+                          AccuracyAnnotation.new(have.matcher_range)
+                        end
+        end
+
+        private
+
         def build_expectation(subject, type)
           case type
           when :should

data/lib/transpec/syntax/have/source_builder.rb

@@ -35,22 +35,6 @@ module Transpec
           source << ".#{have.query_method}"
         end
 
-        def base_subject_source(node)
-          if node.send_type? && (arg_node = node.children[2])
-            left_of_arg_source = node.loc.selector.end.join(arg_node.loc.expression.begin).source
-
-            if left_of_arg_source.match(/\A\s*\Z/)
-              source = node.loc.expression.begin.join(node.loc.selector.end).source
-              source << '('
-              source << arg_node.loc.expression.begin.join(node.loc.expression.end).source
-              source << ')'
-              return source
-            end
-          end
-
-          node.loc.expression.source
-        end
-
         def replacement_matcher_source(parenthesize_arg = true)
           case have.expectation.current_syntax_type
           when :should
@@ -60,6 +44,24 @@ module Transpec
           end
         end
 
+        private
+
+        def base_subject_source(node)
+          map = node.loc
+          source = map.expression.source
+
+          if node.send_type? && (arg_node = node.children[2])
+            left_of_arg_range = map.selector.end.join(arg_node.loc.expression.begin)
+            unless left_of_arg_range.source.include?('(')
+              relative_index = left_of_arg_range.begin_pos - map.expression.begin_pos
+              source[relative_index, left_of_arg_range.length] = '('
+              source << ')'
+            end
+          end
+
+          source
+        end
+
         def replacement_matcher_source_for_should
           case have.method_name
           when :have, :have_exactly then "== #{size_source}"

data/lib/transpec/syntax/its.rb

@@ -16,7 +16,7 @@ module Transpec
       define_dynamic_analysis_request do |rewriter|
         key = :project_requires_its?
         code = 'defined?(RSpec::Its)'
-        rewriter.register_request(@node, key, code, :context)
+        rewriter.register_request(node, key, code, :context)
       end
 
       def convert_to_describe_subject_it!
@@ -42,12 +42,11 @@ module Transpec
       alias_method :attribute_node, :arg_node
 
       def block_node
-        @node.parent_node
+        node.parent_node
       end
 
       def project_requires_its?
-        node_data = runtime_node_data(@node)
-        node_data && node_data[:project_requires_its?].result
+        runtime_data[node, :project_requires_its?]
       end
 
       private
@@ -89,11 +88,11 @@ module Transpec
       end
 
       def base_indentation
-        @base_indentation ||= indentation_of_line(@node)
+        @base_indentation ||= indentation_of_line(node)
       end
 
       def register_record
-        @report.records << Record.new(original_syntax, converted_syntax)
+        report.records << Record.new(original_syntax, converted_syntax)
       end
 
       def original_syntax
@@ -113,16 +112,18 @@ module Transpec
       end
 
       class AttributeExpression
+        attr_reader :node
+
         def initialize(node)
           @node = node
         end
 
         def brackets?
-          @node.array_type?
+          node.array_type?
         end
 
         def literal?
-          Util.literal?(@node)
+          Util.literal?(node)
         end
 
         def attributes
@@ -136,20 +137,20 @@ module Transpec
         private
 
         def brackets_attributes
-          selector = @node.loc.expression.source
+          selector = node.loc.expression.source
           description = literal? ? quote(selector) : selector
           [Attribute.new(selector, description)]
         end
 
         def non_brackets_attributes
           if literal?
-            expression = @node.children.first.to_s
+            expression = node.children.first.to_s
             chained_names = expression.split('.')
             chained_names.map do |name|
               Attribute.new(".#{name}", quote("##{name}"))
             end
           else
-            source = @node.loc.expression.source
+            source = node.loc.expression.source
             selector = ".send(#{source})"
             [Attribute.new(selector, source)]
           end

data/lib/transpec/syntax/matcher_definition.rb

@@ -23,7 +23,7 @@ module Transpec
         replacement_method_name = CONVERSION_CORRESPONDENCE[method_name].to_s
         replace(selector_range, replacement_method_name)
 
-        @report.records << Record.new("#{method_name} { }", "#{replacement_method_name} { }")
+        report.records << Record.new("#{method_name} { }", "#{replacement_method_name} { }")
       end
     end
   end

data/lib/transpec/syntax/method_stub.rb

@@ -19,10 +19,6 @@ module Transpec
       ]
       # rubocop:enable LineLength
 
-      def self.dynamic_analysis_target_node?(node)
-        target_node?(node)
-      end
-
       def self.conversion_target_node?(node, runtime_data = nil)
         return false unless check_target_node_statically(node)
 
@@ -64,7 +60,7 @@ module Transpec
         return if method_name == :stub_chain && !rspec_version.receive_message_chain_available?
 
         unless allow_to_receive_available?
-          fail ContextError.new(selector_range, "##{method_name}", '#allow')
+          fail ContextError.new("##{method_name}", '#allow', selector_range)
         end
 
         source, type = replacement_source_and_conversion_type(rspec_version)
@@ -121,7 +117,7 @@ module Transpec
         hash_node.children.each_with_index do |pair_node, index|
           key_node, value_node = *pair_node
           expression = build_allow_to_receive(key_node, value_node, false)
-          expression.prepend(indentation_of_line(@node)) if index > 0
+          expression.prepend(indentation_of_line(node)) if index > 0
           expressions << expression
         end
 
@@ -182,7 +178,7 @@ module Transpec
                        else
                          AllowRecord
                        end
-        @report.records << record_class.new(self, conversion_type)
+        report.records << record_class.new(self, conversion_type)
       end
 
       class AllowRecord < Record

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

@@ -25,7 +25,7 @@ module Transpec
                 return instance_variable_get(matcher_ivar_name)
               end
 
-              if matcher_class.conversion_target_node?(matcher_node, @runtime_data)
+              if matcher_class.conversion_target_node?(matcher_node, runtime_data)
                 instance_variable_set(matcher_ivar_name, send(matcher_creator_name))
               else
                 instance_variable_set(matcher_ivar_name, nil)
@@ -33,7 +33,7 @@ module Transpec
             end
 
             define_method(matcher_creator_name) do
-              matcher_class.new(matcher_node, self, @source_rewriter, @runtime_data, @report)
+              matcher_class.new(matcher_node, self, source_rewriter, runtime_data, report)
             end
           end
         end