rubocop 0.4.0 → 0.8.0

data/spec/rubocop/cops/class_methods_spec.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe ClassMethods do
+      let(:cm) { ClassMethods.new }
+
+      it 'registers an offence for methods using a class name' do
+        inspect_source(cm,
+                       ['class Test',
+                        '  def Test.some_method',
+                        '    do_something',
+                        '  end',
+                        'end'])
+        expect(cm.offences.size).to eq(1)
+      end
+
+      it 'registers an offence for methods using a module name' do
+        inspect_source(cm,
+                       ['module Test',
+                        '  def Test.some_method',
+                        '    do_something',
+                        '  end',
+                        'end'])
+        expect(cm.offences.size).to eq(1)
+      end
+
+      it 'does not register an offence for methods using self' do
+        inspect_source(cm,
+                       ['module Test',
+                        '  def self.some_method',
+                        '    do_something',
+                        '  end',
+                        'end'])
+        expect(cm.offences).to be_empty
+      end
+
+      it 'does not register an offence outside class/module bodies' do
+        inspect_source(cm,
+                       ['def self.some_method',
+                        '  do_something',
+                        'end'])
+        expect(cm.offences).to be_empty
+      end
+    end
+  end
+end

data/spec/rubocop/cops/collection_methods_spec.rb

@@ -8,32 +8,37 @@ module Rubocop
       let(:cm) { CollectionMethods.new }
 
       it 'registers an offence for collect' do
-        inspect_source(cm, 'file.rb', ['[1, 2, 3].collect { |e| e + 1 }'])
+        inspect_source(cm, ['[1, 2, 3].collect { |e| e + 1 }'])
         expect(cm.offences.size).to eq(1)
         expect(cm.offences.map(&:message))
           .to eq(['Prefer map over collect.'])
       end
 
       it 'registers an offence for inject' do
-        inspect_source(cm, 'file.rb', ['[1, 2, 3].inject { |e| e + 1 }'])
+        inspect_source(cm, ['[1, 2, 3].inject { |e| e + 1 }'])
         expect(cm.offences.size).to eq(1)
         expect(cm.offences.map(&:message))
           .to eq(['Prefer reduce over inject.'])
       end
 
       it 'registers an offence for detect' do
-        inspect_source(cm, 'file.rb', ['[1, 2, 3].detect { |e| e + 1 }'])
+        inspect_source(cm, ['[1, 2, 3].detect { |e| e + 1 }'])
         expect(cm.offences.size).to eq(1)
         expect(cm.offences.map(&:message))
           .to eq(['Prefer find over detect.'])
       end
 
       it 'registers an offence for find_all' do
-        inspect_source(cm, 'file.rb', ['[1, 2, 3].find_all { |e| e + 1 }'])
+        inspect_source(cm, ['[1, 2, 3].find_all { |e| e + 1 }'])
         expect(cm.offences.size).to eq(1)
         expect(cm.offences.map(&:message))
           .to eq(['Prefer select over find_all.'])
       end
+
+      it 'ignores find_all without an explicit receiver' do
+        inspect_source(cm, ['find_all { |e| e + 1 }'])
+        expect(cm.offences).to be_empty
+      end
     end
   end
 end

data/spec/rubocop/cops/colon_method_call_spec.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe ColonMethodCall do
+      let(:smc) { ColonMethodCall.new }
+
+      it 'registers an offence for instance method call' do
+        inspect_source(smc,
+                       ['test::method_name'])
+        expect(smc.offences.size).to eq(1)
+      end
+
+      it 'registers an offence for instance method call with arg' do
+        inspect_source(smc,
+                       ['test::method_name(arg)'])
+        expect(smc.offences.size).to eq(1)
+      end
+
+      it 'registers an offence for class method call' do
+        inspect_source(smc,
+                       ['Class::method_name'])
+        expect(smc.offences.size).to eq(1)
+      end
+
+      it 'registers an offence for class method call with arg' do
+        inspect_source(smc,
+                       ['Class::method_name(arg, arg2)'])
+        expect(smc.offences.size).to eq(1)
+      end
+
+      it 'does not register an offence for constant access' do
+        inspect_source(smc,
+                       ['Tip::Top::SOME_CONST'])
+        expect(smc.offences).to be_empty
+      end
+
+      it 'does not register an offence for nested class' do
+        inspect_source(smc,
+                       ['Tip::Top.some_method'])
+        expect(smc.offences).to be_empty
+      end
+
+      it 'does not register an offence for op methods' do
+        inspect_source(smc,
+                       ['Tip::Top.some_method[3]'])
+        expect(smc.offences).to be_empty
+      end
+    end
+  end
+end

