transpec 1.10.3 → 1.10.4

data/lib/transpec/syntax/mixin/useless_and_return.rb

@@ -48,21 +48,19 @@ module Transpec
             @host = host
           end
 
-          def original_syntax
+          def build_original_syntax
             syntax = base_syntax
             syntax << '.and_return'
             syntax << ' { value }' if @host.and_return_with_block?
             syntax
           end
 
-          def converted_syntax
+          def build_converted_syntax
             syntax = base_syntax
             syntax << ' { value }' if @host.and_return_with_block?
             syntax
           end
 
-          private
-
           def base_syntax
             fail NotImplementedError
           end

data/lib/transpec/syntax/oneliner_should.rb

@@ -13,15 +13,15 @@ module Transpec
 
       attr_reader :current_syntax_type
 
-      def self.target_method?(receiver_node, method_name)
-        receiver_node.nil? && [:should, :should_not].include?(method_name)
-      end
-
       def initialize(node, source_rewriter = nil, runtime_data = nil, report = nil)
         super
         @current_syntax_type = :should
       end
 
+      def dynamic_analysis_target?
+        super && receiver_node.nil? && [:should, :should_not].include?(method_name)
+      end
+
       def expectize!(negative_form = 'not_to', parenthesize_matcher_arg = true)
         replacement = 'is_expected.'
         replacement << (positive? ? 'to' : negative_form)
@@ -169,23 +169,21 @@ module Transpec
           @negative_form_of_to = negative_form_of_to
         end
 
-        def original_syntax
-          @original_syntax ||= begin
-            syntax = should.example_has_description? ? "it '...' do" : 'it {'
-            syntax << " #{should.method_name} #{have.method_name}(n).#{original_items} "
-            syntax << (should.example_has_description? ? 'end' : '}')
-          end
+        private
+
+        def build_original_syntax
+          syntax = should.example_has_description? ? "it '...' do" : 'it {'
+          syntax << " #{should.method_name} #{have.method_name}(n).#{original_items} "
+          syntax << (should.example_has_description? ? 'end' : '}')
         end
 
-        def converted_syntax
-          @converted_syntax ||= begin
-            syntax = converted_description
-            syntax << ' '
-            syntax << converted_expectation
-            syntax << ' '
-            syntax << source_builder.replacement_matcher_source
-            syntax << ' end'
-          end
+        def build_converted_syntax
+          syntax = converted_description
+          syntax << ' '
+          syntax << converted_expectation
+          syntax << ' '
+          syntax << source_builder.replacement_matcher_source
+          syntax << ' end'
         end
 
         def converted_description

data/lib/transpec/syntax/operator.rb

@@ -15,25 +15,16 @@ module Transpec
       OPERATORS = [:==, :===, :<, :<=, :>, :>=, :=~].freeze
       BE_NODE = s(:send, nil, :be)
 
-      def self.standalone?
-        false
-      end
-
-      def self.check_target_node_statically(node)
-        node = node.parent_node if node == BE_NODE
-        super(node)
-      end
-
-      def self.target_method?(receiver_node, method_name)
-        !receiver_node.nil? && OPERATORS.include?(method_name)
-      end
-
-      define_dynamic_analysis_request do |rewriter|
+      define_dynamic_analysis do |rewriter|
         if method_name == :=~
           rewriter.register_request(arg_node, :enumerable_arg?, 'is_a?(Enumerable)')
         end
       end
 
+      def self.standalone?
+        false
+      end
+
       def initialize(node, expectation, source_rewriter = nil, runtime_data = nil, report = nil)
         operator_node = if node == BE_NODE
                           node.parent_node
@@ -44,6 +35,10 @@ module Transpec
         super(operator_node, expectation, source_rewriter, runtime_data, report)
       end
 
+      def dynamic_analysis_target?
+        super && !receiver_node.nil? && OPERATORS.include?(method_name)
+      end
+
       def convert_operator!(parenthesize_arg = true)
         case method_name
         when :==

data/lib/transpec/syntax/pending.rb

@@ -9,31 +9,30 @@ module Transpec
     class Pending < Syntax
       include Mixin::Send, Util
 
-      def self.conversion_target_node?(node, runtime_data = nil)
-        return false unless target_node?(node, runtime_data)
+      define_dynamic_analysis do |rewriter|
+        code = 'is_a?(RSpec::Core::ExampleGroup)'
+        rewriter.register_request(node, :example_context?, code, :context)
+      end
+
+      def dynamic_analysis_target?
+        super && receiver_node.nil? && method_name == :pending
+      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 && runtime_data.run?(node)
+        if runtime_data.run?(node)
           # If we have runtime data, check with it.
           runtime_data[node, :example_context?]
         else
           # Otherwise check statically.
