transpec 1.2.2 → 1.3.0

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

@@ -4,17 +4,56 @@ module Transpec
   class Syntax
     module Mixin
       module AnyInstance
+        include ::AST::Sexp
+
+        def register_request_of_any_instance_inspection(rewriter)
+          key = :any_instance_target_class_name
+          code = <<-END.gsub(/^\s+\|/, '').chomp
+            |if self.class.name == 'RSpec::Mocks::AnyInstance::Recorder'
+            |  if respond_to?(:klass)
+            |    klass.name
+            |  elsif instance_variable_defined?(:@klass)
+            |    instance_variable_get(:@klass).name
+            |  else
+            |    nil
+            |  end
+            |else
+            |  nil
+            |end
+          END
+          rewriter.register_request(subject_node, key, code)
+        end
+
         def any_instance?
-          !class_node_of_any_instance.nil?
+          return true unless any_instance_target_node.nil?
+          node_data = runtime_node_data(subject_node)
+          return false unless node_data
+          return false unless node_data[:any_instance_target_class_name]
+          !node_data[:any_instance_target_class_name].result.nil?
         end
 
-        def class_node_of_any_instance
+        def any_instance_target_class_source
+          return nil unless any_instance?
+
+          if any_instance_target_node
+            any_instance_target_node.loc.expression.source
+          else
+            runtime_node_data(subject_node)[:any_instance_target_class_name].result
+          end
+        end
+
+        def any_instance_target_node
           return nil unless subject_node.type == :send
           return nil unless subject_node.children.count == 2
           receiver_node, method_name = *subject_node
+          return nil unless receiver_node
           return nil unless method_name == :any_instance
-          return nil unless receiver_node.type == :const
-          receiver_node
+
+          if receiver_node.type == :const || receiver_node == s(:send, nil, :described_class)
+            receiver_node
+          else
+            nil
+          end
         end
       end
     end

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

@@ -88,6 +88,10 @@ module Transpec
           arg_node.loc.expression
         end
 
+        def args_range
+          arg_nodes.first.loc.expression.begin.join(arg_nodes.last.loc.expression.end)
+        end
+
         def parentheses_range
           selector_range.end.join(expression_range.end)
         end

data/lib/transpec/syntax/should_receive.rb

@@ -34,6 +34,8 @@ module Transpec
           :allow_to_receive_available?,
           [:allow, :receive]
         )
+
+        register_request_of_any_instance_inspection(rewriter)
       end
 
       def expect_to_receive_available?
@@ -83,7 +85,7 @@ module Transpec
 
       def convert_to_syntax!(syntax, negative_form)
         if any_instance?
-          wrap_class_with_any_instance_of!(syntax)
+          wrap_subject_with_any_instance_of!(syntax)
         else
           wrap_subject_with_method!(syntax)
         end
@@ -104,11 +106,9 @@ module Transpec
         end
       end
 
-      def wrap_class_with_any_instance_of!(syntax)
-        insert_before(subject_range, "#{syntax}_any_instance_of(")
-        map = subject_node.loc
-        dot_any_instance_range = map.dot.join(map.selector)
-        replace(dot_any_instance_range, ')')
+      def wrap_subject_with_any_instance_of!(syntax)
+        expression = "#{syntax}_any_instance_of(#{any_instance_target_class_source})"
+        replace(subject_range, expression)
       end
 
       def broken_block_nodes
@@ -164,7 +164,7 @@ module Transpec
 
       def original_syntax(conversion_type)
         syntax = if any_instance? && conversion_type != :stub
-                  'SomeClass.any_instance.'
+                  'Klass.any_instance.'
                  else
                   'obj.'
                  end
@@ -186,13 +186,13 @@ module Transpec
         syntax = case conversion_type
                  when :expect
                    if any_instance?
-                     'expect_any_instance_of(SomeClass).'
+                     'expect_any_instance_of(Klass).'
                    else
                      'expect(obj).'
                    end
                  when :allow
                    if any_instance?
