transpec 2.2.5 → 2.3.0

data/lib/transpec/syntax/matcher_definition.rb

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

data/lib/transpec/syntax/method_stub.rb

@@ -71,29 +71,37 @@ module Transpec
 
         replace(expression_range, source)
 
-        add_record(type)
+        add_record(AllowRecordBuilder.build(self, type))
       end
 
       def convert_deprecated_method!
-        return unless replacement_method_for_deprecated_method
-
-        replace(selector_range, replacement_method_for_deprecated_method)
-
-        add_record(:deprecated)
+        return unless replacement_for_deprecated_method
+        replace(selector_range, replacement_for_deprecated_method)
+        add_record(DeprecatedMethodRecordBuilder.build(self))
       end
 
       def remove_no_message_allowance!
         return unless allow_no_message?
         super
-        add_record(:no_message_allowance)
+        add_record(NoMessageAllowanceRecordBuilder.build(self))
       end
 
       def remove_useless_and_return!
-        super && add_record(:useless_and_return)
+        return unless super
+        add_record(Mixin::UselessAndReturn::MonkeyPatchRecordBuilder.build(self))
       end
 
       def add_receiver_arg_to_any_instance_implementation_block!
-        super && add_record(:any_instance_block)
+        return unless super
+        add_record(Mixin::AnyInstanceBlock::MonkeyPatchRecordBuilder.build(self))
+      end
+
+      def replacement_for_deprecated_method
+        case method_name
+        when :stub!   then 'stub'
+        when :unstub! then 'unstub'
+        else nil
+        end
       end
 
       private
@@ -161,51 +169,34 @@ module Transpec
         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 add_record(conversion_type)
-        record_class = case conversion_type
-                       when :deprecated           then DeprecatedMethodRecord
-                       when :no_message_allowance then NoMessageAllowanceRecord
-                       when :useless_and_return   then MonkeyPatchUselessAndReturnRecord
-                       when :any_instance_block   then MonkeyPatchAnyInstanceBlockRecord
-                       else                            AllowRecord
-                       end
-        report.records << record_class.new(self, conversion_type)
-      end
+      class AllowRecordBuilder < RecordBuilder
+        attr_reader :method_stub, :conversion_type
 
-      class AllowRecord < Record
         def initialize(method_stub, conversion_type)
           @method_stub = method_stub
           @conversion_type = conversion_type
         end
 
-        def build_original_syntax
-          syntax = @method_stub.any_instance? ? 'Klass.any_instance' : 'obj'
-          syntax << ".#{@method_stub.method_name}"
+        def old_syntax
+          syntax = method_stub.any_instance? ? 'Klass.any_instance' : 'obj'
+          syntax << ".#{method_stub.method_name}"
 
-          if @method_stub.method_name == :stub_chain
+          if method_stub.method_name == :stub_chain
             syntax << '(:message1, :message2)'
           else
-            syntax << (@method_stub.hash_arg? ? '(:message => value)' : '(:message)')
+            syntax << (method_stub.hash_arg? ? '(:message => value)' : '(:message)')
           end
         end
 
-        def build_converted_syntax
-          syntax = @method_stub.any_instance? ? 'allow_any_instance_of(Klass)' : 'allow(obj)'
+        def new_syntax
+          syntax = method_stub.any_instance? ? 'allow_any_instance_of(Klass)' : 'allow(obj)'
           syntax << '.to '
 
-          case @conversion_type
+          case conversion_type
           when :allow_to_receive
             syntax << 'receive(:message)'
-            syntax << '.and_return(value)' if @method_stub.hash_arg?
-            syntax << '.and_call_original' if @method_stub.unstub?
+            syntax << '.and_return(value)' if method_stub.hash_arg?
+            syntax << '.and_call_original' if method_stub.unstub?
           when :allow_to_receive_messages
             syntax << 'receive_messages(:message => value)'
           when :allow_to_receive_message_chain
@@ -216,38 +207,40 @@ module Transpec
         end
       end
 
-      class DeprecatedMethodRecord < Record
-        def initialize(method_stub, *)
+      class DeprecatedMethodRecordBuilder < RecordBuilder
+        attr_reader :method_stub
+
+        def initialize(method_stub)
           @method_stub = method_stub
         end
 
