rubocop 0.13.1 → 0.14.0

data/spec/rubocop/cop/variable_inspector/scope_spec.rb

@@ -2,190 +2,184 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module VariableInspector
-      describe Scope do
-        include ASTHelper
-        include AST::Sexp
-
-        describe '.new' do
-          context 'when non scope node is passed' do
-            it 'raises error' do
-              node = s(:lvasgn)
-              expect { Scope.new(node) }.to raise_error(ArgumentError)
-            end
-          end
+describe Rubocop::Cop::VariableInspector::Scope do
+  include ASTHelper
+  include AST::Sexp
+
+  describe '.new' do
+    context 'when non scope node is passed' do
+      it 'raises error' do
+        node = s(:lvasgn)
+        expect { described_class.new(node) }.to raise_error(ArgumentError)
+      end
+    end
 
-          context 'when begin node is passed' do
-            it 'accepts that as pseudo scope for top level scope' do
-              node = s(:begin)
-              expect { Scope.new(node) }.not_to raise_error
-            end
-          end
-        end
+    context 'when begin node is passed' do
+      it 'accepts that as pseudo scope for top level scope' do
+        node = s(:begin)
+        expect { described_class.new(node) }.not_to raise_error
+      end
+    end
+  end
 
-        let(:ast) do
-          processed_source = Rubocop::SourceParser.parse(source)
-          processed_source.ast
-        end
+  let(:ast) do
+    processed_source = Rubocop::SourceParser.parse(source)
+    processed_source.ast
+  end
 
-        let(:scope_node_type) { :def }
+  let(:scope_node_type) { :def }
 
-        let(:scope_node) do
-          found_node = scan_node(ast, include_origin_node: true) do |node|
-            break node if node.type == scope_node_type
-          end
-          fail 'No scope node found!' unless found_node
-          found_node
-        end
+  let(:scope_node) do
+    found_node = scan_node(ast, include_origin_node: true) do |node|
+      break node if node.type == scope_node_type
+    end
+    fail 'No scope node found!' unless found_node
+    found_node
+  end
 
-        subject(:scope) { Scope.new(scope_node) }
-
-        describe '#ancestors_of_node' do
-          let(:source) do
-            <<-END
-              puts 1
-
-              class SomeClass
-                def some_method
-                  foo = 1
-
-                  if foo > 0
-                    while foo < 10
-                      this_is_target
-                      foo += 1
-                    end
-                  else
-                    do_something
-                  end
-                end
-              end
-            END
-          end
+  subject(:scope) { described_class.new(scope_node) }
 
-          let(:target_node) do
-            found_node = scan_node(ast) do |node|
-              next unless node.type == :send
-              _receiver_node, method_name = *node
-              break node if method_name == :this_is_target
-            end
-            fail 'No target node found!' unless found_node
-            found_node
-          end
+  describe '#ancestors_of_node' do
+    let(:source) do
+      <<-END
+        puts 1
 
-          it 'returns nodes in between the scope node and the passed node' do
-            ancestor_nodes = scope.ancestors_of_node(target_node)
-            ancestor_types = ancestor_nodes.map(&:type)
-            expect(ancestor_types).to eq([:begin, :if, :while, :begin])
-          end
-        end
+        class SomeClass
+          def some_method
+            foo = 1
 
-        describe '#body_node' do
-          shared_examples 'returns the body node' do
-            it 'returns the body node' do
-              expect(scope.body_node.children[1]).to eq(:this_is_target)
+            if foo > 0
+              while foo < 10
+                this_is_target
+                foo += 1
+              end
+            else
+              do_something
             end
           end
+        end
+      END
+    end
 
-          context 'when the scope is instance method' do
-            let(:source) do
-              <<-END
-                def some_method
-                  this_is_target
-                end
-              END
-            end
+    let(:target_node) do
+      found_node = scan_node(ast) do |node|
+        next unless node.type == :send
+        _receiver_node, method_name = *node
+        break node if method_name == :this_is_target
+      end
+      fail 'No target node found!' unless found_node
+      found_node
+    end
 
-            let(:scope_node_type) { :def }
+    it 'returns nodes in between the scope node and the passed node' do
+      ancestor_nodes = scope.ancestors_of_node(target_node)
+      ancestor_types = ancestor_nodes.map(&:type)
+      expect(ancestor_types).to eq([:begin, :if, :while, :begin])
+    end
+  end
 
-            include_examples 'returns the body node'
+  describe '#body_node' do
+    shared_examples 'returns the body node' do
+      it 'returns the body node' do
+        expect(scope.body_node.children[1]).to eq(:this_is_target)
+      end
+    end
+
+    context 'when the scope is instance method' do
+      let(:source) do
+        <<-END
+          def some_method
+            this_is_target
           end
+        END
+      end
 
-          context 'when the scope is singleton method' do
-            let(:source) do
-              <<-END
-                def self.some_method
-                  this_is_target
-                end
-              END
-            end
+      let(:scope_node_type) { :def }
 
-            let(:scope_node_type) { :defs }
+      include_examples 'returns the body node'
+    end
 
-            include_examples 'returns the body node'
+    context 'when the scope is singleton method' do
+      let(:source) do
+        <<-END
+          def self.some_method
+            this_is_target
           end
+        END
+      end
 
-          context 'when the scope is module' do
-            let(:source) do
-              <<-END
-                module SomeModule
-                  this_is_target
-                end
-              END
-            end
+      let(:scope_node_type) { :defs }
 
-            let(:scope_node_type) { :module }
+      include_examples 'returns the body node'
+    end
 
