transpec 0.2.6 → 1.0.0

data/lib/transpec/dynamic_analyzer.rb

@@ -0,0 +1,166 @@
+# coding: utf-8
+
+require 'transpec/file_finder'
+require 'transpec/dynamic_analyzer/rewriter'
+require 'transpec/dynamic_analyzer/runtime_data'
+require 'tmpdir'
+require 'fileutils'
+require 'ostruct'
+require 'shellwords'
+require 'English'
+
+module Transpec
+  class DynamicAnalyzer
+    EVAL_TARGET_TYPES = [:object, :context]
+    ANALYSIS_METHOD = 'transpec_analysis'
+    HELPER_FILE = 'transpec_analysis_helper.rb'
+    RESULT_FILE = 'transpec_analysis_result.dump'
+    HELPER_SOURCE = <<-END
+      require 'ostruct'
+      require 'pathname'
+
+      module TranspecAnalysis
+        @base_pathname = Pathname.pwd
+
+        def self.data
+          @data ||= {}
+        end
+
+        def self.node_id(filename, begin_pos, end_pos)
+          absolute_path = File.expand_path(filename)
+          relative_path = Pathname.new(absolute_path).relative_path_from(@base_pathname).to_s
+          [relative_path, begin_pos, end_pos].join('_')
+        end
+
+        at_exit do
+          File.open('#{RESULT_FILE}', 'w') do |file|
+            Marshal.dump(data, file)
+          end
+        end
+      end
+
+      def #{ANALYSIS_METHOD}(object, context, analysis_codes, filename, begin_pos, end_pos)
+        pair_array = analysis_codes.map do |key, (target_type, code)|
+          target = case target_type
+                   when :object  then object
+                   when :context then context
+                   end
+
+          eval_data = OpenStruct.new
+
+          begin
+            eval_data.result = target.instance_eval(code)
+          rescue Exception => error
+            eval_data.error = error
+          end
+
+          [key, eval_data]
+        end
+
+        object_data = Hash[pair_array]
+
+        id = TranspecAnalysis.node_id(filename, begin_pos, end_pos)
+        TranspecAnalysis.data[id] = object_data
+
+        object
+      end
+    END
+
+    attr_reader :project_path, :rspec_command, :silent
+    alias_method :silent?, :silent
+
+    def initialize(options = {})
+      @project_path = options[:project_path] || Dir.pwd
+      @rspec_command = options[:rspec_command] || default_rspec_command
+      @silent = options[:silent] || false
+
+      if block_given?
+        in_copied_project do
+          yield self
+        end
+      end
+    end
+
+    def default_rspec_command
+      if File.exist?('Gemfile')
+        'bundle exec rspec'
+      else
+        'rspec'
+      end
+    end
+
+    def analyze(paths = [])
+      in_copied_project do
+        rewriter = Rewriter.new
+
+        FileFinder.find(paths).each do |file_path|
+          begin
+            rewriter.rewrite_file!(file_path)
+          rescue Parser::SyntaxError # rubocop:disable HandleExceptions
+            # Syntax errors will be reported in CLI with Converter.
+          end
+        end
+
+        File.write(HELPER_FILE, HELPER_SOURCE)
+
+        run_rspec(paths)
+
+        File.open(RESULT_FILE) do |file|
+          hash = Marshal.load(file)
+          RuntimeData.new(hash)
+        end
+      end
+    end
+
+    def in_copied_project
+      return yield if @in_copied_project
+
+      @in_copied_project = true
+
+      Dir.mktmpdir do |tmpdir|
+        FileUtils.cp_r(@project_path, tmpdir)
+        @copied_project_path = File.join(tmpdir, File.basename(@project_path))
+        Dir.chdir(@copied_project_path) do
+          yield
+        end
+      end
+    ensure
+      @in_copied_project = false
+    end
+
+    def run_rspec(paths)
+      with_bundler_clean_env do
+        ENV['SPEC_OPTS'] = ['-r', "./#{HELPER_FILE}"].shelljoin
+
+        command = "#{rspec_command} #{paths.shelljoin}"
+
+        if silent?
+          rspec_output = `#{command} 2> /dev/null`
+        else
+          system(command)
+        end
+
+        unless $CHILD_STATUS.exitstatus == 0
+          message = 'Dynamic analysis failed!'
+          if silent?
+            message << "\n"
+            message << rspec_output
+          end
+          fail message
+        end
+      end
+    end
+
+    def with_bundler_clean_env
+      if defined?(Bundler)
+        Bundler.with_clean_env do
+          # Bundler.with_clean_env cleans environment variables
+          # which are set after bundler is loaded.
+          yield
+        end
+      else
+        yield
+      end
+    end
+  end
+end

data/lib/transpec/file_finder.rb

