transpec 0.2.6 → 1.0.0

data/lib/transpec/cli.rb

@@ -1,27 +1,17 @@
 # coding: utf-8
 
-require 'transpec/configuration'
 require 'transpec/commit_message'
-require 'transpec/git'
+require 'transpec/configuration'
+require 'transpec/converter'
+require 'transpec/dynamic_analyzer'
+require 'transpec/file_finder'
+require 'transpec/option_parser'
 require 'transpec/report'
-require 'transpec/rewriter'
-require 'transpec/version'
-require 'optparse'
-require 'find'
 require 'rainbow'
 
 module Transpec
   class CLI
-    CONFIG_ATTRS_FOR_CLI_TYPES = {
-      expect_to_matcher: :convert_to_expect_to_matcher=,
-      expect_to_receive: :convert_to_expect_to_receive=,
-       allow_to_receive: :convert_to_allow_to_receive=,
-             deprecated: :replace_deprecated_method=
-    }
-
-    attr_reader :configuration, :forced, :generates_commit_message
-    alias_method :forced?, :forced
-    alias_method :generates_commit_message?, :generates_commit_message
+    attr_reader :configuration
 
     def self.run(args = ARGV)
       new.run(args)
@@ -29,172 +19,67 @@ module Transpec
 
     def initialize
       @configuration = Configuration.new
-      @forced = false
-      @generates_commit_message = false
       @report = Report.new
     end
 
     def run(args)
-      non_option_args = parse_options(args)
-
-      fail_if_should_not_continue!
-
-      base_paths = base_target_paths(non_option_args)
-
-      target_files(base_paths).each do |file_path|
-        process_file(file_path)
+      begin
+        paths = OptionParser.new(@configuration).parse(args)
+        fail_if_should_not_continue!
+      rescue => error
+        warn error.message
+        return false
       end
 
+      process(paths)
+
       display_summary
-      generate_commit_message if generates_commit_message?
+      generate_commit_message if @configuration.generate_commit_message?
+      display_final_guide
 
       true
-    rescue => error
-      warn error.message
-      false
     end
 
-    def process_file(file_path)
-      puts "Processing #{file_path}"
-
-      rewriter = Rewriter.new(@configuration, @report)
-      rewriter.rewrite_file!(file_path)
-
-      @report.invalid_context_errors.concat(rewriter.invalid_context_errors)
+    def process(paths)
+      runtime_data = nil
 
-      rewriter.invalid_context_errors.each do |error|
-        warn_invalid_context_error(error)
-      end
-    rescue Parser::SyntaxError => error
-      @report.syntax_errors << error
-      warn_syntax_error(error)
-    end
-
-    # rubocop:disable MethodLength
-    def parse_options(args)
-      parser = OptionParser.new
-      parser.banner = "Usage: transpec [options] [files or directories]\n\n"
-
-      parser.on(
-        '-f', '--force',
-        'Force processing even if the current Git',
-        'repository is not clean.'
-      ) do
-        @forced = true
-      end
-
-      parser.on(
-        '-m', '--commit-message',
-        'Generate commit message that describes',
-        'conversion summary. Only Git is supported.'
-      ) do
-        unless Git.inside_of_repository?
-          fail '-m/--commit-message option is specified but not in a Git repository'
-        end
-
-        @generates_commit_message = true
-      end
-
-      parser.on(
-        '-d', '--disable TYPE[,TYPE...]',
-        'Disable specific conversions.',
-        'Available conversion types:',
-        '  expect_to_matcher (from `should`)',
-        '  expect_to_receive (from `should_receive`)',
-        '  allow_to_receive  (from `stub`)',
-        '  deprecated (e.g. from `stub!` to `stub`)',
-        'These are all enabled by default.'
-      ) do |types|
-        types.split(',').each do |type|
-          config_attr = CONFIG_ATTRS_FOR_CLI_TYPES[type.to_sym]
-          fail ArgumentError, "Unknown conversion type #{type.inspect}" unless config_attr
-          @configuration.send(config_attr, false)
+      unless @configuration.skip_dynamic_analysis?
+        puts 'Copying project for dynamic analysis...'
+        DynamicAnalyzer.new(rspec_command: @configuration.rspec_command) do |analyzer|
+          puts "Running dynamic analysis with command \"#{analyzer.rspec_command}\"..."
+          runtime_data = analyzer.analyze(paths)
         end
