rubocop 0.25.0 → 0.26.0

data/spec/rubocop/cop/style/variable_name_spec.rb

@@ -51,10 +51,10 @@ describe RuboCop::Cop::Style::VariableName, :config do
       expect(cop.highlights).to eq(['@myAttribute'])
     end
 
-    it 'registers an offense for camel case in setter name' do
-      inspect_source(cop, 'self.mySetter = 2')
+    it 'registers an offense for camel case in class variable name' do
+      inspect_source(cop, '@@myAttr = 2')
       expect(cop.offenses.size).to eq(1)
-      expect(cop.highlights).to eq(['mySetter'])
+      expect(cop.highlights).to eq(['@@myAttr'])
     end
 
     include_examples 'always accepted'
@@ -88,8 +88,8 @@ describe RuboCop::Cop::Style::VariableName, :config do
       expect(cop.offenses).to be_empty
     end
 
-    it 'accepts camel case in setter name' do
-      inspect_source(cop, 'self.mySetter = 2')
+    it 'accepts camel case in class variable name' do
+      inspect_source(cop, '@@myAttr = 2')
       expect(cop.offenses).to be_empty
     end
 

data/spec/rubocop/cop/style/when_then_spec.rb

@@ -35,6 +35,8 @@ describe RuboCop::Cop::Style::WhenThen do
     new_source = autocorrect_source(cop, ['case a',
                                           'when b; c',
                                           'end'])
-    expect(new_source).to eq("case a\nwhen b then c\nend")
+    expect(new_source).to eq(['case a',
+                              'when b then c',
+                              'end'].join("\n"))
   end
 end

data/spec/rubocop/cop/style/while_until_do_spec.rb

@@ -42,12 +42,14 @@ describe RuboCop::Cop::Style::WhileUntilDo do
   it 'auto-corrects the usage of "do" in multiline while' do
     new_source = autocorrect_source(cop, ['while cond do',
                                           'end'])
-    expect(new_source).to eq("while cond\nend")
+    expect(new_source).to eq(['while cond',
+                              'end'].join("\n"))
   end
 
   it 'auto-corrects the usage of "do" in multiline until' do
     new_source = autocorrect_source(cop, ['until cond do',
                                           'end'])
-    expect(new_source).to eq("until cond\nend")
+    expect(new_source).to eq(['until cond',
+                              'end'].join("\n"))
   end
 end

data/spec/rubocop/cop/util_spec.rb

@@ -4,8 +4,6 @@ require 'spec_helper'
 
 describe RuboCop::Cop::Util do
   describe '#line_range' do
-    include ASTHelper
-
     let(:source) do
       <<-END
         foo = 1
@@ -24,13 +22,7 @@ describe RuboCop::Cop::Util do
       processed_source.ast
     end
 
-    let(:node) do
-      target_node = scan_node(ast) do |node|
-        break node if node.type == :class
-      end
-      fail 'No target node found!' unless target_node
-      target_node
-    end
+    let(:node) { ast.each_node.find(&:class_type?) }
 
     context 'when Source::Range object is passed' do
       it 'returns line range of that' do

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

@@ -3,7 +3,6 @@
 require 'spec_helper'
 
 describe RuboCop::Cop::VariableForce::Assignment do
-  include ASTHelper
   include AST::Sexp
 
   let(:ast) do
@@ -25,21 +24,9 @@ describe RuboCop::Cop::VariableForce::Assignment do
     END
   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(:def_node) { ast.each_node.find(&:def_type?) }
 
-  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(:lvasgn_node) { ast.each_node.find(&:lvasgn_type?) }
 
   let(:name) { lvasgn_node.children.first }
   let(:scope) { RuboCop::Cop::VariableForce::Scope.new(def_node) }

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

@@ -3,7 +3,6 @@
 require 'spec_helper'
 
 describe RuboCop::Cop::VariableForce::Locatable do
-  include ASTHelper
   include AST::Sexp
 
   class LocatableObject
@@ -22,46 +21,12 @@ describe RuboCop::Cop::VariableForce::Locatable do
     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(:def_node) { ast.each_node.find(&:def_type?) }
+  let(:lvasgn_node) { ast.each_node.find(&:lvasgn_type?) }
 
   let(:scope) { RuboCop::Cop::VariableForce::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

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

@@ -3,7 +3,6 @@
 require 'spec_helper'
 
 describe RuboCop::Cop::VariableForce::Scope do
-  include ASTHelper
   include AST::Sexp
 
   describe '.new' do
@@ -24,18 +23,12 @@ describe RuboCop::Cop::VariableForce::Scope do
 
   let(:ast) do
     ast = RuboCop::ProcessedSource.new(source).ast
-    RuboCop::Cop::VariableForce.wrap_with_top_level_node(ast)
+    RuboCop::Cop::VariableForce.wrap_with_top_level_scope_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
+  let(:scope_node) { ast.each_node(scope_node_type).first }
 
   subject(:scope) { described_class.new(scope_node) }
 
@@ -67,45 +60,6 @@ describe RuboCop::Cop::VariableForce::Scope do
     end
   end
 
-  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
@@ -204,9 +158,162 @@ describe RuboCop::Cop::VariableForce::Scope do
         END
       end
 
-      let(:scope_node_type) { :top_level }
+      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,9 +1,10 @@
 # encoding: utf-8
 
 require 'spec_helper'
+require 'astrolabe/sexp'
 
 describe RuboCop::Cop::VariableForce::Variable do
-  include AST::Sexp
+  include Astrolabe::Sexp
 
   describe '.new' do
     context 'when non variable declaration node is passed' do

data/spec/rubocop/cop/variable_force_spec.rb

@@ -1,9 +1,10 @@
 # encoding: utf-8
 
 require 'spec_helper'
+require 'astrolabe/sexp'
 
 describe RuboCop::Cop::VariableForce do
-  include AST::Sexp
+  include Astrolabe::Sexp
 
   subject(:force) { described_class.new([]) }
 

data/spec/rubocop/formatter/emacs_style_formatter_spec.rb

@@ -24,7 +24,8 @@ module RuboCop
 
           formatter.file_finished('test', cop.offenses)
           expect(output.string).to eq ['test:1:1: C: message 1',
-                                       "test:3:6: C: message 2\n"].join("\n")
+                                       'test:3:6: C: message 2',
+                                       ''].join("\n")
         end
 
         context 'when the offense is automatically corrected' do