-        def build_original_syntax
-          syntax = @method_stub.any_instance? ? 'Klass.any_instance' : 'obj'
-          syntax << ".#{@method_stub.method_name}(:message)"
+        def old_syntax
+          syntax = method_stub.any_instance? ? 'Klass.any_instance' : 'obj'
+          syntax << ".#{method_stub.method_name}(:message)"
         end
 
-        def build_converted_syntax
+        def new_syntax
           syntax = 'obj.'
-          syntax << @method_stub.send(:replacement_method_for_deprecated_method)
+          syntax << method_stub.replacement_for_deprecated_method
           syntax << '(:message)'
         end
       end
 
-      class NoMessageAllowanceRecord < Record
-        def initialize(method_stub, *)
+      class NoMessageAllowanceRecordBuilder < RecordBuilder
+        attr_reader :method_stub
+
+        def initialize(method_stub)
           @method_stub = method_stub
         end
 
-        private
-
-        def build_original_syntax
+        def old_syntax
           syntax = base_syntax
           syntax << '.any_number_of_times' if @method_stub.any_number_of_times?
           syntax << '.at_least(0)' if @method_stub.at_least_zero?
           syntax
         end
 
-        def build_converted_syntax
+        def new_syntax
           base_syntax
         end
 

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

@@ -36,16 +36,18 @@ module Transpec
           Util.each_backward_chained_node(node).find(&:block_type?)
         end
 
-        class AnyInstanceBlockRecord < Record
-          def initialize(host, *)
+        class RecordBuilder < Transpec::RecordBuilder
+          attr_reader :host
+
+          def initialize(host)
             @host = host
           end
 
-          def build_original_syntax
+          def old_syntax
             "#{base_syntax} { |arg| }"
           end
 
-          def build_converted_syntax
+          def new_syntax
             "#{base_syntax} { |instance, arg| }"
           end
 
@@ -54,9 +56,9 @@ module Transpec
           end
         end
 
-        class MonkeyPatchAnyInstanceBlockRecord < AnyInstanceBlockRecord
+        class MonkeyPatchRecordBuilder < AnyInstanceBlock::RecordBuilder
           def base_syntax
-            "Klass.any_instance.#{@host.method_name}(:message)"
+            "Klass.any_instance.#{host.method_name}(:message)"
           end
         end
       end

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

@@ -48,21 +48,23 @@ module Transpec
           receiver_node.loc.expression.end.join(and_return_node.loc.expression.end)
         end
 
-        class UselessAndReturnRecord < Record
+        class RecordBuilder < Transpec::RecordBuilder
+          attr_reader :host
+
           def initialize(host, *)
             @host = host
           end
 
-          def build_original_syntax
+          def old_syntax
             syntax = base_syntax
             syntax << '.and_return'
-            syntax << ' { value }' if @host.and_return_with_block?
+            syntax << ' { value }' if host.and_return_with_block?
             syntax
           end
 
-          def build_converted_syntax
+          def new_syntax
             syntax = base_syntax
-            syntax << ' { value }' if @host.and_return_with_block?
+            syntax << ' { value }' if host.and_return_with_block?
             syntax
           end
 
@@ -71,9 +73,9 @@ module Transpec
           end
         end
 
-        class MonkeyPatchUselessAndReturnRecord < UselessAndReturnRecord
+        class MonkeyPatchRecordBuilder < UselessAndReturn::RecordBuilder
           def base_syntax
-            "obj.#{@host.method_name}(:message)"
+            "obj.#{host.method_name}(:message)"
           end
         end
       end

data/lib/transpec/syntax/oneliner_should.rb

@@ -3,6 +3,7 @@
 require 'transpec/syntax'
 require 'transpec/syntax/mixin/should_base'
 require 'transpec/syntax/example'
+require 'transpec/syntax/its'
 require 'transpec/util'
 require 'active_support/inflector/methods'
 require 'active_support/inflector/inflections'
@@ -41,7 +42,7 @@ module Transpec
 
         @current_syntax_type = :expect
 
-        add_record(negative_form)
+        add_record(ExpectRecordBuilder.build(self, negative_form))
       end
 
       def convert_have_items_to_standard_should!
@@ -52,7 +53,7 @@ module Transpec
         subject_source = have_matcher.replacement_subject_source('subject')
         insert_before(expression_range, "#{subject_source}.")
 