+        puts
       end
 
-      parser.on(
-        '-n', '--negative-form FORM',
-        'Specify negative form of `to` that is used',
-        'in `expect(...).to` syntax.',
-        'Either `not_to` or `to_not`.',
-        'Default: not_to'
-      ) do |form|
-        @configuration.negative_form_of_to = form
+      FileFinder.find(paths).each do |file_path|
+        convert_file(file_path, runtime_data)
       end
+    end
 
-      parser.on(
-        '-p', '--no-parentheses-matcher-arg',
-        'Suppress parenthesizing argument of matcher',
-        'when converting operator to non-operator',
-        'in `expect` syntax. 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])`'
-      ) do
-        @configuration.parenthesize_matcher_arg = false
-      end
+    def convert_file(file_path, runtime_data = nil)
+      puts "Converting #{file_path}"
 
-      parser.on('--no-color', 'Disable color in the output.') do
-        Sickill::Rainbow.enabled = false
-      end
+      converter = Converter.new(@configuration, runtime_data, @report)
+      converter.convert_file!(file_path)
 
-      parser.on('--version', 'Show Transpec version.') do
-        puts Version.to_s
-        exit
-      end
+      @report.invalid_context_errors.concat(converter.invalid_context_errors)
 
-      args = args.dup
-      parser.parse!(args)
-      args
-    end
-    # rubocop:enable MethodLength
-
-    def target_files(paths)
-      paths.reduce([]) do |file_paths, path|
-        if File.directory?(path)
-          file_paths.concat(ruby_files_in_directory(path))
-        elsif File.file?(path)
-          file_paths << path
-        elsif !File.exists?(path)
-          fail ArgumentError, "No such file or directory #{path.inspect}"
-        end
+      converter.invalid_context_errors.each do |error|
+        warn_invalid_context_error(error)
       end
+    rescue Parser::SyntaxError => error
+      @report.syntax_errors << error
+      warn_syntax_error(error)
     end
 
     private
 
-    def base_target_paths(args)
-      return args unless args.empty?
-      return ['spec'] if Dir.exists?('spec')
-      fail ArgumentError, 'Specify target files or directories.'
-    end
-
-    def ruby_files_in_directory(directory_path)
-      ruby_file_paths = []
-
-      Find.find(directory_path) do |path|
-        next unless File.file?(path)
-        next unless File.extname(path) == '.rb'
-        ruby_file_paths << path
-      end
-
-      ruby_file_paths
-    end
-
     def fail_if_should_not_continue!
-      return if forced?
-
-      # TODO: Check each repository of target files / directories,
-      #   not only the current working directory.
+      return if @configuration.forced?
       return unless Git.command_available?
       return unless Git.inside_of_repository?
       return if Git.clean?
-
       fail 'The current Git repository is not clean. Aborting.'
     end
 
@@ -223,6 +108,11 @@ module Transpec
       puts '    git commit -eF .git/COMMIT_EDITMSG'
     end
 
+    def display_final_guide
+      puts
+      puts "Done! Now run #{'rspec'.bright} and check if all the converted specs pass."
+    end
+
     def warn_syntax_error(error)
       warn "Syntax error at #{error.diagnostic.location}. Skipping the file.".color(:red)
     end

data/lib/transpec/configuration.rb

