transpec 1.10.4 → 1.11.0

data/lib/transpec/option_parser.rb

@@ -7,10 +7,8 @@ require 'optparse'
 require 'rainbow'
 require 'rainbow/ext/string' unless String.respond_to?(:color)
 
-# rubocop:disable ClassLength
-
 module Transpec
-  class OptionParser
+  class OptionParser # rubocop:disable ClassLength
     CONFIG_ATTRS_FOR_KEEP_TYPES = {
               should: :convert_should=,
             oneliner: :convert_oneliner=,
@@ -22,6 +20,11 @@ module Transpec
           deprecated: :convert_deprecated_method=
     }
 
+    CONFIG_ATTRS_FOR_CONVERT_TYPES = {
+      stub_with_hash: :convert_stub_with_hash_to_allow_to_receive_and_return=,
+       example_group: :convert_example_group=
+    }
+
     VALID_BOOLEAN_MATCHER_TYPES = %w(truthy,falsey truthy,falsy true,false)
 
     attr_reader :configuration
@@ -36,7 +39,7 @@ module Transpec
     end
 
     def parse(args)
-      args = exclude_deprecated_options(args)
+      args = convert_deprecated_options(args)
       @parser.parse!(args)
       args
     end
@@ -47,28 +50,27 @@ module Transpec
 
     private
 
-    # rubocop:disable MethodLength
-    def setup_parser
+    def setup_parser # rubocop:disable MethodLength
       @parser = create_parser
 
       define_option('-f', '--force') do
         configuration.forced = true
       end
 
-      define_option('-s', '--skip-dynamic-analysis') do
-        configuration.skip_dynamic_analysis = true
-      end
-
       define_option('-c', '--rspec-command COMMAND') do |command|
         configuration.rspec_command = command
       end
 
       define_option('-k', '--keep TYPE[,TYPE...]') do |types|
-        types.split(',').each do |type|
-          config_attr = CONFIG_ATTRS_FOR_KEEP_TYPES[type.to_sym]
-          fail ArgumentError, "Unknown syntax type #{type.inspect}" unless config_attr
-          configuration.send(config_attr, false)
-        end
+        configure_conversion(CONFIG_ATTRS_FOR_KEEP_TYPES, types, false)
+      end
+
+      define_option('-v', '--convert TYPE[,TYPE...]') do |types|
+        configure_conversion(CONFIG_ATTRS_FOR_CONVERT_TYPES, types, true)
+      end
+
+      define_option('-s', '--skip-dynamic-analysis') do
+        configuration.skip_dynamic_analysis = true
       end
 
       define_option('-n', '--negative-form FORM') do |form|
@@ -88,10 +90,6 @@ module Transpec
         configuration.add_receiver_arg_to_any_instance_implementation_block = false
       end
 
-      define_option('-t', '--convert-stub-with-hash') do
-        configuration.convert_stub_with_hash_to_stub_and_return = true
-      end
-
       define_option('-p', '--no-parentheses-matcher-arg') do
         configuration.parenthesize_matcher_arg = false
       end
@@ -105,7 +103,6 @@ module Transpec
         exit
       end
     end
-    # rubocop:enable MethodLength
 
     def create_parser
       banner = "Usage: transpec [options] [files or directories]\n\n"
@@ -116,81 +113,72 @@ module Transpec
 
     def define_option(*options, &block)
       description_lines = descriptions[options.first]
+      description_lines = description_lines.map { |line| highlight_text(line) }
       @parser.on(*options, *description_lines, &block)
     end
 
