rubocop 0.12.0 → 0.13.0

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

@@ -0,0 +1,191 @@
+# encoding: utf-8
+
+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
+
+          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
+
+        let(:ast) do
+          processed_source = Rubocop::SourceParser.parse(source)
+          processed_source.ast
+        end
+
+        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
+
+        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
+
+          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
+
+          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
+
+        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
+
+            let(:scope_node_type) { :def }
+
+            include_examples 'returns the body node'
+          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) { :defs }
+
+            include_examples 'returns the body node'
+          end
+
+          context 'when the scope is module' do
+            let(:source) do
+              <<-END
+                module SomeModule
+                  this_is_target
+                end
+              END
+            end
+
+            let(:scope_node_type) { :module }
+
+            include_examples 'returns the body node'
+          end
+
+          context 'when the scope is class' do
+            let(:source) do
+              <<-END
+                class SomeClass
+                  this_is_target
+                end
+              END
+            end
+
+            let(:scope_node_type) { :class }
+
+            include_examples 'returns the body node'
+          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) { :sclass }
+
+            include_examples 'returns the body node'
+          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) { :block }
+
+            include_examples 'returns the body node'
+          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
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module VariableInspector
+      describe 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) }
+
+          subject { variable.referenced? }
+
+          context 'when the variable is not yet assigned' 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 not yet referenced' do
+              it { should be_false }
+            end
+
+            context 'and the assignment is referenced' do
+              before do
+                variable.assignments.first.reference!
+              end
+
+              it { should be_true }
+            end
+          end
+
+          context 'when the variable has multiple assignments' do
+            before do
+              variable.assign(s(:lvasgn, :foo))
+              variable.assign(s(:lvasgn, :foo))
+            end
+
+            context 'and only once assignment is referenced' do
+              before do
+                variable.assignments[1].reference!
+              end
+
+              it { should be_true }
+            end
+
+            context 'and all assignments are referenced' do
+              before do
+                variable.assignments.each { |a| a.reference! }
+              end
+
+              it { should be_true }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,275 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module VariableInspector
+      describe VariableTable do
+        include AST::Sexp
+
+        subject(:variable_table) { VariableTable.new }
+
+        describe '#push_scope' do
+          it 'returns pushed scope object' do
+            node = s(:def)
+            scope = variable_table.push_scope(node)
+            expect(scope).to equal(variable_table.current_scope)
+            expect(scope.node).to equal(node)
+          end
+        end
+
+        describe '#pop_scope' do
+          before do
+            node = s(:def)
+            variable_table.push_scope(node)
+          end
+
+          it 'returns popped scope object' do
+            last_scope = variable_table.current_scope
+            popped_scope = variable_table.pop_scope
+            expect(popped_scope).to equal(last_scope)
+          end
+        end
+
+        describe '#current_scope_level' do
+          before do
+            variable_table.push_scope(s(:def))
+          end
+
+          it 'increases by pushing scope' do
+            last_scope_level = variable_table.current_scope_level
+            variable_table.push_scope(s(:def))
+            expect(variable_table.current_scope_level)
+              .to eq(last_scope_level + 1)
+          end
+
+          it 'decreases by popping scope' do
+            last_scope_level = variable_table.current_scope_level
+            variable_table.pop_scope
+            expect(variable_table.current_scope_level)
+              .to eq(last_scope_level - 1)
+          end
+        end
+
+        describe '#declare_variable' do
+          before do
+            2.times do
+              node = s(:def)
+              variable_table.push_scope(node)
+            end
+          end
+
+          it 'adds variable to current scope with its name as key' do
+            node = s(:lvasgn, :foo)
+            variable_table.declare_variable(:foo, node)
+            expect(variable_table.current_scope.variables)
+              .to have_key(:foo)
+            expect(variable_table.scope_stack[-2].variables)
+              .to be_empty
+            variable = variable_table.current_scope.variables[:foo]
+            expect(variable.declaration_node).to equal(node)
+          end
+
+          it 'returns the added variable' do
+            node = s(:lvasgn, :foo)
+            variable = variable_table.declare_variable(:foo, node)
+            expect(variable.declaration_node).to equal(node)
+          end
+        end
+
+        describe '#find_variable' do
+          before do
+            variable_table.push_scope(s(:class))
+            variable_table.declare_variable(:baz, s(:lvasgn, :baz))
+
+            variable_table.push_scope(s(:def))
+            variable_table.declare_variable(:bar, s(:lvasgn, :bar))
+          end
+
+          context 'when current scope is block' do
+            before do
+              variable_table.push_scope(s(:block))
+            end
+
+            context 'when a variable with the target name exists ' +
+                    'in current scope' do
+              before do
+                variable_table.declare_variable(:foo, s(:lvasgn, :foo))
+              end
+
+              context 'and does not exist in outer scope' do
+                it 'returns the current scope variable' do
+                  found_variable = variable_table.find_variable(:foo)
+                  expect(found_variable.name).to eq(:foo)
+                end
+              end
+
+              context 'and also exists in outer scope' do
+                before do
+                  variable_table.declare_variable(:bar, s(:lvasgn, :bar))
+                end
+
+                it 'returns the current scope variable' do
+                  found_variable = variable_table.find_variable(:bar)
+                  expect(found_variable.name).to equal(:bar)
+                  expect(variable_table.current_scope.variables)
+                    .to have_value(found_variable)
+                  expect(variable_table.scope_stack[-2].variables)
+                    .not_to have_value(found_variable)
+                end
+              end
+            end
+
+            context 'when a variable with the target name does not exist ' +
+                    'in current scope' do
+              context 'but exists in the direct outer scope' do
+                it 'returns the direct outer scope variable' do
+                  found_variable = variable_table.find_variable(:bar)
+                  expect(found_variable.name).to equal(:bar)
+                end
+              end
+
+              context 'but exists in a indirect outer scope' do
+                context 'when the direct outer scope is block' do
+                  before do
+                    variable_table.pop_scope
+                    variable_table.pop_scope
+
+                    variable_table.push_scope(s(:block))
+                    variable_table.push_scope(s(:block))
+                  end
+
+                  it 'returns the indirect outer scope variable' do
+                    found_variable = variable_table.find_variable(:baz)
+                    expect(found_variable.name).to equal(:baz)
+                  end
+                end
+
+                context 'when the direct outer scope is not block' do
+                  it 'returns nil' do
+                    found_variable = variable_table.find_variable(:baz)
+                    expect(found_variable).to be_nil
+                  end
+                end
+              end
+
+              context 'and does not exist in all outer scopes' do
+                it 'returns nil' do
+                  found_variable = variable_table.find_variable(:non)
+                  expect(found_variable).to be_nil
+                end
+              end
+            end
+          end
+
+          context 'when current scope is not block' do
+            before do
+              variable_table.push_scope(s(:def))
+            end
+
+            context 'when a variable with the target name exists ' +
+                    'in current scope' do
+              before do
+                variable_table.declare_variable(:foo, s(:lvasgn, :foo))
+              end
+
+              context 'and does not exist in outer scope' do
+                it 'returns the current scope variable' do
+                  found_variable = variable_table.find_variable(:foo)
+                  expect(found_variable.name).to eq(:foo)
+                end
+              end
+
+              context 'and also exists in outer scope' do
+                it 'returns the current scope variable' do
+                  found_variable = variable_table.find_variable(:foo)
+                  expect(found_variable.name).to equal(:foo)
+                  expect(variable_table.current_scope.variables)
+                    .to have_value(found_variable)
+                  expect(variable_table.scope_stack[-2].variables)
+                    .not_to have_value(found_variable)
+                end
+              end
+            end
+
+            context 'when a variable with the target name does not exist ' +
+                    'in current scope' do
+              context 'but exists in the direct outer scope' do
+                it 'returns nil' do
+                  found_variable = variable_table.find_variable(:bar)
+                  expect(found_variable).to be_nil
+                end
+              end
+
+              context 'and does not exist in all outer scopes' do
+                it 'returns nil' do
+                  found_variable = variable_table.find_variable(:non)
+                  expect(found_variable).to be_nil
+                end
+              end
+            end
+          end
+        end
+
+        describe '#accessible_variables' do
+          let(:accessible_variable_names) do
+            variable_table.accessible_variables.map(&:name)
+          end
+
+          before do
+            variable_table.push_scope(s(:class))
+          end
+
+          context 'when there are no variables' do
+            it 'returns empty array' do
+              expect(variable_table.accessible_variables).to be_empty
+            end
+          end
+
+          context 'when the current scope has some variables' do
+            before do
+              variable_table.declare_variable(:foo, s(:lvasgn, :foo))
+              variable_table.declare_variable(:bar, s(:lvasgn, :bar))
+            end
+
+            it 'returns all the variables' do
+              expect(accessible_variable_names).to match_array([:foo, :bar])
+            end
+          end
+
+          context 'when the direct outer scope has some variables' do
+            before do
+              variable_table.declare_variable(:foo, s(:lvasgn, :foo))
+            end
+
+            context 'and the current scope is block' do
+              before do
+                variable_table.push_scope(s(:block))
+                variable_table.declare_variable(:bar, s(:lvasgn, :bar))
+                variable_table.declare_variable(:baz, s(:lvasgn, :baz))
+              end
+
+              it 'returns the current and direct outer scope variables' do
+                expect(accessible_variable_names)
+                  .to match_array([:foo, :bar, :baz])
+              end
+            end
+
+            context 'and the current scope is not block' do
+              before do
+                variable_table.push_scope(s(:def))
+                variable_table.declare_variable(:bar, s(:lvasgn, :bar))
+                variable_table.declare_variable(:baz, s(:lvasgn, :baz))
+              end
+
+              it 'returns only the current scope variables' do
+                expect(accessible_variable_names).to match_array([:bar, :baz])
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end