-                     'allow_any_instance_of(SomeClass).'
+                     'allow_any_instance_of(Klass).'
                    else
                      'allow(obj).'
                    end

data/lib/transpec/version.rb

@@ -4,8 +4,8 @@ module Transpec
   # http://semver.org/
   module Version
     MAJOR = 1
-    MINOR = 2
-    PATCH = 2
+    MINOR = 3
+    PATCH = 0
 
     def self.to_s
       [MAJOR, MINOR, PATCH].join('.')

data/spec/transpec/cli_spec.rb

@@ -224,14 +224,14 @@ module Transpec
         let(:source) do
           <<-END
             describe 'example group' do
-              class SomeClass
+              class Klass
                 def some_method
                   1.should == 1
                 end
               end
 
               it 'is an example' do
-                SomeClass.new.some_method
+                Klass.new.some_method
               end
             end
           END

data/spec/transpec/converter_spec.rb

@@ -97,14 +97,14 @@ module Transpec
         let(:source) do
           <<-END
             describe 'example group' do
-              class SomeClass
+              class Klass
                 def some_method
                   1.should == 1
                 end
               end
 
               it 'is an example' do
-                SomeClass.new.some_method
+                Klass.new.some_method
               end
             end
           END

data/spec/transpec/static_context_inspector_spec.rb

@@ -481,7 +481,7 @@ module Transpec
         <<-END
           describe 'foo' do
             it 'is an example' do
-              class SomeClass
+              class Klass
                 target
               end
             end
@@ -497,13 +497,13 @@ module Transpec
         <<-END
           describe 'foo' do
             it 'is an example' do
-              class SomeClass
+              class Klass
                 def some_method
                   target
                 end
               end
 
-              SomeClass.new.some_method
+              Klass.new.some_method
             end
           end
         END
@@ -583,14 +583,14 @@ module Transpec
     context 'when in an instance method in a class' do
       let(:source) do
         <<-END
-          class SomeClass
+          class Klass
             def some_method
               target
             end
           end
 
           describe 'test' do
-            example { SomeClass.new.some_method }
+            example { Klass.new.some_method }
           end
         END
       end

data/spec/transpec/syntax/have_spec.rb

@@ -70,6 +70,58 @@ module Transpec
       describe '#convert_to_standard_expectation!' do
         let(:record) { have_object.report.records.last }
 
+        context 'when rspec-rails is loaded in the spec' do
+          include_context 'dynamic analysis objects'
+
+          let(:source) do
+            <<-END
+              module RSpec
+                module Rails
+                end
+              end
+
+              describe 'example' do
+                it 'has 2 items' do
+                  [:foo, :bar].should have(2).items
+                end
+              end
+            END
+          end
+
+          let(:have_object) { should_object.have_matcher }
+
+          it 'does nothing' do
+            have_object.convert_to_standard_expectation!
+            rewritten_source.should == source
+          end
+        end
+
+        context 'when rspec-collection_matchers is loaded in the spec' do
+          include_context 'dynamic analysis objects'
+
+          let(:source) do
+            <<-END
+              module RSpec
+                module CollectionMatchers
+                end
+              end
+
+              describe 'example' do
+                it 'has 2 items' do
+                  [:foo, :bar].should have(2).items
+                end
+              end
+            END
+          end
+
+          let(:have_object) { should_object.have_matcher }
+
+          it 'does nothing' do
+            have_object.convert_to_standard_expectation!
+            rewritten_source.should == source
+          end
+        end
+
         context 'when it is `collection.should have(2).items` form' do
           let(:source) do
             <<-END
@@ -618,6 +670,309 @@ module Transpec
             end
           end
         end