-    # rubocop:disable MethodLength, AlignHash
-    def descriptions
+    # rubocop:disable AlignHash
+    def descriptions # rubocop:disable MethodLength
       @descriptions ||= {
         '-f' => [
-          'Force processing even if the current Git',
-          'repository is not clean.'
+          'Force processing even if the current Git repository is not clean.'
         ],
         '-s' => [
-          'Skip dynamic analysis and convert with only',
-          'static analysis. Note that specifying this',
-          'option decreases the conversion accuracy.'
+          'Skip dynamic analysis and convert with only static analysis. Note',
+          'that specifying this option decreases the conversion accuracy.'
         ],
         '-c' => [
-          'Specify a command to run your specs that is',
-          'used for dynamic analysis.',
+          'Specify a command to run your specs that is used for dynamic',
+          'analysis.',
           'Default: "bundle exec rspec"'
         ],
         '-k' => [
-          'Keep specific syntaxes by disabling',
-          'conversions.',
-          'Available syntax types:',
-          "  #{'should'.bright} (to #{'expect(obj).to'.underline})",
-          "  #{'oneliner'.bright} (from #{'should'.underline} to #{'is_expected.to'.underline})",
-          "  #{'should_receive'.bright} (to #{'expect(obj).to receive'.underline})",
-          "  #{'stub'.bright}  (to #{'allow(obj).to receive'.underline})",
-          "  #{'have_items'.bright} (to #{'expect(obj.size).to eq(n)'.underline})",
-          "  #{'its'.bright} (to #{'describe { subject { }; it { } }'.underline})",
-          "  #{'pending'.bright} (to #{'skip'.underline})",
-          "  #{'deprecated'.bright} (e.g. from #{'mock'.underline} to #{'double'.underline})",
+          'Keep specific syntaxes by disabling conversions.',
+          'Conversion Types:',
+          '  *should* (to `expect(obj).to`)',
+          '  *oneliner* (from `it { should ... }` to `it { is_expected.to ... }`)',
+          '  *should_receive* (to `expect(obj).to receive`)',
+          '  *stub*  (to `allow(obj).to receive`)',
+          '  *have_items* (to `expect(collection.size).to eq(n)`)',
+          "  *its* (to `describe '#attr' { subject { }; it { } }`)",
+          '  *pending* (to `skip`)',
+          '  *deprecated* (all other deprecated syntaxes to latest syntaxes)',
           'These are all converted by default.'
         ],
+        '-v' => [
+          'Enable specific conversions that are disabled by default.',
+          'Conversion Types:',
+          '  *stub_with_hash* (`obj.stub(:msg => val)` to',
+          '                  `allow(obj).to receive(:msg).and_return(val)`)',
+          'These conversions are disabled by default.'
+        ],
         '-n' => [
-          "Specify a negative form of #{'to'.underline} that is used in",
-          "the #{'expect(...).to'.underline} syntax.",
-          "Either #{'not_to'.bright} or #{'to_not'.bright}.",
-          "Default: #{'not_to'.bright}"
+          'Specify a negative form of `to` that is used in the `expect(...).to`',
+          'syntax. Either *not_to* or *to_not*.',
+          'Default: *not_to*'
         ],
         '-b' => [
-          "Specify a matcher type that #{'be_true'.underline} and",
-          "#{'be_false'.underline} will be converted to.",
-          "  #{'truthy,falsey'.bright} (conditional semantics)",
-          "  #{'truthy,falsy'.bright}  (alias of #{'falsey'.underline})",
-          "  #{'true,false'.bright}    (exact equality)",
-          "Default: #{'truthy,falsey'.bright}"
+          'Specify a matcher type that `be_true` and `be_false` will be',
+          'converted to.',
+          '  *truthy,falsey* (conditional semantics)',
+          '  *truthy,falsy*  (alias of `falsey`)',
+          '  *true,false*    (exact equality)',
+          'Default: *truthy,falsey*'
         ],
         '-a' => [
-          'Suppress yielding receiver instances to',
-          "#{'any_instance'.underline} implementation blocks as the",
-          'first block argument.'
-        ],
-        '-t' => [
-          "Enable conversion of #{'obj.stub(:msg => val)'.underline} to",
-          "#{'allow(obj).to receive(:msg).and_return(val)'.underline}",
-          "when #{'receive_messages(:msg => val)'.underline} is",
-          'unavailable (prior to RSpec 3.0). It will be',
-          'converted to multiple statements if the hash',
-          'includes multiple pairs. This conversion is',
-          'disabled by default.'
+          'Suppress yielding receiver instances to `any_instance`',
+          'implementation blocks as the first block argument.'
         ],
         '-p' => [
-          'Suppress parenthesizing arguments of matchers',
-          "when converting #{'should'.underline} with operator matcher",
-          "to #{'expect'.underline} with non-operator matcher. Note",
-          'that it will be parenthesized even if this',
-          'option is specified when parentheses are',
-          'necessary to keep the meaning of the',
-          'expression. By default, arguments of the',
-          'following operator matchers will be',
-          'parenthesized.',
-          "  #{'== 10'.underline} to #{'eq(10)'.underline}",
-          "  #{'=~ /pattern/'.underline} to #{'match(/pattern/)'.underline}",
-          "  #{'=~ [1, 2]'.underline} to #{'match_array([1, 2])'.underline}"
+          'Suppress parenthesizing arguments of matchers when converting',
+          '`should` with operator matcher to `expect` with non-operator matcher.',
+          'Note that it will be parenthesized even if this option is',
+          'specified when parentheses are necessary to keep the meaning of',
+          'the expression. By default, arguments of the following operator',
+          'matchers will be parenthesized.',
+          '  `== 10` to `eq(10)`',
+          '  `=~ /pattern/` to `match(/pattern/)`',
+          '  `=~ [1, 2]` to `match_array([1, 2])`'
         ],
         '--no-color' => [
           'Disable color in the output.'
@@ -200,19 +188,39 @@ module Transpec
         ]
       }
     end