data/spec/rubocop/cops/constant_name_spec.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe ConstantName do
+      let(:const) { ConstantName.new }
+
+      it 'registers an offence for camel case in const name' do
+        inspect_source(const,
+                       ['TopCase = 5'])
+        expect(const.offences.size).to eq(1)
+      end
+
+      it 'registers an offence for snake case in const name' do
+        inspect_source(const,
+                       ['TOP_test = 5'])
+        expect(const.offences.size).to eq(1)
+      end
+
+      it 'allows screaming snake case in const name' do
+        inspect_source(const,
+                       ['TOP_TEST = 5'])
+        expect(const.offences).to be_empty
+      end
+
+      it 'does not check names if rhs is a method call' do
+        inspect_source(const,
+                       ['AnythingGoes = test'])
+        expect(const.offences).to be_empty
+      end
+
+      it 'checks qualified const names' do
+        inspect_source(const,
+                       ['::AnythingGoes = 30',
+                        'a::Bar_foo = 10'])
+        expect(const.offences.size).to eq(2)
+      end
+    end
+  end
+end

data/spec/rubocop/cops/def_with_parentheses_spec.rb

@@ -10,23 +10,28 @@ module Rubocop
       it 'reports an offence for def with empty parens' do
         src = ['def func()',
                'end']
-        inspect_source(def_par, '', src)
-        expect(def_par.offences.map(&:message)).to eq(
-          ["Omit the parentheses in defs when the method doesn't accept any " +
-           'arguments.'])
+        inspect_source(def_par, src)
+        expect(def_par.offences.size).to eq(1)
+      end
+
+      it 'reports an offence for class def with empty parens' do
+        src = ['def Test.func()',
+               'end']
+        inspect_source(def_par, src)
+        expect(def_par.offences.size).to eq(1)
       end
 
       it 'accepts def with arg and parens' do
         src = ['def func(a)',
                'end']
-        inspect_source(def_par, '', src)
-        expect(def_par.offences.map(&:message)).to be_empty
+        inspect_source(def_par, src)
+        expect(def_par.offences).to be_empty
       end
 
       it 'accepts empty parentheses in one liners' do
         src = ["def to_s() join '/' end"]
-        inspect_source(def_par, '', src)
-        expect(def_par.offences.map(&:message)).to be_empty
+        inspect_source(def_par, src)
+        expect(def_par.offences).to be_empty
       end
     end
   end

data/spec/rubocop/cops/def_without_parentheses_spec.rb

@@ -10,16 +10,22 @@ module Rubocop
       it 'reports an offence for def with parameters but no parens' do
         src = ['def func a, b',
                'end']
-        inspect_source(def_par, '', src)
-        expect(def_par.offences.map(&:message)).to eq(
-          ['Use def with parentheses when there are arguments.'])
+        inspect_source(def_par, src)
+        expect(def_par.offences.size).to eq(1)
+      end
+
+      it 'reports an offence for class def with parameters but no parens' do
+        src = ['def Test.func a, b',
+               'end']
+        inspect_source(def_par, src)
+        expect(def_par.offences.size).to eq(1)
       end
 
       it 'accepts def with no args and no parens' do
         src = ['def func',
                'end']
-        inspect_source(def_par, '', src)
-        expect(def_par.offences.map(&:message)).to be_empty
+        inspect_source(def_par, src)
+        expect(def_par.offences).to be_empty
       end
     end
   end

