transpec 0.1.3 → 0.2.0

data/lib/transpec/rewriter.rb

@@ -1,5 +1,6 @@
 # coding: utf-8
 
+require 'transpec/report'
 require 'transpec/ast/builder'
 require 'transpec/ast/scanner'
 require 'transpec/configuration'
@@ -16,11 +17,12 @@ require 'parser/current'
 
 module Transpec
   class Rewriter
-    attr_reader :errors
+    attr_reader :report, :invalid_context_errors
 
-    def initialize(configuration = Configuration.new)
+    def initialize(configuration = Configuration.new, report = Report.new)
       @configuration = configuration
-      @errors = []
+      @report = report
+      @invalid_context_errors = []
     end
 
     def rewrite_file!(file_path)
@@ -35,7 +37,10 @@ module Transpec
 
       @source_rewriter = Parser::Source::Rewriter.new(source_buffer)
       failed_overlapping_rewrite = false
-      @source_rewriter.diagnostics.consumer = proc { failed_overlapping_rewrite = true }
+      @source_rewriter.diagnostics.consumer = proc do
+        failed_overlapping_rewrite = true
+        fail OverlappedRewriteError
+      end
 
       AST::Scanner.scan(ast) do |node, ancestor_nodes|
         dispatch_node(node, ancestor_nodes)
@@ -44,7 +49,7 @@ module Transpec
       rewritten_source = @source_rewriter.process
 
       if failed_overlapping_rewrite
-        rewriter = self.class.new(@configuration)
+        rewriter = self.class.new(@configuration, @report)
         rewritten_source = rewriter.rewrite(rewritten_source, name)
       end
 
@@ -71,7 +76,8 @@ module Transpec
         syntax = syntax_class.new(
           node,
           ancestor_nodes,
-          @source_rewriter
+          @source_rewriter,
+          @report
         )
 
         handler_name = "process_#{syntax_class.snake_case_name}"
@@ -79,8 +85,9 @@ module Transpec
 
         break
       end
-    rescue Syntax::NotInExampleGroupContextError => error
-      @errors << error
+    rescue OverlappedRewriteError # rubocop:disable HandleExceptions
+    rescue Syntax::InvalidContextError => error
+      @invalid_context_errors << error
     end
 
     def process_should(should)
@@ -152,5 +159,7 @@ module Transpec
                       !@configuration.convert_to_allow_to_receive?
       rspec_configure.mock_syntaxes == [:should]
     end
+
+    class OverlappedRewriteError < StandardError; end
   end
 end

data/lib/transpec/syntax.rb

@@ -1,30 +1,12 @@
 # coding: utf-8
 
 require 'transpec/context'
+require 'transpec/report'
+require 'transpec/record'
 
 module Transpec
   class Syntax
-    class NotInExampleGroupContextError < StandardError
-      attr_reader :message, :source_range
-
-      def initialize(source_range, original_syntax, target_syntax)
-        @source_range = source_range
-        @message = build_message(original_syntax, target_syntax)
-      end
-
-      def source_buffer
-        @source_range.source_buffer
-      end
-
-      private
-
-      def build_message(original_syntax, target_syntax)
-        "Cannot convert #{original_syntax} into #{target_syntax} " +
-        "since #{target_syntax} is not available in the context."
-      end
-    end
-
-    attr_reader :node, :ancestor_nodes, :source_rewriter
+    attr_reader :node, :ancestor_nodes, :source_rewriter, :report
 
     def self.all
       @subclasses ||= []
@@ -48,10 +30,11 @@ module Transpec
       target_method_names.include?(method_name)
     end
 
-    def initialize(node, ancestor_nodes, source_rewriter)
+    def initialize(node, ancestor_nodes, source_rewriter, report = Report.new)
       @node = node
       @ancestor_nodes = ancestor_nodes
       @source_rewriter = source_rewriter
+      @report = report
     end
 
     def context
@@ -91,5 +74,25 @@ module Transpec
     def replace(range, content)
       @source_rewriter.replace(range, content)
     end
+
+    class InvalidContextError < StandardError
+      attr_reader :message, :source_range
+
+      def initialize(source_range, original_syntax, target_syntax)
+        @source_range = source_range
+        @message = build_message(original_syntax, target_syntax)
+      end
+
+      def source_buffer
+        @source_range.source_buffer
+      end
+
+      private
+
+      def build_message(original_syntax, target_syntax)
+        "Cannot convert #{original_syntax} into #{target_syntax} " +
+        "since #{target_syntax} is not available in the context."
+      end
+    end
   end
 end

data/lib/transpec/syntax/be_close.rb

@@ -16,6 +16,8 @@ module Transpec
         be_within_source << ')'
 
         replace(expression_range, be_within_source)
+
+        register_record
       end
 
       private
@@ -27,6 +29,10 @@ module Transpec
       def self.target_method_names
         [:be_close]
       end