@@ -5,23 +5,27 @@ module Transpec
     NEGATIVE_FORMS_OF_TO = ['not_to', 'to_not'].freeze
 
     PREDICATES = [
-      :convert_to_expect_to_matcher,
-      :convert_to_expect_to_receive,
-      :convert_to_allow_to_receive,
-      :replace_deprecated_method,
-      :parenthesize_matcher_arg
+      [:convert_should,            true],
+      [:convert_should_receive,    true],
+      [:convert_stub,              true],
+      [:convert_have_items,        true],
+      [:convert_deprecated_method, true],
+      [:parenthesize_matcher_arg,  true],
+      [:forced,                    false],
+      [:skip_dynamic_analysis,     false],
+      [:generate_commit_message,   false]
     ].freeze
 
-    PREDICATES.each do |predicate|
+    PREDICATES.each do |predicate, _|
       attr_accessor predicate
       alias_method predicate.to_s + '?', predicate
     end
 
-    attr_accessor :negative_form_of_to
+    attr_accessor :negative_form_of_to, :rspec_command
 
     def initialize
-      PREDICATES.each do |predicate|
-        instance_variable_set('@' + predicate.to_s, true)
+      PREDICATES.each do |predicate, default_value|
+        instance_variable_set('@' + predicate.to_s, default_value)
       end
 
       self.negative_form_of_to = 'not_to'

data/lib/transpec/{rewriter.rb → converter.rb}

@@ -1,83 +1,48 @@
 # coding: utf-8
 
+require 'transpec/base_rewriter'
+require 'transpec/configuration'
 require 'transpec/report'
-require 'transpec/ast/builder'
 require 'transpec/ast/scanner'
-require 'transpec/configuration'
 require 'transpec/syntax'
 require 'transpec/syntax/be_close'
 require 'transpec/syntax/double'
-require 'transpec/syntax/matcher'
+require 'transpec/syntax/expect'
 require 'transpec/syntax/method_stub'
 require 'transpec/syntax/raise_error'
 require 'transpec/syntax/rspec_configure'
 require 'transpec/syntax/should'
 require 'transpec/syntax/should_receive'
-require 'parser/current'
 
 module Transpec
-  class Rewriter
-    attr_reader :report, :invalid_context_errors
+  class Converter < BaseRewriter
+    attr_reader :configuration, :runtime_data, :report, :invalid_context_errors
 
-    def initialize(configuration = Configuration.new, report = Report.new)
-      @configuration = configuration
-      @report = report
-      @invalid_context_errors = []
-    end
+    alias_method :convert_file!, :rewrite_file!
+    alias_method :convert, :rewrite
 
-    def rewrite_file!(file_path)
-      source = File.read(file_path)
-      rewritten_source = rewrite(source, file_path)
-      return if source == rewritten_source
-      File.write(file_path, rewritten_source)
+    def initialize(configuration = nil, runtime_data = nil, report = nil)
+      @configuration = configuration || Configuration.new
+      @runtime_data = runtime_data
+      @report = report || Report.new
+      @invalid_context_errors = []
     end
 
-    def rewrite(source, name = '(string)')
-      source_buffer = create_source_buffer(source, name)
-      ast = parse(source_buffer)
-
-      @source_rewriter = Parser::Source::Rewriter.new(source_buffer)
-      failed_overlapping_rewrite = false
-      @source_rewriter.diagnostics.consumer = proc do
-        failed_overlapping_rewrite = true
-        fail OverlappedRewriteError
-      end
-
+    def process(ast, source_rewriter)
       AST::Scanner.scan(ast) do |node, ancestor_nodes|
-        dispatch_node(node, ancestor_nodes)
-      end
-
-      rewritten_source = @source_rewriter.process
-
-      if failed_overlapping_rewrite
-        rewriter = self.class.new(@configuration, @report)
-        rewritten_source = rewriter.rewrite(rewritten_source, name)
+        dispatch_node(node, ancestor_nodes, source_rewriter)
       end
-
-      rewritten_source
-    end
-
-    def create_source_buffer(source, name)
-      source_buffer = Parser::Source::Buffer.new(name)
-      source_buffer.source = source
-      source_buffer
     end
 
