transpec 2.2.5 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6344cbf3016bb43e49fb70dbe7a4105439b45ef0
-  data.tar.gz: 8e5692f353278c6cf1cf120d582c504c9859493c
+  metadata.gz: 3cc32f4f45ab036ddecaefb46245014a4713fdee
+  data.tar.gz: 2b7feec59ef424cb3df9d47145683fcc6c496b9e
 SHA512:
-  metadata.gz: 163b3f743c5033a58d8a4c8643f2b71e7c771e79a0183f8c785f56f6fa59fad65e83f291c20973ecc1354fcb453909451f2384d1a7a1617df972a77820502964
-  data.tar.gz: 6e68356769b715ea2becfcfea1d8e80807b973b2d6322022b79438400b0ffa64fee65b0a82835ecd9284b133017bfcb882f968f26c7a86f2ed65cc7856d80cce
+  metadata.gz: b53e41a17861208c396e6955152123dca5a623041265987c8f03caf3f3bb14fb28ddaabcd1f46dad918a477ad499e155e801e042ab3b6464ccc46d0ebdb7f361
+  data.tar.gz: 3b3cf2d94a9a6adfd671235d639ae65a2cf8c8887acccb28b6b4eee9c9dabd266a84d195f680b425410685f466a3e726f07610e9045750b6e3377427044d3002

data/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## Development
 
