transpec 0.2.3 → 0.2.4

data/lib/transpec/syntax/method_stub.rb

@@ -22,7 +22,7 @@ module Transpec
 
         fail 'Already replaced deprecated method, cannot allowize.' if @replaced_deprecated_method
 
-        unless context.in_example_group?
+        unless context.allow_to_receive_available?
           fail InvalidContextError.new(selector_range, "##{method_name}", '#allow')
         end
 

data/lib/transpec/syntax/rspec_configure.rb

@@ -44,30 +44,31 @@ module Transpec
         def syntaxes_node
           return nil unless framework_block_node
 
-          @syntaxes_node ||= begin
-            framework_config_variable_name = first_block_arg_name(framework_block_node)
-
-            AST::Scanner.scan(framework_block_node) do |descendent_node|
-              next unless descendent_node.type == :send
-              receiver_node, method_name, arg_node, *_ = *descendent_node
-              next unless receiver_node == s(:lvar, framework_config_variable_name)
-              next unless method_name == :syntax=
-              break arg_node
-            end
+          return @syntaxes_node if instance_variable_defined?(:@syntaxes_node)
+
+          framework_config_variable_name = first_block_arg_name(framework_block_node)
+
+          framework_block_node.each_descendent_node do |node|
+            next unless node.type == :send
+            receiver_node, method_name, arg_node, *_ = *node
+            next unless receiver_node == s(:lvar, framework_config_variable_name)
+            next unless method_name == :syntax=
+            return @syntaxes_node = arg_node
           end
+
+          @syntaxes_node = nil
         end
 
         def framework_block_node
-          @framework_block_node ||= begin
-            AST::Scanner.scan(@rspec_configure_node) do |descendent_node|
-              next unless descendent_node.type == :block
-              send_node = descendent_node.children.first
-              receiver_node, method_name, *_ = *send_node
-              next unless receiver_node == s(:lvar, rspec_configure_block_arg_name)
-              next unless method_name == @framework_config_method_name
-              # TODO: Check expectation framework.
-              break descendent_node
-            end
+          return @framework_block_node if instance_variable_defined?(:@framework_block_node)
+
+          @framework_block_node = @rspec_configure_node.each_descendent_node.find do |node|
+            next unless node.type == :block
+            send_node = node.children.first
+            receiver_node, method_name, *_ = *send_node
+            next unless receiver_node == s(:lvar, rspec_configure_block_arg_name)
+            method_name == @framework_config_method_name
+            # TODO: Check expectation framework.
           end
         end
 

data/lib/transpec/syntax/should.rb

@@ -15,7 +15,7 @@ module Transpec
       end
 
       def expectize!(negative_form = 'not_to', parenthesize_matcher_arg = true)
-        unless context.in_example_group?
+        unless context.expect_to_matcher_available?
           fail InvalidContextError.new(selector_range, "##{method_name}", '#expect')
         end
 

data/lib/transpec/syntax/should_receive.rb

@@ -42,7 +42,7 @@ module Transpec
       private
 
       def convert_to_syntax!(syntax, negative_form)
-        unless context.in_example_group?
+        unless context.non_monkey_patch_mock_available?
           fail InvalidContextError.new(selector_range, "##{method_name}", "##{syntax}")
         end
 

data/lib/transpec/version.rb

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

data/spec/.rubocop.yml

@@ -17,3 +17,7 @@ Blocks:
 # Sometimes block alignment does not suit RSpec syntax.
 BlockAlignment:
   Enabled: false
+
+# Suppress offences for namespace classes only with #describe.
+ClassLength:
+  Enabled: false

data/spec/support/shared_context.rb

@@ -28,7 +28,7 @@ end
 
 shared_context 'should object' do
   let(:should_object) do
