rubocop 0.29.1 → 0.30.0

data/spec/rubocop/cop/variable_force/reference_spec.rb

@@ -1,19 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-require 'astrolabe/sexp'
-
-describe RuboCop::Cop::VariableForce::Reference do
-  include Astrolabe::Sexp
-
-  describe '.new' do
-    context 'when non variable reference node is passed' do
-      it 'raises error' do
-        node = s(:def)
-        scope = RuboCop::Cop::VariableForce::Scope.new(s(:class))
-        expect { described_class.new(node, scope) }
-          .to raise_error(ArgumentError)
-      end
-    end
-  end
-end

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

@@ -1,319 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::VariableForce::Scope do
-  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::ProcessedSource.new(source).ast
-    RuboCop::Cop::VariableForce.wrap_with_top_level_scope_node(ast)
-  end
-
-  let(:scope_node_type) { :def }
-
-  let(:scope_node) { ast.each_node(scope_node_type).first }
-
-  subject(:scope) { described_class.new(scope_node) }
-
-  describe '#name' do
-    context 'when the scope is instance method definition' do
-      let(:source) { <<-END }
-        def some_method
-        end
-      END
-
-      let(:scope_node_type) { :def }
-
-      it 'returns the method name' do
-        expect(scope.name).to eq(:some_method)
-      end
-    end
-
-    context 'when the scope is singleton method definition' do
-      let(:source) { <<-END }
-        def self.some_method
-        end
-      END
-
-      let(:scope_node_type) { :defs }
-
-      it 'returns the method name' do
-        expect(scope.name).to eq(:some_method)
-      end
-    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) { :begin }
-
-      include_examples 'returns the body node'
-    end
-  end
-
-  describe '#each_node' do
-    shared_examples 'yields' do |description|
-      it "yields #{description}" do
-        yielded_types = []
-
-        scope.each_node do |node|
-          yielded_types << node.type
-        end
-
-        expect(yielded_types).to eq(expected_types.map(&:to_sym))
-      end
-    end
-
-    describe 'outer scope boundary handling' do
-      context 'when the scope is instance method' do
-        let(:source) { <<-END }
-          def some_method(arg1, arg2)
-            :body
-          end
-        END
-
-        let(:scope_node_type) { :def }
-        let(:expected_types) { %w(args arg arg sym) }
-        include_examples 'yields', 'the argument and the body nodes'
-      end
-
-      context 'when the scope is singleton method' do
-        let(:source) { <<-END }
-          def self.some_method(arg1, arg2)
-            :body
-          end
-        END
-
-        let(:scope_node_type) { :defs }
-        let(:expected_types) { %w(args arg arg sym) }
-        include_examples 'yields', 'the argument and the body nodes'
-      end
-
-      context 'when the scope is module' do
-        let(:source) { <<-END }
-          module SomeModule
-            :body
-          end
-        END
-
-        let(:scope_node_type) { :module }
-        let(:expected_types) { %w(sym) }
-        include_examples 'yields', 'the body nodes'
-      end
-
-      context 'when the scope is class' do
-        let(:source) { <<-END }
-          some_super_class = Class.new
-
-          class SomeClass < some_super_class
-            :body
-          end
-        END
-
-        let(:scope_node_type) { :class }
-        let(:expected_types) { %w(sym) }
-        include_examples 'yields', 'the body nodes'
-      end
-
-      context 'when the scope is singleton class' do
-        let(:source) { <<-END }
-          some_object = Object.new
-
-          class << some_object
-            :body
-          end
-        END
-
-        let(:scope_node_type) { :sclass }
-        let(:expected_types) { %w(sym) }
-        include_examples 'yields', 'the body nodes'
-      end
-
-      context 'when the scope is block' do
-        let(:source) { <<-END }
-          1.times do |arg1, arg2|
-            :body
-          end
-        END
-
-        let(:scope_node_type) { :block }
-        let(:expected_types) { %w(args arg arg sym) }
-        include_examples 'yields', 'the argument and the body nodes'
-      end
-
-      context 'when the scope is top level' do
-        let(:source) { <<-END }
-          :body
-        END
-
-        let(:scope_node_type) { :begin }
-        let(:expected_types) { %w(sym) }
-        include_examples 'yields', 'the body nodes'
-      end
-    end
-
-    describe 'inner scope boundary handling' do
-      context "when there's a method invocation with block" do
-        let(:source) { <<-END }
-          foo = 1
-
-          do_something(1, 2) do |arg|
-            :body
-          end
-
-          foo
-        END
-
-        let(:scope_node_type) { :begin }
-        let(:expected_types) { %w(lvasgn int block send int int lvar) }
-        include_examples 'yields', 'only the block node and the child send node'
-      end
-
-      context "when there's a singleton method definition" do
-        let(:source) { <<-END }
-          foo = 1
-
-          def self.some_method(arg1, arg2)
-            :body
-          end
-
-          foo
-        END
-
-        let(:scope_node_type) { :begin }
-        let(:expected_types) { %w(lvasgn int defs self lvar) }
-        include_examples 'yields', 'only the defs node and the method host node'
-      end
-
-      context 'when there are grouped nodes with a begin node' do
-        let(:source) { <<-END }
-          foo = 1
-
-          if true
-            do_something
-            do_anything
-          end
-
-          foo
-        END
-
-        let(:scope_node_type) { :begin }
-        let(:expected_types) { %w(lvasgn int if true begin send send lvar) }
-        include_examples 'yields', 'them without confused with top level scope'
-      end
-    end
-  end
-end

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

@@ -1,59 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-require 'astrolabe/sexp'
-
-describe RuboCop::Cop::VariableForce::Variable do
-  include Astrolabe::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::VariableForce::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').as_null_object }
-    let(:variable) { described_class.new(name, declaration_node, scope) }
-
-    subject { variable.referenced? }
-
-    context 'when the variable is not assigned' do
-      it { should be_falsey }
-
-      context 'and the variable is referenced' do
-        before do
-          variable.reference!(s(:lvar, name))
-        end
-
-        it { should be_truthy }
-      end
-    end
-
-    context 'when the variable has an assignment' do
-      before do
-        variable.assign(s(:lvasgn, name))
-      end
-
-      context 'and the variable is not yet referenced' do
-        it { should be_falsey }
-      end
-
-      context 'and the variable is referenced' do
-        before do
-          variable.reference!(s(:lvar, name))
-        end
-
-        it { should be_truthy }
-      end
-    end
-  end
-end

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

@@ -1,276 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::VariableForce::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 '#find_variable with an empty scope stack' do
-    it 'returns nil' do
-      found_variable = variable_table.find_variable(:unknown)
-      expect(found_variable).to be_nil
-    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