@@ -0,0 +1,53 @@
+# coding: utf-8
+
+require 'find'
+
+module Transpec
+  module FileFinder
+    module_function
+
+    def find(paths)
+      base_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
+      end
+    end
+
+    def base_paths(paths)
+      if paths.empty?
+        if Dir.exists?('spec')
+          ['spec']
+        else
+          fail ArgumentError, 'Specify target files or directories.'
+        end
+      else
+        if paths.all? { |path| inside_of_current_working_directory?(path) }
+          paths
+        else
+          fail ArgumentError, 'Target path must be inside of the current working directory.'
+        end
+      end
+    end
+
+    def inside_of_current_working_directory?(path)
+      File.expand_path(path).start_with?(Dir.pwd)
+    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
+  end
+end

data/lib/transpec/option_parser.rb

@@ -0,0 +1,166 @@
+# coding: utf-8
+
+require 'transpec/configuration'
+require 'transpec/git'
+require 'transpec/version'
+require 'optparse'
+require 'rainbow'
+
+module Transpec
+  class OptionParser
+    CONFIG_ATTRS_FOR_CLI_TYPES = {
+              should: :convert_should=,
+      should_receive: :convert_should_receive=,
+                stub: :convert_stub=,
+          have_items: :convert_have_items=,
+          deprecated: :convert_deprecated_method=
+    }
+
+    attr_reader :configuration
+
+    def self.available_conversion_types
+      CONFIG_ATTRS_FOR_CLI_TYPES.keys
+    end
+
+    def initialize(configuration = Configuration.new)
+      @configuration = configuration
+      setup_parser
+    end
+
+    def parse(args)
+      args = args.dup
+      @parser.parse!(args)
+      args
+    end
+
+    def help
+      @parser.help
+    end
+
+    private
+
+    # rubocop:disable MethodLength
+    def setup_parser
+      @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('-m', '--generate-commit-message') do
+        unless Git.inside_of_repository?
+          fail '-m/--generate-commit-message option is specified but not in a Git repository'
+        end
+
+        @configuration.generate_commit_message = true
+      end
+
+      define_option('-k', '--keep TYPE[,TYPE...]') do |types|
+        types.split(',').each do |type|
+          config_attr = CONFIG_ATTRS_FOR_CLI_TYPES[type.to_sym]
+          fail ArgumentError, "Unknown syntax type #{type.inspect}" unless config_attr
+          @configuration.send(config_attr, false)
+        end
+      end
+
+      define_option('-n', '--negative-form FORM') do |form|
+        @configuration.negative_form_of_to = form
+      end
+
+      define_option('-p', '--no-parentheses-matcher-arg') do
+        @configuration.parenthesize_matcher_arg = false
+      end
+
+      define_option('--no-color') do
+        Sickill::Rainbow.enabled = false
+      end
+
+      define_option('--version') do
+        puts Version.to_s
+        exit
+      end
+    end
+    # rubocop:enable MethodLength
+
+    def create_parser
+      banner = "Usage: transpec [options] [files or directories]\n\n"
+      summary_width = 32 # Default
+      indentation = ' ' * 2
+      ::OptionParser.new(banner, summary_width, indentation)
+    end
+
+    def define_option(*options, &block)
+      description_lines = descriptions[options.first]
+      @parser.on(*options, *description_lines, &block)
+    end
+
+    # rubocop:disable MethodLength, AlignHash
+    def descriptions
+      @descriptions ||= {
+        '-f' => [
+          '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.'
+        ],
+        '-c' => [
+          'Specify command to run RSpec that is used for',
+          'dynamic analysis.',
+          'Default: "bundle exec rspec"'
+        ],
+        '-m' => [
+          'Generate commit message that describes',
+          'conversion summary. Only Git is supported.'
+        ],
+        '-k' => [
+          'Keep specific syntaxes by disabling',
+          'conversions.',
+          'Available syntax types:',
+          "  #{'should'.bright} (to #{'expect(obj).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(x)'.underline})",
+          "  #{'deprecated'.bright} (e.g. from #{'mock'.underline} to #{'double'.underline})",
+          'These are all converted by default.'
+        ],
+        '-n' => [
+          "Specify negative form of #{'to'.underline} that is used in",
+          "#{'expect(...).to'.underline} syntax.",
+          "Either #{'not_to'.bright} or #{'to_not'.bright}.",
+          "Default: #{'not_to'.bright}"
+        ],
+        '-p' => [
+          'Suppress parenthesizing argument of matcher',
+          'when converting operator to non-operator in',
+          "#{'expect'.underline} 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'.underline} to #{'eq(10)'.underline}",
+          "  #{'=~ /pattern/'.underline} to #{'match(/pattern/)'.underline}",
+          "  #{'=~ [1, 2]'.underline} to #{'match_array([1, 2])'.underline}"
+        ],
+        '--no-color' => [
+          'Disable color in the output.'
+        ],
+        '--version' => [
+          'Show Transpec version.'
+        ]
+      }
+    end
+    # rubocop:enable MethodLength, AlignHash
+  end
+end

