rubocop 0.13.1 → 0.14.0

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

@@ -2,35 +2,29 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Style
-      describe NilComparison do
-        subject(:cop) { described_class.new }
+describe Rubocop::Cop::Style::NilComparison do
+  subject(:cop) { described_class.new }
 
-        it 'registers an offence for == nil' do
-          inspect_source(cop,
-                         ['x == nil'])
-          expect(cop.offences.size).to eq(1)
-        end
+  it 'registers an offence for == nil' do
+    inspect_source(cop,
+                   ['x == nil'])
+    expect(cop.offences.size).to eq(1)
+  end
 
-        it 'registers an offence for === nil' do
-          inspect_source(cop,
-                         ['x === nil'])
-          expect(cop.offences.size).to eq(1)
-        end
+  it 'registers an offence for === nil' do
+    inspect_source(cop,
+                   ['x === nil'])
+    expect(cop.offences.size).to eq(1)
+  end
 
-        it 'registers an offence for === nil' do
-          inspect_source(cop,
-                         ['x != nil'])
-          expect(cop.offences.size).to eq(1)
-        end
+  it 'registers an offence for === nil' do
+    inspect_source(cop,
+                   ['x != nil'])
+    expect(cop.offences.size).to eq(1)
+  end
 
-        it 'works with lambda.()' do
-          inspect_source(cop, ['a.(x) == nil'])
-          expect(cop.offences.size).to eq(1)
-        end
-      end
-    end
+  it 'works with lambda.()' do
+    inspect_source(cop, ['a.(x) == nil'])
+    expect(cop.offences.size).to eq(1)
   end
 end

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

@@ -2,27 +2,21 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Style
-      describe Not do
-        subject(:a) { Not.new }
+describe Rubocop::Cop::Style::Not do
+  subject(:cop) { described_class.new }
 
-        it 'registers an offence for not' do
-          inspect_source(a, ['not test'])
-          expect(a.offences.size).to eq(1)
-        end
+  it 'registers an offence for not' do
+    inspect_source(cop, ['not test'])
+    expect(cop.offences.size).to eq(1)
+  end
 
-        it 'does not register an offence for !' do
-          inspect_source(a, ['!test'])
-          expect(a.offences).to be_empty
-        end
+  it 'does not register an offence for !' do
+    inspect_source(cop, ['!test'])
+    expect(cop.offences).to be_empty
+  end
 
-        it 'does not register an offence for :not' do
-          inspect_source(a, ['[:not, :if, :else]'])
-          expect(a.offences).to be_empty
-        end
-      end
-    end
+  it 'does not register an offence for :not' do
+    inspect_source(cop, ['[:not, :if, :else]'])
+    expect(cop.offences).to be_empty
   end
 end

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