-        report.records << OnelinerShouldHaveRecord.new(self, have_matcher)
+        add_record(HaveRecordBuilder.build(self, have_matcher))
       end
 
       def convert_have_items_to_standard_expect!(negative_form = 'not_to')
@@ -67,7 +68,7 @@ module Transpec
 
         @current_syntax_type = :expect
 
-        report.records << OnelinerShouldHaveRecord.new(self, have_matcher, negative_form)
+        add_record(HaveRecordBuilder.build(self, have_matcher, negative_form))
       end
 
       def example
@@ -131,25 +132,28 @@ module Transpec
         example.is_a?(Its)
       end
 
-      def add_record(negative_form_of_to)
-        original_syntax = 'it { should'
-        converted_syntax = 'it { is_expected.'
+      class ExpectRecordBuilder < RecordBuilder
+        attr_reader :should, :negative_form_of_to
 
-        if positive?
-          converted_syntax << 'to'
-        else
-          original_syntax << '_not'
-          converted_syntax << negative_form_of_to
+        def initialize(should, negative_form_of_to = nil)
+          @should = should
+          @negative_form_of_to = negative_form_of_to
         end
 
-        [original_syntax, converted_syntax].each do |syntax|
+        def old_syntax
+          syntax = 'it { should'
+          syntax << '_not' unless should.positive?
           syntax << ' ... }'
         end
 
-        report.records << Record.new(original_syntax, converted_syntax)
+        def new_syntax
+          syntax = 'it { is_expected.'
+          syntax << (should.positive? ? 'to' : negative_form_of_to)
+          syntax << ' ... }'
+        end
       end
 
-      class OnelinerShouldHaveRecord < Have::HaveRecord
+      class HaveRecordBuilder < Have::RecordBuilder
         attr_reader :should, :negative_form_of_to
 
         def initialize(should, have, negative_form_of_to = nil)
@@ -158,24 +162,22 @@ module Transpec
           @negative_form_of_to = negative_form_of_to
         end
 
-        private
-
-        def build_original_syntax
+        def old_syntax
           syntax = should.example.description? ? "it '...' do" : 'it {'
-          syntax << " #{should.method_name} #{have.method_name}(n).#{original_items} "
+          syntax << " #{should.method_name} #{have.method_name}(n).#{old_items} "
           syntax << (should.example.description? ? 'end' : '}')
         end
 
-        def build_converted_syntax
-          syntax = converted_description
+        def new_syntax
+          syntax = new_description
           syntax << ' '
-          syntax << converted_expectation
+          syntax << new_expectation
           syntax << ' '
           syntax << source_builder.replacement_matcher_source
           syntax << ' end'
         end
 
-        def converted_description
+        def new_description
           if should.example.description?
             "it '...' do"
           else
@@ -183,17 +185,17 @@ module Transpec
           end
         end
 
-        def converted_expectation
+        def new_expectation
           case should.current_syntax_type
           when :should
-            "#{converted_subject}.#{should.method_name}"
+            "#{new_subject}.#{should.method_name}"
           when :expect
-            "expect(#{converted_subject})." + (should.positive? ? 'to' : negative_form_of_to)
+            "expect(#{new_subject})." + (should.positive? ? 'to' : negative_form_of_to)
           end
         end
 
-        def converted_subject
-          build_converted_subject('subject')
+        def new_subject
+          build_new_subject('subject')
         end
       end
     end

data/lib/transpec/syntax/operator.rb

@@ -157,10 +157,10 @@ module Transpec
         end
       end
 
-      def add_record(original_syntax, converted_syntax, accurate = true)
-        original_syntax ||= "#{method_name} expected"
+      def add_record(old_syntax, new_syntax, accurate = true)
+        old_syntax ||= "#{method_name} expected"
         annotation = AccuracyAnnotation.new(matcher_range) unless accurate
-        report.records << Record.new(original_syntax, converted_syntax, annotation)
+        super(old_syntax, new_syntax, { annotation: annotation })
       end
     end
   end

data/lib/transpec/syntax/pending.rb

@@ -81,10 +81,6 @@ module Transpec
       def range_from_body_end_to_block_close
         block_body_node.loc.expression.end.join(block_node.loc.end)
       end
-
-      def add_record(original_syntax, converted_syntax)
-        report.records << Record.new(original_syntax, converted_syntax)
-      end
     end
   end
 end

