rubocop 0.13.1 → 0.14.0

data/spec/rubocop/cop/style/method_name_spec.rb

@@ -0,0 +1,103 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::MethodName, :config do
+  subject(:cop) { described_class.new(config) }
+
+  shared_examples 'never accepted' do
+    it 'registers an offence for mixed snake case and camel case' do
+      inspect_source(cop, ['def visit_Arel_Nodes_SelectStatement',
+                           'end'])
+      expect(cop.offences).to have(1).item
+      expect(cop.highlights).to eq(['visit_Arel_Nodes_SelectStatement'])
+    end
+
+    it 'registers an offence for capitalized camel case' do
+      inspect_source(cop, ['def MyMethod',
+                           'end'])
+      expect(cop.offences).to have(1).item
+      expect(cop.highlights).to eq(['MyMethod'])
+    end
+  end
+
+  shared_examples 'always accepted' do
+    it 'accepts one line methods' do
+      inspect_source(cop, "def body; '' end")
+      expect(cop.offences).to be_empty
+    end
+
+    it 'accepts operator definitions' do
+      inspect_source(cop, ['def +(other)',
+                           '  # ...',
+                           'end'])
+      expect(cop.offences).to be_empty
+    end
+  end
+
+  context 'when configured for snake_case' do
+    let(:cop_config) { { 'EnforcedStyle' => 'snake_case' } }
+
+    it 'registers an offence for camel case in instance method name' do
+      inspect_source(cop, ['def myMethod',
+                           '  # ...',
+                           'end'])
+      expect(cop.offences).to have(1).item
+      expect(cop.highlights).to eq(['myMethod'])
+    end
+
+    it 'registers an offence for camel case in singleton method name' do
+      inspect_source(cop, ['def self.myMethod',
+                           '  # ...',
+                           'end'])
+      expect(cop.offences).to have(1).item
+      expect(cop.highlights).to eq(['myMethod'])
+    end
+
+    it 'accepts snake case in names' do
+      inspect_source(cop, ['def my_method',
+                           'end'])
+      expect(cop.offences).to be_empty
+    end
+
+    include_examples 'never accepted'
+    include_examples 'always accepted'
+  end
+
+  context 'when configured for camelCase' do
+    let(:cop_config) { { 'EnforcedStyle' => 'camelCase' } }
+
+    it 'accepts camel case in instance method name' do
+      inspect_source(cop, ['def myMethod',
+                           '  # ...',
+                           'end'])
+      expect(cop.offences).to be_empty
+    end
+
+    it 'accepts camel case in singleton method name' do
+      inspect_source(cop, ['def self.myMethod',
+                           '  # ...',
+                           'end'])
+      expect(cop.offences).to be_empty
+    end
+
+    it 'registers an offence for snake case in names' do
+      inspect_source(cop, ['def my_method',
+                           'end'])
+      expect(cop.offences).to have(1).item
+      expect(cop.highlights).to eq(['my_method'])
+    end
+
+    include_examples 'always accepted'
+    include_examples 'never accepted'
+  end
+
+  context 'when configured with a bad value' do
+    let(:cop_config) { { 'EnforcedStyle' => 'other' } }
+
+    it 'fails' do
+      expect { inspect_source(cop, ['def a', 'end']) }
+        .to raise_error(RuntimeError)
+    end
+  end
+end

data/spec/rubocop/cop/style/module_function_spec.rb

@@ -2,29 +2,23 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Style
-      describe ModuleFunction do
-        subject(:cop) { described_class.new }
+describe Rubocop::Cop::Style::ModuleFunction do
+  subject(:cop) { described_class.new }
 
