rubocop 0.16.0 → 0.17.0

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

@@ -0,0 +1,200 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::TrailingComma, :config do
+  subject(:cop) { described_class.new(config) }
+  let(:cop_config) { { 'EnforcedStyleForMultiline' => 'no_comma' } }
+
+  context 'with single line list of values' do
+    it 'registers an offence for trailing comma in an Array literal' do
+      inspect_source(cop, 'VALUES = [1001, 2020, 3333, ]')
+      expect(cop.messages)
+        .to eq(['Avoid comma after the last item of an array.'])
+      expect(cop.highlights).to eq([','])
+    end
+
+    it 'registers an offence for trailing comma in a Hash literal' do
+      inspect_source(cop, 'MAP = { a: 1001, b: 2020, c: 3333, }')
+      expect(cop.messages)
+        .to eq(['Avoid comma after the last item of a hash.'])
+      expect(cop.highlights).to eq([','])
+    end
+
+    it 'registers an offence for trailing comma in a method call' do
+      inspect_source(cop, 'some_method(a, b, c, )')
+      expect(cop.messages)
+        .to eq(['Avoid comma after the last parameter of a method call.'])
+      expect(cop.highlights).to eq([','])
+    end
+
+    it 'registers an offence for trailing comma in a method call with hash' +
+      ' parameters at the end' do
+      inspect_source(cop, 'some_method(a, b, c: 0, d: 1, )')
+      expect(cop.messages)
+        .to eq(['Avoid comma after the last parameter of a method call.'])
+      expect(cop.highlights).to eq([','])
+    end
+
+    it 'accepts Array literal without trailing comma' do
+      inspect_source(cop, 'VALUES = [1001, 2020, 3333]')
+      expect(cop.offences).to be_empty
+    end
+
+    it 'accepts empty Array literal' do
+      inspect_source(cop, 'VALUES = []')
+      expect(cop.offences).to be_empty
+    end
+
+    it 'accepts rescue clause' do
+      # The list of rescued classes is an array.
+      inspect_source(cop, ['begin',
+                           '  do_something',
+                           'rescue RuntimeError',
+                           'end'])
+      expect(cop.offences).to be_empty
+    end
+
+    it 'accepts Hash literal without trailing comma' do
+      inspect_source(cop, 'MAP = { a: 1001, b: 2020, c: 3333 }')
+      expect(cop.offences).to be_empty
+    end
+
+    it 'accepts empty Hash literal' do
+      inspect_source(cop, 'MAP = {}')
+      expect(cop.offences).to be_empty
+    end
+
+    it 'accepts method call without trailing comma' do
+      inspect_source(cop, 'some_method(a, b, c)')
+      expect(cop.offences).to be_empty
+    end
+
+    it 'accepts method call without parameters' do
+      inspect_source(cop, 'some_method')
+      expect(cop.offences).to be_empty
+    end
+  end
+
+  context 'with multi-line list of values' do
+    context 'when EnforcedStyleForMultiline is no_comma' do
+      it 'registers an offence for trailing comma in an Array literal' do
+        inspect_source(cop, ['VALUES = [',
+                             '           1001,',
+                             '           2020,',
+                             '           3333,',
+                             '         ]'])
+        expect(cop.highlights).to eq([','])
+      end
+
+      it 'registers an offence for trailing comma in a Hash literal' do
+        inspect_source(cop, ['MAP = { a: 1001,',
+                             '        b: 2020,',
+                             '        c: 3333,',
+                             '      }'])
+        expect(cop.highlights).to eq([','])
+      end
+
+      it 'registers an offence for trailing comma in a method call with ' +
+        'hash parameters at the end' do
+        inspect_source(cop, ['some_method(',
+                             '              a,',
+                             '              b,',
+                             '              c: 0,',
+                             '              d: 1,)'])
+        expect(cop.highlights).to eq([','])
+      end
+
+      it 'accepts an Array literal with no trailing comma' do
+        inspect_source(cop, ['VALUES = [ 1001,',
+                             '           2020,',
+                             '           3333 ]'])
+        expect(cop.offences).to be_empty
+      end
+
+      it 'accepts a Hash literal with no trailing comma' do
+        inspect_source(cop, ['MAP = {',
+                             '        a: 1001,',
+                             '        b: 2020,',
+                             '        c: 3333',
+                             '      }'])
+        expect(cop.offences).to be_empty
+      end
+
+      it 'accepts a method call with ' +
+        'hash parameters at the end and no trailing comma' do
+        inspect_source(cop, ['some_method(a,',
+                             '            b,',
+                             '            c: 0,',
+                             '            d: 1',
+                             '           )'])
+        expect(cop.offences).to be_empty
+      end
+    end
+
+    context 'when EnforcedStyleForMultiline is comma' do
+      let(:cop_config) { { 'EnforcedStyleForMultiline' => 'comma' } }
+
+      it 'registers an offence for no trailing comma in an Array literal' do
+        inspect_source(cop, ['VALUES = [',
+                             '           1001,',
+                             '           2020,',
+                             '           3333]'])
+        expect(cop.messages)
+          .to eq(['Put a comma after the last item of a multiline array.'])
+        expect(cop.highlights).to eq(['3333'])
+      end
+
+      it 'registers an offence for no trailing comma in a Hash literal' do
+        inspect_source(cop, ['MAP = { a: 1001,',
+                             '        b: 2020,',
+                             '        c: 3333 }'])
+        expect(cop.messages)
+          .to eq(['Put a comma after the last item of a multiline hash.'])
+        expect(cop.highlights).to eq(['c: 3333'])
+      end
+
+      it 'registers an offence for no trailing comma in a method call with' +
+        ' hash parameters at the end' do
+        inspect_source(cop, ['some_method(',
+                             '              a,',
+                             '              b,',
+                             '              c: 0,',
+                             '              d: 1',
+                             '           )'])
+        expect(cop.messages)
+          .to eq(['Put a comma after the last parameter of a multiline ' +
+                  'method call.'])
+        expect(cop.highlights).to eq(['d: 1'])
+      end
+
+      it 'accepts trailing comma in an Array literal' do
+        inspect_source(cop, ['VALUES = [1001,',
+                             '          2020,',
+                             '          3333,',
+                             '         ]'])
+        expect(cop.offences).to be_empty
+      end
+
+      it 'accepts trailing comma in a Hash literal' do
+        inspect_source(cop, ['MAP = {',
+                             '        a: 1001,',
+                             '        b: 2020,',
+                             '        c: 3333,',
+                             '      }'])
+        expect(cop.offences).to be_empty
+      end
+
+      it 'accepts trailing comma in a method call with hash' +
+        ' parameters at the end' do
+        inspect_source(cop, ['some_method(',
+                             '              a,',
+                             '              b,',
+                             '              c: 0,',
+                             '              d: 1,',
+                             '           )'])
+        expect(cop.offences).to be_empty
+      end
+    end
+  end
+end

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

