rubocop 0.8.3 → 0.9.0

data/spec/rubocop/cops/style/def_without_parentheses_spec.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      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
+end

data/spec/rubocop/cops/style/documentation_spec.rb

@@ -0,0 +1,79 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe Documentation do
+        let(:documentation) { Documentation.new }
+
+        it 'registers an offence for non-empty class' do
+          inspect_source(documentation,
+                         ['class My_Class',
+                          '  TEST = 20',
+                          'end'
+                         ])
+          expect(documentation.offences.size).to eq(1)
+        end
+
+        it 'registers an offence for non-namespace' do
+          inspect_source(documentation,
+                         ['module My_Class',
+                          '  TEST = 20',
+                          'end'
+                         ])
+          expect(documentation.offences.size).to eq(1)
+        end
+
+        it 'registers an offence for empty module without documentation' do
+          # Because why would you have an empty module? It requires some
+          # explanation.
+          inspect_source(documentation,
+                         ['module Test',
+                          'end'
+                         ])
+          expect(documentation.offences.size).to eq(1)
+        end
+
+        it 'accepts non-empty class with documentation' do
+          inspect_source(documentation,
+                         ['# class comment',
+                          'class My_Class',
+                          '  TEST = 20',
+                          'end'
+                         ])
+          expect(documentation.offences).to be_empty
+        end
+
+        it 'accepts non-empty module with documentation' do
+          inspect_source(documentation,
+                         ['# class comment',
+                          'module My_Class',
+                          '  TEST = 20',
+                          'end'
+                         ])
+          expect(documentation.offences).to be_empty
+        end
+
+        it 'accepts empty class without documentation' do
+          inspect_source(documentation,
+                         ['class My_Class',
+                          'end'
+                         ])
+          expect(documentation.offences).to be_empty
+        end
+
+        it 'accepts namespace module without documentation' do
+          inspect_source(documentation,
+                         ['module Test',
+                          '  class A; end',
+                          '  class B; end',
+                          'end'
+                         ])
+          expect(documentation.offences).to be_empty
+        end
+      end
+    end
+  end
+end

data/spec/rubocop/cops/style/dot_position_spec.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe DotPosition do
+        let(:cop) { DotPosition.new }
+
+        it 'registers an offence for trailing dot in multi-line method call' do
+          inspect_source(cop, ['something.',
+                               '  method_name'])
+          expect(cop.offences.size).to eq(1)
+        end
+
+        it 'accepts leading do in multi-line method call' do
+          inspect_source(cop, ['something',
+                               '  .method_name'])
+          expect(cop.offences).to be_empty
+        end
+
+        it 'does not err on method call with no dots' do
+          inspect_source(cop, ['puts something'])
+          expect(cop.offences).to be_empty
+        end
+      end
+    end
+  end
+end

data/spec/rubocop/cops/style/empty_line_between_defs_spec.rb

@@ -0,0 +1,85 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      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).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
+end

data/spec/rubocop/cops/style/empty_lines_spec.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      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
+end

data/spec/rubocop/cops/style/empty_literal_spec.rb

@@ -0,0 +1,91 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      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
+end

data/spec/rubocop/cops/style/encoding_spec.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      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
+end

data/spec/rubocop/cops/style/end_block_spec.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe EndBlock do
+        let(:cop) { EndBlock.new }
+
+        it 'reports an offence for an END block' do
+          src = ['END { test }']
+          inspect_source(cop, src)
+          expect(cop.offences.size).to eq(1)
+        end
+      end
+    end
+  end
+end

data/spec/rubocop/cops/style/end_of_line_spec.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      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
+end