data/lib/transpec/syntax/raise_error.rb

@@ -15,30 +15,50 @@ module Transpec
 
       def remove_error_specification_with_negative_expectation!
         return if expectation.positive?
-
-        _receiver_node, _method_name, *arg_nodes = *node
-        return if arg_nodes.empty?
-
+        return unless specific_error?
         remove(parentheses_range)
-
-        add_record
+        add_record(RecordBuilder.build(self))
       end
 
-      private
+      def specific_error?
+        !arg_nodes.empty?
+      end
 
-      def add_record
-        original_syntax = 'expect { }.not_to raise_error('
+      def specific_class?
+        specific_error? && arg_nodes.first.const_type?
+      end
 
-        if arg_nodes.first.const_type?
-          original_syntax << 'SpecificErrorClass'
-          original_syntax << ', message' if arg_nodes.count >= 2
+      def specific_message?
+        if specific_class?
+          arg_nodes.count >= 2
         else
-          original_syntax << 'message'
+          specific_error?
+        end
+      end
+
+      class RecordBuilder < Transpec::RecordBuilder
+        attr_reader :raise_error
+
+        def initialize(raise_error)
+          @raise_error = raise_error
         end
 
-        original_syntax << ')'
+        def old_syntax
+          syntax = 'expect { }.not_to raise_error('
+
+          if raise_error.specific_class?
+            syntax << 'SpecificErrorClass'
+            syntax << ', ' if raise_error.specific_message?
+          end
+
+          syntax << 'message' if raise_error.specific_message?
 
-        report.records << Record.new(original_syntax, 'expect { }.not_to raise_error')
+          syntax << ')'
+        end
+
+        def new_syntax
+          'expect { }.not_to raise_error'
+        end
       end
     end
   end

data/lib/transpec/syntax/receive.rb

@@ -17,13 +17,13 @@ module Transpec
       def remove_useless_and_return!
         removed = super
         return unless removed
-        report.records << ReceiveUselessAndReturnRecord.new(self)
+        add_record(UselessAndReturnRecordBuilder.build(self))
       end
 
       def add_receiver_arg_to_any_instance_implementation_block!
         added = super
         return unless added
-        report.records << ReceiveAnyInstanceBlockRecord.new(self)
+        add_record(AnyInstanceBlockRecordBuilder.build(self))
       end
 
       def any_instance?
@@ -35,15 +35,15 @@ module Transpec
         super || expectation.block_node
       end
 
-      class ReceiveAnyInstanceBlockRecord < AnyInstanceBlockRecord
+      class UselessAndReturnRecordBuilder < Mixin::UselessAndReturn::RecordBuilder
         def base_syntax
-          "#{@host.expectation.method_name}(Klass).to receive(:message)"
+          "#{host.expectation.method_name_for_instance}(obj).to receive(:message)"
         end
       end
 
-      class ReceiveUselessAndReturnRecord < UselessAndReturnRecord
+      class AnyInstanceBlockRecordBuilder < Mixin::AnyInstanceBlock::RecordBuilder
         def base_syntax
-          "#{@host.expectation.method_name_for_instance}(obj).to receive(:message)"
+          "#{host.expectation.method_name}(Klass).to receive(:message)"
         end
       end
     end

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

@@ -15,12 +15,13 @@ module Transpec
 
         private
 
-        def set_config!(config_name, value, comment = nil)
-          setter_node = find_config_node("#{config_name}=")
+        def set_config_value!(config_name, value, comment = nil)
+          config_node = find_config_node("#{config_name}=")
 
-          if setter_node
-            arg_node = setter_node.children[2]
-            source_rewriter.replace(arg_node.loc.expression, value.to_s)
+          if config_node
+            current_value = config_node.children[2].loc.expression.source
+            return if value.to_s == current_value
+            modify_config_value!(config_node, value)
           else
             add_config!(config_name, value, comment)
           end
@@ -39,11 +40,42 @@ module Transpec
           end
         end
 