-    # rubocop:enable MethodLength, AlignHash
+    # rubocop:enable AlignHash
+
+    def highlight_text(text)
+      text.gsub(/`.+?`/) { |code| code.gsub('`', '').underline }
+          .gsub(/\*.+?\*/) { |code| code.gsub('*', '').bright }
+    end
 
-    def exclude_deprecated_options(args)
-      args.reject do |arg|
+    def convert_deprecated_options(raw_args)
+      raw_args.each_with_object([]) do |arg, args|
         case arg
         when '-m', '--generate-commit-message'
-          warn 'DEPRECATION: The -m/--generate-commit-message option is deprecated. ' \
-               'Now Transpec always generates the commit message.'
-          true
+          deprecate('-m/--generate-commit-message option')
+        when '-t', '--convert-stub-with-hash'
+          deprecate('-t/--convert-stub-with-hash', '`--convert stub_with_hash`')
+          args.concat(%w(--convert stub_with_hash))
         else
-          false
+          args << arg
         end
       end
     end
+
+    def deprecate(subject, alternative = nil)
+      message =  "DEPRECATION: #{subject} is deprecated."
+      message << " Please use #{alternative} instead." if alternative
+      warn message
+    end
+
+    def configure_conversion(type_to_attr_map, inputted_types, boolean)
+      inputted_types.split(',').each do |type|
+        config_attr = type_to_attr_map[type.to_sym]
+        fail ArgumentError, "Unknown syntax type #{type.inspect}" unless config_attr
+        configuration.send(config_attr, boolean)
+      end
+    end
   end
 end

data/lib/transpec/processed_source.rb

@@ -0,0 +1,48 @@
+# coding: utf-8
+
+begin
+  require 'parser/current'
+rescue NotImplementedError
+  warn 'Falling back to Ruby 2.1 parser.'
+  require 'parser/ruby21'
+  Parser::CurrentRuby = Parser::Ruby21 # rubocop:disable ConstantName
+end
+
+require 'transpec/ast/builder'
+
+module Transpec
+  class ProcessedSource
+    attr_reader :buffer, :ast, :path, :syntax_error
+
+    def self.parse_file(path)
+      source = File.read(path)
+      parse(source, path)
+    end
+
+    def self.parse(source, path = nil)
+      buffer = Parser::Source::Buffer.new(path || '(string)')
+      buffer.source = source
+
+      builder = AST::Builder.new
+      parser = Parser::CurrentRuby.new(builder)
+
+      begin
+        ast = parser.parse(buffer)
+        new(buffer, ast, path)
+      rescue Parser::SyntaxError => error
+        new(buffer, nil, path, error)
+      end
+    end
+
+    def initialize(buffer, ast, path = nil, syntax_error = nil)
+      @buffer = buffer
+      @ast = ast
+      @path = path
+      @syntax_error = syntax_error
+    end
+
+    def to_s
+      buffer.source
+    end
+  end
+end