data/lib/transpec/{context.rb → static_context_inspector.rb}

@@ -3,7 +3,7 @@
 require 'transpec/util'
 
 module Transpec
-  class Context
+  class StaticContextInspector
     include Util
 
     SCOPE_TYPES = [:module, :class, :sclass, :def, :defs, :block].freeze
@@ -67,7 +67,7 @@ module Transpec
       @expectation_available = match_scopes(NON_MONKEY_PATCH_EXPECTATION_AVAILABLE_CONTEXT)
     end
 
-    alias_method :expect_to_matcher_available?, :non_monkey_patch_expectation_available?
+    alias_method :expect_available?, :non_monkey_patch_expectation_available?
 
     def non_monkey_patch_mock_available?
       return @mock_available if instance_variable_defined?(:@mock_available)

data/lib/transpec/syntax/be_close.rb

@@ -1,11 +1,17 @@
 # coding: utf-8
 
 require 'transpec/syntax'
-require 'transpec/syntax/send_node_syntax'
+require 'transpec/syntax/mixin/send'
 
 module Transpec
   class Syntax
     class BeClose < Syntax
+      include Mixin::Send
+
+      def self.target_method?(receiver_node, method_name)
+        receiver_node.nil? && method_name == :be_close
+      end
+
       def convert_to_be_within!
         _receiver_node, _method_name, expected_node, delta_node = *node
 
@@ -22,14 +28,6 @@ module Transpec
 
       private
 
-      def self.target_receiver_node?(node)
-        node.nil?
-      end
-
-      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

data/lib/transpec/syntax/double.rb

@@ -1,12 +1,16 @@
 # coding: utf-8
 
 require 'transpec/syntax'
-require 'transpec/syntax/send_node_syntax'
+require 'transpec/syntax/mixin/send'
 
 module Transpec
   class Syntax
     class Double < Syntax
-      include SendNodeSyntax
+      include Mixin::Send
+
+      def self.target_method?(receiver_node, method_name)
+        receiver_node.nil? && [:double, :mock, :stub].include?(method_name)
+      end
 
       def convert_to_double!
         return if method_name == :double
@@ -16,14 +20,6 @@ module Transpec
 
       private
 
-      def self.target_receiver_node?(node)
-        node.nil?
-      end
-
-      def self.target_method_names
-        [:double, :mock, :stub]
-      end
-
       def register_record
         @report.records << Record.new("#{method_name}('something')", "double('something')")
       end

data/lib/transpec/syntax/expect.rb

@@ -0,0 +1,35 @@
+# coding: utf-8
+
+require 'transpec/syntax'
+require 'transpec/syntax/mixin/send'
+require 'transpec/syntax/mixin/have_matcher'
+
+module Transpec
+  class Syntax
+    class Expect < Syntax
+      include Mixin::Send, Mixin::HaveMatcher
+
+      def self.target_method?(receiver_node, method_name)
+        receiver_node.nil? && method_name == :expect
+      end
+
+      def register_request_for_dynamic_analysis(rewriter)
+        have_matcher.register_request_for_dynamic_analysis(rewriter) if have_matcher
+      end
+
+      def current_syntax_type
+        :expect
+      end
+
+      def matcher_node
+        parent_node.children[2]
+      end
+
+      alias_method :subject_node, :arg_node
+
+      def subject_range
+        subject_node.loc.expression
+      end
+    end
+  end
+end

data/lib/transpec/syntax/have.rb