-            include_examples 'returns the body node'
+    context 'when the scope is module' do
+      let(:source) do
+        <<-END
+          module SomeModule
+            this_is_target
           end
+        END
+      end
 
-          context 'when the scope is class' do
-            let(:source) do
-              <<-END
-                class SomeClass
-                  this_is_target
-                end
-              END
-            end
+      let(:scope_node_type) { :module }
 
-            let(:scope_node_type) { :class }
+      include_examples 'returns the body node'
+    end
 
-            include_examples 'returns the body node'
+    context 'when the scope is class' do
+      let(:source) do
+        <<-END
+          class SomeClass
+            this_is_target
           end
+        END
+      end
 
-          context 'when the scope is singleton class' do
-            let(:source) do
-              <<-END
-                class << self
-                  this_is_target
-                end
-              END
-            end
+      let(:scope_node_type) { :class }
 
-            let(:scope_node_type) { :sclass }
+      include_examples 'returns the body node'
+    end
 
-            include_examples 'returns the body node'
+    context 'when the scope is singleton class' do
+      let(:source) do
+        <<-END
+          class << self
+            this_is_target
           end
+        END
+      end
 
-          context 'when the scope is block' do
-            let(:source) do
-              <<-END
-                1.times do
-                  this_is_target
-                end
-              END
-            end
+      let(:scope_node_type) { :sclass }
 
-            let(:scope_node_type) { :block }
+      include_examples 'returns the body node'
+    end
 
-            include_examples 'returns the body node'
+    context 'when the scope is block' do
+      let(:source) do
+        <<-END
+          1.times do
+            this_is_target
           end
+        END
+      end
 
-          context 'when the scope is top level' do
-            let(:source) do
-              <<-END
-                foo = 1
-                this_is_target
-              END
-            end
+      let(:scope_node_type) { :block }
 
-            let(:scope_node_type) { :begin }
+      include_examples 'returns the body node'
+    end
 
-            include_examples 'returns the body node'
-          end
-        end
+    context 'when the scope is top level' do
+      let(:source) do
+        <<-END
+          foo = 1
+          this_is_target
+        END
       end
+
+      let(:scope_node_type) { :begin }
+
+      include_examples 'returns the body node'
     end
   end
 end

data/spec/rubocop/cop/variable_inspector/variable_spec.rb

@@ -2,77 +2,71 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module VariableInspector
-      describe Variable do
-        include AST::Sexp
+describe Rubocop::Cop::VariableInspector::Variable do
+  include AST::Sexp
 
-        describe '.new' do
-          context 'when non variable declaration node is passed' do
-            it 'raises error' do
-              name = :foo
-              declaration_node = s(:def)
-              scope = Scope.new(s(:class))
-              expect { Variable.new(name, declaration_node, scope) }
-                .to raise_error(ArgumentError)
-            end
-          end
-        end
-
-        describe '#referenced?' do
-          let(:name) { :foo }
-          let(:declaration_node) { s(:arg, name) }
-          let(:scope) { double('scope') }
-          let(:variable) { Variable.new(name, declaration_node, scope) }
+  describe '.new' do
+    context 'when non variable declaration node is passed' do
+      it 'raises error' do
+        name = :foo
+        declaration_node = s(:def)
+        scope = Rubocop::Cop::VariableInspector::Scope.new(s(:class))
+        expect { described_class.new(name, declaration_node, scope) }
+          .to raise_error(ArgumentError)
+      end
+    end
+  end
 
-          subject { variable.referenced? }
+  describe '#referenced?' do
+    let(:name) { :foo }
+    let(:declaration_node) { s(:arg, name) }
+    let(:scope) { double('scope') }
+    let(:variable) { described_class.new(name, declaration_node, scope) }
 
-          context 'when the variable is not yet assigned' do
-            it { should be_false }
-          end
+    subject { variable.referenced? }
 
-          context 'when the variable has an assignment' do
-            before do
-              variable.assign(s(:lvasgn, :foo))
-            end
+    context 'when the variable is not yet assigned' do
+      it { should be_false }
+    end
 
-            context 'and the assignment is not yet referenced' do
-              it { should be_false }
-            end
+    context 'when the variable has an assignment' do
+      before do
+        variable.assign(s(:lvasgn, :foo))
+      end
 
-            context 'and the assignment is referenced' do
-              before do
-                variable.assignments.first.reference!
-              end
+      context 'and the assignment is not yet referenced' do
+        it { should be_false }
+      end
 
-              it { should be_true }
-            end
-          end
+      context 'and the assignment is referenced' do
+        before do
+          variable.assignments.first.reference!
+        end
 
-          context 'when the variable has multiple assignments' do
-            before do
-              variable.assign(s(:lvasgn, :foo))
-              variable.assign(s(:lvasgn, :foo))
-            end
+        it { should be_true }
+      end
+    end
 
-            context 'and only once assignment is referenced' do
-              before do
-                variable.assignments[1].reference!
-              end
+    context 'when the variable has multiple assignments' do
+      before do
+        variable.assign(s(:lvasgn, :foo))
+        variable.assign(s(:lvasgn, :foo))
+      end
 
-              it { should be_true }
-            end
+      context 'and only once assignment is referenced' do
+        before do
+          variable.assignments[1].reference!
+        end
 
-            context 'and all assignments are referenced' do
-              before do
-                variable.assignments.each { |a| a.reference! }
-              end
+        it { should be_true }
+      end
 
-              it { should be_true }
-            end
-          end
+      context 'and all assignments are referenced' do
+        before do
+          variable.assignments.each { |a| a.reference! }
         end
+
+        it { should be_true }
       end
     end
   end