+        def modify_config_value!(config_node, value)
+          arg_range = config_node.children[2].loc.expression
+          source_rewriter.replace(arg_range, value.to_s)
+
+          config_name = config_node.loc.selector.source
+          old_syntax = config_record_syntax(config_name, arg_range.source)
+          new_syntax = config_record_syntax(config_name, value)
+          add_record(old_syntax, new_syntax, type: :modification)
+        end
+
+        def replace_config!(old_config_name, new_config_name)
+          config_node = find_config_node(old_config_name)
+          return unless config_node
+          new_selector = new_config_name.to_s.sub(/=$/, '')
+          source_rewriter.replace(config_node.loc.selector, new_selector)
+
+          old_syntax = config_record_syntax(old_config_name)
+          new_syntax = config_record_syntax(new_config_name)
+          add_record(old_syntax, new_syntax)
+        end
+
         def block_arg_name
           return nil unless block_node
           first_block_arg_name(block_node)
         end
 
+        def config_record_syntax(config_name, value = nil)
+          selector = config_name.to_s.sub(/=$/, '')
+          syntax = "RSpec.configure { |c| c.#{selector}"
+
+          value = 'something' if config_name.to_s.end_with?('=')
+          syntax << " = #{value}" unless value.nil?
+
+          syntax << ' }'
+        end
+
         # TODO: Refactor this to remove messy overrides in Framework.
         module ConfigAddition
           def add_config!(config_name, value = nil, comment = nil)
@@ -55,6 +87,8 @@ module Transpec
             source_rewriter.insert_before(insertion_position, lines.join(''))
 
             block_node_to_insert_code.metadata[:added_config] = true
+
+            add_record(nil, config_record_syntax(config_name, value))
           end
 
           def generate_config_lines(config_name, value = nil, comment = nil)

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

@@ -5,14 +5,23 @@ require 'transpec/syntax/rspec_configure/config_modification'
 module Transpec
   class Syntax
     class RSpecConfigure
+      # This cannot be a Syntax class since this can be instanciated and used even when there's no
+      # corresponding node in the existing code.
       class Framework
         include ConfigModification
 
-        attr_reader :rspec_configure, :source_rewriter
+        attr_reader :rspec_configure
 
-        def initialize(rspec_configure, source_rewriter)
+        def initialize(rspec_configure)
           @rspec_configure = rspec_configure
-          @source_rewriter = source_rewriter
+        end
+
+        def source_rewriter
+          rspec_configure.source_rewriter
+        end
+
+        def add_record(*args)
+          rspec_configure.add_record(*args)
         end
 
         def block_node
@@ -50,14 +59,17 @@ module Transpec
         end
 
         def new_config_variable_name
-          framework_name = self.class.name.split('::').last.downcase
-          if rspec_configure.block_arg_name.to_s == framework_name
+          if rspec_configure.block_arg_name.to_s == framework_type_name
             'config'
           else
-            framework_name
+            framework_type_name
           end
         end
 
+        def framework_type_name
+          @framework_type_name ||= self.class.name.split('::').last.downcase
+        end
+
         def body_indentation
           if block_node
             super
@@ -86,6 +98,14 @@ module Transpec
           indentation_of_line(rspec_configure.node) + (' ' * 2)
         end
 
+        def config_record_syntax(config_name, value = nil)
+          inner_block_arg = framework_type_name[0]
+          syntax = "RSpec.configure { |c| c.#{block_method_name} :rspec "
+          syntax << "{ |#{inner_block_arg}| #{inner_block_arg}.#{config_name}"
+          syntax << " = #{value}" unless value.nil?
+          syntax << ' } }'
+        end
+
         module SyntaxConfig
           def syntaxes
             return [] unless syntaxes_node
@@ -107,7 +127,7 @@ module Transpec
               fail ArgumentError, 'Syntaxes must be either an array or a symbol.'
             end
 
-            set_config!(:syntax, syntaxes.inspect)
+            set_config_value!(:syntax, syntaxes.inspect)
           end
 
           private

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

@@ -10,7 +10,7 @@ module Transpec
           :mock_with
         end
 
-        def yield_receiver_to_any_instance_implementation_blocks=(boolean)
+        def yield_receiver_to_any_instance_implementation_blocks=(value)
           # rubocop:disable LineLength
           #
           # Based on the deprecation warning in RSpec 2.99:
@@ -26,7 +26,7 @@ module Transpec
             |`any_instance` implementation blocks to account for the first block argument
             |being the receiving instance.
           END
-          set_config!(:yield_receiver_to_any_instance_implementation_blocks, boolean, comment)
+          set_config_value!(:yield_receiver_to_any_instance_implementation_blocks, value, comment)
         end
       end
     end