rubocop 0.7.2 → 0.8.0

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

@@ -8,62 +8,62 @@ module Rubocop
       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(2)
-        expect(empty_lines.offences.map(&:line_number).sort).to eq([7, 11])
+        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'])
+        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'])
+        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'])
+        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',
-                                       ])
+        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
 
@@ -75,7 +75,7 @@ module Rubocop
                   '  end',
                   'end',
                  ]
-        inspect_source(empty_lines, '', source)
+        inspect_source(empty_lines, source)
         expect(empty_lines.offences.map(&:message)).to be_empty
       end
     end

data/spec/rubocop/cops/empty_lines_spec.rb

@@ -8,17 +8,29 @@ module Rubocop
       let(:empty_lines) { EmptyLines.new }
 
       it 'registers an offence for consecutive empty lines' do
-        inspect_source(empty_lines, 'file.rb',
+        inspect_source(empty_lines,
                        ['test = 5', '', '', '', 'top'])
         expect(empty_lines.offences.size).to eq(2)
       end
 
+      it 'works when there are no tokens' do
+        inspect_source(empty_lines,
+                       ['#comment'])
+        expect(empty_lines.offences).to be_empty
+      end
+
+      it 'handles comments' do
+        inspect_source(empty_lines,
+                       ['test', '', '#comment', 'top'])
+        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, 'file.rb', ['result = "test
+        inspect_source(empty_lines, ['result = "test
 
 
 
-                                                 string"'])
+                                      string"'])
         expect(empty_lines.offences).to be_empty
       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 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 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

@@ -9,7 +9,6 @@ module Rubocop
 
       it 'registers an offence for return in ensure' do
         inspect_source(er,
-                       'file.rb',
                        ['begin',
                         '  something',
                         'ensure',
@@ -18,12 +17,11 @@ module Rubocop
                         'end'])
         expect(er.offences.size).to eq(1)
         expect(er.offences.map(&:message))
-          .to eq([EnsureReturn::ERROR_MESSAGE])
+          .to eq([EnsureReturn::MSG])
       end
 
       it 'does not register an offence for return outside ensure' do
         inspect_source(er,
-                       'file.rb',
                        ['begin',
                         '  something',
                         '  return',

data/spec/rubocop/cops/eval_spec.rb

@@ -9,28 +9,31 @@ module Rubocop
 
       it 'registers an offence for eval as function' do
         inspect_source(a,
-                       'file.rb',
                        ['eval(something)'])
         expect(a.offences.size).to eq(1)
         expect(a.offences.map(&:message))
-          .to eq([Eval::ERROR_MESSAGE])
+          .to eq([Eval::MSG])
       end
 
       it 'registers an offence for eval as command' do
         inspect_source(a,
-                       'file.rb',
                        ['eval something'])
         expect(a.offences.size).to eq(1)
         expect(a.offences.map(&:message))
-          .to eq([Eval::ERROR_MESSAGE])
+          .to eq([Eval::MSG])
       end
 
       it 'does not register an offence for eval as variable' do
         inspect_source(a,
-                       'file.rb',
                        ['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