-        it 'registers an offence for extend self in module' do
-          inspect_source(cop,
-                         ['module Test',
-                          '  extend self',
-                          '  def test; end',
-                          'end'])
-          expect(cop.offences.size).to eq(1)
-        end
+  it 'registers an offence for extend self in module' do
+    inspect_source(cop,
+                   ['module Test',
+                    '  extend self',
+                    '  def test; end',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+  end
 
-        it 'accepts extend self in class' do
-          inspect_source(cop,
-                         ['class Test',
-                          '  extend self',
-                          'end'])
-          expect(cop.offences).to be_empty
-        end
-      end
-    end
+  it 'accepts extend self in class' do
+    inspect_source(cop,
+                   ['class Test',
+                    '  extend self',
+                    'end'])
+    expect(cop.offences).to be_empty
   end
 end

data/spec/rubocop/cop/style/multiline_block_chain_spec.rb

@@ -2,83 +2,77 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Style
-      describe MultilineBlockChain do
-        subject(:cop) { described_class.new }
+describe Rubocop::Cop::Style::MultilineBlockChain do
+  subject(:cop) { described_class.new }
 
-        context 'with multi-line block chaining' do
-          it 'registers an offence for a simple case' do
-            inspect_source(cop, ['a do',
-                                 '  b',
-                                 'end.c do',
-                                 '  d',
-                                 'end'])
-            expect(cop.offences).to have(1).item
-            expect(cop.highlights).to eq(['end.c'])
-          end
+  context 'with multi-line block chaining' do
+    it 'registers an offence for a simple case' do
+      inspect_source(cop, ['a do',
+                           '  b',
+                           'end.c do',
+                           '  d',
+                           'end'])
+      expect(cop.offences).to have(1).item
+      expect(cop.highlights).to eq(['end.c'])
+    end
 
-          it 'registers an offence for a slightly more complicated case' do
-            inspect_source(cop, ['a do',
-                                 '  b',
-                                 'end.c1.c2 do',
-                                 '  d',
-                                 'end'])
-            expect(cop.offences).to have(1).item
-            expect(cop.highlights).to eq(['end.c1.c2'])
-          end
+    it 'registers an offence for a slightly more complicated case' do
+      inspect_source(cop, ['a do',
+                           '  b',
+                           'end.c1.c2 do',
+                           '  d',
+                           'end'])
+      expect(cop.offences).to have(1).item
+      expect(cop.highlights).to eq(['end.c1.c2'])
+    end
 
-          it 'registers two offences for a chain of three blocks' do
-            inspect_source(cop, ['a do',
-                                 '  b',
-                                 'end.c do',
-                                 '  d',
-                                 'end.e do',
-                                 '  f',
-                                 'end'])
-            expect(cop.offences).to have(2).item
-            expect(cop.highlights).to eq(['end.c', 'end.e'])
-          end
+    it 'registers two offences for a chain of three blocks' do
+      inspect_source(cop, ['a do',
+                           '  b',
+                           'end.c do',
+                           '  d',
+                           'end.e do',
+                           '  f',
+                           'end'])
+      expect(cop.offences).to have(2).item
+      expect(cop.highlights).to eq(['end.c', 'end.e'])
+    end
 
-          it 'registers an offence for a chain where the second block is ' +
-            'single-line' do
-            inspect_source(cop, ['Thread.list.find_all { |t|',
-                                 '  t.alive?',
-                                 '}.map { |thread| thread.object_id }'])
-            expect(cop.offences).to have(1).item
-            expect(cop.highlights).to eq(['}.map'])
-          end
+    it 'registers an offence for a chain where the second block is ' +
+      'single-line' do
+      inspect_source(cop, ['Thread.list.find_all { |t|',
+                           '  t.alive?',
+                           '}.map { |thread| thread.object_id }'])
+      expect(cop.offences).to have(1).item
+      expect(cop.highlights).to eq(['}.map'])
+    end
 
-          it 'accepts a chain where the first block is single-line' do
-            inspect_source(cop,
-                           ['Thread.list.find_all { |t| t.alive? }.map { |t| ',
-                            '  t.object_id',
-                            '}'])
-            expect(cop.offences).to be_empty
-          end
-        end
+    it 'accepts a chain where the first block is single-line' do
+      inspect_source(cop,
+                     ['Thread.list.find_all { |t| t.alive? }.map { |t| ',
+                      '  t.object_id',
+                      '}'])
+      expect(cop.offences).to be_empty
+    end
+  end
 
-        it 'accepts a chain of blocks spanning one line' do
-          inspect_source(cop, ['a { b }.c { d }',
-                               'w do x end.y do z end'])
-          expect(cop.offences).to be_empty
-        end
+  it 'accepts a chain of blocks spanning one line' do
+    inspect_source(cop, ['a { b }.c { d }',
+                         'w do x end.y do z end'])
+    expect(cop.offences).to be_empty
+  end
 
-        it 'accepts a multi-line block chained with calls on one line' do
-          inspect_source(cop, ['a do',
-                               '  b',
-                               'end.c.d'])
-          expect(cop.offences).to be_empty
-        end
+  it 'accepts a multi-line block chained with calls on one line' do
+    inspect_source(cop, ['a do',
+                         '  b',
+                         'end.c.d'])
+    expect(cop.offences).to be_empty
+  end
 
-        it 'accepts a chain of calls followed by a multi-line block' do
-          inspect_source(cop, ['a1.a2.a3 do',
-                               '  b',
-                               'end'])
-          expect(cop.offences).to be_empty
-        end
-      end
-    end
+  it 'accepts a chain of calls followed by a multi-line block' do
+    inspect_source(cop, ['a1.a2.a3 do',
+                         '  b',
+                         'end'])
+    expect(cop.offences).to be_empty
   end
 end

data/spec/rubocop/cop/style/multiline_if_then_spec.rb

@@ -2,96 +2,90 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Style
-      describe MultilineIfThen do
-        subject(:mit) { MultilineIfThen.new }
+describe Rubocop::Cop::Style::MultilineIfThen do
+  subject(:cop) { described_class.new }
 
-        # if
+  # if
 
-        it 'registers an offence for then in multiline if' do
-          inspect_source(mit, ['if cond then',
-                               'end',
-                               "if cond then\t",
-                               'end',
-                               'if cond then  ',
-                               'end',
-                               'if cond',
-                               'then',
-                               'end',
-                               'if cond then # bad',
-                               'end'])
-          expect(mit.offences.map(&:line)).to eq([1, 3, 5, 7, 10])
-        end
+  it 'registers an offence for then in multiline if' do
+    inspect_source(cop, ['if cond then',
+                         'end',
+                         "if cond then\t",
+                         'end',
+                         'if cond then  ',
+                         'end',
+                         'if cond',
+                         'then',
+                         'end',
+                         'if cond then # bad',
+                         'end'])
+    expect(cop.offences.map(&:line)).to eq([1, 3, 5, 7, 10])
+  end
 
-        it 'accepts multiline if without then' do
-          inspect_source(mit, ['if cond',
-                               'end'])
-          expect(mit.offences).to be_empty
-        end
+  it 'accepts multiline if without then' do
+    inspect_source(cop, ['if cond',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
 
-        it 'accepts table style if/then/elsif/ends' do
-          inspect_source(mit,
-                         ['if    @io == $stdout then str << "$stdout"',
-                          'elsif @io == $stdin  then str << "$stdin"',
-                          'elsif @io == $stderr then str << "$stderr"',
-                          'else                      str << @io.class.to_s',
-                          'end'])
-          expect(mit.offences).to be_empty
-        end
+  it 'accepts table style if/then/elsif/ends' do
+    inspect_source(cop,
+                   ['if    @io == $stdout then str << "$stdout"',
+                    'elsif @io == $stdin  then str << "$stdin"',
+                    'elsif @io == $stderr then str << "$stderr"',
+                    'else                      str << @io.class.to_s',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
 
-        it 'does not get confused by a then in a when' do
-          inspect_source(mit,
-                         ['if a',
-                          '  case b',
-                          '  when c then',
-                          '  end',
-                          'end'])
-          expect(mit.offences).to be_empty
-        end
+  it 'does not get confused by a then in a when' do
+    inspect_source(cop,
+                   ['if a',
+                    '  case b',
+                    '  when c then',
+                    '  end',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
 
-        it 'does not get confused by a commented-out then' do
-          inspect_source(mit,
-                         ['if a # then',
-                          '  b',
-                          'end',
-                          'if c # then',
-                          'end'])
-          expect(mit.offences).to be_empty
-        end
+  it 'does not get confused by a commented-out then' do
+    inspect_source(cop,
+                   ['if a # then',
+                    '  b',
+                    'end',
+                    'if c # then',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
 
-        # unless
+  # unless
 
-        it 'registers an offence for then in multiline unless' do
-          inspect_source(mit, ['unless cond then',
-                               'end'])
-          expect(mit.messages).to eq(
-            ['Never use then for multi-line if/unless.'])
-        end
+  it 'registers an offence for then in multiline unless' do
+    inspect_source(cop, ['unless cond then',
+                         'end'])
+    expect(cop.messages).to eq(
+      ['Never use then for multi-line if/unless.'])
+  end
 
-        it 'accepts multiline unless without then' do
-          inspect_source(mit, ['unless cond',
-                               'end'])
-          expect(mit.offences).to be_empty
-        end
+  it 'accepts multiline unless without then' do
+    inspect_source(cop, ['unless cond',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
 
-        it 'does not get confused by a postfix unless' do
-          inspect_source(mit,
-                         ['two unless one',
-                         ])
-          expect(mit.offences).to be_empty
-        end
+  it 'does not get confused by a postfix unless' do
+    inspect_source(cop,
+                   ['two unless one',
+                   ])
+    expect(cop.offences).to be_empty
+  end
 
-        it 'does not get confused by a nested postfix unless' do
-          inspect_source(mit,
-                         ['if two',
-                          '  puts 1',
-                          'end unless two'
-                         ])
-          expect(mit.offences).to be_empty
-        end
-      end
-    end
+  it 'does not get confused by a nested postfix unless' do
+    inspect_source(cop,
+                   ['if two',
+                    '  puts 1',
+                    'end unless two'
+                   ])
+    expect(cop.offences).to be_empty
   end
 end