+
+        context 'when it is `expect(subject).to have(1).word` form' do
+          let(:have_object) { expect_object.have_matcher }
+
+          context 'with runtime information' do
+            include_context 'dynamic analysis objects'
+
+            context 'when the subject responds to #words and #words responds to #size' do
+              context 'and ActiveSupport::Inflector.pluralize is available in the spec' do
+                let(:source) do
+                  <<-END
+                    require 'active_support/inflector'
+
+                    class String
+                      def words
+                        split(' ')
+                      end
+                    end
+
+                    describe 'string' do
+                      it 'has a word' do
+                        expect(subject).to have(1).word
+                      end
+                    end
+                  END
+                end
+
+                let(:expected_source) do
+                  <<-END
+                    require 'active_support/inflector'
+
+                    class String
+                      def words
+                        split(' ')
+                      end
+                    end
+
+                    describe 'string' do
+                      it 'has a word' do
+                        expect(subject.words.size).to eq(1)
+                      end
+                    end
+                  END
+                end
+
+                it 'converts into `expect(subject.words.size).to eq(1)` form' do
+                  have_object.convert_to_standard_expectation!
+                  rewritten_source.should == expected_source
+                end
+
+                it 'adds record "`expect(obj).to have(n).words` -> `expect(obj.words.size).to eq(n)`"' do
+                  have_object.convert_to_standard_expectation!
+                  record.original_syntax.should  == 'expect(obj).to have(n).words'
+                  record.converted_syntax.should == 'expect(obj.words.size).to eq(n)'
+                end
+              end
+
+              context 'and ActiveSupport::Inflector.pluralize is not available in the spec' do
+                let(:source) do
+                  <<-END
+                    class String
+                      def words
+                        split(' ')
+                      end
+                    end
+
+                    describe 's' do
+                      it 'has a character' do
+                        expect(subject).to have(1).word
+                      end
+                    end
+                  END
+                end
+
+                let(:expected_source) do
+                  <<-END
+                    class String
+                      def words
+                        split(' ')
+                      end
+                    end
+
+                    describe 's' do
+                      it 'has a character' do
+                        expect(subject.size).to eq(1)
+                      end
+                    end
+                  END
+                end
+
+                it 'converts into `expect(subject.size).to eq(1)` form' do
+                  have_object.convert_to_standard_expectation!
+                  rewritten_source.should == expected_source
+                end
+
+                it 'adds record "`expect(collection).to have(n).items` -> `expect(collection.size).to eq(n)`"' do
+                  have_object.convert_to_standard_expectation!
+                  record.original_syntax.should  == 'expect(collection).to have(n).items'
+                  record.converted_syntax.should == 'expect(collection.size).to eq(n)'
+                end
+              end
+            end
+          end
+
+          context 'without runtime information' do
+            let(:source) do
+              <<-END
+                require 'active_support/inflector'
+
+                class String
+                  def words
+                    split(' ')
+                  end
+                end
+
+                describe 'string' do
+                  it 'has a word' do
+                    expect(subject).to have(1).word
+                  end
+                end
+              END
+            end
+
+            let(:expected_source) do
+              <<-END
+                require 'active_support/inflector'
+
+                class String
+                  def words
+                    split(' ')
+                  end
+                end
+
+                describe 'string' do
+                  it 'has a word' do
+                    expect(subject.size).to eq(1)
+                  end
+                end
+              END
+            end
+
+            it 'converts into `expect(subject.size).to eq(1)` form' do
+              have_object.convert_to_standard_expectation!
+              rewritten_source.should == expected_source
+            end
+
+            it 'adds record "`expect(collection).to have(n).items` -> `expect(collection.size).to eq(n)`"' do
+              have_object.convert_to_standard_expectation!
+              record.original_syntax.should  == 'expect(collection).to have(n).items'
+              record.converted_syntax.should == 'expect(collection.size).to eq(n)'
+            end
+          end
+        end
+
+        context 'when it is `expect(subject).to have(2).errors_on(:name)` form' do
+          let(:have_object) { expect_object.have_matcher }
+
+          context 'with runtime information' do
+            include_context 'dynamic analysis objects'
+
+            context 'and subject responds to #errors_on' do
+              let(:source) do
+                <<-END
+                  class SomeModel
+                    def errors_on(attribute)
+                      [:foo, :bar]
+                    end
+                  end
+
+                  describe SomeModel do
+                    it 'has 2 errors on name' do
+                      expect(subject).to have(2).errors_on(:name)
+                    end
+                  end
+                END
+              end
+
+              let(:expected_source) do
+                <<-END
+                  class SomeModel
+                    def errors_on(attribute)
+                      [:foo, :bar]
+                    end
+                  end
+
+                  describe SomeModel do
+                    it 'has 2 errors on name' do
+                      expect(subject.errors_on(:name).size).to eq(2)
+                    end
+                  end
+                END
+              end
+
+              it 'converts into `expect(subject.errors_on(:name).size).to eq(2)` form' do
+                have_object.convert_to_standard_expectation!
+                rewritten_source.should == expected_source
+              end
+
+              it 'adds record ' +
+                 '"`expect(obj).to have(n).errors_on(...)` -> `expect(obj.errors_on(...).size).to eq(n)`"' do
+                have_object.convert_to_standard_expectation!
+                record.original_syntax.should  == 'expect(obj).to have(n).errors_on(...)'
+                record.converted_syntax.should == 'expect(obj.errors_on(...).size).to eq(n)'
+              end
+            end
+
+            context 'and #errors_on is a private method' do
+              let(:source) do
+                <<-END
+                  class SomeModel
+                    private
+
+                    def errors_on(attribute)
+                      [:foo, :bar]
+                    end
+                  end
+
+                  describe SomeModel do
+                    it 'has 2 errors on name' do
+                      expect(subject).to have(2).errors_on(:name)
+                    end
+                  end
+                END
+              end
+
+              let(:expected_source) do
+                <<-END
+                  class SomeModel
+                    private
+
+                    def errors_on(attribute)
+                      [:foo, :bar]
+                    end
+                  end
+
+                  describe SomeModel do
+                    it 'has 2 errors on name' do
+                      expect(subject.send(:errors_on, :name).size).to eq(2)
+                    end
+                  end
+                END
+              end
+
+              it 'converts into `expect(subject.send(:errors_on, :name).size).to eq(2)` form' do
+                have_object.convert_to_standard_expectation!
+                rewritten_source.should == expected_source
+              end
+
+              it 'adds record ' +
+                 '"`expect(obj).to have(n).errors_on(...)` -> `expect(obj.send(:errors_on, ...).size).to eq(n)`"' do
+                have_object.convert_to_standard_expectation!
+                record.original_syntax.should  == 'expect(obj).to have(n).errors_on(...)'
+                record.converted_syntax.should == 'expect(obj.send(:errors_on, ...).size).to eq(n)'
+              end
+            end
+          end
+
+          context 'without runtime information' do
+            let(:source) do
+              <<-END
+                class SomeModel
+                  def errors_on(attribute)
+                    [:foo, :bar]
+                  end
+                end
+
+                describe SomeModel do
+                  it 'has 2 errors on name' do
+                    expect(subject).to have(2).errors_on(:name)
+                  end
+                end
+              END
+            end
+
+            let(:expected_source) do
+              <<-END
+                class SomeModel
+                  def errors_on(attribute)
+                    [:foo, :bar]
+                  end
+                end
+
+                describe SomeModel do
+                  it 'has 2 errors on name' do
+                    expect(subject.errors_on(:name).size).to eq(2)
+                  end
+                end
+              END
+            end
+
+            it 'converts into `expect(subject.errors_on(:name).size).to eq(2)` form' do
+              have_object.convert_to_standard_expectation!
+              rewritten_source.should == expected_source
+            end
+
+            it 'adds record ' +
+               '"`expect(obj).to have(n).errors_on(...)` -> `expect(obj.errors_on(...).size).to eq(n)`"' do
+              have_object.convert_to_standard_expectation!
+              record.original_syntax.should  == 'expect(obj).to have(n).errors_on(...)'
+              record.converted_syntax.should == 'expect(obj.errors_on(...).size).to eq(n)'
+            end
+          end
+        end
       end
     end
   end