-          inspector = StaticContextInspector.new(node)
-          inspector.scopes.last == :example
+          static_context_inspector.scopes.last == :example
         end
       end
 
-      def self.target_method?(receiver_node, method_name)
-        receiver_node.nil? && method_name == :pending
-      end
-
-      define_dynamic_analysis_request do |rewriter|
-        code = 'is_a?(RSpec::Core::ExampleGroup)'
-        rewriter.register_request(node, :example_context?, code, :context)
-      end
-
       def convert_deprecated_syntax!
         if block_node
           unblock!
@@ -51,16 +50,14 @@ module Transpec
 
       def unblock!
         if block_beginning_line == block_body_line
-          range_between_pending_and_body =
-            expression_range.end.join(block_body_node.loc.expression.begin)
           replace(range_between_pending_and_body, "\n" + indentation_of_line(node))
         else
-          remove(expression_range.end.join(block_node.loc.begin))
+          remove(range_from_pending_end_to_block_open)
           outdent!(block_body_node, node)
         end
 
         if block_body_line == block_end_line
-          remove(block_body_node.loc.expression.end.join(block_node.loc.end))
+          remove(range_from_body_end_to_block_close)
         else
           remove(line_range(block_node.loc.end))
         end
@@ -102,6 +99,18 @@ module Transpec
         block_node.loc.end.line
       end
 
+      def range_between_pending_and_body
+        expression_range.end.join(block_body_node.loc.expression.begin)
+      end
+
+      def range_from_pending_end_to_block_open
+        expression_range.end.join(block_node.loc.begin)
+      end
+
+      def range_from_body_end_to_block_close
+        block_body_node.loc.expression.end.join(block_node.loc.end)
+      end
+
       def register_record(original_syntax, converted_syntax)
         report.records << Record.new(original_syntax, converted_syntax)
       end

data/lib/transpec/syntax/raise_error.rb

@@ -9,8 +9,8 @@ module Transpec
     class RaiseError < Syntax
       include Mixin::Send, Mixin::OwnedMatcher
 
-      def self.target_method?(receiver_node, method_name)
-        receiver_node.nil? && method_name == :raise_error
+      def dynamic_analysis_target?
+        super && receiver_node.nil? && method_name == :raise_error
       end
 
       def remove_error_specification_with_negative_expectation!

data/lib/transpec/syntax/receive.rb

@@ -10,8 +10,8 @@ module Transpec
     class Receive < Syntax
       include Mixin::Send, Mixin::OwnedMatcher, Mixin::MessagingHost
 
-      def self.target_method?(receiver_node, method_name)
-        receiver_node.nil? && method_name == :receive
+      def dynamic_analysis_target?
+        super && receiver_node.nil? && method_name == :receive
       end
 
       def remove_useless_and_return!

data/lib/transpec/syntax/rspec_configure.rb

@@ -11,11 +11,11 @@ module Transpec
 
       include Util
 
-      def self.target_node?(node, runtime_data = nil)
+      def dynamic_analysis_target?
         return false unless node && node.block_type?
         send_node = node.children.first
         receiver_node, method_name, *_ = *send_node
-        Util.const_name(receiver_node) == 'RSpec' && method_name == :configure
+        const_name(receiver_node) == 'RSpec' && method_name == :configure
       end
 
       def expectations

data/lib/transpec/syntax/should.rb

@@ -13,8 +13,12 @@ module Transpec
 
       attr_reader :current_syntax_type
 
-      def self.target_method?(receiver_node, method_name)
-        !receiver_node.nil? && [:should, :should_not].include?(method_name)
+      define_dynamic_analysis do |rewriter|
+        register_syntax_availability_analysis_request(
+          rewriter,
+          :expect_available?,
+          [:expect]
+        )
       end
 
       def initialize(node, source_rewriter = nil, runtime_data = nil, report = nil)
@@ -22,16 +26,12 @@ module Transpec
         @current_syntax_type = :should
       end
 
-      define_dynamic_analysis_request do |rewriter|
-        register_request_of_syntax_availability_inspection(
-          rewriter,
-          :expect_available?,
-          [:expect]
-        )
+      def dynamic_analysis_target?
+        super && !receiver_node.nil? && [:should, :should_not].include?(method_name)
       end
 
       def expect_available?
-        check_syntax_availability(__method__)
+        syntax_available?(__method__)
       end
 
       def expectize!(negative_form = 'not_to', parenthesize_matcher_arg = true)

data/lib/transpec/syntax/should_receive.rb

@@ -11,32 +11,34 @@ module Transpec
     class ShouldReceive < Syntax
       include Mixin::Expectizable, Mixin::MonkeyPatchAnyInstance, Mixin::MessagingHost, Util
 