@@ -32,19 +32,28 @@ describe Rubocop::Cop::Style::VariableName, :config do
 
     it 'registers an offence for camel case in local variable name' do
       inspect_source(cop, 'myLocal = 1')
-      expect(cop.offences).to have(1).item
+      expect(cop.offences.size).to eq(1)
       expect(cop.highlights).to eq(['myLocal'])
+      expect(cop.config_to_allow_offences).to eq('EnforcedStyle' =>
+                                                 'camelCase')
+    end
+
+    it 'registers an offence for correct + opposite' do
+      inspect_source(cop, ['my_local = 1',
+                           'myLocal = 1'])
+      expect(cop.highlights).to eq(['myLocal'])
+      expect(cop.config_to_allow_offences).to eq('Enabled' => false)
     end
 
     it 'registers an offence for camel case in instance variable name' do
       inspect_source(cop, '@myAttribute = 3')
-      expect(cop.offences).to have(1).item
+      expect(cop.offences.size).to eq(1)
       expect(cop.highlights).to eq(['@myAttribute'])
     end
 
     it 'registers an offence for camel case in setter name' do
       inspect_source(cop, 'self.mySetter = 2')
-      expect(cop.offences).to have(1).item
+      expect(cop.offences.size).to eq(1)
       expect(cop.highlights).to eq(['mySetter'])
     end
 
