rubocop 0.12.0 → 0.13.0

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

@@ -0,0 +1,740 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module VariableInspector
+      describe Locatable do
+        include ASTHelper
+        include AST::Sexp
+
+        class LocatableObject
+          include Locatable
+
+          attr_reader :node, :scope
+
+          def initialize(node, scope)
+            @node = node
+            @scope = scope
+          end
+        end
+
+        let(:ast) do
+          processed_source = Rubocop::SourceParser.parse(source)
+          processed_source.ast
+        end
+
+        let(:def_node) do
+          found_node = scan_node(ast, include_origin_node: true) do |node|
+            break node if node.type == :def
+          end
+          fail 'No def node found!' unless found_node
+          found_node
+        end
+
+        let(:lvasgn_node) do
+          found_node = scan_node(ast) do |node|
+            break node if node.type == :lvasgn
+          end
+          fail 'No lvasgn node found!' unless found_node
+          found_node
+        end
+
+        let(:scope) { Scope.new(def_node) }
+        let(:assignment) { LocatableObject.new(lvasgn_node, scope) }
+
+        describe '#ancestor_nodes_in_scope' do
+          let(:source) do
+            <<-END
+              class SomeClass
+                def some_method(flag)
+                  puts 'Hello World!'
+
+                  if flag > 0
+                    foo = 1
+                  end
+                end
+              end
+            END
+          end
+
+          it 'returns its ancestor nodes in the scope excluding scope node' do
+            ancestor_types = assignment.ancestor_nodes_in_scope.map(&:type)
+            expect(ancestor_types).to eq([:begin, :if])
+          end
+        end
+
+        describe '#branch_point_node' do
+          context 'when it is not in branch' do
+            let(:source) do
+              <<-END
+                def some_method(flag)
+                  foo = 1
+                end
+              END
+            end
+
+            it 'returns nil' do
+              expect(assignment.branch_point_node).to be_nil
+            end
+          end
+
+          context 'when it is inside of if' do
+            let(:source) do
+              <<-END
+                def some_method(flag)
+                  if flag
+                    foo = 1
+                  end
+                end
+              END
+            end
+
+            it 'returns the if node' do
+              expect(assignment.branch_point_node.type).to eq(:if)
+            end
+          end
+
+          context 'when it is inside of else of if' do
+            let(:source) do
+              <<-END
+                def some_method(flag)
+                  if flag
+                  else
+                    foo = 1
+                  end
+                end
+              END
+            end
+
+            it 'returns the if node' do
+              expect(assignment.branch_point_node.type).to eq(:if)
+            end
+          end
+
+          context 'when it is inside of if condition' do
+            let(:source) do
+              <<-END
+                def some_method(flag)
+                  if foo = 1
+                    do_something
+                  end
+                end
+              END
+            end
+
+            it 'returns nil' do
+              expect(assignment.branch_point_node).to be_nil
+            end
+          end
+
+          context 'when multiple if are nested' do
+            context 'and it is inside of inner if' do
+              let(:source) do
+                <<-END
+                  def some_method(a, b)
+                    if a
+                      if b
+                        foo = 1
+                      end
+                    end
+                  end
+                END
+              end
+
+              it 'returns inner if node' do
+                if_node = assignment.branch_point_node
+                expect(if_node.type).to eq(:if)
+                condition_node = if_node.children.first
+                expect(condition_node).to eq(s(:lvar, :b))
+              end
+            end
+
+            context 'and it is inside of inner if condition' do
+              let(:source) do
+                <<-END
+                  def some_method(a, b)
+                    if a
+                      if foo = 1
+                        do_something
+                      end
+                    end
+                  end
+                END
+              end
+
+              it 'returns the next outer if node' do
+                if_node = assignment.branch_point_node
+                expect(if_node.type).to eq(:if)
+                condition_node = if_node.children.first
+                expect(condition_node).to eq(s(:lvar, :a))
+              end
+            end
+          end
+
+          context 'when it is inside of when of case' do
+            let(:source) do
+              <<-END
+                def some_method(flag)
+                  case flag
+                  when 1
+                    foo = 1
+                  end
+                end
+              END
+            end
+
+            it 'returns the case node' do
+              expect(assignment.branch_point_node.type).to eq(:case)
+            end
+          end
+
+          context 'when it is on the left side of &&' do
+            let(:source) do
+              <<-END
+                def some_method
+                  (foo = 1) && do_something
+                end
+              END
+            end
+
+            it 'returns nil' do
+              expect(assignment.branch_point_node).to be_nil
+            end
+          end
+
+          context 'when it is on the right side of &&' do
+            let(:source) do
+              <<-END
+                def some_method
+                  do_something && (foo = 1)
+                end
+              END
+            end
+
+            it 'returns the and node' do
+              expect(assignment.branch_point_node.type).to eq(:and)
+            end
+          end
+
+          context 'when it is on the left side of ||' do
+            let(:source) do
+              <<-END
+                def some_method
+                  (foo = 1) || do_something
+                end
+              END
+            end
+
+            it 'returns nil' do
+              expect(assignment.branch_point_node).to be_nil
+            end
+          end
+
+          context 'when it is on the right side of ||' do
+            let(:source) do
+              <<-END
+                def some_method
+                  do_something || (foo = 1)
+                end
+              END
+            end
+
+            it 'returns the or node' do
+              expect(assignment.branch_point_node.type).to eq(:or)
+            end
+          end
+
+          context 'when multiple && are chained' do
+            context 'and it is on the right side of the right &&' do
+              let(:source) do
+                <<-END
+                  def some_method
+                    do_something && do_anything && (foo = 1)
+                  end
+                END
+              end
+
+              it 'returns the right and node' do
+                and_node = assignment.branch_point_node
+                expect(and_node.type).to eq(:and)
+                right_side_node = and_node.children[1]
+                expect(right_side_node.type).to eq(:begin)
+              end
+            end
+
+            context 'and it is on the right side of the left &&' do
+              let(:source) do
+                <<-END
+                  def some_method
+                    do_something && (foo = 1) && do_anything
+                  end
+                END
+              end
+
+              it 'returns the left and node' do
+                and_node = assignment.branch_point_node
+                expect(and_node.type).to eq(:and)
+                right_side_node = and_node.children[1]
+                expect(right_side_node.type).to eq(:begin)
+              end
+            end
+          end
+
+          context 'when it is inside of begin with rescue' do
+            let(:source) do
+              <<-END
+                def some_method(flag)
+                  begin
+                    foo = 1
+                  rescue
+                    do_something
+                  end
+                end
+              END
+            end
+
+            it 'returns the rescue node' do
+              expect(assignment.branch_point_node.type).to eq(:rescue)
+            end
+          end
+
+          context 'when it is inside of rescue' do
+            let(:source) do
+              <<-END
+                def some_method(flag)
+                  begin
+                    do_something
+                  rescue
+                    foo = 1
+                  end
+                end
+              END
+            end
+
+            it 'returns the rescue node' do
+              expect(assignment.branch_point_node.type).to eq(:rescue)
+            end
+          end
+
+          context 'when it is inside of begin with ensure' do
+            let(:source) do
+              <<-END
+                def some_method(flag)
+                  begin
+                    foo = 1
+                  ensure
+                    do_something
+                  end
+                end
+              END
+            end
+
+            it 'returns the ensure node' do
+              expect(assignment.branch_point_node.type).to eq(:ensure)
+            end
+          end
+
+          context 'when it is inside of ensure' do
+            let(:source) do
+              <<-END
+                def some_method(flag)
+                  begin
+                    do_something
+                  ensure
+                    foo = 1
+                  end
+                end
+              END
+            end
+
+            it 'returns nil' do
+              expect(assignment.branch_point_node).to be_nil
+            end
+          end
+
+          context 'when it is inside of begin without rescue' do
+            let(:source) do
+              <<-END
+                def some_method(flag)
+                  begin
+                    foo = 1
+                  end
+                end
+              END
+            end
+
+            it 'returns nil' do
+              expect(assignment.branch_point_node).to be_nil
+            end
+          end
+        end
+
+        describe '#branch_body_node' do
+          context 'when it is not in branch' do
+            let(:source) do
+              <<-END
+                def some_method(flag)
+                  foo = 1
+                end
+              END
+            end
+
+            it 'returns nil' do
+              expect(assignment.branch_body_node).to be_nil
+            end
+          end
+
+          context 'when it is inside body of if' do
+            let(:source) do
+              <<-END
+                def some_method(flag)
+                  if flag
+                    foo = 1
+                    puts foo
+                  end
+                end
+              END
+            end
+
+            it 'returns the body node' do
+              expect(assignment.branch_body_node.type).to eq(:begin)
+            end
+          end
+
+          context 'when it is inside body of else of if' do
+            let(:source) do
+              <<-END
+                def some_method(flag)
+                  if flag
+                    do_something
+                  else
+                    foo = 1
+                    puts foo
+                  end
+                end
+              END
+            end
+
+            it 'returns the body node' do
+              expect(assignment.branch_body_node.type).to eq(:begin)
+            end
+          end
+
+          context 'when it is on the right side of &&' do
+            let(:source) do
+              <<-END
+                def some_method
+                  do_something && (foo = 1)
+                end
+              END
+            end
+
+            it 'returns the right side node' do
+              expect(assignment.branch_body_node.type).to eq(:begin)
+            end
+          end
+
+          context 'when it is on the right side of ||' do
+            let(:source) do
+              <<-END
+                def some_method
+                  do_something || (foo = 1)
+                end
+              END
+            end
+
+            it 'returns the right side node' do
+              expect(assignment.branch_body_node.type).to eq(:begin)
+            end
+          end
+
+          context 'when it is inside of begin with rescue' do
+            let(:source) do
+              <<-END
+                def some_method(flag)
+                  begin
+                    foo = 1
+                  rescue
+                    do_something
+                  end
+                end
+              END
+            end
+
+            it 'returns the body node' do
+              expect(assignment.branch_body_node.type).to eq(:lvasgn)
+            end
+          end
+
+          context 'when it is inside of rescue' do
+            let(:source) do
+              <<-END
+                def some_method(flag)
+                  begin
+                    do_something
+                  rescue
+                    foo = 1
+                  end
+                end
+              END
+            end
+
+            it 'returns the resbody node' do
+              expect(assignment.branch_body_node.type).to eq(:resbody)
+            end
+          end
+
+          context 'when it is inside of begin with ensure' do
+            let(:source) do
+              <<-END
+                def some_method(flag)
+                  begin
+                    foo = 1
+                  ensure
+                    do_something
+                  end
+                end
+              END
+            end
+
+            it 'returns the body node' do
+              expect(assignment.branch_body_node.type).to eq(:lvasgn)
+            end
+          end
+        end
+
+        describe '#branch_id' do
+          context 'when it is not in branch' do
+            let(:source) do
+              <<-END
+                def some_method(flag)
+                  foo = 1
+                end
+              END
+            end
+
+            it 'returns nil' do
+              expect(assignment.branch_id).to be_nil
+            end
+          end
+
+          context 'when it is inside body of if' do
+            let(:source) do
+              <<-END
+                def some_method(flag)
+                  if flag
+                    foo = 1
+                    puts foo
+                  end
+                end
+              END
+            end
+
+            it 'returns BRANCHNODEID_if_true' do
+              expect(assignment.branch_id).to match(/^\d+_if_true/)
+            end
+          end
+
+          context 'when it is inside body of else of if' do
+            let(:source) do
+              <<-END
+                def some_method(flag)
+                  if flag
+                    do_something
+                  else
+                    foo = 1
+                    puts foo
+                  end
+                end
+              END
+            end
+
+            it 'returns BRANCHNODEID_if_false' do
+              expect(assignment.branch_id).to match(/^\d+_if_false/)
+            end
+          end
+
+          context 'when it is inside body of when of case' do
+            let(:source) do
+              <<-END
+                def some_method(flag)
+                  case flag
+                  when first
+                    do_something
+                  when second
+                    foo = 1
+                    puts foo
+                  else
+                    do_something
+                  end
+                end
+              END
+            end
+
+            it 'returns BRANCHNODEID_case_whenINDEX' do
+              expect(assignment.branch_id).to match(/^\d+_case_when1/)
+            end
+          end
+
+          context 'when it is inside body of when of case' do
+            let(:source) do
+              <<-END
+                def some_method(flag)
+                  case flag
+                  when first
+                    do_something
+                  when second
+                    do_something
+                  else
+                    foo = 1
+                    puts foo
+                  end
+                end
+              END
+            end
+
+            it 'returns BRANCHNODEID_case_else' do
+              expect(assignment.branch_id).to match(/^\d+_case_else/)
+            end
+          end
+
+          context 'when it is on the left side of &&' do
+            let(:source) do
+              <<-END
+                def some_method
+                  (foo = 1) && do_something
+                end
+              END
+            end
+
+            it 'returns nil' do
+              expect(assignment.branch_id).to be_nil
+            end
+          end
+
+          context 'when it is on the right side of &&' do
+            let(:source) do
+              <<-END
+                def some_method
+                  do_something && (foo = 1)
+                end
+              END
+            end
+
+            it 'returns BRANCHNODEID_and_right' do
+              expect(assignment.branch_id).to match(/^\d+_and_right/)
+            end
+          end
+
+          context 'when it is on the left side of ||' do
+            let(:source) do
+              <<-END
+                def some_method
+                  (foo = 1) || do_something
+                end
+              END
+            end
+
+            it 'returns nil' do
+              expect(assignment.branch_id).to be_nil
+            end
+          end
+
+          context 'when it is on the right side of ||' do
+            let(:source) do
+              <<-END
+                def some_method
+                  do_something || (foo = 1)
+                end
+              END
+            end
+
+            it 'returns BRANCHNODEID_or_right' do
+              expect(assignment.branch_id).to match(/^\d+_or_right/)
+            end
+          end
+
+          context 'when it is inside of begin with rescue' do
+            let(:source) do
+              <<-END
+                def some_method(flag)
+                  begin
+                    foo = 1
+                  rescue
+                    do_something
+                  end
+                end
+              END
+            end
+
+            it 'returns BRANCHNODEID_rescue_main' do
+              expect(assignment.branch_id).to match(/^\d+_rescue_main/)
+            end
+          end
+
+          context 'when it is inside of rescue' do
+            let(:source) do
+              <<-END
+                def some_method(flag)
+                  begin
+                    do_something
+                  rescue FirstError
+                    do_something
+                  rescue SecondError
+                    foo = 1
+                  end
+                end
+              END
+            end
+
+            it 'returns BRANCHNODEID_rescue_rescueINDEX' do
+              expect(assignment.branch_id).to match(/^\d+_rescue_rescue1/)
+            end
+          end
+
+          context 'when it is inside of else of rescue' do
+            let(:source) do
+              <<-END
+                def some_method(flag)
+                  begin
+                    do_something
+                  rescue FirstError
+                    do_something
+                  rescue SecondError
+                    do_something
+                  else
+                    foo = 1
+                  end
+                end
+              END
+            end
+
+            it 'returns BRANCHNODEID_rescue_else' do
+              expect(assignment.branch_id).to match(/^\d+_rescue_else/)
+            end
+          end
+
+          context 'when it is inside of begin with ensure' do
+            let(:source) do
+              <<-END
+                def some_method(flag)
+                  begin
+                    foo = 1
+                  ensure
+                    do_something
+                  end
+                end
+              END
+            end
+
+            it 'returns BRANCHNODEID_ensure_main' do
+              expect(assignment.branch_id).to match(/^\d+_ensure_main/)
+            end
+          end
+        end
+      end
+    end
+  end
+end