data/spec/rubocop/cops/empty_line_between_defs_spec.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe EmptyLineBetweenDefs do
+      let(:empty_lines) { EmptyLineBetweenDefs.new }
+
+      it 'finds offences in inner classes' do
+        inspect_source(empty_lines, ['class K',
+                                     '  def m',
+                                     '  end',
+                                     '  class J',
+                                     '    def n',
+                                     '    end',
+                                     '    def o',
+                                     '    end',
+                                     '  end',
+                                     '  # checks something',
+                                     '  def p',
+                                     '  end',
+                                     'end'])
+        expect(empty_lines.offences.size).to eq(1)
+        expect(empty_lines.offences.map(&:line_number).sort).to eq([7])
+      end
+
+      # Only one def, so rule about empty line *between* defs does not
+      # apply.
+      it 'accepts a def that follows a line with code' do
+        inspect_source(empty_lines, ['x = 0',
+                                     'def m',
+                                     'end'])
+        expect(empty_lines.offences).to be_empty
+      end
+
+      # Only one def, so rule about empty line *between* defs does not
+      # apply.
+      it 'accepts a def that follows code and a comment' do
+        inspect_source(empty_lines, ['  x = 0',
+                                     '  # 123',
+                                     '  def m',
+                                     '  end'])
+        expect(empty_lines.offences).to be_empty
+      end
+
+      it 'accepts the first def without leading empty line in a class' do
+        inspect_source(empty_lines, ['class K',
+                                     '  def m',
+                                     '  end',
+                                     'end'])
+        expect(empty_lines.offences).to be_empty
+      end
+
+      it 'accepts a def that follows an empty line and then a comment' do
+        inspect_source(empty_lines, ['class A',
+                                     '  # calculates value',
+                                     '  def m',
+                                     '  end',
+                                     '',
+                                     '  private',
+                                     '  # calculates size',
+                                     '  def n',
+                                     '  end',
+                                     'end',
+                                    ])
+        expect(empty_lines.offences).to be_empty
+      end
+
+      it 'accepts a def that is the first of a module' do
+        source = ['module Util',
+                  '  public',
+                  '  #',
+                  '  def html_escape(s)',
+                  '  end',
+                  'end',
+                 ]
+        inspect_source(empty_lines, source)
+        expect(empty_lines.offences.map(&:message)).to be_empty
+      end
+    end
+  end
+end

data/spec/rubocop/cops/empty_lines_spec.rb

@@ -7,76 +7,31 @@ module Rubocop
     describe EmptyLines do
       let(:empty_lines) { EmptyLines.new }
 
-      it 'finds offences in inner classes' do
-        inspect_source(empty_lines, '', ['class K',
-                                        '  def m',
-                                        '  end',
-                                        '  class J',
-                                        '    def n',
-                                        '    end',
-                                        '    def o',
-                                        '    end',
-                                        '  end',
-                                        '  # checks something',
-                                        '  def p',
-                                        '  end',
-                                        'end'])
+      it 'registers an offence for consecutive empty lines' do
+        inspect_source(empty_lines,
+                       ['test = 5', '', '', '', 'top'])
         expect(empty_lines.offences.size).to eq(2)
-        expect(empty_lines.offences.map(&:line_number).sort).to eq([7, 11])
       end
 
-      # Only one def, so rule about empty line *between* defs does not
-      # apply.
-      it 'accepts a def that follows a line with code' do
-        inspect_source(empty_lines, '', ['x = 0',
-                                        'def m',
-                                        'end'])
+      it 'works when there are no tokens' do
+        inspect_source(empty_lines,
+                       ['#comment'])
         expect(empty_lines.offences).to be_empty
       end
 
-      # Only one def, so rule about empty line *between* defs does not
-      # apply.
-      it 'accepts a def that follows code and a comment' do
-        inspect_source(empty_lines, '', ['  x = 0',
-                                        '  # 123',
-                                        '  def m',
-                                        '  end'])
+      it 'handles comments' do
+        inspect_source(empty_lines,
+                       ['test', '', '#comment', 'top'])
         expect(empty_lines.offences).to be_empty
       end
 