data/lib/transpec/record.rb

@@ -4,7 +4,7 @@ require 'transpec/annotatable'
 
 module Transpec
   class Record
-    OVERRIDDE_FORBIDDEN_METHODS = [
+    OVERRIDE_FORBIDDEN_METHODS = [
       :original_syntax,
       :original_syntax_type,
       :converted_syntax,
@@ -62,7 +62,7 @@ module Transpec
     end
 
     def self.method_added(method_name)
-      return unless OVERRIDDE_FORBIDDEN_METHODS.include?(method_name)
+      return unless OVERRIDE_FORBIDDEN_METHODS.include?(method_name)
       fail "Do not override Record##{method_name}."
     end
   end

data/lib/transpec/report.rb

@@ -26,7 +26,11 @@ module Transpec
         record_counts[record] += 1
       end
 
-      Hash[record_counts.sort_by { |record, count| -count }]
+      sorted_record_counts = record_counts.sort_by do |record, count|
+        [-count, record.original_syntax_type, record.converted_syntax_type]
+      end
+
+      Hash[sorted_record_counts]
     end
 
     def colored_summary(options = nil)

data/lib/transpec/rspec_dsl.rb

@@ -3,18 +3,28 @@
 # Aliases by Capybara:
 # https://github.com/jnicklas/capybara/blob/2.2.0/lib/capybara/rspec/features.rb
 
+# rubocop:disable LineLength
+
 module Transpec
   module RSpecDSL
+    # https://github.com/rspec/rspec-core/blob/77cc21e/lib/rspec/core/example_group.rb#L239-L265
+    # https://github.com/rspec/rspec-core/blob/77cc21e/lib/rspec/core/shared_example_group.rb#L50-L61
     EXAMPLE_GROUP_METHODS = [
+      :example_group,
       :describe, :context,
+      :xdescribe, :xcontext,
+      :fdescribe, :fcontext,
       :shared_examples, :shared_context, :share_examples_for, :shared_examples_for,
       :feature # Capybara
     ].freeze
 
+    # https://github.com/rspec/rspec-core/blob/77cc21e/lib/rspec/core/example_group.rb#L130-L171
     EXAMPLE_METHODS = [
       :example, :it, :specify,
-      :focus, :focused, :fit,
-      :pending, :xexample, :xit, :xspecify,
+      :focus, :fexample, :fit, :fspecify,
+      :focused, # TODO: Support conversion
+      :xexample, :xit, :xspecify,
+      :skip, :pending,
       :scenario, :xscenario # Capybara
     ].freeze
 

data/lib/transpec/rspec_version.rb

@@ -41,14 +41,15 @@ module Transpec
       gem_version.to_s
     end
 
-    define_feature :be_truthy,                   '2.99.0.beta1'
-    define_feature :yielded_example,             '2.99.0.beta1'
+    define_feature :be_truthy,                      '2.99.0.beta1'
+    define_feature :yielded_example,                '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 :receive_messages,            '3.0.0.beta1'
-    define_feature :receive_message_chain,       '3.0.0.beta2'
-    define_feature :non_should_matcher_protocol, '3.0.0.beta2'
+    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 :receive_messages,               '3.0.0.beta1'
+    define_feature :receive_message_chain,          '3.0.0.beta2'
+    define_feature :non_should_matcher_protocol,    '3.0.0.beta2'
+    define_feature :non_monkey_patch_example_group, '3.0.0.beta2'
 
     RSPEC_2_99 = new('2.99.0.beta1')
     RSPEC_3_0  = new('3.0.0.beta1')

data/lib/transpec/spec_suite.rb

@@ -0,0 +1,114 @@
+# coding: utf-8
+
+require 'transpec/file_finder'
+require 'transpec/processed_source'
+require 'transpec/syntax'
+
+Transpec::Syntax.require_all
+
+module Transpec
+  class SpecSuite
+    ANALYSIS_TARGET_CLASSES = [Syntax::Mixin::AnyInstanceBlock]
+
+    attr_reader :runtime_data
+
+    def initialize(base_paths = [], runtime_data = nil)
+      @base_paths = base_paths
+      @runtime_data = runtime_data
+      @analyzed = false
+    end
+
+    def specs
+      @specs ||= begin
+        FileFinder.find(@base_paths).map do |path|
+          ProcessedSource.parse_file(path)
+        end
+      end
+    end
+
+    def analyze
+      return if @analyzed
+
+      specs.each do |spec|
+        next unless spec.ast
+        spec.ast.each_node do |node|
+          dispatch_node(node)
+        end
+      end
+
+      @analyzed = true
+    end
+
+    def need_to_modify_yield_receiver_to_any_instance_implementation_blocks_config?
+      analyze
+      @need_to_modify_yield_receiver_to_any_instance_implementation_blocks_config
+    end
+
+    def main_rspec_configure_node?(node)
+      analyze
+
+      if @main_rspec_configure
+        @main_rspec_configure.node.equal?(node)
+      else
+        true
+      end
+    end
+
+    private
+
+    def dispatch_node(node)
+      Syntax.standalone_syntaxes.each do |syntax_class|
+        syntax = syntax_class.new(node, nil, runtime_data)
+        next unless syntax.conversion_target?
+        dispatch_syntax(syntax)
+        break
+      end
+    end
+
+    def dispatch_syntax(syntax)
+      invoke_handler(syntax.class, syntax)
+
+      syntax_mixins.each do |mixin|
+        next unless syntax.class.ancestors.include?(mixin)
+        invoke_handler(mixin, syntax)
+      end
+
+      syntax.dependent_syntaxes.each do |dependent_syntax|
+        next unless dependent_syntax.conversion_target?
+        dispatch_syntax(dependent_syntax)
+      end
+    end
+
+    def syntax_mixins
+      Syntax::Mixin.constants.map do |const_name|
+        Syntax::Mixin.const_get(const_name, false)
+      end
+    end
+
+    def invoke_handler(klass, syntax)
+      class_name = klass.name.split('::').last.gsub(/([a-z])([A-Z])/, '\1_\2').downcase
+      handler_name = "process_#{class_name}"
+      send(handler_name, syntax) if respond_to?(handler_name, true)
+    end
+
+    def process_any_instance_block(syntax)
+      @need_to_modify_yield_receiver_to_any_instance_implementation_blocks_config ||=
+        syntax.need_to_add_receiver_arg_to_any_instance_implementation_block?
+    end
+
+    def process_rspec_configure(rspec_configure)
+      return unless runtime_data
+      run_order = runtime_data[rspec_configure.node, :run_order]
+      return unless run_order
+
+      unless @main_rspec_configure
+        @main_rspec_configure = rspec_configure
+        return
+      end
+
+      if run_order < runtime_data[@main_rspec_configure.node, :run_order]
+        @main_rspec_configure = rspec_configure
+      end
+    end
+  end
+end

data/lib/transpec/syntax/example.rb

@@ -1,36 +1,20 @@
 # coding: utf-8
 
 require 'transpec/syntax'
-require 'transpec/syntax/mixin/send'
+require 'transpec/syntax/mixin/context_sensitive'
 require 'transpec/rspec_dsl'
 
 module Transpec
   class Syntax
     class Example < Syntax
-      include Mixin::Send, RSpecDSL
-
-      define_dynamic_analysis do |rewriter|
-        code = "is_a?(Class) && ancestors.any? { |a| a.name == 'RSpec::Core::ExampleGroup' }"
-        rewriter.register_request(node, :example_group_context?, code, :context)
-      end
+      include Mixin::ContextSensitive, RSpecDSL
 
       def dynamic_analysis_target?
         super && receiver_node.nil? && EXAMPLE_METHODS.include?(method_name)
       end
 
-      def conversion_target?
-        return false unless dynamic_analysis_target?
-
-        # 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.run?(node)
-          # If we have runtime data, check with it.
-          runtime_data[node, :example_group_context?]
-        else
-          # Otherwise check statically.
-          static_context_inspector.scopes.last == :example_group
-        end
+      def should_be_in_example_group_context?
+        true
       end
 
       def convert_pending_to_skip!

data/lib/transpec/syntax/example_group.rb

@@ -0,0 +1,38 @@
+# coding: utf-8
+
+require 'transpec/syntax'
+require 'transpec/syntax/mixin/context_sensitive'
+require 'transpec/syntax/mixin/monkey_patch'
+require 'transpec/rspec_dsl'
+
+module Transpec
+  class Syntax
+    class ExampleGroup < Syntax
+      include Mixin::ContextSensitive, Mixin::MonkeyPatch, RSpecDSL
+
+      def dynamic_analysis_target?
+        super && receiver_node.nil? && EXAMPLE_GROUP_METHODS.include?(method_name)
+      end
+
+      def should_be_in_example_group_context?
+        false
+      end
+
+      def convert_to_non_monkey_patch!
+        insert_before(expression_range, 'RSpec.')
+        register_record
+      end
+
+      def register_record
+        original_syntax = method_name.to_s
+        converted_syntax = "RSpec.#{method_name}"
+
+        [original_syntax, converted_syntax].each do |syntax|
+          syntax << " 'something' { }"
+        end
+
+        @report.records << Record.new(original_syntax, converted_syntax)
+      end
+    end
+  end
+end

data/lib/transpec/syntax/have.rb

@@ -28,12 +28,13 @@ module Transpec
           [:have, :have_exactly, :have_at_least, :have_at_most].include?(method_name)
       end
 
-      def convert_to_standard_expectation!(parenthesize_matcher_arg = true)
-        return if project_requires_collection_matcher?
+      def conversion_target?
+        super && !runtime_subject_data(:project_requires_collection_matcher?)
+      end
 
+      def convert_to_standard_expectation!(parenthesize_matcher_arg = true)
         replace(expectation.subject_range, replacement_subject_source) if explicit_subject?
         replace(matcher_range, source_builder.replacement_matcher_source(parenthesize_matcher_arg))
-
         register_record if explicit_subject?
       end
 
@@ -56,10 +57,6 @@ module Transpec
         items_node.children[1]
       end
 
-      def project_requires_collection_matcher?
-        runtime_subject_data(:project_requires_collection_matcher?)
-      end
-
       def collection_accessor
         if runtime_subject_data(:collection_accessor)
           runtime_subject_data(:collection_accessor).to_sym
@@ -70,7 +67,7 @@ module Transpec
 
       def subject_is_owner_of_collection?
         return true if items_method_has_arguments?
-        !runtime_subject_data(:collection_accessor).nil?
+        runtime_subject_data(:collection_accessor)
       end
 
       def collection_accessor_is_private?
@@ -99,7 +96,7 @@ module Transpec
       end
 
       def accurate_conversion?
-        !runtime_subject_data.nil?
+        runtime_subject_data
       end
 
       def matcher_range

data/lib/transpec/syntax/its.rb

@@ -19,9 +19,11 @@ module Transpec
         super && receiver_node.nil? && method_name == :its
       end
 
-      def convert_to_describe_subject_it!
-        return if project_requires_its?
+      def conversion_target?
+        super && !runtime_data[node, :project_requires_its?]
+      end
 
+      def convert_to_describe_subject_it!
         front, rear = build_wrapper_codes
 
         insert_before(beginning_of_line_range(block_node), front)
@@ -45,10 +47,6 @@ module Transpec
         node.parent_node
       end
 
-      def project_requires_its?
-        runtime_data[node, :project_requires_its?]
-      end
-
       private
 
       def build_wrapper_codes
@@ -74,7 +72,7 @@ module Transpec
 
       def previous_line_is_blank?
         return false unless previous_line_source
-        previous_line_source.empty? || !previous_line_source.match(/\A\s*\Z/).nil?
+        previous_line_source.empty? || previous_line_source.match(/\A\s*\Z/)
       end
 
       def previous_and_current_line_are_same_indentation_level?