@@ -0,0 +1,195 @@
+# coding: utf-8
+
+require 'transpec/syntax'
+require 'transpec/syntax/mixin/send'
+
+module Transpec
+  class Syntax
+    class Have < Syntax
+      include Mixin::Send
+
+      # String#count is not query method, and there's no way to determine
+      # whether a method is query method.
+      # Method#arity and Method#parameters return same results
+      # for Array#count (0+ args) and String#count (1+ args).
+      #
+      # So I make #size a priority over #count so that #count won't be chosen
+      # for String (String responds to #size).
+      QUERY_METHOD_PRIORITIES = [:size, :count, :length].freeze
+
+      def self.standalone?
+        false
+      end
+
+      def self.target_method?(have_node, items_method_name)
+        return false unless have_node
+        have_receiver_node, have_method_name, *_ = *have_node
+        return false if have_receiver_node
+        [:have, :have_exactly, :have_at_least, :have_at_most].include?(have_method_name)
+      end
+
+      def initialize(node, expectation, source_rewriter = nil, runtime_data = nil, report = nil)
+        @node = node
+        @expectation = expectation
+        @source_rewriter = source_rewriter
+        @runtime_data = runtime_data
+        @report = report || Report.new
+      end
+
+      def register_request_for_dynamic_analysis(rewriter)
+        node = @expectation.subject_node
+
+        # `expect(owner).to have(n).things` invokes private owner#things with Object#__send__
+        # if the owner does not respond to any of #size, #count and #length.
+        #
+        # rubocop:disable LineLength
+        # https://github.com/rspec/rspec-expectations/blob/v2.14.3/lib/rspec/matchers/built_in/have.rb#L48-L58
+        # rubocop:enable LineLength
+        key = :subject_is_owner_of_collection?
+        code = "respond_to?(#{items_name.inspect}) || " +
+               "(methods & #{QUERY_METHOD_PRIORITIES.inspect}).empty?"
+        rewriter.register_request(node, key, code)
+
+        key = :available_query_methods
+        code = "target = #{code} ? #{items_name} : self; " +
+               "target.methods & #{QUERY_METHOD_PRIORITIES.inspect}"
+        rewriter.register_request(node, key, code)
+
+        key = :collection_accessor_is_private?
+        code = "private_methods.include?(#{items_name.inspect})"
+        rewriter.register_request(node, key, code)
+      end
+
+      def convert_to_standard_expectation!
+        replace(@expectation.subject_range, replacement_subject_source)
+        replace(expression_range, replacement_matcher_source(size_source))
+        register_record
+      end
+
+      def have_node
+        node.children.first
+      end
+
+      def size_node
+        have_node.children[2]
+      end
+
+      alias_method :items_node, :node
+
+      def have_method_name
+        have_node.children[1]
+      end
+
+      def items_name
+        items_node.children[1]
+      end
+
+      def subject_is_owner_of_collection?
+        node_data = runtime_node_data(@expectation.subject_node)
+        node_data && node_data[:subject_is_owner_of_collection?].result
+      end
+
+      def collection_accessor_is_private?
+        node_data = runtime_node_data(@expectation.subject_node)
+        node_data && node_data[:collection_accessor_is_private?].result
+      end
+
+      def query_method
+        node_data = runtime_node_data(@expectation.subject_node)
+        if node_data
+          (QUERY_METHOD_PRIORITIES & node_data[:available_query_methods].result).first
+        else
+          default_query_method
+        end
+      end
+
+      private
+
+      def default_query_method
+        QUERY_METHOD_PRIORITIES.first
+      end
+
+      def replacement_subject_source
+        source = @expectation.subject_range.source
+        if subject_is_owner_of_collection?
+          if collection_accessor_is_private?
+            source << ".send(#{items_name.inspect})"
+          else
+            source << ".#{items_name}"
+          end
+        end
+        source << ".#{query_method}"
+      end
+
+      def replacement_matcher_source(size_source)
+        case @expectation.current_syntax_type
+        when :should
+          case have_method_name
+          when :have, :have_exactly then "== #{size_source}"
+          when :have_at_least       then ">= #{size_source}"
+          when :have_at_most        then "<= #{size_source}"
+          end
+        when :expect
+          case have_method_name
+          when :have, :have_exactly then "eq(#{size_source})"
+          when :have_at_least       then "be >= #{size_source}"
+          when :have_at_most        then "be <= #{size_source}"
+          end
+        end
+      end
+
+      def size_source
+        size_node.loc.expression.source
+      end
+
+      def dot_items_range
+        map = items_node.loc
+        map.dot.join(map.selector)
+      end
+
+      def register_record
+        @report.records << Record.new(original_syntax, converted_syntax)
+      end
+
+      def original_syntax
+        if subject_is_owner_of_collection?
+          subject = 'obj'
+          items = items_name
+        else
+          subject = 'collection'
+          items = 'items'
+        end
+
+        syntax = case @expectation
+                 when Should
+                   "#{subject}.should"
+                 when Expect
+                   "expect(#{subject}).to"
+                 end
+
+        syntax << " #{have_method_name}(n).#{items}"
+      end
+
+      def converted_syntax
+        subject = if subject_is_owner_of_collection?
+                    if collection_accessor_is_private?
+                      "obj.send(#{items_name.inspect}).#{query_method}"
+                    else
+                      "obj.#{items_name}.#{query_method}"
+                    end
+                  else
+                    "collection.#{default_query_method}"
+                  end
+
+        syntax = case @expectation.current_syntax_type
+                 when :should
+                   "#{subject}.should"
+                 when :expect
+                   "expect(#{subject}).to"
+                 end
+
+        syntax << " #{replacement_matcher_source('n')}"
+      end
+    end
+  end
+end