rubocop 0.4.0 → 0.8.0

data/spec/rubocop/cops/align_parameters_spec.rb

@@ -8,43 +8,45 @@ module Rubocop
       let(:align) { AlignParameters.new }
 
       it 'registers an offence for parameters with single indent' do
-        inspect_source(align, 'file.rb', ['function(a,',
-                                         '  if b then c else d end)'])
-        expect(align.offences.map(&:message)).to eq(
-          ['Align the parameters of a method call if they span more than ' +
-           'one line.'])
+        inspect_source(align, ['function(a,',
+                               '  if b then c else d end)'])
+        expect(align.offences.size).to eq(1)
       end
 
       it 'registers an offence for parameters with double indent' do
-        inspect_source(align, 'file.rb', ['function(a,',
-                                         '    if b then c else d end)'])
-        expect(align.offences.map(&:message)).to eq(
-          ['Align the parameters of a method call if they span more than ' +
-           'one line.'])
+        inspect_source(align, ['function(a,',
+                               '    if b then c else d end)'])
+        expect(align.offences.size).to eq(1)
+      end
+
+      it 'accepts multiline []= method call' do
+        inspect_source(align, ['Test.config["something"] =',
+                                          ' true'])
+        expect(align.offences).to be_empty
       end
 
       it 'accepts correctly aligned parameters' do
-        inspect_source(align, 'file.rb', ['function(a,',
-                                         '         0, 1,',
-                                         '         (x + y),',
-                                         '         if b then c else d end)'])
-        expect(align.offences.map(&:message)).to be_empty
+        inspect_source(align, ['function(a,',
+                               '         0, 1,',
+                               '         (x + y),',
+                               '         if b then c else d end)'])
+        expect(align.offences).to be_empty
       end
 
       it 'accepts calls that only span one line' do
-        inspect_source(align, 'file.rb', ['find(path, s, @special[sexp[0]])'])
-        expect(align.offences.map(&:message)).to be_empty
+        inspect_source(align, ['find(path, s, @special[sexp[0]])'])
+        expect(align.offences).to be_empty
       end
 
       it "doesn't get confused by a symbol argument" do
-        inspect_source(align, '',
+        inspect_source(align,
                        ['add_offence(:convention, index,',
-                        '            ERROR_MESSAGE % kind)'])
-        expect(align.offences.map(&:message)).to be_empty
+                        '            MSG % kind)'])
+        expect(align.offences).to be_empty
       end
 
       it "doesn't get confused by splat operator" do
