rubocop 0.12.0 → 0.13.0

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

@@ -5,11 +5,9 @@ require 'spec_helper'
 module Rubocop
   module Cop
     module Style
-      describe TrivialAccessors do
-        subject(:cop) { described_class.new }
-        before do
-          described_class.config = {}
-        end
+      describe TrivialAccessors, :config do
+        subject(:cop) { described_class.new(config) }
+        let(:cop_config) { {} }
 
         it 'finds trivial reader' do
           inspect_source(cop,
@@ -348,7 +346,7 @@ module Rubocop
         end
 
         context 'exact name match required' do
-          before { described_class.config['ExactNameMatch'] = true }
+          let(:cop_config) { { 'ExactNameMatch' => true } }
 
           it 'finds only 1 trivial reader' do
             inspect_source(cop,
@@ -380,9 +378,7 @@ module Rubocop
         end
 
         context 'with predicates allowed' do
-          before do
-            described_class.config['AllowPredicates'] = true
-          end
+          let(:cop_config) { { 'AllowPredicates' => true } }
 
           it 'ignores accessors ending with a question mark' do
             inspect_source(cop,
@@ -394,11 +390,7 @@ module Rubocop
         end
 
         context 'with whitelist defined' do
-          before do
-            described_class.config = {
-              'Whitelist' => ['to_foo', 'bar=']
-            }
-          end
+          let(:cop_config) { { 'Whitelist' => ['to_foo', 'bar='] } }
 
           it 'ignores accessors in the whitelist' do
             inspect_source(cop,

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

@@ -6,7 +6,7 @@ module Rubocop
   module Cop
     module Style
       describe UnlessElse do
-        let(:ue) { UnlessElse.new }
+        subject(:ue) { UnlessElse.new }
 
         it 'registers an offence for an unless with else' do
           inspect_source(ue, ['unless x',
@@ -14,7 +14,7 @@ module Rubocop
                               'else',
                               '  a = 0',
                               'end'])
-          expect(ue.offences.map(&:message)).to eq(
+          expect(ue.messages).to eq(
             ['Never use unless with else. Rewrite these with the ' +
              'positive case first.'])
         end
@@ -23,7 +23,7 @@ module Rubocop
           inspect_source(ue, ['unless x',
                               '  a = 1',
                               'end'])
-          expect(ue.offences.map(&:message)).to be_empty
+          expect(ue.messages).to be_empty
         end
       end
     end

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

@@ -6,13 +6,13 @@ module Rubocop
   module Cop
     module Style
       describe VariableInterpolation do
-        let(:vi) { VariableInterpolation.new }
+        subject(:vi) { VariableInterpolation.new }
 
         it 'registers an offence for interpolated global variables' do
           inspect_source(vi,
                          ['puts "this is a #$test"'])
           expect(vi.offences.size).to eq(1)
-          expect(vi.offences.map(&:message))
+          expect(vi.messages)
             .to eq(['Replace interpolated var $test' +
               ' with expression #{$test}.'])
         end
@@ -21,7 +21,7 @@ module Rubocop
           inspect_source(vi,
                          ['puts "this is a #$1"'])
           expect(vi.offences.size).to eq(1)
-          expect(vi.offences.map(&:message))
+          expect(vi.messages)
             .to eq(['Replace interpolated var $1 with expression #{$1}.'])
         end
 
@@ -29,7 +29,7 @@ module Rubocop
           inspect_source(vi,
                          ['puts "this is a #@test"'])
           expect(vi.offences.size).to eq(1)
-          expect(vi.offences.map(&:message))
+          expect(vi.messages)
             .to eq(['Replace interpolated var @test' +
               ' with expression #{@test}.'])
         end
@@ -38,7 +38,7 @@ module Rubocop
           inspect_source(vi,
                          ['puts "this is a #@@t"'])
           expect(vi.offences.size).to eq(1)
-          expect(vi.offences.map(&:message))
+          expect(vi.messages)
             .to eq(['Replace interpolated var @@t with expression #{@@t}.'])
         end
 

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

@@ -6,33 +6,33 @@ module Rubocop
   module Cop
     module Style
       describe WhenThen do
-        let(:cop) { WhenThen.new }
+        subject(:cop) { WhenThen.new }
 
         it 'registers an offence for when x;' do
           inspect_source(cop, ['case a',
-                              'when b; c',
-                              'end'])
-          expect(cop.offences.map(&:message)).to eq(
+                               'when b; c',
+                               'end'])
+          expect(cop.messages).to eq(
             ['Never use "when x;". Use "when x then" instead.'])
         end
 
         it 'accepts when x then' do
           inspect_source(cop, ['case a',
-                              'when b then c',
-                              'end'])
-          expect(cop.offences.map(&:message)).to be_empty
+                               'when b then c',
+                               'end'])
+          expect(cop.messages).to be_empty
         end
 
         it 'accepts ; separating statements in the body of when' do
           inspect_source(cop, ['case a',
-                              'when b then c; d',
-                              'end',
-                              '',
-                              'case e',
-                              'when f',
-                              '  g; h',
-                              'end'])
-          expect(cop.offences.map(&:message)).to be_empty
+                               'when b then c; d',
+                               'end',
+                               '',
+                               'case e',
+                               'when f',
+                               '  g; h',
+                               'end'])
+          expect(cop.messages).to be_empty
         end
 
         it 'auto-corrects "when x;" with "when x then"' do

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