-      alias_method :useless_expectation?, :allow_no_message?
-
-      def self.target_method?(receiver_node, method_name)
-        !receiver_node.nil? && [:should_receive, :should_not_receive].include?(method_name)
-      end
-
-      define_dynamic_analysis_request do |rewriter|
-        register_request_of_syntax_availability_inspection(
+      define_dynamic_analysis do |rewriter|
+        register_syntax_availability_analysis_request(
           rewriter,
           :expect_to_receive_available?,
           [:expect, :receive]
         )
 
-        register_request_of_syntax_availability_inspection(
+        register_syntax_availability_analysis_request(
           rewriter,
           :allow_to_receive_available?,
           [:allow, :receive]
         )
       end
 
+      alias_method :useless_expectation?, :allow_no_message?
+
+      def dynamic_analysis_target?
+        super &&
+          !receiver_node.nil? &&
+          [:should_receive, :should_not_receive].include?(method_name)
+      end
+
       def expect_to_receive_available?
-        check_syntax_availability(__method__)
+        syntax_available?(__method__)
       end
 
       def allow_to_receive_available?
-        check_syntax_availability(__method__)
+        syntax_available?(__method__)
       end
 
       def positive?
@@ -170,7 +172,7 @@ module Transpec
           fail NotImplementedError
         end
 
-        def original_syntax
+        def build_original_syntax
           syntax = if @should_receive.any_instance?
                      'Klass.any_instance.'
                    else
@@ -179,7 +181,7 @@ module Transpec
           syntax << "#{@should_receive.method_name}(:message)"
         end
 
-        def converted_syntax
+        def build_converted_syntax
           syntax = if @should_receive.any_instance?
                      "#{syntax_name}_any_instance_of(Klass)."
                    else
@@ -201,7 +203,7 @@ module Transpec
           'allow'
         end
 
-        def original_syntax
+        def build_original_syntax
           syntax = super
           syntax << '.any_number_of_times' if @should_receive.any_number_of_times?
           syntax << '.at_least(0)' if @should_receive.at_least_zero?
@@ -214,14 +216,14 @@ module Transpec
           @should_receive = should_receive
         end
 
-        def original_syntax
+        def build_original_syntax
           syntax = "obj.#{@should_receive.method_name}(:message)"
           syntax << '.any_number_of_times' if @should_receive.any_number_of_times?
           syntax << '.at_least(0)' if @should_receive.at_least_zero?
           syntax
         end
 
-        def converted_syntax
+        def build_converted_syntax
           'obj.stub(:message)'
         end
       end

data/lib/transpec/version.rb

@@ -5,7 +5,7 @@ module Transpec
   module Version
     MAJOR = 1
     MINOR = 10
-    PATCH = 3
+    PATCH = 4
 
     def self.to_s
       [MAJOR, MINOR, PATCH].join('.')

data/spec/spec_helper.rb

@@ -15,6 +15,13 @@ RSpec.configure do |config|
   config.color_enabled = true
   config.treat_symbols_as_metadata_keys_with_true_values = true
 
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
   config.before(:suite) do
     require 'rainbow'
     Rainbow.enabled = false

data/spec/support/shared_context.rb

@@ -13,7 +13,7 @@ shared_context 'parsed objects' do
 
   let(:ast) do
     require 'transpec/ast/builder'
-    require 'parser/current'
+    require 'transpec/parser'
     builder = Transpec::AST::Builder.new
     parser = Parser::CurrentRuby.new(builder)
     parser.parse(source_buffer)
@@ -55,11 +55,11 @@ end
 shared_context 'syntax object' do |syntax_class, name|
   let(name) do
     ast.each_node do |node|
-      next unless syntax_class.conversion_target_node?(node)
-      return syntax_class.new(node, source_rewriter, runtime_data)
+      syntax = syntax_class.new(node, source_rewriter, runtime_data)
+      return syntax if syntax.conversion_target?
     end
 
-    fail "No #{syntax_class.name} node is found!"
+    fail "No #{syntax_class.name} conversion target is found!"
   end
 end
 

data/spec/transpec/cli_spec.rb

@@ -10,7 +10,7 @@ module Transpec
     subject(:cli) { CLI.new }
 
     before do
-      cli.project.stub(:rspec_version).and_return(Transpec.current_rspec_version)
+      cli.project.stub(:rspec_version).and_return(Transpec.required_rspec_version)
     end
 
     describe '.run' do

data/spec/transpec/converter_spec.rb

@@ -6,7 +6,7 @@ require 'transpec/converter'
 module Transpec
   describe Converter do
     subject(:converter) { Converter.new(configuration, rspec_version) }
-    let(:rspec_version) { Transpec.current_rspec_version }
+    let(:rspec_version) { Transpec.required_rspec_version }
     let(:configuration) { Configuration.new }
 
     describe '#convert_file!' do

data/spec/transpec/dynamic_analyzer/rewriter_spec.rb

@@ -21,8 +21,8 @@ module Transpec
 
         # rubocop:disable LineLength
         let(:expected_source) do
-          <<-END
-            transpec_analyze((transpec_analyze((subject), self, "(string)_12_19", { :should_source_location => [:object, "method(:should).source_location"] }).should be(foo)), self, "(string)_12_34", { :expect_available? => [:context, "self.class.ancestors.any? { |a| a.name.start_with?('RSpec::') } && respond_to?(:expect)"] })
+          <<-'END'
+            transpec_analyze((transpec_analyze((subject), self, "(string)_12_19", { :should_source_location => [:object, "method(:should).source_location"], :should_example_method_defined_by_user? => [:object, "owner = method(:should).owner\nowner != RSpec::Core::ExampleGroup &&\n  owner.ancestors.include?(RSpec::Core::ExampleGroup)"] }).should be(foo)), self, "(string)_12_34", { :expect_available? => [:context, "self.class.ancestors.any? { |a| a.name.start_with?('RSpec::') } && respond_to?(:expect)"] })
           END
         end
         # rubocop:enable LineLength
@@ -42,8 +42,8 @@ module Transpec
 
           # rubocop:disable LineLength
           let(:expected_source) do
-            <<-END
-              transpec_analyze((transpec_analyze((subject), self, "(string)_14_21", { :should_source_location => [:object, "method(:should).source_location"] }).should), self, "(string)_14_28", { :"=~_source_location" => [:object, "method(:=~).source_location"], :expect_available? => [:context, "self.class.ancestors.any? { |a| a.name.start_with?('RSpec::') } && respond_to?(:expect)"] }) =~ transpec_analyze((<<-HEREDOC.gsub('foo', 'bar')), self, "(string)_32_61", { :enumerable_arg? => [:object, "is_a?(Enumerable)"] })
+            <<-'END'
+              transpec_analyze((transpec_analyze((subject), self, "(string)_14_21", { :should_source_location => [:object, "method(:should).source_location"], :should_example_method_defined_by_user? => [:object, "owner = method(:should).owner\nowner != RSpec::Core::ExampleGroup &&\n  owner.ancestors.include?(RSpec::Core::ExampleGroup)"] }).should), self, "(string)_14_28", { :"=~_source_location" => [:object, "method(:=~).source_location"], :"=~_example_method_defined_by_user?" => [:object, "owner = method(:=~).owner\nowner != RSpec::Core::ExampleGroup &&\n  owner.ancestors.include?(RSpec::Core::ExampleGroup)"], :expect_available? => [:context, "self.class.ancestors.any? { |a| a.name.start_with?('RSpec::') } && respond_to?(:expect)"] }) =~ transpec_analyze((<<-HEREDOC.gsub('foo', 'bar')), self, "(string)_32_61", { :enumerable_arg? => [:object, "is_a?(Enumerable)"] })
               foo
               HEREDOC
             END
@@ -64,8 +64,8 @@ module Transpec
 
           # rubocop:disable LineLength
           let(:expected_source) do
-            <<-END
-              transpec_analyze((expect { do_something }), self, "(string)_14_20", { :expect_source_location => [:context, "method(:expect).source_location"] }).to throw_symbol
+            <<-'END'
+              transpec_analyze((expect { do_something }), self, "(string)_14_20", { :expect_source_location => [:context, "method(:expect).source_location"], :expect_example_method_defined_by_user? => [:context, "owner = method(:expect).owner\nowner != RSpec::Core::ExampleGroup &&\n  owner.ancestors.include?(RSpec::Core::ExampleGroup)"] }).to throw_symbol
             END
           end
           # rubocop:enable LineLength
@@ -84,8 +84,8 @@ module Transpec
 
           # rubocop:disable LineLength
           let(:expected_source) do
-            <<-END
-              transpec_analyze((double 'something'), self, "(string)_14_32", { :double_source_location => [:context, "method(:double).source_location"] })
+            <<-'END'
+              transpec_analyze((double 'something'), self, "(string)_14_32", { :double_source_location => [:context, "method(:double).source_location"], :double_example_method_defined_by_user? => [:context, "owner = method(:double).owner\nowner != RSpec::Core::ExampleGroup &&\n  owner.ancestors.include?(RSpec::Core::ExampleGroup)"] })
             END
           end
           # rubocop:enable LineLength