-    def parse(source_buffer)
-      builder = AST::Builder.new
-      parser = Parser::CurrentRuby.new(builder)
-      ast = parser.parse(source_buffer)
-      ast
-    end
-
-    def dispatch_node(node, ancestor_nodes)
-      Syntax.all.each do |syntax_class|
-        next unless syntax_class.target_node?(node)
+    def dispatch_node(node, ancestor_nodes, source_rewriter)
+      Syntax.standalone_syntaxes.each do |syntax_class|
+        next unless syntax_class.target_node?(node, @runtime_data)
 
         syntax = syntax_class.new(
           node,
           ancestor_nodes,
-          @source_rewriter,
+          source_rewriter,
+          @runtime_data,
           @report
         )
 
@@ -92,50 +57,60 @@ module Transpec
     end
 
     def process_should(should)
-      if @configuration.convert_to_expect_to_matcher?
+      if @configuration.convert_should?
         should.expectize!(
           @configuration.negative_form_of_to,
           @configuration.parenthesize_matcher_arg?
         )
       end
+
+      if should.have_matcher && @configuration.convert_have_items?
+        should.have_matcher.convert_to_standard_expectation!
+      end
+    end
+
+    def process_expect(expect)
+      if expect.have_matcher && @configuration.convert_have_items?
+        expect.have_matcher.convert_to_standard_expectation!
+      end
     end
 
     def process_should_receive(should_receive)
       if should_receive.useless_expectation?
-        if @configuration.replace_deprecated_method?
-          if @configuration.convert_to_allow_to_receive?
+        if @configuration.convert_deprecated_method?
+          if @configuration.convert_stub?
             should_receive.allowize_useless_expectation!(@configuration.negative_form_of_to)
           else
             should_receive.stubize_useless_expectation!
           end
-        elsif @configuration.convert_to_expect_to_receive?
+        elsif @configuration.convert_should_receive?
           should_receive.expectize!(@configuration.negative_form_of_to)
         end
-      elsif @configuration.convert_to_expect_to_receive?
+      elsif @configuration.convert_should_receive?
         should_receive.expectize!(@configuration.negative_form_of_to)
       end
     end
 
     def process_double(double)
-      double.convert_to_double! if @configuration.replace_deprecated_method?
+      double.convert_to_double! if @configuration.convert_deprecated_method?
     end
 
     def process_method_stub(method_stub)
-      if @configuration.convert_to_allow_to_receive?
+      if @configuration.convert_stub?
         method_stub.allowize!
-      elsif @configuration.replace_deprecated_method?
-        method_stub.replace_deprecated_method!
+      elsif @configuration.convert_deprecated_method?
+        method_stub.convert_deprecated_method!
       end
 
-      method_stub.remove_allowance_for_no_message! if @configuration.replace_deprecated_method?
+      method_stub.remove_allowance_for_no_message! if @configuration.convert_deprecated_method?
     end
 
     def process_be_close(be_close)
-      be_close.convert_to_be_within! if @configuration.replace_deprecated_method?
+      be_close.convert_to_be_within! if @configuration.convert_deprecated_method?
     end
 
     def process_raise_error(raise_error)
-      if @configuration.replace_deprecated_method?
+      if @configuration.convert_deprecated_method?
         raise_error.remove_error_specification_with_negative_expectation!
       end
     end
@@ -151,20 +126,18 @@ module Transpec
     end
 
     def need_to_modify_expectation_syntax_configuration?(rspec_configure)
-      return false unless @configuration.convert_to_expect_to_matcher?
+      return false unless @configuration.convert_should?
       rspec_configure.expectation_syntaxes == [:should]
     rescue Syntax::RSpecConfigure::UnknownSyntaxError
       false
     end
 
     def need_to_modify_mock_syntax_configuration?(rspec_configure)
-      return false if !@configuration.convert_to_expect_to_receive? &&
-                      !@configuration.convert_to_allow_to_receive?
+      return false if !@configuration.convert_should_receive? &&
+                      !@configuration.convert_stub?
       rspec_configure.mock_syntaxes == [:should]
     rescue Syntax::RSpecConfigure::UnknownSyntaxError
       false
     end