+
+      def register_record
+        @report.records << Record.new('be_close(expected, delta)', 'be_within(delta).of(expected)')
+      end
     end
   end
 end

data/lib/transpec/syntax/double.rb

@@ -11,6 +11,7 @@ module Transpec
       def convert_to_double!
         return if method_name == :double
         replace(selector_range, 'double')
+        register_record
       end
 
       private
@@ -22,6 +23,10 @@ module Transpec
       def self.target_method_names
         [:double, :mock, :stub]
       end
+
+      def register_record
+        @report.records << Record.new("#{method_name}('something')", "double('something')")
+      end
     end
   end
 end

data/lib/transpec/syntax/matcher.rb

@@ -13,9 +13,10 @@ module Transpec
         false
       end
 
-      def initialize(node, source_rewriter)
+      def initialize(node, source_rewriter, report = Report.new)
         @node = node
         @source_rewriter = source_rewriter
+        @report = report
       end
 
       def correct_operator!(parenthesize_arg = true)
@@ -47,11 +48,13 @@ module Transpec
         handle_anterior_of_operator!
         replace(selector_range, 'eq')
         parenthesize!(parenthesize_arg)
+        register_record(nil, 'eq(expected)')
       end
 
       def convert_to_be_operator!
         return if prefixed_with_be?
         insert_before(selector_range, 'be ')
+        register_record(nil, "be #{method_name} expected")
       end
 
       def convert_to_match!(parenthesize_arg)
@@ -64,6 +67,14 @@ module Transpec
         end
 
         parenthesize!(parenthesize_arg)
+
+        # Need to register record after all source rewrites are done
+        # to avoid false record when failed with overlapped rewrite.
+        if arg_node.type == :array
+          register_record('=~ [1, 2]', 'match_array([1, 2])')
+        else
+          register_record('=~ /pattern/', 'match(/pattern/)')
+        end
       end
 
       def handle_anterior_of_operator!
@@ -113,6 +124,11 @@ module Transpec
         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)
+      end
     end
   end
 end

data/lib/transpec/syntax/method_stub.rb

@@ -23,7 +23,7 @@ module Transpec
         fail 'Already replaced deprecated method, cannot allowize.' if @replaced_deprecated_method
 
         unless context.in_example_group?
-          fail NotInExampleGroupContextError.new(selector_range, "##{method_name}", '#allow')
+          fail InvalidContextError.new(selector_range, "##{method_name}", '#allow')
         end
 
         if arg_node.type == :hash
@@ -34,20 +34,19 @@ module Transpec
           replace(expression_range, expression)
         end
 
+        register_record(:allow)
+
         @allowized = true
       end
 
       def replace_deprecated_method!
-        replacement_method_name = case method_name
-                                  when :stub!   then 'stub'
-                                  when :unstub! then 'unstub'
-                                  end
-
-        return unless replacement_method_name
+        return unless replacement_method_for_deprecated_method
 
         fail 'Already allowized, cannot replace deprecated method.' if @allowized
 
-        replace(selector_range, replacement_method_name)
+        replace(selector_range, replacement_method_for_deprecated_method)
+
+        register_record(:deprecated)
 
         @replaced_deprecated_method = true
       end
@@ -107,6 +106,39 @@ module Transpec
         message_source.prepend(':') if node.type == :sym && !message_source.start_with?(':')
         message_source
       end
+
+      def replacement_method_for_deprecated_method
+        case method_name
+        when :stub!   then 'stub'
+        when :unstub! then 'unstub'
+        else nil
+        end
+      end
+
+      def register_record(conversion_type)
+        @report.records << Record.new(original_syntax, converted_syntax(conversion_type))
+      end
+
+      def original_syntax
+        syntax = any_instance? ? 'SomeClass.any_instance' : 'obj'
+        syntax << ".#{method_name}"
+        syntax << (arg_node.type == :hash ? '(:message => value)' : '(:message)')
+      end
+
+      def converted_syntax(conversion_type)
+        case conversion_type
+        when :allow
+          syntax = any_instance? ? 'allow_any_instance_of(SomeClass)' : 'allow(obj)'
+          syntax << '.to receive(:message)'
+          syntax << '.and_return(value)' if arg_node.type == :hash
+        when :deprecated
+          syntax = 'obj.'
+          syntax << replacement_method_for_deprecated_method
+          syntax << '(:message)'
+        end
+
+        syntax
+      end
     end
   end
 end

data/lib/transpec/syntax/raise_error.rb

@@ -15,6 +15,8 @@ module Transpec
         return if arg_nodes.empty?
 
         remove(parentheses_range)
+
+        register_record
       end
 
       def positive?
@@ -31,6 +33,21 @@ module Transpec
       def self.target_method_names
         [:raise_error]
       end
