rubocop 0.8.3 → 0.9.0

data/spec/rubocop/cops/constant_name_spec.rb

@@ -1,42 +0,0 @@
-# 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

@@ -1,38 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe DefWithParentheses do
-      let(:def_par) { DefWithParentheses.new }
-
-      it 'reports an offence for def with empty parens' do
-        src = ['def func()',
-               'end']
-        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).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).to be_empty
-      end
-    end
-  end
-end

data/spec/rubocop/cops/def_without_parentheses_spec.rb

@@ -1,32 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe DefWithoutParentheses do
-      let(:def_par) { DefWithoutParentheses.new }
-
-      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.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).to be_empty
-      end
-    end
-  end
-end

data/spec/rubocop/cops/empty_line_between_defs_spec.rb

@@ -1,83 +0,0 @@
-# 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

@@ -1,38 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe EmptyLines do
-      let(:empty_lines) { EmptyLines.new }
-
-      it 'registers an offence for consecutive empty lines' do
-        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, ['result = "test
-
-
-
-                                      string"'])
-        expect(empty_lines.offences).to be_empty
-      end
-    end
-  end
-end

data/spec/rubocop/cops/empty_literal_spec.rb

@@ -1,90 +0,0 @@
-# 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

@@ -1,47 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe Encoding do
-      let(:encoding) { Encoding.new }
-
-      it 'registers an offence when no encoding present', ruby: 1.9 do
-        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, ['# 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, ['#!/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, ['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, ['def foo() end'])
-
-        expect(encoding.offences).to be_empty
-      end
-    end
-  end
-end

data/spec/rubocop/cops/end_of_line_spec.rb

@@ -1,23 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe EndOfLine do
-      let(:eol) { EndOfLine.new }
-
-      it 'registers an offence for CR+LF' do
-        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, ["x=0\r"])
-        expect(eol.offences.map(&:message)).to eq(
-          ['Carriage return character detected.'])
-      end
-    end
-  end
-end

data/spec/rubocop/cops/ensure_return_spec.rb

@@ -1,35 +0,0 @@
-# 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

@@ -1,39 +0,0 @@
-# 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