ridecharge-rubocop 0.0.1

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

@@ -0,0 +1,184 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+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 { described_class.new(node) }.not_to raise_error
+      end
+    end
+  end
+
+  let(:ast) do
+    ast = Rubocop::SourceParser.parse(source).ast
+    Rubocop::Cop::VariableInspector.wrap_with_top_level_node(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) { described_class.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
+          this_is_target
+        END
+      end
+
+      let(:scope_node_type) { :top_level }
+
+      include_examples 'returns the body node'
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+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 = Rubocop::Cop::VariableInspector::Scope.new(s(:class))
+        expect { described_class.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) { described_class.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

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

@@ -0,0 +1,269 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::VariableInspector::VariableTable do
+  include AST::Sexp
+
+  subject(:variable_table) { described_class.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