-    Transpec::AST::Scanner.scan(ast) do |node, ancestor_nodes, in_example_group_context|
+    Transpec::AST::Scanner.scan(ast) do |node, ancestor_nodes|
       next unless Transpec::Syntax::Should.target_node?(node)
       return Transpec::Syntax::Should.new(
         node,

data/spec/transpec/context_spec.rb

@@ -5,30 +5,32 @@ require 'transpec/context'
 
 module Transpec
   describe Context do
+    include ::AST::Sexp
     include_context 'parsed objects'
+    include_context 'isolated environment'
 
-    def node_id(node)
-      id = node.type.to_s
-      node.children.each do |child|
-        break if child.is_a?(Parser::AST::Node)
-        id << " #{child.inspect}"
+    describe '#scopes' do
+      def node_id(node)
+        id = node.type.to_s
+        node.children.each do |child|
+          break if child.is_a?(Parser::AST::Node)
+          id << " #{child.inspect}"
+        end
+        id
       end
-      id
-    end
 
-    describe '#scopes' do
       let(:source) do
         <<-END
-          some_var = 1
+          top_level
 
           RSpec.configure do |config|
             config.before do
-              prepare_something
+              in_before
             end
           end
 
           module SomeModule
-            SOME_CONST = 1
+            in_module
 
             describe 'something' do
               def some_method(some_arg)
@@ -36,9 +38,13 @@ module Transpec
               end
 
               it 'is 1' do
-                something.should == 1
+                in_example
               end
             end
+
+            1.times do
+              in_normal_block
+            end
           end
         END
       end
@@ -47,15 +53,15 @@ module Transpec
         AST::Scanner.scan(ast) do |node, ancestor_nodes|
           expected_scopes = begin
             case node_id(node)
-            when 'lvasgn :some_var'
+            when 'send nil :top_level'
               []
-            when 'send nil :prepare_something'
-              [:rspec_configure, :block]
+            when 'send nil :in_before'
+              [:rspec_configure, :each_before_after]
             when 'module'
               []
             when 'const nil :SomeModule'
               # [:module] # TODO
-            when 'casgn nil :SOME_CONST'
+            when 'send nil :in_module'
               [:module]
             when 'send nil :describe'
               # [:module] # TODO
@@ -69,8 +75,10 @@ module Transpec
               # [:module, :example_group] # TODO
             when 'str "is 1"'
               # [:module, :example_group] # TODO
-            when 'send nil :something'
-              [:module, :example_group, :block]
+            when 'send nil :in_example'
+              [:module, :example_group, :example]
+            when 'send nil :in_normal_block'
+              [:module]
             end
           end
 
@@ -87,170 +95,550 @@ module Transpec
       end
     end
 
-    describe '#in_example_group?' do
+    shared_examples 'context inspection methods' do
+      let(:context_object) do
+        AST::Scanner.scan(ast) do |node, ancestor_nodes|
+          next unless node == s(:send, nil, :target)
+          return Context.new(ancestor_nodes)
+        end
+
+        fail 'Target node not found!'
+      end
+
+      def eval_with_rspec_in_context(eval_source)
+        result_path = 'result'
+
+        helper_source = <<-END
+          def target
+            File.open(#{result_path.inspect}, 'w') do |file|
+              Marshal.dump(#{eval_source}, file)
+            end
+          end
+        END
+
+        source_path = 'spec.rb'
+        File.write(source_path, helper_source + source)
+
+        `rspec #{source_path}`
+
+        Marshal.load(File.read(result_path))
+      end
+
+      describe '#non_monkey_patch_expectation_available?' do
+        subject { context_object.non_monkey_patch_expectation_available? }
+
+        let(:expected) do
+          eval_with_rspec_in_context('respond_to?(:expect)')
+        end
+
+        it { should == expected }
+      end
+
+      describe '#non_monkey_patch_mock_available?' do
+        subject { context_object.non_monkey_patch_mock_available? }
+
+        let(:expected) do
+          eval_with_rspec_in_context('respond_to?(:allow) && respond_to?(:receive)')
+        end
+
+        it { should == expected }
+      end
+    end
+
+    context 'when in top level' do
       let(:source) do
-        <<-END
-          top
+        'target'
+      end
+
+      include_examples 'context inspection methods'
+    end
 
+    context 'when in an instance method in top level' do
+      let(:source) do
+        <<-END
           def some_method
-            imethod_top
+            target
+          end
+
+          describe('test') { example { target } }
+        END
+      end
+
+      include_examples 'context inspection methods'
+    end
 
+    context 'when in a block in an instance method in top level' do
+      let(:source) do
+        <<-END
+          def some_method
             1.times do
-              block_imethod_top
+              target
             end
           end
 
+          describe('test') { example { target } }
+        END
+      end
+
+      include_examples 'context inspection methods'
+    end
+
+    context 'when in #describe block in top level' do
+      let(:source) do
+        <<-END
           describe 'foo' do
-            describe_top
+            target
+          end
+        END
+      end
+
+      include_examples 'context inspection methods'
+    end
 
+    context 'when in an instance method in #describe block in top level' do
+      let(:source) do
+        <<-END
+          describe 'foo' do
             def some_method
-              imethod_describe_top
+              target
             end
 
+            example { some_method }
+          end
+        END
+      end
+
+      include_examples 'context inspection methods'
+    end
+
+    context 'when in #it block in #describe block in top level' do
+      let(:source) do
+        <<-END
+          describe 'foo' do
             it 'is an example' do
-              block_describe_top
+              target
+            end
+          end
+        END
+      end
 
-              class SomeClass
-                class_block_describe_top
+      include_examples 'context inspection methods'
+    end
 
-                def some_method
-                  imethod_class_block_describe_top
-                end
-              end
+    context 'when in #before block in #describe block in top level' do
+      let(:source) do
+        <<-END
+          describe 'foo' do
+            before do
+              target
             end
+
+            example { }
           end
+        END
+      end
 
-          module SomeModule
-            describe 'bar' do
-              describe_module
+      include_examples 'context inspection methods'
+    end
 
-              def some_method
-                imethod_describe_module
-              end
+    context 'when in #before(:each) block in #describe block in top level' do
+      let(:source) do
+        <<-END
+          describe 'foo' do
+            before(:each) do
+              target
+            end
 
-              it 'is an example' do
-                block_describe_module
-              end
+            example { }
+          end
+        END
+      end
+
+      include_examples 'context inspection methods'
+    end
+
+    context 'when in #before(:all) block in #describe block in top level' do
+      let(:source) do
+        <<-END
+          describe 'foo' do
+            before(:all) do
+              target
             end
+
+            example { }
           end
+        END
+      end
 
-          module AnotherModule
-            def some_method
-              imethod_module
+      include_examples 'context inspection methods'
+    end
+
+    context 'when in #after block in #describe block in top level' do
+      let(:source) do
+        <<-END
+          describe 'foo' do
+            after do
+              target
             end
+
+            example { }
           end
+        END
+      end
 
-          class SomeClass
-            def some_method
-              imethod_class
+      include_examples 'context inspection methods'
+    end
+
+    context 'when in #after(:each) block in #describe block in top level' do
+      let(:source) do
+        <<-END
+          describe 'foo' do
+            after(:each) do
+              target
             end
+
+            example { }
           end
+        END
+      end
 
-          RSpec.configure do |config|
-            rspecconfigure
+      include_examples 'context inspection methods'
+    end
 
-            def some_method
-              imethod_rspecconfigure
+    context 'when in #after(:all) block in #describe block in top level' do
+      let(:source) do
+        <<-END
+          describe 'foo' do
+            after(:all) do
+              target
             end
 
-            config.before do
-              block_rspecconfigure
+            example { }
+          end
+        END
+      end
+
+      include_examples 'context inspection methods'
+    end
+
+    context 'when in #around block in #describe block in top level' do
+      let(:source) do
+        <<-END
+          describe 'foo' do
+            around do
+              target
             end
+
+            example { }
           end
         END
       end
 
-      let(:context_object) do
-        AST::Scanner.scan(ast) do |node, ancestor_nodes|
-          next unless node_id(node) == target_node_id
-          return Context.new(ancestor_nodes)
-        end
+      include_examples 'context inspection methods'
+    end
 
-        fail 'Target node not found!'
+    context 'when in #subject block in #describe block in top level' do
+      let(:source) do
+        <<-END
+          describe 'foo' do
+            subject do
+              target
+            end
+
+            example { subject }
+          end
+        END
+      end
+
+      include_examples 'context inspection methods'
+    end
+
+    context 'when in #subject! block in #describe block in top level' do
+      let(:source) do
+        <<-END
+          describe 'foo' do
+            subject! do
+              target
+            end
+
+            example { subject }
+          end
+        END
       end
 
-      subject { context_object.in_example_group? }
+      include_examples 'context inspection methods'
+    end
+
+    context 'when in #let block in #describe block in top level' do
+      let(:source) do
+        <<-END
+          describe 'foo' do
+            let(:something) do
+              target
+            end
 
-      context 'when in top level' do
-        let(:target_node_id) { 'send nil :top' }
-        it { should be_false }
+            example { something }
+          end
+        END
       end
 
-      context 'when in an instance method in top level' do
-        let(:target_node_id) { 'send nil :imethod_top' }
-        it { should be_true }
+      include_examples 'context inspection methods'
+    end
+
+    context 'when in #let! block in #describe block in top level' do
+      let(:source) do
+        <<-END
+          describe 'foo' do
+            let!(:something) do
+              target
+            end
+
+            example { something }
+          end
+        END
       end
 
-      context 'when in a block in an instance method in top level' do
-        let(:target_node_id) { 'send nil :block_imethod_top' }
-        it { should be_true }
+      include_examples 'context inspection methods'
+    end
+
+    context 'when in any other block in #describe block in top level' do
+      let(:source) do
+        <<-END
+          describe 'foo' do
+            1.times do
+              target
+            end
+
+            example { }
+          end
+        END
       end
 
-      context 'when in #describe block in top level' do
-        let(:target_node_id) { 'send nil :describe_top' }
-        it { should be_false }
+      include_examples 'context inspection methods'
+    end
+
+    context 'when in #before block in singleton method with self in #describe block in top level' do
+      let(:source) do
+        <<-END
+          describe 'foo' do
+            def self.some_method
+              before do
+                target
+              end
+            end
+
+            some_method
+
+            example { something }
+          end
+        END
       end
 
-      context 'when in an instance method in #describe block in top level' do
-        let(:target_node_id) { 'send nil :imethod_describe_top' }
-        it { should be_true }
+      include_examples 'context inspection methods'
+    end
+
+    context 'when in #before block in singleton method with other object in #describe block in top level' do
+      let(:source) do
+        <<-END
+          describe 'foo' do
+            some_object = 'some object'
+
+            def some_object.before
+              yield
+            end
+
+            def some_object.some_method
+              before do
+                target
+              end
+            end
+
+            some_object.some_method
+          end
+        END
       end
 
-      context 'when in a block in #describe block in top level' do
-        let(:target_node_id) { 'send nil :block_describe_top' }
-        it { should be_true }
+      include_examples 'context inspection methods'
+    end
+
+    context 'when in a class in a block in #describe block' do
+       let(:source) do
+        <<-END
+          describe 'foo' do
+            it 'is an example' do
+              class SomeClass
+                target
+              end
+            end
+          end
+        END
       end
 
-      context 'when in a class in a block in #describe block' do
-        let(:target_node_id) { 'send nil :class_block_describe_top' }
-        it { should be_false }
+      include_examples 'context inspection methods'
+    end
+
+    context 'when in an instance method in a class in a block in #describe block' do
+       let(:source) do
+        <<-END
+          describe 'foo' do
+            it 'is an example' do
+              class SomeClass
+                def some_method
+                  target
+                end
+              end
+
+              SomeClass.new.some_method
+            end
+          end
+        END
       end
 
-      context 'when in an instance method in a class in a block in #describe block' do
-        let(:target_node_id) { 'send nil :imethod_class_block_describe_top' }
-        it { should be_false }
+      include_examples 'context inspection methods'
+    end
+
+    context 'when in #describe block in a module' do
+      let(:source) do
+        <<-END
+          module SomeModule
+            describe 'foo' do
+              target
+            end
+          end
+        END
       end
 
-      context 'when in #describe block in a module' do
-        let(:target_node_id) { 'send nil :describe_module' }
-        it { should be_false }
+      include_examples 'context inspection methods'
+    end
+
+    context 'when in an instance method in #describe block in a module' do
+      let(:source) do
+        <<-END
+          module SomeModule
+            describe 'foo' do
+              def some_method
+                target
+              end
+
+              example { some_method }
+            end
+          end
+        END
       end
 
-      context 'when in an instance method in #describe block in a module' do
-        let(:target_node_id) { 'send nil :imethod_describe_module' }
-        it { should be_true }
+      include_examples 'context inspection methods'
+    end
+
+    context 'when in a block in #describe block in a module' do
+      let(:source) do
+        <<-END
+          module SomeModule
+            describe 'foo' do
+              it 'is an example' do
+                target
+              end
+            end
+          end
+        END
       end
 
-      context 'when in a block in #describe block in a module' do
-        let(:target_node_id) { 'send nil :block_describe_module' }
-        it { should be_true }
+      include_examples 'context inspection methods'
+    end
+
+    context 'when in an instance method in a module' do
+      let(:source) do
+        <<-END
+          module SomeModule
+            def some_method
+              target
+            end
+          end
+
+          describe 'test' do
+            include SomeModule
+            example { some_method }
+          end
+        END
       end
 
-      context 'when in an instance method in a module' do
-        # Instance methods of module can be used by `include SomeModule` in #describe block.
-        let(:target_node_id) { 'send nil :imethod_module' }
-        it { should be_true }
+      # Instance methods of module can be used by `include SomeModule` in #describe block.
+      include_examples 'context inspection methods'
+    end
+
+    context 'when in an instance method in a class' do
+      let(:source) do
+        <<-END
+          class SomeClass
+            def some_method
+              target
+            end
+          end
+
+          describe 'test' do
+            example { SomeClass.new.some_method }
+          end
+        END
       end
 
-      context 'when in an instance method in a class' do
-        let(:target_node_id) { 'send nil :imethod_class' }
-        it { should be_false }
+      include_examples 'context inspection methods'
+    end
+
+    context 'when in RSpec.configure' do
+      let(:source) do
+        <<-END
+          RSpec.configure do |config|
+            target
+          end
+        END
       end
 
-      context 'when in RSpec.configure' do
-        let(:target_node_id) { 'send nil :rspecconfigure' }
-        it { should be_false }
+      include_examples 'context inspection methods'
+    end
+
+    context 'when in #before block in RSpec.configure' do
+      let(:source) do
+        <<-END
+          RSpec.configure do |config|
+            config.before do
+              target
+            end
+          end
+
+          describe('test') { example { } }
+        END
       end
 
-      context 'when in a block in RSpec.configure' do
-        let(:target_node_id) { 'send nil :block_rspecconfigure' }
-        it { should be_true }
+      include_examples 'context inspection methods'
+    end
+
+    context 'when in a normal block in RSpec.configure' do
+      let(:source) do
+        <<-END
+          RSpec.configure do |config|
+            1.times do
+              target
+            end
+          end
+        END
       end
 
-      context 'when in an instance method in RSpec.configure' do
-        let(:target_node_id) { 'send nil :imethod_rspecconfigure' }
-        it { should be_true }
+      include_examples 'context inspection methods'
+    end
+
+    context 'when in an instance method in RSpec.configure' do
+      let(:source) do
+        <<-END
+          RSpec.configure do |config|
+            def some_method
+              target
+            end
+          end
+
+          describe('test') { example { some_method } }
+        END
       end
+
+      include_examples 'context inspection methods'
     end
   end
 end