@@ -2,40 +2,41 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Style
-      describe NumericLiterals, :config do
-        subject(:cop) { described_class.new(config) }
-        let(:cop_config) { { 'MinDigits' => 5 } }
-
-        it 'registers an offence for a long integer without underscores' do
-          inspect_source(cop, ['a = 123456'])
-          expect(cop.offences.size).to eq(1)
-        end
-
-        it 'registers an offence for an integer with misplaced' do
-          inspect_source(cop, ['a = 123_456_78_90_00'])
-          expect(cop.offences.size).to eq(1)
-        end
-
-        it 'accepts long numbers with underscore' do
-          inspect_source(cop, ['a = 123_456',
-                               'b = 123_456.55'])
-          expect(cop.messages).to be_empty
-        end
-
-        it 'accepts a short integer without underscore' do
-          inspect_source(cop, ['a = 123'])
-          expect(cop.messages).to be_empty
-        end
-
-        it 'accepts short numbers without underscore' do
-          inspect_source(cop, ['a = 123',
-                               'b = 123.456'])
-          expect(cop.messages).to be_empty
-        end
-      end
-    end
+describe Rubocop::Cop::Style::NumericLiterals, :config do
+  subject(:cop) { described_class.new(config) }
+  let(:cop_config) { { 'MinDigits' => 5 } }
+
+  it 'registers an offence for a long integer without underscores' do
+    inspect_source(cop, ['a = 123456'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'registers an offence for an integer with misplaced' do
+    inspect_source(cop, ['a = 123_456_78_90_00'])
+    expect(cop.offences.size).to eq(1)
+  end
+
+  it 'accepts long numbers with underscore' do
+    inspect_source(cop, ['a = 123_456',
+                         'b = 123_456.55'])
+    expect(cop.messages).to be_empty
+  end
+
+  it 'accepts a short integer without underscore' do
+    inspect_source(cop, ['a = 123'])
+    expect(cop.messages).to be_empty
+  end
+
+  it 'accepts short numbers without underscore' do
+    inspect_source(cop, ['a = 123',
+                         'b = 123.456'])
+    expect(cop.messages).to be_empty
+  end
+
+  it 'ignores non-decimal literals' do
+    inspect_source(cop, ['a = 0b1010101010101',
+                         'b = 01919191919191',
+                         'c = 0xab11111111bb'])
+    expect(cop.offences).to be_empty
   end
 end

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

@@ -2,17 +2,11 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Style
-      describe OneLineConditional do
-        subject(:olc) { OneLineConditional.new }
+describe Rubocop::Cop::Style::OneLineConditional do
+  subject(:cop) { described_class.new }
 
-        it 'registers an offence for one line if/then/end' do
-          inspect_source(olc, ['if cond then run else dont end'])
-          expect(olc.messages).to eq([olc.error_message])
-        end
-      end
-    end
+  it 'registers an offence for one line if/then/end' do
+    inspect_source(cop, ['if cond then run else dont end'])
+    expect(cop.messages).to eq([cop.error_message])
   end
 end

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

@@ -2,79 +2,73 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Style
-      describe OpMethod do
-        subject(:om) { OpMethod.new }
+describe Rubocop::Cop::Style::OpMethod do
+  subject(:cop) { described_class.new }
 
-        it 'registers an offence for arg not named other' do
-          inspect_source(om,
-                         ['def +(another)',
-                          '  another',
-                          'end'])
-          expect(om.offences.size).to eq(1)
-          expect(om.messages)
-            .to eq([sprintf(OpMethod::MSG, '+')])
-        end
+  it 'registers an offence for arg not named other' do
+    inspect_source(cop,
+                   ['def +(another)',
+                    '  another',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.messages)
+      .to eq(['When defining the + operator, name its argument *other*.'])
+  end
 
-        it 'works properly even if the argument not surrounded with braces' do
-          inspect_source(om,
-                         ['def + another',
-                          '  another',
-                          'end'])
-          expect(om.offences.size).to eq(1)
-          expect(om.messages)
-            .to eq([sprintf(OpMethod::MSG, '+')])
-        end
+  it 'works properly even if the argument not surrounded with braces' do
+    inspect_source(cop,
+                   ['def + another',
+                    '  another',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.messages)
+      .to eq(['When defining the + operator, name its argument *other*.'])
+  end
 
-        it 'does not register an offence for arg named other' do
-          inspect_source(om,
-                         ['def +(other)',
-                          '  other',
-                          'end'])
-          expect(om.offences).to be_empty
-        end
+  it 'does not register an offence for arg named other' do
+    inspect_source(cop,
+                   ['def +(other)',
+                    '  other',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
 
-        it 'does not register an offence for []' do
-          inspect_source(om,
-                         ['def [](index)',
-                          '  other',
-                          'end'])
-          expect(om.offences).to be_empty
-        end
+  it 'does not register an offence for []' do
+    inspect_source(cop,
+                   ['def [](index)',
+                    '  other',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
 
-        it 'does not register an offence for []=' do
-          inspect_source(om,
-                         ['def []=(index, value)',
-                          '  other',
-                          'end'])
-          expect(om.offences).to be_empty
-        end
+  it 'does not register an offence for []=' do
+    inspect_source(cop,
+                   ['def []=(index, value)',
+                    '  other',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
 
-        it 'does not register an offence for <<' do
-          inspect_source(om,
-                         ['def <<(cop)',
-                          '  other',
-                          'end'])
-          expect(om.offences).to be_empty
-        end
+  it 'does not register an offence for <<' do
+    inspect_source(cop,
+                   ['def <<(cop)',
+                    '  other',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
 
-        it 'does not register an offence for non binary operators' do
-          inspect_source(om,
-                         ['def -@', # Unary minus
-                          'end',
-                          '',
-                          # This + is not a unary operator. It can only be
-                          # called with dot notation.
-                          'def +',
-                          'end',
-                          '',
-                          'def *(a, b)', # Quite strange, but legal ruby.
-                          'end'])
-          expect(om.offences).to be_empty
-        end
-      end
-    end
+  it 'does not register an offence for non binary operators' do
+    inspect_source(cop,
+                   ['def -@', # Unary minus
+                    'end',
+                    '',
+                    # This + is not a unary operator. It can only be
+                    # called with dot notation.
+                    'def +',
+                    'end',
+                    '',
+                    'def *(a, b)', # Quite strange, but legal ruby.
+                    'end'])
+    expect(cop.offences).to be_empty
   end
 end

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

@@ -2,48 +2,42 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Style
-      describe ParameterLists, :config do
-        subject(:list) { ParameterLists.new(config) }
-        let(:cop_config) do
-          {
-            'Max' => 4,
-            'CountKeywordArgs' => true
-          }
-        end
+describe Rubocop::Cop::Style::ParameterLists, :config do
+  subject(:cop) { described_class.new(config) }
+  let(:cop_config) do
+    {
+      'Max' => 4,
+      'CountKeywordArgs' => true
+    }
+  end
 
-        it 'registers an offence for a method def with 5 parameters' do
-          inspect_source(list, ['def meth(a, b, c, d, e)',
-                                'end'])
-          expect(list.offences.size).to eq(1)
-        end
+  it 'registers an offence for a method def with 5 parameters' do
+    inspect_source(cop, ['def meth(a, b, c, d, e)',
+                         'end'])
+    expect(cop.offences.size).to eq(1)
+  end
 
-        it 'accepts a method def with 4 parameters' do
-          inspect_source(list, ['def meth(a, b, c, d)',
-                                'end'])
-          expect(list.offences).to be_empty
-        end
+  it 'accepts a method def with 4 parameters' do
+    inspect_source(cop, ['def meth(a, b, c, d)',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
 
-        context 'When CountKeywordArgs is true' do
-          it 'counts keyword arguments as well', ruby: 2.0 do
-            inspect_source(list, ['def meth(a, b, c, d: 1, e: 2)',
-                                  'end'])
-            expect(list.offences.size).to eq(1)
-          end
-        end
+  context 'When CountKeywordArgs is true' do
+    it 'counts keyword arguments as well', ruby: 2.0 do
+      inspect_source(cop, ['def meth(a, b, c, d: 1, e: 2)',
+                           'end'])
+      expect(cop.offences.size).to eq(1)
+    end
+  end
 
-        context 'When CountKeywordArgs is false' do
-          before { cop_config['CountKeywordArgs'] = false }
+  context 'When CountKeywordArgs is false' do
+    before { cop_config['CountKeywordArgs'] = false }
 
-          it 'it does not count keyword arguments', ruby: 2.0 do
-            inspect_source(list, ['def meth(a, b, c, d: 1, e: 2)',
-                                  'end'])
-            expect(list.offences).to be_empty
-          end
-        end
-      end
+    it 'it does not count keyword arguments', ruby: 2.0 do
+      inspect_source(cop, ['def meth(a, b, c, d: 1, e: 2)',
+                           'end'])
+      expect(cop.offences).to be_empty
     end
   end
 end

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

@@ -2,82 +2,76 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Style
-      describe ParenthesesAroundCondition, :config do
-        subject(:cop) { ParenthesesAroundCondition.new(config) }
-        let(:cop_config) { { 'AllowSafeAssignment' => true } }
+describe Rubocop::Cop::Style::ParenthesesAroundCondition, :config do
+  subject(:cop) { described_class.new(config) }
+  let(:cop_config) { { 'AllowSafeAssignment' => true } }
 
-        it 'registers an offence for parentheses around condition' do
-          inspect_source(cop, ['if (x > 10)',
-                               'elsif (x < 3)',
-                               'end',
-                               'unless (x > 10)',
-                               'end',
-                               'while (x > 10)',
-                               'end',
-                               'until (x > 10)',
-                               'end',
-                               'x += 1 if (x < 10)',
-                               'x += 1 unless (x < 10)',
-                               'x += 1 while (x < 10)',
-                               'x += 1 until (x < 10)',
-                              ])
-          expect(cop.offences.size).to eq(9)
-        end
+  it 'registers an offence for parentheses around condition' do
+    inspect_source(cop, ['if (x > 10)',
+                         'elsif (x < 3)',
+                         'end',
+                         'unless (x > 10)',
+                         'end',
+                         'while (x > 10)',
+                         'end',
+                         'until (x > 10)',
+                         'end',
+                         'x += 1 if (x < 10)',
+                         'x += 1 unless (x < 10)',
+                         'x += 1 while (x < 10)',
+                         'x += 1 until (x < 10)',
+                        ])
+    expect(cop.offences.size).to eq(9)
+  end
 
-        it 'accepts condition without parentheses' do
-          inspect_source(cop, ['if x > 10',
-                               'end',
-                               'unless x > 10',
-                               'end',
-                               'while x > 10',
-                               'end',
-                               'until x > 10',
-                               'end',
-                               'x += 1 if x < 10',
-                               'x += 1 unless x < 10',
-                               'x += 1 while x < 10',
-                               'x += 1 until x < 10',
-                              ])
-          expect(cop.offences).to be_empty
-        end
+  it 'accepts condition without parentheses' do
+    inspect_source(cop, ['if x > 10',
+                         'end',
+                         'unless x > 10',
+                         'end',
+                         'while x > 10',
+                         'end',
+                         'until x > 10',
+                         'end',
+                         'x += 1 if x < 10',
+                         'x += 1 unless x < 10',
+                         'x += 1 while x < 10',
+                         'x += 1 until x < 10',
+                        ])
+    expect(cop.offences).to be_empty
+  end
 
-        it 'is not confused by leading brace in subexpression' do
-          inspect_source(cop, ['(a > b) && other ? one : two'])
-          expect(cop.offences).to be_empty
-        end
+  it 'is not confused by leading brace in subexpression' do
+    inspect_source(cop, ['(a > b) && other ? one : two'])
+    expect(cop.offences).to be_empty
+  end
 
-        it 'is not confused by unbalanced parentheses' do
-          inspect_source(cop, ['if (a + b).c()',
-                               'end'])
-          expect(cop.offences).to be_empty
-        end
+  it 'is not confused by unbalanced parentheses' do
+    inspect_source(cop, ['if (a + b).c()',
+                         'end'])
+    expect(cop.offences).to be_empty
+  end
 
-        context 'safe assignment is allowed' do
-          it 'accepts = in condition surrounded with braces' do
-            inspect_source(cop,
-                           ['if (test = 10)',
-                            'end'
-                           ])
-            expect(cop.offences).to be_empty
-          end
+  context 'safe assignment is allowed' do
+    it 'accepts = in condition surrounded with braces' do
+      inspect_source(cop,
+                     ['if (test = 10)',
+                      'end'
+                     ])
+      expect(cop.offences).to be_empty
+    end
 
-        end
+  end
 
-        context 'safe assignment is not allowed' do
-          let(:cop_config) { { 'AllowSafeAssignment' => false } }
+  context 'safe assignment is not allowed' do
+    let(:cop_config) { { 'AllowSafeAssignment' => false } }
 
-          it 'does not accepts = in condition surrounded with braces' do
-            inspect_source(cop,
-                           ['if (test = 10)',
-                            'end'
-                           ])
-            expect(cop.offences.size).to eq(1)
-          end
-        end
-      end
+    it 'does not accepts = in condition surrounded with braces' do
+      inspect_source(cop,
+                     ['if (test = 10)',
+                      'end'
+                     ])
+      expect(cop.offences.size).to eq(1)
     end
   end
 end