@@ -6,7 +6,7 @@ module Rubocop
   module Cop
     module Style
       describe WhileUntilDo do
-        let(:cop) { WhileUntilDo.new }
+        subject(:cop) { WhileUntilDo.new }
 
         it 'registers an offence for do in multiline while' do
           inspect_source(cop, ['while cond do',
@@ -45,13 +45,13 @@ module Rubocop
         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\nend")
         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\nend")
         end
       end
     end

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

@@ -6,7 +6,7 @@ module Rubocop
   module Cop
     module Style
       describe WordArray do
-        let(:wa) { WordArray.new }
+        subject(:wa) { WordArray.new }
 
         it 'registers an offence for arrays of single quoted strings' do
           inspect_source(wa,

data/spec/rubocop/cop/team_spec.rb

@@ -0,0 +1,158 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe Team do
+      subject(:team) { Team.new(cop_classes, config, options) }
+      let(:cop_classes) { Cop.all }
+      let(:config) { Config.default_configuration }
+      let(:options) { nil }
+
+      describe '#autocorrect?' do
+        subject { team.autocorrect? }
+
+        context 'when the option argument of .new is omitted' do
+          subject { Team.new(cop_classes, config).autocorrect? }
+          it { should be_false }
+        end
+
+        context 'when { autocorrect: true } is passed to .new' do
+          let(:options) { { autocorrect: true } }
+          it { should be_true }
+        end
+      end
+
+      describe '#debug?' do
+        subject { team.debug? }
+
+        context 'when the option argument of .new is omitted' do
+          subject { Team.new(cop_classes, config).debug? }
+          it { should be_false }
+        end
+
+        context 'when { debug: true } is passed to .new' do
+          let(:options) { { debug: true } }
+          it { should be_true }
+        end
+      end
+
+      describe '#inspect_file', :isolated_environment do
+        include FileHelper
+
+        let(:file_path) { 'example.rb' }
+        let(:offences) { team.inspect_file(file_path) }
+
+        before do
+          create_file(file_path, [
+            '#' * 90,
+            'puts test;'
+          ])
+        end
+
+        it 'returns offences' do
+          expect(offences).not_to be_empty
+          expect(offences.all? { |o| o.is_a?(Offence) }).to be_true
+        end
+
+        context 'when Parser cannot parse the file' do
+          before do
+            create_file(file_path, [
+              '#' * 90,
+              'class Test'
+            ])
+          end
+
+          it 'returns only error offences' do
+            expect(offences.size).to eq(1)
+            offence = offences.first
+            expect(offence.cop_name).to eq('Syntax')
+            expect(offence.severity).to eq(:error)
+          end
+        end
+
+        context 'when Parser reports non-fatal warning for the file' do
+          before do
+            create_file(file_path, [
+              '# encoding: utf-8',
+              '#' * 90,
+              'puts *test'
+            ])
+          end
+
+          let(:cop_names) { offences.map(&:cop_name) }
+
+          it 'returns Parser warning offences' do
+            expect(cop_names).to include('Syntax')
+          end
+
+          it 'returns offences from cops' do
+            expect(cop_names).to include('LineLength')
+          end
+        end
+
+        context 'when autocorrection is enabled' do
+          let(:options) { { autocorrect: true } }
+
+          before do
+            create_file(file_path, [
+              '# encoding: utf-8',
+              'puts "string"'
+            ])
+          end
+
+          it 'does autocorrection' do
+            team.inspect_file(file_path)
+            corrected_source = File.read(file_path)
+            expect(corrected_source).to eq([
+              '# encoding: utf-8',
+              "puts 'string'",
+              ''
+            ].join("\n"))
+          end
+
+          it 'still returns offences' do
+            expect(offences.first.cop_name).to eq('StringLiterals')
+          end
+        end
+      end
+
+      describe '#cops' do
+        subject(:cops) { team.cops }
+
+        it 'returns cop instances' do
+          expect(cops).not_to be_empty
+          expect(cops.all? { |c| c.is_a?(Cop) }).to be_true
+        end
+
+        context 'when only some cop classes are passed to .new' do
+          let(:cop_classes) { [Lint::Void, Style::LineLength] }
+
+          it 'returns only intances of the classes' do
+            expect(cops.size).to eq(2)
+            cops.sort! { |a, b| a.name <=> b.name }
+            expect(cops[0].name).to eq('LineLength')
+            expect(cops[1].name).to eq('Void')
+          end
+        end
+
+        context 'when some classes are disabled with config' do
+          before do
+            %w(Void LineLength).each do |cop_name|
+              config.for_cop(cop_name)['Enabled'] = false
+            end
+          end
+
+          let(:cop_names) { cops.map(&:name) }
+
+          it 'does not return intances of the classes' do
+            expect(cops).not_to be_empty
+            expect(cop_names).not_to include('Void')
+            expect(cop_names).not_to include('LineLength')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,217 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module VariableInspector
+      describe Assignment do
+        include ASTHelper
+        include AST::Sexp
+
+        let(:ast) do
+          processed_source = Rubocop::SourceParser.parse(source)
+          processed_source.ast
+        end
+
+        let(:source) do
+          <<-END
+            class SomeClass
+              def some_method(flag)
+                puts 'Hello World!'
+
+                if flag > 0
+                  foo = 1
+                end
+              end
+            end
+          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(: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(:name) { lvasgn_node.children.first }
+        let(:scope) { Scope.new(def_node) }
+        let(:variable) { Variable.new(name, lvasgn_node, scope) }
+        let(:assignment) { Assignment.new(lvasgn_node, variable) }
+
+        describe '.new' do
+          let(:variable) { double('variable') }
+
+          context 'when an assignment node is passed' do
+            it 'does not raise error' do
+              node = s(:lvasgn, :foo)
+              expect { Assignment.new(node, variable) }.not_to raise_error
+            end
+          end
+
+          context 'when an argument declaration node is passed' do
+            it 'raises error' do
+              node = s(:arg, :foo)
+              expect { Assignment.new(node, variable) }
+                .to raise_error(ArgumentError)
+            end
+          end
+
+          context 'when any other type node is passed' do
+            it 'raises error' do
+              node = s(:def)
+              expect { Assignment.new(node, variable) }
+                .to raise_error(ArgumentError)
+            end
+          end
+        end
+
+        describe '#name' do
+          it 'returns the variable name' do
+            expect(assignment.name).to eq(:foo)
+          end
+        end
+
+        describe '#meta_assignment_node' do
+          context 'when it is += operator assignment' do
+            let(:source) do
+              <<-END
+                def some_method
+                  foo += 1
+                end
+              END
+            end
+
+            it 'returns op_asgn node' do
+              expect(assignment.meta_assignment_node.type).to eq(:op_asgn)
+            end
+          end
+
+          context 'when it is ||= operator assignment' do
+            let(:source) do
+              <<-END
+                def some_method
+                  foo ||= 1
+                end
+              END
+            end
+
+            it 'returns or_asgn node' do
+              expect(assignment.meta_assignment_node.type).to eq(:or_asgn)
+            end
+          end
+
+          context 'when it is &&= operator assignment' do
+            let(:source) do
+              <<-END
+                def some_method
+                  foo &&= 1
+                end
+              END
+            end
+
+            it 'returns and_asgn node' do
+              expect(assignment.meta_assignment_node.type).to eq(:and_asgn)
+            end
+          end
+
+          context 'when it is multiple assignment' do
+            let(:source) do
+              <<-END
+                def some_method
+                  foo, bar = [1, 2]
+                end
+              END
+            end
+
+            it 'returns masgn node' do
+              expect(assignment.meta_assignment_node.type).to eq(:masgn)
+            end
+          end
+        end
+
+        describe '#operator' do
+          context 'when it is normal assignment' do
+            let(:source) do
+              <<-END
+                def some_method
+                  foo = 1
+                end
+              END
+            end
+
+            it 'returns =' do
+              expect(assignment.operator).to eq('=')
+            end
+          end
+
+          context 'when it is += operator assignment' do
+            let(:source) do
+              <<-END
+                def some_method
+                  foo += 1
+                end
+              END
+            end
+
+            it 'returns +=' do
+              expect(assignment.operator).to eq('+=')
+            end
+          end
+
+          context 'when it is ||= operator assignment' do
+            let(:source) do
+              <<-END
+                def some_method
+                  foo ||= 1
+                end
+              END
+            end
+
+            it 'returns ||=' do
+              expect(assignment.operator).to eq('||=')
+            end
+          end
+
+          context 'when it is &&= operator assignment' do
+            let(:source) do
+              <<-END
+                def some_method
+                  foo &&= 1
+                end
+              END
+            end
+
+            it 'returns &&=' do
+              expect(assignment.operator).to eq('&&=')
+            end
+          end
+
+          context 'when it is multiple assignment' do
+            let(:source) do
+              <<-END
+                def some_method
+                  foo, bar = [1, 2]
+                end
+              END
+            end
+
+            it 'returns =' do
+              expect(assignment.operator).to eq('=')
+            end
+          end
+        end
+      end
+    end
+  end
+end