transpec 1.3.1 → 1.4.0

data/lib/transpec/ast/node.rb

@@ -5,9 +5,13 @@ require 'parser'
 module Transpec
   module AST
     class Node < Parser::AST::Node
+      attr_reader :metadata
+
       def initialize(type, children = [], properties = {})
-        @properties = {}
+        @metadata = {}
+        @mutable_attributes = {}
 
+        # ::AST::Node#initialize freezes itself.
         super
 
         each_child_node do |child_node|
@@ -16,11 +20,11 @@ module Transpec
       end
 
       def parent_node
-        @properties[:parent_node]
+        @mutable_attributes[:parent_node]
       end
 
       def parent_node=(node)
-        @properties[:parent_node] = node
+        @mutable_attributes[:parent_node] = node
       end
 
       protected :parent_node=

data/lib/transpec/cli.rb

@@ -46,7 +46,7 @@ module Transpec
       runtime_data = nil
 
       unless @configuration.skip_dynamic_analysis?
-        puts 'Copying project for dynamic analysis...'
+        puts 'Copying the 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)

data/lib/transpec/configuration.rb

@@ -8,6 +8,7 @@ module Transpec
 
     PREDICATES = [
       [:convert_should,            true],
+      [:convert_oneliner,          true],
       [:convert_should_receive,    true],
       [:convert_stub,              true],
       [:convert_have_items,        true],

data/lib/transpec/converter.rb

@@ -8,9 +8,11 @@ require 'transpec/syntax'
 require 'transpec/syntax/be_boolean'
 require 'transpec/syntax/be_close'
 require 'transpec/syntax/double'
+require 'transpec/syntax/example'
 require 'transpec/syntax/expect'
 require 'transpec/syntax/its'
 require 'transpec/syntax/method_stub'
+require 'transpec/syntax/oneliner_should'
 require 'transpec/syntax/raise_error'
 require 'transpec/syntax/rspec_configure'
 require 'transpec/syntax/should'
@@ -68,9 +70,31 @@ module Transpec
       end
     end
 
+    def process_oneliner_should(oneliner_should)
+      negative_form = @configuration.negative_form_of_to
+      parenthesize = @configuration.parenthesize_matcher_arg?
+
+      # TODO: Referencing oneliner_should.have_matcher.project_requires_collection_matcher?
+      #   from this converter is considered bad design.
+      should_convert_have_items = @configuration.convert_have_items? &&
+                                  oneliner_should.have_matcher &&
+                                  !oneliner_should.have_matcher.project_requires_collection_matcher?
+
+      if should_convert_have_items
+        if @configuration.convert_should?
+          oneliner_should.convert_have_items_to_standard_expect!(negative_form, parenthesize)
+        else
+          oneliner_should.convert_have_items_to_standard_should!
+        end
+      elsif @configuration.convert_oneliner? && @rspec_version.one_liner_is_expected_available?
+        oneliner_should.expectize!(negative_form, parenthesize)
+      end
+    end
+
     def process_expect(expect)
       if expect.have_matcher && @configuration.convert_have_items?
-        expect.have_matcher.convert_to_standard_expectation!
+        parenthesize_matcher_arg = @configuration.parenthesize_matcher_arg
+        expect.have_matcher.convert_to_standard_expectation!(parenthesize_matcher_arg)
       end
     end
 
@@ -96,7 +120,7 @@ module Transpec
 
     def process_method_stub(method_stub)
       if @configuration.convert_stub?
-        method_stub.allowize!(@rspec_version.receive_messages_available?)
+        method_stub.allowize!(@rspec_version)
       elsif @configuration.convert_deprecated_method?
         method_stub.convert_deprecated_method!
       end
@@ -130,6 +154,11 @@ module Transpec
       its.convert_to_describe_subject_it! if @configuration.convert_its?
     end
 
+    def process_example(example)
+      return unless @rspec_version.yielded_example_available?
+      example.convert! if @configuration.convert_deprecated_method?
+    end
+
     def process_rspec_configure(rspec_configure)
       if need_to_modify_expectation_syntax_configuration?(rspec_configure)
         rspec_configure.modify_expectation_syntaxes!(:expect)

data/lib/transpec/dynamic_analyzer.rb

@@ -19,7 +19,6 @@ module Transpec
     RESULT_FILE = 'transpec_analysis_result.json'
     HELPER_SOURCE = <<-END
       require 'pathname'
-      require 'json'
 
       module TranspecAnalysis
         @base_path = Dir.pwd
@@ -44,6 +43,7 @@ module Transpec
           #   (Such objects are stored as a string.)
           # * Singleton method information won't be serialized.
           #   (With Marshal.load, `singleton can't be dumped (TypeError)` will be raised.)
+          require 'json'
           path = File.join(@base_path, '#{RESULT_FILE}')
           File.open(path, 'w') do |file|
             JSON.dump(data, file)

data/lib/transpec/option_parser.rb

@@ -10,6 +10,7 @@ module Transpec
   class OptionParser
     CONFIG_ATTRS_FOR_KEEP_TYPES = {
               should: :convert_should=,
+            oneliner: :convert_oneliner=,
       should_receive: :convert_should_receive=,
                 stub: :convert_stub=,
           have_items: :convert_have_items=,
@@ -140,6 +141,7 @@ module Transpec
           '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(x)'.underline})",