-      it 'accepts the first def without leading empty line in a class' do
-        inspect_source(empty_lines, '', ['class K',
-                                        '  def m',
-                                        '  end',
-                                        'end'])
-        expect(empty_lines.offences).to be_empty
-      end
+      it 'does not register an offence for empty lines in a string' do
+        inspect_source(empty_lines, ['result = "test
+
 
-      it 'accepts a def that follows an empty line and then a comment' do
-        inspect_source(empty_lines, '', ['class A',
-                                        '  # calculates value',
-                                        '  def m',
-                                        '  end',
-                                        '',
-                                        '  private',
-                                        '  # calculates size',
-                                        '  def n',
-                                        '  end',
-                                        'end',
-                                       ])
-        expect(empty_lines.offences).to be_empty
-      end
 
-      it 'accepts a def that is the first of a module' do
-        source = ['module Util',
-                  '  public',
-                  '  #',
-                  '  def html_escape(s)',
-                  '  end',
-                  'end',
-                 ]
-        inspect_source(empty_lines, '', source)
-        expect(empty_lines.offences.map(&:message)).to be_empty
+                                      string"'])
+        expect(empty_lines.offences).to be_empty
       end
     end
   end

data/spec/rubocop/cops/empty_literal_spec.rb

@@ -0,0 +1,90 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe EmptyLiteral do
+      let(:a) { EmptyLiteral.new }
+
+      describe 'Empty Array' do
+        it 'registers an offence for Array.new()' do
+          inspect_source(a,
+                         ['test = Array.new()'])
+          expect(a.offences.size).to eq(1)
+          expect(a.offences.map(&:message))
+            .to eq([EmptyLiteral::ARR_MSG])
+        end
+
+        it 'registers an offence for Array.new' do
+          inspect_source(a,
+                         ['test = Array.new'])
+          expect(a.offences.size).to eq(1)
+          expect(a.offences.map(&:message))
+            .to eq([EmptyLiteral::ARR_MSG])
+        end
+
+        it 'does not register an offence for Array.new(3)' do
+          inspect_source(a,
+                         ['test = Array.new(3)'])
+          expect(a.offences).to be_empty
+        end
+      end
+
+      describe 'Empty Hash' do
+        it 'registers an offence for Hash.new()' do
+          inspect_source(a,
+                         ['test = Hash.new()'])
+          expect(a.offences.size).to eq(1)
+          expect(a.offences.map(&:message))
+            .to eq([EmptyLiteral::HASH_MSG])
+        end
+
+        it 'registers an offence for Hash.new' do
+          inspect_source(a,
+                         ['test = Hash.new'])
+          expect(a.offences.size).to eq(1)
+          expect(a.offences.map(&:message))
+            .to eq([EmptyLiteral::HASH_MSG])
+        end
+
+        it 'does not register an offence for Hash.new(3)' do
+          inspect_source(a,
+                         ['test = Hash.new(3)'])
+          expect(a.offences).to be_empty
+        end
+
+        it 'does not register an offence for Hash.new { block }' do
+          inspect_source(a,
+                         ['test = Hash.new { block }'])
+          expect(a.offences).to be_empty
+        end
+      end
+
+      describe 'Empty String' do
+        it 'registers an offence for String.new()' do
+          inspect_source(a,
+                         ['test = String.new()'])
+          expect(a.offences.size).to eq(1)
+          expect(a.offences.map(&:message))
+            .to eq([EmptyLiteral::STR_MSG])
+        end
+
+        it 'registers an offence for String.new' do
+          inspect_source(a,
+                         ['test = String.new'])
+          expect(a.offences.size).to eq(1)
+          expect(a.offences.map(&:message))
+            .to eq([EmptyLiteral::STR_MSG])
+        end
+
+        it 'does not register an offence for String.new("top")' do
+          inspect_source(a,
+                         ['test = String.new("top")'])
+          expect(a.offences).to be_empty
+        end
+      end
+
+    end
+  end
+end

data/spec/rubocop/cops/encoding_spec.rb

@@ -8,37 +8,37 @@ module Rubocop
       let(:encoding) { Encoding.new }
 
       it 'registers an offence when no encoding present', ruby: 1.9 do
-        inspect_source(encoding, 'file.rb', ['def foo() end'])
+        inspect_source(encoding, ['def foo() end'])
 
         expect(encoding.offences.map(&:message)).to eq(
-          ['Missing encoding comment.'])
+          ['Missing utf-8 encoding comment.'])
       end
 
       it 'accepts encoding on first line', ruby: 1.9 do
-        inspect_source(encoding, 'file.rb', ['# encoding: utf-8',
-                                             'def foo() end'])
+        inspect_source(encoding, ['# encoding: utf-8',
+                                  'def foo() end'])
 
         expect(encoding.offences).to be_empty
       end
 
       it 'accepts encoding on second line when shebang present', ruby: 1.9 do
-        inspect_source(encoding, 'file.rb', ['#!/usr/bin/env ruby',
-                                             '# encoding: utf-8',
-                                             'def foo() end'])
+        inspect_source(encoding, ['#!/usr/bin/env ruby',
+                                  '# encoding: utf-8',
+                                  'def foo() end'])
 
         expect(encoding.offences.map(&:message)).to be_empty
       end
 
       it 'books an offence when encoding is in the wrong place', ruby: 1.9 do
-        inspect_source(encoding, 'file.rb', ['def foo() end',
-                                             '# encoding: utf-8'])
+        inspect_source(encoding, ['def foo() end',
+                                  '# encoding: utf-8'])
 
         expect(encoding.offences.map(&:message)).to eq(
-          ['Missing encoding comment.'])
+          ['Missing utf-8 encoding comment.'])
       end
 
       it 'does not register an offence on Ruby 2.0', ruby: 2.0 do