+## v2.3.0
+
+* Report configuration modifications of `RSpec.configure` in the final summary.
+* Support conversion of configuration options `backtrace_clean_patterns`, `backtrace_clean_patterns=`, `color_enabled=`, `output`, `output=`, `out`, `out=`, `filename_pattern`, `filename_pattern=`, `backtrace_cleaner`, `backtrace_cleaner=`, `color?` and `warnings`.
+
 ## v2.2.5
 
 * Fix invalid conversion of `unstub` without parentheses (`obj.unstub :message`). ([#74](https://github.com/yujinakayama/transpec/pull/74))

data/lib/transpec/conversion_error.rb

@@ -8,16 +8,16 @@ module Transpec
   end
 
   class ContextError < ConversionError
-    def initialize(original_syntax, target_syntax, source_range)
-      message = build_message(original_syntax, target_syntax)
+    def initialize(old_syntax, new_syntax, source_range)
+      message = build_message(old_syntax, new_syntax)
       super(message, source_range)
     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."
+    def build_message(old_syntax, new_syntax)
+      "Cannot convert #{old_syntax} into #{new_syntax} " \
+      "since #{new_syntax} is not available in the context."
     end
   end
 end

data/lib/transpec/converter.rb

@@ -165,21 +165,23 @@ module Transpec
     end
 
     def process_rspec_configure(rspec_configure)
-      return unless spec_suite.main_rspec_configure_node?(rspec_configure.node)
+      rspec_configure.convert_deprecated_options!(rspec_version)
 
-      if rspec_version.non_monkey_patch_example_group_available? &&
-         config.convert_example_group?
-        rspec_configure.expose_dsl_globally = false
-      end
+      if spec_suite.main_rspec_configure_node?(rspec_configure.node)
+        if rspec_version.non_monkey_patch_example_group_available? &&
+           config.convert_example_group?
+          rspec_configure.expose_dsl_globally = false
+        end
 
-      if need_to_modify_yield_receiver_to_any_instance_implementation_blocks_config?
-        should_yield = config.add_receiver_arg_to_any_instance_implementation_block?
-        rspec_configure.mocks.yield_receiver_to_any_instance_implementation_blocks = should_yield
-      end
+        if need_to_modify_yield_receiver_to_any_instance_implementation_blocks_config?
+          should_yield = config.add_receiver_arg_to_any_instance_implementation_block?
+          rspec_configure.mocks.yield_receiver_to_any_instance_implementation_blocks = should_yield
+        end
 
-      if rspec_version.implicit_spec_type_disablement_available? &&
-         !config.add_explicit_type_metadata_to_example_group?
-        rspec_configure.infer_spec_type_from_file_location!
+        if rspec_version.implicit_spec_type_disablement_available? &&
+           !config.add_explicit_type_metadata_to_example_group?
+          rspec_configure.infer_spec_type_from_file_location!
+        end
       end
     end
 

data/lib/transpec/record.rb

@@ -4,66 +4,123 @@ require 'transpec/annotatable'
 
 module Transpec
   class Record
-    OVERRIDE_FORBIDDEN_METHODS = [
-      :original_syntax,
-      :original_syntax_type,
-      :converted_syntax,
-      :converted_syntax_type
-    ]
+    include Comparable
 
-    attr_reader :original_syntax_type, :converted_syntax_type, :annotation
+    TYPES = [:conversion, :addition, :removal, :modification]
+    COMPARISON_ATTRIBUTES = [:type_sort_key, :old_syntax, :new_syntax].freeze
 
-    def initialize(original_syntax, converted_syntax, annotation = nil)
-      @original_syntax_type = original_syntax.to_sym
-      @converted_syntax_type = converted_syntax.to_sym
-      @annotation = annotation
-    end
+    attr_reader :old_syntax_type, :new_syntax_type, :annotation
+
+    def initialize(old_syntax, new_syntax, options = {})
+      # Keep these syntax data as symbols for:
+      #   * Better memory footprint
+      #   * Better summarizing performance in Report
+      @old_syntax_type = old_syntax && old_syntax.to_sym
+      @new_syntax_type = new_syntax && new_syntax.to_sym
+
+      @type = options[:type]
+      @annotation = options[:annotation]
 
-    def original_syntax
-      original_syntax_type.to_s
+      fail ArgumentError, "Invalid type: #{type}" unless TYPES.include?(type)
     end
 
-    def converted_syntax
-      converted_syntax_type.to_s
+    def type
+      @type ||= if old_syntax_type && new_syntax_type
+                  :conversion
+                elsif new_syntax_type
+                  :addition
+                else
+                  :removal
+                end
     end
 
-    def original_syntax_type
-      @original_syntax_type ||= build_original_syntax.to_sym
+    def old_syntax
+      old_syntax_type && old_syntax_type.to_s
     end
 
-    def converted_syntax_type
-      @converted_syntax_type ||= build_converted_syntax.to_sym
+    def new_syntax
+      new_syntax_type && new_syntax_type.to_s
     end
 
     def ==(other)
       self.class == other.class &&
-        original_syntax_type == other.original_syntax_type &&
-        converted_syntax_type == other.converted_syntax_type
+        old_syntax_type == other.old_syntax_type &&
+        new_syntax_type == other.new_syntax_type
     end
 
     alias_method :eql?, :==
 
     def hash
-      original_syntax_type.hash ^ converted_syntax_type.hash
+      old_syntax_type.hash ^ new_syntax_type.hash
     end
 
     def to_s
-      "`#{original_syntax_type}` -> `#{converted_syntax_type}`"
+      string = type.to_s.capitalize
+
+      string << case type
+                when :conversion, :modification
+                  " from `#{old_syntax_type}` to `#{new_syntax_type}`"
+                when :addition
+                  " of `#{new_syntax_type}`"
+                when :removal
+                  " of `#{old_syntax_type}`"
+                end
+    end
+
+    def <=>(other)
+      COMPARISON_ATTRIBUTES.each do |attribute|
+        result = send(attribute) <=> other.send(attribute)
+        return result unless result == 0
+      end
+      0
+    end
+
+    private
+
+    def type_sort_key
+      case type
+      when :conversion   then 1
+      when :modification then 2
+      when :addition     then 3
+      when :removal      then 4
+      end
+    end
+  end
+
+  # This class is intended to be inherited to build complex record.
+  # The reasons why you should inherit this class rather than Record are:
+  #   * You need to care about String and Symbol around Record#old_syntax and #new_syntax.
+  #   * All record instances are kept in a Report until the end of Transpec process.
+  #     This mean that if a custom record keeps a syntax object as an ivar,
+  #     the AST kept by the syntax object won't be GCed.
+  class RecordBuilder
+    def self.build(*args)
+      new(*args).build
+    end
+
+    def build
+      Record.new(old_syntax, new_syntax, { type: type, annotation: annotation })
     end
 
     private
 
-    def build_original_syntax
-      fail NotImplementedError
+    def initialize(*)
+    end
+
+    def old_syntax
+      nil
+    end
+
+    def new_syntax
+      nil
     end
 
-    def build_converted_syntax
-      fail NotImplementedError
+    def type
+      nil
     end
 
-    def self.method_added(method_name)
-      return unless OVERRIDE_FORBIDDEN_METHODS.include?(method_name)
-      fail "Do not override Record##{method_name}."
+    def annotation
+      nil
     end
   end
 

data/lib/transpec/report.rb

@@ -27,7 +27,7 @@ module Transpec
       end
 
       sorted_record_counts = record_counts.sort_by do |record, count|
-        [-count, record.original_syntax_type, record.converted_syntax_type]
+        [-count, record]
       end
 
       Hash[sorted_record_counts]
@@ -85,16 +85,24 @@ module Transpec
     end
 
     def format_record(record, count, bullet = nil)
-      entry_prefix = bullet ? bullet + ' ' : ''
-      indentation = if bullet
-                      ' ' * entry_prefix.length
-                    else
-                      ''
-                    end
-
-      text = entry_prefix + colorize(pluralize(count, 'conversion'), :cyan) + "\n"
-      text << indentation + '  ' + colorize('from: ', :cyan) + record.original_syntax + "\n"
-      text << indentation + '    ' + colorize('to: ', :cyan) + record.converted_syntax + "\n"
+      entry_prefix = bullet ? "#{bullet} " : ''
+      text = entry_prefix + colorize(pluralize(count, record.type), :cyan) + "\n"
+
+      justification = entry_prefix.length + 6
+
+      case record.type
+      when :conversion
+        text << labeled_line('from', record.old_syntax, justification)
+        text << labeled_line('to',   record.new_syntax, justification)
+      when :addition
+        text << labeled_line('of',   record.new_syntax, justification)
+      when :removal
+        text << labeled_line('of',   record.old_syntax, justification)
+      end
+    end
+
+    def labeled_line(label, content, justification)
+      colorize("#{label.rjust(justification)}: ", :cyan) + content + "\n"
     end
 
     def conversion_incomplete_warning_stats(color)

data/lib/transpec/rspec_version.rb

@@ -43,11 +43,20 @@ module Transpec
 
     define_feature :be_truthy,                      '2.99.0.beta1'
     define_feature :yielded_example,                '2.99.0.beta1'
+    define_feature :config_output_stream,           '2.99.0.beta1'
     define_feature :yielding_receiver_to_any_instance_implementation_block, '2.99.0.beta1'
 
     define_feature :oneliner_is_expected,           '2.99.0.beta2', except: '3.0.0.beta1'
     define_feature :skip,                           '2.99.0.beta2', except: '3.0.0.beta1'
 
+    define_feature :config_pattern,                 '2.99.0.rc1',
+                   except: ['3.0.0.beta1', '3.0.0.beta2']
+    define_feature :config_backtrace_formatter,     '2.99.0.rc1',
+                   except: ['3.0.0.beta1', '3.0.0.beta2']
+    define_feature :config_predicate_color_enabled, '2.99.0.rc1',
+                   except: ['3.0.0.beta1', '3.0.0.beta2']
+    define_feature :config_predicate_warnings,      '2.99.0.rc1',
+                   except: ['3.0.0.beta1', '3.0.0.beta2']
     define_feature :implicit_spec_type_disablement, '2.99.0.rc1',
                    except: ['3.0.0.beta1', '3.0.0.beta2']
 

data/lib/transpec/syntax/be_boolean.rb

@@ -30,8 +30,8 @@ module Transpec
 
       private
 
-      def add_record(converted_syntax)
-        report.records << Record.new(method_name.to_s, converted_syntax)
+      def add_record(new_syntax)
+        super(method_name, new_syntax)
       end
     end
   end

data/lib/transpec/syntax/be_close.rb

@@ -29,7 +29,7 @@ module Transpec
       private
 
       def add_record
-        report.records << Record.new('be_close(expected, delta)', 'be_within(delta).of(expected)')
+        super('be_close(expected, delta)', 'be_within(delta).of(expected)')
       end
     end
   end

data/lib/transpec/syntax/current_example.rb

@@ -28,13 +28,7 @@ module Transpec
           replace(selector_range, 'RSpec.current_example')
         end
 
-        add_record
-      end
-
-      private
-
-      def block_has_argument?
-        block_arg_node || block_node.metadata[:added_example_block_arg]
+        add_record(RecordBuilder.build(self))
       end
 
       def block_node
@@ -51,6 +45,12 @@ module Transpec
         method_name_of_block_node(block_node)
       end
 
+      private
+
+      def block_has_argument?
+        block_arg_node || block_node.metadata[:added_example_block_arg]
+      end
+
       def block_arg_node
         args_node = block_node.children[1]
         args_node.children.first
@@ -69,18 +69,36 @@ module Transpec
         send_node.children[1]
       end
 
-      def add_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 }"
-        else
-          original_syntax = 'def helper_method example; end'
-          converted_syntax = 'def helper_method RSpec.current_example; end'
+      class RecordBuilder < Transpec::RecordBuilder
+        include RSpecDSL
+
+        attr_reader :current_example
+
+        def initialize(current_example)
+          @current_example = current_example
         end
 
-        report.records << Record.new(original_syntax, converted_syntax)
+        def old_syntax
+          if current_example.block_node
+            "#{base_dsl} { example }"
+          else
+            'def helper_method example; end'
+          end
+        end
+
+        def new_syntax
+          if current_example.block_node
+            "#{base_dsl} { |example| example }"
+          else
+            'def helper_method RSpec.current_example; end'
+          end
+        end
+
+        def base_dsl
+          dsl = "#{current_example.block_method_name}"
+          dsl << '(:name)' if HELPER_METHODS.include?(current_example.block_method_name)
+          dsl
+        end
       end
     end
   end

data/lib/transpec/syntax/double.rb

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

data/lib/transpec/syntax/example.rb

@@ -64,10 +64,6 @@ module Transpec
           range
         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/example_group.rb

@@ -39,7 +39,7 @@ module Transpec
       def convert_to_non_monkey_patch!
         return if receiver_node
         insert_before(expression_range, 'RSpec.')
-        report.records << NonMonkeyPatchDescribeRecord.new(self)
+        add_record(NonMonkeyPatchRecordBuilder.build(self))
       end
 
       def add_explicit_type_metadata!
@@ -59,7 +59,7 @@ module Transpec
 
         insert_after(arg_node.loc.expression, code)
 
-        report.records << ExplicitTypeMetadataRecord.new(self)
+        add_record(ExplicitTypeMetadataRecordBuilder.build(self))
       end
 
       def implicit_type_metadata
@@ -96,18 +96,18 @@ module Transpec
         end
       end
 
-      class NonMonkeyPatchDescribeRecord < Record
+      class NonMonkeyPatchRecordBuilder < RecordBuilder
         attr_reader :example_group
 
         def initialize(example_group)
           @example_group = example_group
         end
 
-        def build_original_syntax
+        def old_syntax
           base_syntax
         end
 
-        def build_converted_syntax
+        def new_syntax
           "RSpec.#{base_syntax}"
         end
 
@@ -116,22 +116,22 @@ module Transpec
         end
       end
 
-      class ExplicitTypeMetadataRecord < Record
+      class ExplicitTypeMetadataRecordBuilder < RecordBuilder
         attr_reader :example_group
 
         def initialize(example_group)
           @example_group = example_group
         end
 
-        def build_original_syntax
-          "describe 'some #{type}' { }"
+        def old_syntax
+          "describe 'some #{spec_type}' { }"
         end
 
-        def build_converted_syntax
-          "describe 'some #{type}', :type => #{type.inspect} { }"
+        def new_syntax
+          "describe 'some #{spec_type}', :type => #{spec_type.inspect} { }"
         end
 
-        def type
+        def spec_type
           example_group.implicit_type_metadata
         end
       end

data/lib/transpec/syntax/have/{have_record.rb → record_builder.rb}

@@ -5,7 +5,7 @@ require 'transpec/syntax/have'
 module Transpec
   class Syntax
     class Have
-      class HaveRecord < Record
+      class RecordBuilder < Transpec::RecordBuilder
         attr_reader :have
 
         def initialize(have)
@@ -22,17 +22,15 @@ module Transpec
                         end
         end
 
-        private
-
-        def build_original_syntax
+        def old_syntax
           type = have.expectation.class.snake_case_name.to_sym
-          syntax = build_expectation(original_subject, type)
-          syntax << " #{have.method_name}(n).#{original_items}"
+          syntax = build_expectation(old_subject, type)
+          syntax << " #{have.method_name}(n).#{old_items}"
         end
 
-        def build_converted_syntax
+        def new_syntax
           type = have.expectation.current_syntax_type
-          syntax = build_expectation(converted_subject, type)
+          syntax = build_expectation(new_subject, type)
           syntax << " #{source_builder.replacement_matcher_source}"
         end
 
@@ -53,7 +51,7 @@ module Transpec
           have.expectation.positive?
         end
 
-        def original_subject
+        def old_subject
           if have.subject_is_owner_of_collection?
             'obj'
           else
@@ -61,7 +59,7 @@ module Transpec
           end
         end
 
-        def original_items
+        def old_items
           if have.subject_is_owner_of_collection?
             if have.items_method_has_arguments?
               "#{have.collection_accessor}(...)"
@@ -73,23 +71,23 @@ module Transpec
           end
         end
 
-        def converted_subject
-          if @have.subject_is_owner_of_collection?
-            build_converted_subject('obj')
+        def new_subject
+          if have.subject_is_owner_of_collection?
+            build_new_subject('obj')
           else
-            build_converted_subject('collection')
+            build_new_subject('collection')
           end
         end
 
-        def build_converted_subject(subject)
+        def build_new_subject(subject)
           if have.subject_is_owner_of_collection?
-            converted_owner_of_collection(subject)
+            new_owner_of_collection(subject)
           else
             subject << ".#{have.default_query_method}"
           end
         end
 
-        def converted_owner_of_collection(subject)
+        def new_owner_of_collection(subject)
           subject << '.'
 
           if have.collection_accessor_is_private?

data/lib/transpec/syntax/have.rb

@@ -8,8 +8,8 @@ module Transpec
   class Syntax
     class Have < Syntax
       require 'transpec/syntax/have/dynamic_analysis'
+      require 'transpec/syntax/have/record_builder'
       require 'transpec/syntax/have/source_builder'
-      require 'transpec/syntax/have/have_record'
 
       include Mixin::Send, Mixin::OwnedMatcher, DynamicAnalysis
 
@@ -132,7 +132,7 @@ module Transpec
       end
 
       def add_record
-        report.records << HaveRecord.new(self)
+        super(Have::RecordBuilder.build(self))
       end
     end
   end

data/lib/transpec/syntax/hook.rb

@@ -36,9 +36,9 @@ module Transpec
       end
 
       def add_record
-        original_syntax = "#{method_name}(#{scope_name.inspect}) { }"
-        converted_syntax = "#{method_name}(#{replacement_scope_name.inspect}) { }"
-        report.records << Record.new(original_syntax, converted_syntax)
+        old_syntax = "#{method_name}(#{scope_name.inspect}) { }"
+        new_syntax = "#{method_name}(#{replacement_scope_name.inspect}) { }"
+        super(old_syntax, new_syntax)
       end
     end
   end

data/lib/transpec/syntax/its.rb

@@ -120,23 +120,7 @@ module Transpec
       end
 
       def add_record
-        report.records << Record.new(original_syntax, converted_syntax)
-      end
-
-      def original_syntax
-        if attribute_expression.brackets?
-          'its([:key]) { }'
-        else
-          'its(:attr) { }'
-        end
-      end
-
-      def converted_syntax
-        if attribute_expression.brackets?
-          "describe '[:key]' do subject { super()[:key] }; it { } end"
-        else
-          "describe '#attr' do subject { super().attr }; it { } end"
-        end
+        super(RecordBuilder.build(self))
       end
 
       class AttributeExpression
@@ -196,6 +180,30 @@ module Transpec
       end
 
       Attribute = Struct.new(:selector, :description)
+
+      class RecordBuilder < Transpec::RecordBuilder
+        attr_reader :its
+
+        def initialize(its)
+          @its = its
+        end
+
+        def old_syntax
+          if its.attribute_expression.brackets?
+            'its([:key]) { }'
+          else
+            'its(:attr) { }'
+          end
+        end
+
+        def new_syntax
+          if its.attribute_expression.brackets?
+            "describe '[:key]' do subject { super()[:key] }; it { } end"
+          else
+            "describe '#attr' do subject { super().attr }; it { } end"
+          end
+        end
+      end
     end
   end
 end