@@ -154,7 +156,7 @@ module Transpec
           "Default: #{'not_to'.bright}"
         ],
         '-b' => [
-          "Specify matcher type that #{'be_true'.underline} and",
+          "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})",
@@ -162,14 +164,15 @@ module Transpec
           "Default: #{'truthy,falsey'.bright}"
         ],
         '-p' => [
-          'Suppress parenthesizing argument of matcher',
-          'when converting operator to non-operator in',
-          "the #{'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.',
+          '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}"

data/lib/transpec/project.rb

@@ -1,6 +1,7 @@
 # coding: utf-8
 
 require 'transpec/rspec_version'
+require 'English'
 
 module Transpec
   class Project
@@ -20,18 +21,7 @@ module Transpec
     end
 
     def rspec_version
-      @rspec_version ||= begin
-        command = 'rspec --version'
-        command = 'bundle exec ' + command if require_bundler?
-
-        version_string = nil
-
-        Dir.chdir(@path) do
-          with_bundler_clean_env { version_string = `#{command}`.chomp }
-        end
-
-        RSpecVersion.new(version_string)
-      end
+      @rspec_version ||= RSpecVersion.new(fetch_rspec_version)
     end
 
     def with_bundler_clean_env
@@ -45,5 +35,26 @@ module Transpec
         yield
       end
     end
+
+    private
+
+    def fetch_rspec_version
+      command = 'rspec --version'
+      command = 'bundle exec ' + command if require_bundler?
+
+      output = nil
+
+      Dir.chdir(@path) do
+        with_bundler_clean_env do
+          IO.popen(command) do |io|
+            output = io.read
+          end
+        end
+      end
+
+      fail 'Failed checking RSpec version.' if output.nil? || $CHILD_STATUS.exitstatus != 0
+
+      output.chomp
+    end
   end
 end

data/lib/transpec/rspec_version.rb

@@ -15,8 +15,10 @@ module Transpec
     # Prerelease parts are sorted alphabetically using the normal Ruby string sorting rules.
     # If a prerelease part contains both letters and numbers, it will be broken into multiple parts
     # to provide expected sort behavior (1.0.a10 becomes 1.0.a.10, and is greater than 1.0.a9).
-    GEM_VERSION_2_99 = Gem::Version.new('2.99.aaaaaaaaaa')
-    GEM_VERSION_3_0  = Gem::Version.new('3.0.aaaaaaaaaa')
+    GEM_VERSION_2_99_0_BETA1 = Gem::Version.new('2.99.0.beta1')
+    GEM_VERSION_2_99_0_BETA2 = Gem::Version.new('2.99.0.beta2')
+    GEM_VERSION_3_0_0_BETA1  = Gem::Version.new('3.0.0.beta1')
+    GEM_VERSION_3_0_0_BETA2  = Gem::Version.new('3.0.0.beta2')
 
     attr_reader :gem_version
 
@@ -29,11 +31,23 @@ module Transpec
     end
 
     def be_truthy_available?
-      @gem_version >= GEM_VERSION_2_99
+      @gem_version >= GEM_VERSION_2_99_0_BETA1
+    end
+
+    def yielded_example_available?
+      @gem_version >= GEM_VERSION_2_99_0_BETA1
+    end
+
+    def one_liner_is_expected_available?
+      @gem_version >= GEM_VERSION_2_99_0_BETA2
     end
 
     def receive_messages_available?
-      @gem_version >= GEM_VERSION_3_0
+      @gem_version >= GEM_VERSION_3_0_0_BETA1
+    end
+
+    def receive_message_chain_available?
+      @gem_version >= GEM_VERSION_3_0_0_BETA2
     end
 
     def <=>(other)

data/lib/transpec/static_context_inspector.rb

@@ -8,21 +8,6 @@ module Transpec
 
     SCOPE_TYPES = [:module, :class, :sclass, :def, :defs, :block].freeze
 
-    EXAMPLE_GROUP_METHODS = [
-      :describe, :context,
-      :shared_examples, :shared_context, :share_examples_for, :shared_examples_for
-    ].freeze
-
-    EXAMPLE_METHODS = [
-      :example, :it, :specify,
-      :focus, :focused, :fit,
-      :pending, :xexample, :xit, :xspecify
-    ].freeze
-
-    HOOK_METHODS = [:before, :after, :around].freeze
-
-    HELPER_METHODS = [:subject, :subject!, :let, :let!]
-
     NON_MONKEY_PATCH_EXPECTATION_AVAILABLE_CONTEXT = [
       [:example_group, :example],
       [:example_group, :each_before_after],

data/lib/transpec/syntax/example.rb

@@ -0,0 +1,83 @@
+# coding: utf-8
+
+require 'transpec/syntax'
+require 'transpec/syntax/mixin/send'
+require 'transpec/util'
+
+module Transpec
+  class Syntax
+    class Example < Syntax
+      include Mixin::Send, Util
+
+      METHODS_YIELD_EXAMPLE = (EXAMPLE_METHODS + HOOK_METHODS + HELPER_METHODS).freeze
+
+      def self.target_method?(receiver_node, method_name)
+        receiver_node.nil? && [:example, :running_example].include?(method_name)
+      end
+
+      def convert!
+        if block_node
+          insert_after(block_node.loc.begin, " |#{block_arg_name}|") unless block_has_argument?
+          replace(selector_range, block_arg_name.to_s) unless method_name == block_arg_name
+          block_node.metadata[:added_example_block_arg] = true
+        else
+          replace(selector_range, 'RSpec.current_example')
+        end
+
+        register_record
+      end
+
+      private
+
+      def block_has_argument?
+        block_arg_node || block_node.metadata[:added_example_block_arg]
+      end
+
+      def block_node
+        return @block_node if instance_variable_defined?(:@block_node)
+
+        @block_node ||= @node.each_ancestor_node.find do |ancestor_node|
+          next false unless ancestor_node.type == :block
+          method_name = method_name_of_block_node(ancestor_node)
+          METHODS_YIELD_EXAMPLE.include?(method_name)
+        end
+      end
+
+      def block_method_name
+        method_name_of_block_node(block_node)
+      end
+
+      def block_arg_node
+        args_node = block_node.children[1]
+        args_node.children.first
+      end
+
+      def block_arg_name
+        if block_arg_node
+          block_arg_node.children.first
+        else
+          :example
+        end
+      end
+
+      def method_name_of_block_node(block_node)
+        send_node = block_node.children.first
+        send_node.children[1]
+      end
+
+      def register_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'
+        end
+
+        @report.records << Record.new(original_syntax, converted_syntax)
+      end
+    end
+  end
+end

data/lib/transpec/syntax/expect.rb

@@ -21,6 +21,11 @@ module Transpec
         :expect
       end
 
+      def positive?
+        to_method_name = parent_node.children[1]
+        to_method_name == :to
+      end
+
       def matcher_node
         parent_node.children[2]
       end

data/lib/transpec/syntax/have.rb

@@ -44,9 +44,13 @@ module Transpec
 
       def convert_to_standard_expectation!(parenthesize_matcher_arg = true)
         return if project_requires_collection_matcher?
-        replace(@expectation.subject_range, replacement_subject_source)
-        replace(expression_range, replacement_matcher_source(size_source, parenthesize_matcher_arg))
-        register_record
+        replace(@expectation.subject_range, replacement_subject_source) if explicit_subject?
+        replace(expression_range, replacement_matcher_source(parenthesize_matcher_arg))
+        register_record if explicit_subject?
+      end
+
+      def explicit_subject?
+        @expectation.respond_to?(:subject_node)
       end
 
       def have_node
@@ -105,24 +109,12 @@ module Transpec
         QUERY_METHOD_PRIORITIES.first
       end
 
-      def replacement_matcher_source(size_source, parenthesize_arg = true)
-        case @expectation.current_syntax_type
-        when :should
-          replacement_matcher_source_for_should(size_source)
-        when :expect
-          replacement_matcher_source_for_expect(size_source, parenthesize_arg)
-        end
-      end
-
-      private
-
-      def runtime_subject_data
-        return @runtime_subject_data if instance_variable_defined?(:@runtime_subject_data)
-        @runtime_subject_data = runtime_node_data(@expectation.subject_node)
+      def replacement_subject_source
+        build_replacement_subject_source(@expectation.subject_range.source)
       end
 
-      def replacement_subject_source
-        source = @expectation.subject_range.source
+      def build_replacement_subject_source(original_subject_source)
+        source = original_subject_source.dup
         if subject_is_owner_of_collection?
           if collection_accessor_is_private?
             source << ".send(#{collection_accessor.inspect}"
@@ -135,7 +127,33 @@ module Transpec
         source << ".#{query_method}"
       end
 
-      def replacement_matcher_source_for_should(size_source)
+      def replacement_matcher_source(parenthesize_arg)
+        size_source = size_node.loc.expression.source
+        build_replacement_matcher_source(size_source, parenthesize_arg)
+      end
+
+      def build_replacement_matcher_source(size_source, parenthesize_arg = true)
+        case @expectation.current_syntax_type
+        when :should
+          build_replacement_matcher_source_for_should(size_source)
+        when :expect
+          build_replacement_matcher_source_for_expect(size_source, parenthesize_arg)
+        end
+      end
+
+      def size_source
+        size_node.loc.expression.source
+      end
+
+      private
+
+      def runtime_subject_data
+        return @runtime_subject_data if instance_variable_defined?(:@runtime_subject_data)
+        node = explicit_subject? ? @expectation.subject_node : @expectation.node
+        @runtime_subject_data = runtime_node_data(node)
+      end
+
+      def build_replacement_matcher_source_for_should(size_source)
         case have_method_name
         when :have, :have_exactly then "== #{size_source}"
         when :have_at_least       then ">= #{size_source}"
@@ -143,7 +161,7 @@ module Transpec
         end
       end
 
-      def replacement_matcher_source_for_expect(size_source, parenthesize_arg)
+      def build_replacement_matcher_source_for_expect(size_source, parenthesize_arg)
         case have_method_name
         when :have, :have_exactly
           if parenthesize_arg
@@ -158,10 +176,6 @@ module Transpec
         end
       end
 
-      def size_source
-        size_node.loc.expression.source
-      end
-
       def register_record
         @report.records << HaveRecord.new(self)
       end
@@ -177,33 +191,47 @@ module Transpec
         end
 
         def target_node
-          @have.expectation.subject_node
+          if @have.explicit_subject?
+            @have.expectation.subject_node
+          else
+            @have.expectation.node
+          end
+        end
+
+        def target_type
+          if @have.explicit_subject?
+            :object
+          else
+            :context
+          end
         end
 
         def register_request
           key = :collection_accessor
           code = collection_accessor_inspection_code
-          @rewriter.register_request(target_node, key, code)
+          @rewriter.register_request(target_node, key, code, target_type)
 
           # Give up inspecting query methods of collection accessor with arguments
           # (e.g. have(2).errors_on(variable)) since this is a context of #instance_eval.
           unless @have.items_method_has_arguments?
             key = :available_query_methods
-            code = "collection_accessor = #{code}; " +
-                   'target = collection_accessor ? __send__(collection_accessor) : self; ' +
-                   "target.methods & #{QUERY_METHOD_PRIORITIES.inspect}"
-            @rewriter.register_request(target_node, key, code)
+            code = available_query_methods_inspection_code
+            @rewriter.register_request(target_node, key, code, target_type)
           end
 
           key = :collection_accessor_is_private?
-          code = "private_methods.include?(#{@have.items_name.inspect})"
-          @rewriter.register_request(target_node, key, code)
+          code = "#{subject_code}.private_methods.include?(#{@have.items_name.inspect})"
+          @rewriter.register_request(target_node, key, code, target_type)
 
           key = :project_requires_collection_matcher?
           code = 'defined?(RSpec::Rails) || defined?(RSpec::CollectionMatchers)'
           @rewriter.register_request(target_node, key, code, :context)
         end
 
+        def subject_code
+          @have.explicit_subject? ? 'self' : 'subject'
+        end
+
         # rubocop:disable MethodLength
         def collection_accessor_inspection_code
           # `expect(owner).to have(n).things` invokes private owner#things with Object#__send__
@@ -212,7 +240,7 @@ module Transpec
           # 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
-          <<-END.gsub(/^\s+\|/, '').chomp
+          @collection_accessor_inspection_code ||= <<-END.gsub(/^\s+\|/, '').chomp
             |begin
             |  exact_name = #{@have.items_name.inspect}
             |
@@ -227,12 +255,13 @@ module Transpec
             |
             |  if inflector
             |    pluralized_name = inflector.pluralize(exact_name).to_sym
-            |    respond_to_pluralized_name = respond_to?(pluralized_name)
+            |    respond_to_pluralized_name = #{subject_code}.respond_to?(pluralized_name)
             |  end
             |
-            |  respond_to_query_methods = !(methods & #{QUERY_METHOD_PRIORITIES.inspect}).empty?
+            |  respond_to_query_methods =
+            |    !(#{subject_code}.methods & #{QUERY_METHOD_PRIORITIES.inspect}).empty?
             |
-            |  if respond_to?(exact_name)
+            |  if #{subject_code}.respond_to?(exact_name)
             |    exact_name
             |  elsif respond_to_pluralized_name
             |    pluralized_name
@@ -245,6 +274,18 @@ module Transpec
           END
         end
         # rubocop:enable MethodLength
+
+        def available_query_methods_inspection_code
+          <<-END.gsub(/^\s+\|/, '').chomp
+            |collection_accessor = #{collection_accessor_inspection_code}
+            |target = if collection_accessor
+            |           #{subject_code}.__send__(collection_accessor)
+            |         else
+            |           #{subject_code}
+            |         end
+            |target.methods & #{QUERY_METHOD_PRIORITIES.inspect}
+          END
+        end
       end
 
       class HaveRecord < Record
@@ -254,28 +295,35 @@ module Transpec
 
         def original_syntax
           @original_syntax ||= begin
-            syntax = case @have.expectation
-                     when Should
-                       "#{original_subject}.should"
-                     when Expect
-                       "expect(#{original_subject}).to"
-                     end
-
+            type = @have.expectation.class.snake_case_name.to_sym
+            syntax = build_expectation(original_subject, type)
             syntax << " #{@have.have_method_name}(n).#{original_items}"
           end
         end
 
         def converted_syntax
           @converted_syntax ||= begin
-            syntax = case @have.expectation.current_syntax_type
-                     when :should
-                       "#{converted_subject}.should"
-                     when :expect
-                       "expect(#{converted_subject}).to"
-                     end
-
-            syntax << " #{@have.replacement_matcher_source('n')}"
+            type = @have.expectation.current_syntax_type
+            syntax = build_expectation(converted_subject, type)
+            syntax << " #{@have.build_replacement_matcher_source('n')}"
+          end
+        end
+
+        def build_expectation(subject, type)
+          case type
+          when :should
+            syntax = "#{subject}.should"
+            syntax << '_not' unless positive?
+          when :expect
+            syntax = "expect(#{subject})."
+            syntax << (positive? ? 'to' : 'not_to')
           end
+
+          syntax
+        end
+
+        def positive?
+          @have.expectation.positive?
         end
 
         def original_subject
@@ -300,7 +348,16 @@ module Transpec
 
         def converted_subject
           if @have.subject_is_owner_of_collection?
-            subject = 'obj.'
+            build_converted_subject('obj')
+          else
+            build_converted_subject('collection')
+          end
+        end
+
+        def build_converted_subject(subject)
+          subject << '.'
+
+          if @have.subject_is_owner_of_collection?
             if @have.collection_accessor_is_private?
               subject << "send(#{@have.collection_accessor.inspect}"
               subject << ', ...' if @have.items_method_has_arguments?
@@ -311,7 +368,7 @@ module Transpec
             end
             subject << ".#{@have.query_method}"
           else
-            "collection.#{@have.default_query_method}"
+            subject << "#{@have.default_query_method}"
           end
         end
       end