-        inspect_source(encoding, 'file.rb', ['def foo() end'])
+        inspect_source(encoding, ['def foo() end'])
 
         expect(encoding.offences).to be_empty
       end

data/spec/rubocop/cops/end_of_line_spec.rb

@@ -8,13 +8,13 @@ module Rubocop
       let(:eol) { EndOfLine.new }
 
       it 'registers an offence for CR+LF' do
-        inspect_source(eol, 'file.rb', ["x=0\r", ''])
+        inspect_source(eol, ["x=0\r", ''])
         expect(eol.offences.map(&:message)).to eq(
           ['Carriage return character detected.'])
       end
 
       it 'registers an offence for CR at end of file' do
-        inspect_source(eol, 'file.rb', ["x=0\r"])
+        inspect_source(eol, ["x=0\r"])
         expect(eol.offences.map(&:message)).to eq(
           ['Carriage return character detected.'])
       end

data/spec/rubocop/cops/ensure_return_spec.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe EnsureReturn do
+      let(:er) { EnsureReturn.new }
+
+      it 'registers an offence for return in ensure' do
+        inspect_source(er,
+                       ['begin',
+                        '  something',
+                        'ensure',
+                        '  file.close',
+                        '  return',
+                        'end'])
+        expect(er.offences.size).to eq(1)
+        expect(er.offences.map(&:message))
+          .to eq([EnsureReturn::MSG])
+      end
+
+      it 'does not register an offence for return outside ensure' do
+        inspect_source(er,
+                       ['begin',
+                        '  something',
+                        '  return',
+                        'ensure',
+                        '  file.close',
+                        'end'])
+        expect(er.offences).to be_empty
+      end
+    end
+  end
+end

data/spec/rubocop/cops/eval_spec.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe Eval do
+      let(:a) { Eval.new }
+
+      it 'registers an offence for eval as function' do
+        inspect_source(a,
+                       ['eval(something)'])
+        expect(a.offences.size).to eq(1)
+        expect(a.offences.map(&:message))
+          .to eq([Eval::MSG])
+      end
+
+      it 'registers an offence for eval as command' do
+        inspect_source(a,
+                       ['eval something'])
+        expect(a.offences.size).to eq(1)
+        expect(a.offences.map(&:message))
+          .to eq([Eval::MSG])
+      end
+
+      it 'does not register an offence for eval as variable' do
+        inspect_source(a,
+                       ['eval = something'])
+        expect(a.offences).to be_empty
+      end
+
+      it 'does not register an offence for eval as method' do
+        inspect_source(a,
+                       ['something.eval'])
+        expect(a.offences).to be_empty
+      end
+    end
+  end
+end