+
+      def register_record
+        original_syntax = 'expect { }.not_to raise_error('
+
+        if arg_nodes.first.type == :const
+          original_syntax << 'SpecificErrorClass'
+          original_syntax << ', message' if arg_nodes.count >= 2
+        else
+          original_syntax << 'message'
+        end
+
+        original_syntax << ')'
+
+        @report.records << Record.new(original_syntax, 'expect { }.not_to raise_error')
+      end
     end
   end
 end

data/lib/transpec/syntax/send_node_syntax.rb

@@ -19,6 +19,10 @@ module Transpec
         @node.children[2]
       end
 
+      def arg_nodes
+        @node.children[2..-1]
+      end
+
       def selector_range
         @node.loc.selector
       end

data/lib/transpec/syntax/should.rb

@@ -16,7 +16,7 @@ module Transpec
 
       def expectize!(negative_form = 'not_to', parenthesize_matcher_arg = true)
         unless context.in_example_group?
-          fail NotInExampleGroupContextError.new(selector_range, "##{method_name}", '#expect')
+          fail InvalidContextError.new(selector_range, "##{method_name}", '#expect')
         end
 
         if proc_literal?(subject_node)
@@ -27,11 +27,13 @@ module Transpec
 
         replace(should_range, positive? ? 'to' : negative_form)
 
+        register_record(negative_form)
+
         matcher.correct_operator!(parenthesize_matcher_arg)
       end
 
       def matcher
-        @matcher ||= Matcher.new(matcher_node, @source_rewriter)
+        @matcher ||= Matcher.new(matcher_node, @source_rewriter, @report)
       end
 
       def matcher_node
@@ -61,6 +63,25 @@ module Transpec
           selector_range.join(expression_range.end)
         end
       end
+
+      def register_record(negative_form_of_to)
+        if proc_literal?(subject_node)
+          original_syntax = 'lambda { }.should'
+          converted_syntax = 'expect { }.'
+        else
+          original_syntax = 'obj.should'
+          converted_syntax = 'expect(obj).'
+        end
+
+        if positive?
+          converted_syntax << 'to'
+        else
+          original_syntax << '_not'
+          converted_syntax << negative_form_of_to
+        end
+
+        @report.records << Record.new(original_syntax, converted_syntax)
+      end
     end
   end
 end

data/lib/transpec/syntax/should_receive.rb

@@ -18,6 +18,7 @@ module Transpec
 
       def expectize!(negative_form = 'not_to')
         convert_to_syntax!('expect', negative_form)
+        register_record(:expect, negative_form)
       end
 
       def allowize_useless_expectation!(negative_form = 'not_to')
@@ -25,20 +26,24 @@ module Transpec
 
         convert_to_syntax!('allow', negative_form)
         remove_allowance_for_no_message!
+
+        register_record(:allow, negative_form)
       end
 
-      def stubize_useless_expectation!(negative_form = 'not_to')
+      def stubize_useless_expectation!
         return unless useless_expectation?
 
         replace(selector_range, 'stub')
         remove_allowance_for_no_message!
+
+        register_record(:stub)
       end
 
       private
 
       def convert_to_syntax!(syntax, negative_form)
         unless context.in_example_group?
-          fail NotInExampleGroupContextError.new(selector_range, "##{method_name}", "##{syntax}")
+          fail InvalidContextError.new(selector_range, "##{method_name}", "##{syntax}")
         end
 
         if any_instance?
@@ -121,6 +126,53 @@ module Transpec
           return child_node if child_node.type == :block
         end
       end
+
+      def register_record(conversion_type, negative_form_of_to = nil)
+        @report.records << Record.new(
+          original_syntax(conversion_type),
+          converted_syntax(conversion_type, negative_form_of_to)
+        )
+      end
+
+      def original_syntax(conversion_type)
+        syntax = if any_instance? && conversion_type != :stub
+                  'SomeClass.any_instance.'
+                 else
+                  'obj.'
+                 end
+
+        syntax << (positive? ? 'should_receive' : 'should_not_receive')
+        syntax << '(:message)'
+
+        if [:allow, :stub].include?(conversion_type)
+          syntax << '.any_number_of_times' if any_number_of_times?
+          syntax << '.at_least(0)' if at_least_zero?
+        end
+
+        syntax
+      end
+
+      def converted_syntax(conversion_type, negative_form_of_to)
+        return 'obj.stub(:message)' if conversion_type == :stub
+
+        syntax = case conversion_type
+                 when :expect
+                   if any_instance?
+                     'expect_any_instance_of(SomeClass).'
+                   else
+                     'expect(obj).'
+                   end
+                 when :allow
+                   if any_instance?
+                     'allow_any_instance_of(SomeClass).'
+                   else
+                     'allow(obj).'
+                   end
+                 end
+
+        syntax << (positive? ? 'to' : negative_form_of_to)
+        syntax << ' receive(:message)'
+      end
     end
   end
 end