-
-    class OverlappedRewriteError < StandardError; end
   end
 end

data/lib/transpec/dynamic_analyzer/rewriter.rb

@@ -0,0 +1,94 @@
+# coding: utf-8
+
+require 'transpec/base_rewriter'
+require 'transpec/util'
+require 'transpec/ast/scanner'
+
+module Transpec
+  class DynamicAnalyzer
+    class Rewriter < BaseRewriter
+      include Util
+
+      def process(ast, source_rewriter)
+        # TODO: Currently multitheading is not considered...
+        clear_requests!
+        collect_requests(ast)
+        process_requests(source_rewriter)
+      end
+
+      def requests
+        @requests ||= {}
+      end
+
+      def clear_requests!
+        @requests = nil
+      end
+
+      def register_request(node, key, instance_eval_string, eval_target_type = :object)
+        unless EVAL_TARGET_TYPES.include?(eval_target_type)
+          fail "Target type must be any of #{EVAL_TARGET_TYPES}"
+        end
+
+        requests[node] ||= {}
+        requests[node][key] = [eval_target_type, instance_eval_string]
+      end
+
+      private
+
+      def collect_requests(ast)
+        AST::Scanner.scan(ast) do |node, ancestor_nodes|
+          Syntax.standalone_syntaxes.each do |syntax_class|
+            syntax_class.register_request_for_dynamic_analysis(node, self)
+            next unless syntax_class.target_node?(node)
+            syntax = syntax_class.new(node, ancestor_nodes)
+            syntax.register_request_for_dynamic_analysis(self)
+          end
+        end
+      end
+
+      def process_requests(source_rewriter)
+        requests.each do |node, analysis_codes|
+          inject_analysis_method(node, analysis_codes, source_rewriter)
+        end
+      end
+
+      def inject_analysis_method(node, analysis_codes, source_rewriter)
+        source_range = node.loc.expression
+
+        front = "#{ANALYSIS_METHOD}(("
+        rear = format(
+          '), self, %s, __FILE__, %d, %d)',
+          hash_literal(analysis_codes), source_range.begin_pos, source_range.end_pos
+        )
+        rear = "\n" + indentation_of_line(source_range.end) + rear if contain_here_document?(node)
+
+        parent_node = node.parent_node
+
+        if parent_node && parent_node.type == :block && parent_node.children.first.equal?(node)
+          source_range = node.parent_node.loc.expression
+        end
+
+        source_rewriter.insert_before(source_range, front)
+        source_rewriter.insert_after(source_range, rear)
+      rescue OverlappedRewriteError # rubocop:disable HandleExceptions
+      end
+
+      # Hash#inspect generates invalid literal with following example:
+      #
+      # > eval({ :predicate? => 1 }.inspect)
+      # SyntaxError: (eval):1: syntax error, unexpected =>
+      # {:predicate?=>1}
+      #               ^
+      def hash_literal(hash)
+        literal = '{ '
+
+        hash.each_with_index do |(key, value), index|
+          literal << ', ' unless index == 0
+          literal << "#{key.inspect} => #{value.inspect}"
+        end
+
+        literal << ' }'
+      end
+    end
+  end
+end

data/lib/transpec/dynamic_analyzer/runtime_data.rb

@@ -0,0 +1,27 @@
+# coding: utf-8
+
+require 'pathname'
+
+module Transpec
+  class DynamicAnalyzer
+    class RuntimeData
+      attr_reader :hash
+
+      def initialize(hash = {})
+        @hash = hash
+      end
+
+      def [](node)
+        @hash[node_id(node)]
+      end
+
+      def node_id(node)
+        source_range = node.loc.expression
+        source_buffer = source_range.source_buffer
+        absolute_path = File.expand_path(source_buffer.name)
+        relative_path = Pathname.new(absolute_path).relative_path_from(Pathname.pwd).to_s
+        [relative_path, source_range.begin_pos, source_range.end_pos].join('_')
+      end
+    end
+  end
+end