@@ -54,6 +63,21 @@ describe Rubocop::Cop::Style::VariableName, :config do
   context 'when configured for camelCase' do
     let(:cop_config) { { 'EnforcedStyle' => 'camelCase' } }
 
+    it 'registers an offence for snake case in local variable name' do
+      inspect_source(cop, 'my_local = 1')
+      expect(cop.offences.size).to eq(1)
+      expect(cop.highlights).to eq(['my_local'])
+      expect(cop.config_to_allow_offences).to eq('EnforcedStyle' =>
+                                                 'snake_case')
+    end
+
+    it 'registers an offence for opposite + correct' do
+      inspect_source(cop, ['my_local = 1',
+                           'myLocal = 1'])
+      expect(cop.highlights).to eq(['my_local'])
+      expect(cop.config_to_allow_offences).to eq('Enabled' => false)
+    end
+
     it 'accepts camel case in local variable name' do
       inspect_source(cop, 'myLocal = 1')
       expect(cop.offences).to be_empty

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

@@ -0,0 +1,75 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::WhileUntilModifier do
+  include StatementModifierHelper
+
+  subject(:cop) { described_class.new(config) }
+  let(:config) do
+    hash = { 'LineLength' => { 'Max' => 79 } }
+    Rubocop::Config.new(hash)
+  end
+
+  it "accepts multiline unless that doesn't fit on one line" do
+    check_too_long(cop, 'unless')
+  end
+
+  it 'accepts multiline unless whose body is more than one line' do
+    check_short_multiline(cop, 'unless')
+  end
+
+  it 'registers an offence for multiline while that fits on one line' do
+    check_really_short(cop, 'while')
+  end
+
+  it "accepts multiline while that doesn't fit on one line" do
+    check_too_long(cop, 'while')
+  end
+
+  it 'accepts multiline while whose body is more than one line' do
+    check_short_multiline(cop, 'while')
+  end
+
+  it 'accepts oneline while when condition has local variable assignment' do
+    inspect_source(cop, ['lines = %w{first second third}',
+                         'while (line = lines.shift)',
+                         '  puts line',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'registers an offence for oneline while when assignment is in body' do
+    inspect_source(cop, ['while true',
+                         '  x = 0',
+                         'end'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'registers an offence for multiline until that fits on one line' do
+    check_really_short(cop, 'until')
+  end
+
+  it "accepts multiline until that doesn't fit on one line" do
+    check_too_long(cop, 'until')
+  end
+
+  it 'accepts multiline until whose body is more than one line' do
+    check_short_multiline(cop, 'until')
+  end
+
+  it 'accepts an empty condition' do
+    check_empty(cop, 'while')
+    check_empty(cop, 'until')
+  end
+
+  it 'accepts modifier while' do
+    inspect_source(cop, ['ala while bala'])
+    expect(cop.offences).to be_empty
+  end
+
+  it 'accepts modifier until' do
+    inspect_source(cop, ['ala until bala'])
+    expect(cop.offences).to be_empty
+  end
+end

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

@@ -10,6 +10,7 @@ describe Rubocop::Cop::Style::WordArray, :config do
     inspect_source(cop,
                    ["['one', 'two', 'three']"])
     expect(cop.offences.size).to eq(1)
+    expect(cop.config_to_allow_offences).to eq('MinSize' => 3)
   end
 
   it 'registers an offence for arrays of double quoted strings' do

data/spec/rubocop/cop/team_spec.rb

@@ -82,7 +82,7 @@ describe Rubocop::Cop::Team do
       let(:cop_names) { offences.map(&:cop_name) }
 
       it 'returns Parser warning offences' do
-        expect(cop_names).to include('Syntax')
+        expect(cop_names).to include('AmbiguousOperator')
       end
 
       it 'returns offences from cops' do

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

@@ -23,8 +23,8 @@ describe Rubocop::Cop::VariableInspector::Scope do
   end
 
   let(:ast) do
-    processed_source = Rubocop::SourceParser.parse(source)
-    processed_source.ast
+    ast = Rubocop::SourceParser.parse(source).ast
+    Rubocop::Cop::VariableInspector.wrap_with_top_level_node(ast)
   end
 
   let(:scope_node_type) { :def }
@@ -172,12 +172,11 @@ describe Rubocop::Cop::VariableInspector::Scope do
     context 'when the scope is top level' do
       let(:source) do
         <<-END
-          foo = 1
           this_is_target
         END
       end
 
-      let(:scope_node_type) { :begin }
+      let(:scope_node_type) { :top_level }
 
       include_examples 'returns the body node'
     end

data/spec/rubocop/file_inspector_spec.rb

@@ -16,7 +16,7 @@ describe Rubocop::FileInspector do
     $stdout = StringIO.new
     $stderr = StringIO.new
 
-    inspector.stub(:inspect_file) do
+    allow(inspector).to receive(:inspect_file) do
       inspector.errors = errors
       offences
     end

data/spec/rubocop/formatter/base_formatter_spec.rb

@@ -30,7 +30,7 @@ module Rubocop
             '# encoding: utf-8'
           ])
 
-          SimpleTextFormatter.stub(:new).and_return(formatter)
+          allow(SimpleTextFormatter).to receive(:new).and_return(formatter)
           $stdout = StringIO.new
         end
 
@@ -76,7 +76,7 @@ module Rubocop
               'no_offence.rb'
             ].map { |path| File.expand_path(path) }.sort
 
-            formatter.should_receive(method_name) do |all_files|
+            expect(formatter).to receive(method_name) do |all_files|
               expect(all_files.sort).to eq(expected_paths)
             end
 
@@ -85,7 +85,7 @@ module Rubocop
 
           describe 'the passed files paths' do
             it 'is frozen' do
-              formatter.should_receive(method_name) do |all_files|
+              expect(formatter).to receive(method_name) do |all_files|
                 all_files.each do |path|
                   expect(path).to be_frozen
                 end
@@ -115,11 +115,11 @@ module Rubocop
                 end
               end
 
-              cli.stub(:wants_to_quit?) do
+              allow(cli).to receive(:wants_to_quit?) do
                 formatter.processed_file_count == 2
               end
 
-              formatter.should_receive(:finished) do |processed_files|
+              expect(formatter).to receive(:finished) do |processed_files|
                 expect(processed_files.size).to eq(2)
               end
 
@@ -130,13 +130,13 @@ module Rubocop
 
         shared_examples 'receives a file path' do |method_name|
           it 'receives a file path' do
-            formatter.should_receive(method_name)
+            expect(formatter).to receive(method_name)
               .with(File.expand_path('1_offence.rb'), anything)
 
-            formatter.should_receive(method_name)
+            expect(formatter).to receive(method_name)
               .with(File.expand_path('4_offences.rb'), anything)
 
-            formatter.should_receive(method_name)
+            expect(formatter).to receive(method_name)
               .with(File.expand_path('no_offence.rb'), anything)
 
             run
@@ -144,7 +144,8 @@ module Rubocop
 
           describe 'the passed path' do
             it 'is frozen' do
-              formatter.should_receive(method_name).exactly(3).times do |path|
+              expect(formatter)
+                .to receive(method_name).exactly(3).times do |path|
                 expect(path).to be_frozen
               end
               run
@@ -156,7 +157,7 @@ module Rubocop
           include_examples 'receives a file path', :file_started
 
           it 'receives file specific information hash' do
-            formatter.should_receive(:file_started)
+            expect(formatter).to receive(:file_started)
               .with(anything, an_instance_of(Hash)).exactly(3).times
             run
           end
@@ -166,7 +167,7 @@ module Rubocop
           include_examples 'receives a file path', :file_finished
 
           it 'receives an array of detected offences for the file' do
-            formatter.should_receive(:file_finished)
+            expect(formatter).to receive(:file_finished)
             .exactly(3).times do |file, offences|
               case File.basename(file)
               when '1_offence.rb'