data/spec/rubocop/formatter/html_formatter_spec.rb

@@ -0,0 +1,145 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'stringio'
+
+module RuboCop
+  describe Formatter::HTMLFormatter do
+    subject(:formatter) { described_class.new(output) }
+    let(:output) { StringIO.new }
+    let(:files) { %w(/path/to/file1 /path/to/file2) }
+    let(:location) do
+      source_buffer = Parser::Source::Buffer.new('test', 1)
+      source_buffer.source = %w(a b cdefghi).join("\n")
+      Parser::Source::Range.new(source_buffer, 9, 10)
+    end
+    let(:offense) do
+      Cop::Offense.new(:convention, location,
+                       'This is message', 'CopName', true)
+    end
+
+    describe '#started' do
+      let(:summary) { formatter.output_hash[:summary] }
+
+      it 'sets target file count in summary' do
+        expect(summary[:target_file_count]).to be_nil
+        formatter.started(%w(/path/to/file1 /path/to/file2))
+        expect(summary[:target_file_count]).to eq(2)
+      end
+    end
+
+    describe '#file_finished' do
+      before do
+        count = 0
+        allow(formatter).to receive(:hash_for_file) do
+          count += 1
+        end
+      end
+
+      let(:summary) { formatter.output_hash[:summary] }
+
+      it 'adds detected offense count in summary' do
+        expect(summary[:offense_count]).to eq(0)
+
+        formatter.file_started(files[0], {})
+        expect(summary[:offense_count]).to eq(0)
+        formatter.file_finished(files[0], [
+          double('offense1'), double('offense2')
+        ])
+        expect(summary[:offense_count]).to eq(2)
+      end
+
+      it 'adds value of #hash_for_file to #output_hash[:files]' do
+        expect(formatter.output_hash[:files]).to be_empty
+
+        formatter.file_started(files[0], {})
+        expect(formatter.output_hash[:files]).to be_empty
+        formatter.file_finished(files[0], [])
+        expect(formatter.output_hash[:files]).to eq([1])
+
+        formatter.file_started(files[1], {})
+        expect(formatter.output_hash[:files]).to eq([1])
+        formatter.file_finished(files[1], [])
+        expect(formatter.output_hash[:files]).to eq([1, 2])
+      end
+    end
+
+    describe '#finished' do
+      let(:summary) { formatter.output_hash[:summary] }
+
+      it 'sets inspected file count in summary' do
+        expect(summary[:inspected_file_count]).to be_nil
+        formatter.finished(%w(/path/to/file1 /path/to/file2))
+        expect(summary[:inspected_file_count]).to eq(2)
+      end
+    end
+
+    describe '#hash_for_file' do
+      subject(:hash) { formatter.hash_for_file(file, offenses) }
+      let(:file) { File.expand_path('spec/spec_helper.rb') }
+      let(:offenses) { [double('offense1'), double('offense2')] }
+
+      it 'sets relative file path for :path key' do
+        expect(hash[:path]).to eq('spec/spec_helper.rb')
+      end
+
+      before do
+        count = 0
+        allow(formatter).to receive(:hash_for_offense) do
+          count += 1
+        end
+      end
+
+      it 'sets an array of #hash_for_offense values for :offenses key' do
+        expect(hash[:offenses]).to eq([1, 2])
+      end
+    end
+
+    describe '#hash_for_offense' do
+      subject(:hash) { formatter.hash_for_offense(offense) }
+
+      it 'sets Offense#severity value for :severity key' do
+        expect(hash[:severity]).to eq(:convention)
+      end
+
+      it 'sets Offense#message value for :message key' do
+        expect(hash[:message]).to eq('This is message')
+      end
+
+      it 'sets Offense#cop_name value for :cop_name key' do
+        expect(hash[:cop_name]).to eq('CopName')
+      end
+
+      it 'sets Offense#corrected? value for :corrected key' do
+        expect(hash[:corrected]).to be_truthy
+      end
+
+      before do
+        allow(formatter)
+          .to receive(:hash_for_location).and_return(location_hash)
+      end
+
+      let(:location_hash) { { line: 1, column: 2 } }
+
+      it 'sets value of #hash_for_location for :location key' do
+        expect(hash[:location]).to eq(location_hash)
+      end
+    end
+
+    describe '#hash_for_location' do
+      subject(:hash) { formatter.hash_for_location(offense) }
+
+      it 'sets line value for :line key' do
+        expect(hash[:line]).to eq(3)
+      end
+
+      it 'sets column value for :column key' do
+        expect(hash[:column]).to eq(6)
+      end
+
+      it 'sets length value for :length key' do
+        expect(hash[:length]).to eq(1)
+      end
+    end
+  end
+end