rubocop 0.8.3 → 0.9.0

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

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

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

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe CaseEquality do
+        let(:ce) { CaseEquality.new }
+
+        it 'registers an offence for ===' do
+          inspect_source(ce, ['Array === var'])
+          expect(ce.offences.size).to eq(1)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe CaseIndentation do
+        let(:ind) { CaseIndentation.new }
+
+        it "registers an offence for a when clause that's deeper than case" do
+          source = ['case a',
+                    '    when 0 then return',
+                    '        case b',
+                    '         when 1 then return',
+                    '        end',
+                    'end']
+          inspect_source(ind, source)
+          expect(ind.offences.map(&:message)).to eq(
+            ['Indent when as deep as case.'] * 2)
+        end
+
+        it "accepts a when clause that's equally indented with case" do
+          source = ['y = case a',
+                    '    when 0 then break',
+                    '    when 0 then return',
+                    '      z = case b',
+                    '          when 1 then return',
+                    '          when 1 then break',
+                    '          end',
+                    '    end',
+                    'case c',
+                    'when 2 then encoding',
+                    'end',
+                    '']
+          inspect_source(ind, source)
+          expect(ind.offences).to be_empty
+        end
+
+        it "doesn't get confused by strings with case in them" do
+          source = ['a = "case"',
+                    'case x',
+                    'when 0',
+                    'end',
+                    '']
+          inspect_source(ind, source)
+          expect(ind.offences.map(&:message)).to be_empty
+        end
+
+        it "doesn't get confused by symbols named case or when" do
+          source = ['KEYWORDS = { :case => true, :when => true }',
+                    'case type',
+                    'when 0',
+                    '  ParameterNode',
+                    'when 1',
+                    '  MethodCallNode',
+                    'end',
+                    '']
+          inspect_source(ind, source)
+          expect(ind.offences.map(&:message)).to be_empty
+        end
+
+        it 'accepts correctly indented whens in complex combinations' do
+          source = ['each {',
+                    '  case state',
+                    '  when 0',
+                    '    case name',
+                    '    when :a',
+                    '    end',
+                    '  when 1',
+                    '    loop {',
+                    '      case name',
+                    '      when :b',
+                    '      end',
+                    '    }',
+                    '  end',
+                    '}',
+                    'case s',
+                    'when Array',
+                    'end',
+                    '']
+          inspect_source(ind, source)
+          expect(ind.offences.map(&:message)).to be_empty
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe CharacterLiteral do
+        let(:cop) { CharacterLiteral.new }
+
+        it 'registers an offence for character literals' do
+          inspect_source(cop, ['x = ?x'])
+          expect(cop.offences.size).to eq(1)
+        end
+
+        it 'registers an offence for literals like \n' do
+          inspect_source(cop, ['x = ?\n'])
+          expect(cop.offences.size).to eq(1)
+        end
+
+        it 'accepts literals like ?\C-\M-d' do
+          inspect_source(cop, ['x = ?\C-\M-d'])
+          expect(cop.offences).to be_empty
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe ClassAndModuleCamelCase do
+        let(:camel_case) { ClassAndModuleCamelCase.new }
+
+        it 'registers an offence for underscore in class and module name' do
+          inspect_source(camel_case,
+                         ['class My_Class',
+                          'end',
+                          '',
+                          'module My_Module',
+                          'end',
+                         ])
+          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,
+                         ['class MyClass',
+                          'end',
+                          '',
+                          'module Mine',
+                          'end',
+                         ])
+          expect(camel_case.offences).to be_empty
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe CollectionMethods do
+        let(:cm) { CollectionMethods.new }
+
+        it 'registers an offence for collect' do
+          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, ['[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, ['[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, ['[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
+end

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

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

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

@@ -0,0 +1,56 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      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 offences for camel case in multiple const assignment' do
+          inspect_source(const,
+                         ['TopCase, Test2, TEST_3 = 5, 6, 7'])
+          expect(const.offences.size).to eq(2)
+        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 'allows screaming snake case in multiple const assignment' do
+          inspect_source(const,
+                         ['TOP_TEST, TEST_2 = 5, 6'])
+          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
+end

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

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