-        inspect_source(align, '',
+        inspect_source(align,
                        ['func1(*a,',
                         '      *b,',
                         '      c)',
@@ -58,53 +60,62 @@ module Rubocop
            'more than one line.'])
       end
 
+      it "doesn't get confused by extra comma at the end" do
+        inspect_source(align,
+                       ['func1(a,',
+                        '     b,)'])
+        expect(align.offences.map(&:to_s)).to eq(
+          ['C:  2: Align the parameters of a method call if they span ' +
+           'more than one line.'])
+      end
+
       it 'can handle a correctly aligned string literal as first argument' do
-        inspect_source(align, '',
+        inspect_source(align,
                        ['add_offence(:convention, x,',
                         '            a)'])
-        expect(align.offences.map(&:message)).to be_empty
+        expect(align.offences).to be_empty
       end
 
       it 'can handle a string literal as other argument' do
-        inspect_source(align, '',
+        inspect_source(align,
                        ['add_offence(:convention,',
                         '            "", a)'])
-        expect(align.offences.map(&:message)).to be_empty
+        expect(align.offences).to be_empty
       end
 
       it "doesn't get confused by a line break inside a parameter" do
-        inspect_source(align, '',
+        inspect_source(align,
                        ['read(path, { headers:    true,',
                         '             converters: :numeric })'])
-        expect(align.offences.map(&:message)).to be_empty
+        expect(align.offences).to be_empty
       end
 
       it "doesn't get confused by symbols with embedded expressions" do
-        inspect_source(align, '',
+        inspect_source(align,
                        ['send(:"#{name}_comments_path")'])
-        expect(align.offences.map(&:message)).to be_empty
+        expect(align.offences).to be_empty
       end
 
       it "doesn't get confused by regexen with embedded expressions" do
-        inspect_source(align, '',
+        inspect_source(align,
                        ['a(/#{name}/)'])
-        expect(align.offences.map(&:message)).to be_empty
+        expect(align.offences).to be_empty
       end
 
       it 'accepts braceless hashes' do
-        inspect_source(align, '',
+        inspect_source(align,
                        ['run(collection, :entry_name => label,',
                         '                :paginator  => paginator)'])
-        expect(align.offences.map(&:message)).to be_empty
+        expect(align.offences).to be_empty
       end
 
       it 'accepts the first parameter being on a new row' do
-        inspect_source(align, '',
+        inspect_source(align,
                        ['  match(',
                         '    a,',
                         '    b',
                         '  )'])
-        expect(align.offences.map(&:message)).to be_empty
+        expect(align.offences).to be_empty
       end
 
       it 'can handle heredoc strings' do
@@ -114,31 +125,31 @@ module Rubocop
                '              return value',
                '            end',
                '            EOS']
-        inspect_source(align, '', src)
-        expect(align.offences.map(&:message)).to be_empty
+        inspect_source(align, src)
+        expect(align.offences).to be_empty
       end
 
       it 'can handle a method call within a method call' do
-        inspect_source(align, '',
+        inspect_source(align,
                        ['a(a1,',
                         '  b(b1,',
                         '    b2),',
                         '  a2)'])
-        expect(align.offences.map(&:message)).to be_empty
+        expect(align.offences).to be_empty
       end
 
       it 'can handle a call embedded in a string' do
-        inspect_source(align, '',
+        inspect_source(align,
                        ['model("#{index(name)}", child)'])
-        expect(align.offences.map(&:message)).to be_empty
+        expect(align.offences).to be_empty
       end
 
       it 'can handle do-end' do
-        inspect_source(align, '',
+        inspect_source(align,
                        ['      run(lambda do |e|',
                         "        w = e['warden']",
                         '      end)'])
-        expect(align.offences.map(&:message)).to be_empty
+        expect(align.offences).to be_empty
       end
 
       it 'can handle a call with a block inside another call' do
@@ -146,55 +157,40 @@ module Rubocop
                '    exec_query("info(\'#{row[\'name\']}\')").map { |col|',
                "      col['name']",
                '    })']
-        inspect_source(align, '', src)
-        expect(align.offences.map(&:message)).to be_empty
+        inspect_source(align, src)
+        expect(align.offences).to be_empty
       end
 
       it 'can handle a ternary condition with a block reference' do
         src = ['cond ? a : func(&b)']
-        inspect_source(align, '', src)
-        expect(align.offences.map(&:message)).to be_empty
+        inspect_source(align, src)
+        expect(align.offences).to be_empty
       end
 
       it 'can handle parentheses used with no parameters' do
         src = ['func()']
-        inspect_source(align, '', src)
-        expect(align.offences.map(&:message)).to be_empty
-      end
-
-      it 'can handle a multiline hash as first parameter' do
-        src = ['assert_equal({',
-               '  :space_before => "",',
-               '}, state)']
-        inspect_source(align, '', src)
-        expect(align.offences.map(&:message)).to be_empty
+        inspect_source(align, src)
+        expect(align.offences).to be_empty
       end
 
       it 'can handle a multiline hash as second parameter' do
         src = ['tag(:input, {',
                '  :value => value',
                '})']
-        inspect_source(align, '', src)
-        expect(align.offences.map(&:message)).to be_empty
+        inspect_source(align, src)
+        expect(align.offences).to be_empty
       end
 
       it 'can handle method calls without parentheses' do
         src = ['a(b c, d)']
-        inspect_source(align, '', src)
-        expect(align.offences.map(&:message)).to be_empty
+        inspect_source(align, src)
+        expect(align.offences).to be_empty
       end
 
       it 'can handle other method calls without parentheses' do
         src = ['chars(Unicode.apply_mapping @wrapped_string, :uppercase)']
-        inspect_source(align, '', src)
-        expect(align.offences.map(&:message)).to be_empty
-      end
-
-      it "doesn't check alignment if tabs are used to indent" do
-        src = ['a(b,',
-               "\tc)"]
-        inspect_source(align, '', src)
-        expect(align.offences.map(&:message)).to be_empty
+        inspect_source(align, src)
+        expect(align.offences).to be_empty
       end
     end
   end

data/spec/rubocop/cops/and_or_spec.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe AndOr do
+      let(:amp) { AndOr.new }
+
+      it 'registers an offence for OR' do
+        inspect_source(amp,
+                       ['test if a or b'])
+        expect(amp.offences.size).to eq(1)
+        expect(amp.messages).to eq(['Use || instead of or.'])
+      end
+
+      it 'registers an offence for AND' do
+        inspect_source(amp,
+                       ['test if a and b'])
+        expect(amp.offences.size).to eq(1)
+        expect(amp.messages).to eq(['Use && instead of and.'])
+      end
+
+      it 'accepts ||' do
+        inspect_source(amp,
+                       ['test if a || b'])
+        expect(amp.offences).to be_empty
+      end
+
+      it 'accepts &&' do
+        inspect_source(amp,
+                       ['test if a && b'])
+        expect(amp.offences).to be_empty
+      end
+    end
+  end
+end

data/spec/rubocop/cops/ascii_comments_spec.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe AsciiComments do
+      let(:ascii) { AsciiComments.new }
+
+      it 'registers an offence for a comment with non-ascii chars' do
+        inspect_source(ascii,
+                       ['# encoding: utf-8',
+                        '# 这是什么？'])
+        expect(ascii.offences.size).to eq(1)
+        expect(ascii.offences.map(&:message))
+          .to eq([AsciiComments::MSG])
+      end
+
+      it 'accepts comments with only ascii chars' do
+        inspect_source(ascii,
+                       ['# AZaz1@$%~,;*_`|'])
+        expect(ascii.offences).to be_empty
+      end
+    end
+  end
+end

data/spec/rubocop/cops/ascii_identifiers_spec.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe AsciiIdentifiers do
+      let(:ascii) { AsciiIdentifiers.new }
+
+      it 'registers an offence for a variable name with non-ascii chars' do
+        inspect_source(ascii,
+                       ['# encoding: utf-8',
+                        'älg = 1'])
+        expect(ascii.offences.size).to eq(1)
+        expect(ascii.offences.map(&:message))
+          .to eq([AsciiIdentifiers::MSG])
+      end
+
+      it 'accepts identifiers with only ascii chars' do
+        inspect_source(ascii,
+                       ['x.empty?'])
+        expect(ascii.offences).to be_empty
+      end
+    end
+  end
+end

data/spec/rubocop/cops/avoid_class_vars_spec.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe AvoidClassVars do
+      let(:acv) { AvoidClassVars.new }
+
+      it 'registers an offence for class variable declaration' do
+        inspect_source(acv,
+                       ['class TestClass; @@test = 10; end'])
+        expect(acv.offences.size).to eq(1)
+        expect(acv.offences.map(&:message))
+          .to eq(['Replace class var @@test with a class instance var.'])
+      end
+
+      it 'does not register an offence for class variable usage' do
+        inspect_source(acv,
+                       ['@@test.test(20)'])
+        expect(acv.offences).to be_empty
+      end
+    end
+  end
+end

data/spec/rubocop/cops/avoid_for_spec.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe AvoidFor do
+      let(:af) { AvoidFor.new }
+
+      it 'registers an offence for for' do
+        inspect_source(af,
+                       ['def func',
+                        '  for n in [1, 2, 3] do',
+                        '    puts n',
+                        '  end',
+                        'end'])
+        expect(af.offences.size).to eq(1)
+        expect(af.offences.map(&:message))
+          .to eq([AvoidFor::MSG])
+      end
+
+      it 'does not register an offence for :for' do
+        inspect_source(af,
+                       ['[:for, :ala, :bala]'])
+        expect(af.offences).to be_empty
+      end
+
+      it 'does not register an offence for def for' do
+        inspect_source(af,
+                       ['def for; end'])
+        expect(af.offences).to be_empty
+      end
+    end
+  end
+end

data/spec/rubocop/cops/avoid_global_vars_spec.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe AvoidGlobalVars do
+      let(:ap) { AvoidGlobalVars.new }
+
+      it 'registers an offence for $custom' do
+        inspect_source(ap, ['puts $custom'])
+        expect(ap.offences.size).to eq(1)
+      end
+
+      it 'does not register an offence for $"' do
+        inspect_source(ap, ['puts $"'])
+
+        expect(ap.offences).to be_empty
+      end
+
+      it 'does not register an offence for $ORS' do
+        inspect_source(ap, ['puts $0'])
+        expect(ap.offences).to be_empty
+      end
+
+      it 'does not register an offence for backrefs like $1' do
+        inspect_source(ap, ['puts $1'])
+        expect(ap.offences).to be_empty
+      end
+    end
+  end
+end

data/spec/rubocop/cops/avoid_perl_backrefs_spec.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe AvoidPerlBackrefs do
+      let(:ap) { AvoidPerlBackrefs.new }
+
+      it 'registers an offence for $1' do
+        inspect_source(ap, ['puts $1'])
+        expect(ap.offences.size).to eq(1)
+        expect(ap.offences.map(&:message))
+          .to eq(['Prefer the use of MatchData over $1.'])
+      end
+    end
+  end
+end

data/spec/rubocop/cops/avoid_perlisms_spec.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe AvoidPerlisms do
+      let(:ap) { AvoidPerlisms.new }
+
+      it 'registers an offence for $:' do
+        inspect_source(ap, ['puts $:'])
+        expect(ap.offences.size).to eq(1)
+        expect(ap.offences.map(&:message))
+          .to eq(['Prefer $LOAD_PATH over $:.'])
+      end
+
+      it 'registers an offence for $"' do
+        inspect_source(ap, ['puts $"'])
+        expect(ap.offences.size).to eq(1)
+        expect(ap.offences.map(&:message))
+          .to eq(['Prefer $LOADED_FEATURES over $".'])
+      end
+
+      it 'registers an offence for $0' do
+        inspect_source(ap, ['puts $0'])
+        expect(ap.offences.size).to eq(1)
+        expect(ap.offences.map(&:message))
+          .to eq(['Prefer $PROGRAM_NAME over $0.'])
+      end
+
+      it 'registers an offence for $$' do
+        inspect_source(ap, ['puts $$'])
+        expect(ap.offences.size).to eq(1)
+        expect(ap.offences.map(&:message))
+          .to eq(['Prefer $PID or $PROCESS_ID from English library over $$.'])
+      end
+
+      it 'does not register an offence for backrefs like $1' do
+        inspect_source(ap, ['puts $1'])
+        expect(ap.offences).to be_empty
+      end
+    end
+  end
+end

data/spec/rubocop/cops/block_comments_spec.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe BlockComments do
+      let(:block) { BlockComments.new }
+
+      it 'registers an offence for block comments' do
+        inspect_source(block,
+                       ['=begin',
+                        'comment',
+                        '=end'])
+        expect(block.offences.size).to eq(1)
+      end
+
+      it 'accepts regular comments' do
+        inspect_source(block,
+                       ['# comment'])
+        expect(block.offences).to be_empty
+      end
+    end
+  end
+end

data/spec/rubocop/cops/blocks_spec.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe Blocks do
+      let(:blocks) { Blocks.new }
+
+      it 'registers an offence for a multiline block with braces' do
+        inspect_source(blocks, ['each { |x|',
+                                '}'])
+        expect(blocks.messages).to eq([Blocks::MULTI_LINE_MSG])
+      end
+
+      it 'accepts a multiline block with do-end' do
+        inspect_source(blocks, ['each do |x|',
+                                'end'])
+        expect(blocks.offences.map(&:message)).to be_empty
+      end
+
+      it 'registers an offence for a single line block with do-end' do
+        inspect_source(blocks, ['each do |x| end'])
+        expect(blocks.messages).to eq([Blocks::SINGLE_LINE_MSG])
+      end
+
+      it 'accepts a single line block with braces' do
+        inspect_source(blocks, ['each { |x| }'])
+        expect(blocks.offences.map(&:message)).to be_empty
+      end
+    end
+  end
+end

data/spec/rubocop/cops/{indentation_spec.rb → case_indentation_spec.rb}

@@ -4,8 +4,8 @@ require 'spec_helper'
 
 module Rubocop
   module Cop
-    describe Indentation do
-      let(:ind) { Indentation.new }
+    describe CaseIndentation do
+      let(:ind) { CaseIndentation.new }
 
       it "registers an offence for a when clause that's deeper than case" do
         source = ['case a',
@@ -14,7 +14,7 @@ module Rubocop
                   '         when 1 then return',
                   '        end',
                   'end']
-        inspect_source(ind, 'file.rb', source)
+        inspect_source(ind, source)
         expect(ind.offences.map(&:message)).to eq(
           ['Indent when as deep as case.'] * 2)
       end
@@ -32,7 +32,7 @@ module Rubocop
                   'when 2 then encoding',
                   'end',
                   '']
-        inspect_source(ind, 'file.rb', source)
+        inspect_source(ind, source)
         expect(ind.offences).to be_empty
       end
 
@@ -42,7 +42,7 @@ module Rubocop
                   'when 0',
                   'end',
                   '']
-        inspect_source(ind, 'file.rb', source)
+        inspect_source(ind, source)
         expect(ind.offences.map(&:message)).to be_empty
       end
 
@@ -55,7 +55,7 @@ module Rubocop
                   '  MethodCallNode',
                   'end',
                   '']
-        inspect_source(ind, 'file.rb', source)
+        inspect_source(ind, source)
         expect(ind.offences.map(&:message)).to be_empty
       end
 
@@ -78,7 +78,7 @@ module Rubocop
                   'when Array',
                   'end',
                   '']
-        inspect_source(ind, 'file.rb', source)
+        inspect_source(ind, source)
         expect(ind.offences.map(&:message)).to be_empty
       end
     end

data/spec/rubocop/cops/class_and_module_camel_case_spec.rb

@@ -8,26 +8,36 @@ module Rubocop
       let(:camel_case) { ClassAndModuleCamelCase.new }
 
       it 'registers an offence for underscore in class and module name' do
-        inspect_source(camel_case, 'file.rb',
+        inspect_source(camel_case,
                        ['class My_Class',
                         'end',
                         '',
                         'module My_Module',
                         'end',
                        ])
-        expect(camel_case.offences.map(&:message)).to eq(
-          ['Use CamelCase for classes and modules.'] * 2)
+        expect(camel_case.offences.size).to eq(2)
+      end
+
+      it 'is not fooled by qualified names' do
+        inspect_source(camel_case,
+                       ['class Top::My_Class',
+                        'end',
+                        '',
+                        'module My_Module::Ala',
+                        'end',
+                       ])
+        expect(camel_case.offences.size).to eq(2)
       end
 
       it 'accepts CamelCase names' do
-        inspect_source(camel_case, 'file.rb',
+        inspect_source(camel_case,
                        ['class MyClass',
                         'end',
                         '',
                         'module Mine',
                         'end',
                        ])
-        expect(camel_case.offences.map(&:message)).to be_empty
+        expect(camel_case.offences).to be_empty
       end
     end
   end