rubocop 0.7.2 → 0.8.0

data/spec/rubocop/cops/method_and_variable_snake_case_spec.rb

@@ -7,20 +7,46 @@ module Rubocop
     describe MethodAndVariableSnakeCase do
       let(:snake_case) { MethodAndVariableSnakeCase.new }
 
-      it 'registers an offence for camel case in names' do
-        inspect_source(snake_case, 'file.rb',
+      it 'registers an offence for camel case in instance method name' do
+        inspect_source(snake_case,
                        ['def myMethod',
-                        '  myLocal = 1',
-                        '  self.mySetter = 2',
-                        '  @myAttribute = 3',
+                        '  # ...',
                         'end',
                        ])
         expect(snake_case.offences.map(&:message)).to eq(
-          ['Use snake_case for methods and variables.'] * 4)
+          ['Use snake_case for methods and variables.'])
+      end
+
+      it 'registers an offence for camel case in singleton method name' do
+        inspect_source(snake_case,
+                       ['def self.myMethod',
+                        '  # ...',
+                        'end',
+                       ])
+        expect(snake_case.offences.map(&:message)).to eq(
+          ['Use snake_case for methods and variables.'])
+      end
+
+      it 'registers an offence for camel case in local variable name' do
+        inspect_source(snake_case, ['myLocal = 1'])
+        expect(snake_case.offences.map(&:message)).to eq(
+          ['Use snake_case for methods and variables.'])
+      end
+
+      it 'registers an offence for camel case in instance variable name' do
+        inspect_source(snake_case, ['@myAttribute = 3'])
+        expect(snake_case.offences.map(&:message)).to eq(
+          ['Use snake_case for methods and variables.'])
+      end
+
+      it 'registers an offence for camel case in setter name' do
+        inspect_source(snake_case, ['self.mySetter = 2'])
+        expect(snake_case.offences.map(&:message)).to eq(
+          ['Use snake_case for methods and variables.'])
       end
 
       it 'registers an offence for capitalized camel case' do
-        inspect_source(snake_case, 'file.rb',
+        inspect_source(snake_case,
                        ['def MyMethod',
                         'end',
                        ])
@@ -29,7 +55,7 @@ module Rubocop
       end
 
       it 'accepts snake case in names' do
-        inspect_source(snake_case, 'file.rb',
+        inspect_source(snake_case,
                        ['def my_method',
                         '  my_local_html = 1',
                         '  self.my_setter = 2',
@@ -40,7 +66,7 @@ module Rubocop
       end
 
       it 'registers an offence for mixed snake case and camel case' do
-        inspect_source(snake_case, 'file.rb',
+        inspect_source(snake_case,
                        ['def visit_Arel_Nodes_SelectStatement',
                         'end'])
         expect(snake_case.offences.map(&:message)).to eq(
@@ -48,17 +74,17 @@ module Rubocop
       end
 
       it 'accepts screaming snake case globals' do
-        inspect_source(snake_case, 'file.rb', ['$MY_GLOBAL = 0'])
+        inspect_source(snake_case, ['$MY_GLOBAL = 0'])
         expect(snake_case.offences.map(&:message)).to be_empty
       end
 
       it 'accepts screaming snake case constants' do
-        inspect_source(snake_case, 'file.rb', ['MY_CONSTANT = 0'])
+        inspect_source(snake_case, ['MY_CONSTANT = 0'])
         expect(snake_case.offences.map(&:message)).to be_empty
       end
 
       it 'accepts assigning to camel case constant' do
-        inspect_source(snake_case, 'file.rb',
+        inspect_source(snake_case,
                        ['Paren = Struct.new :left, :right, :kind'])
         expect(snake_case.offences.map(&:message)).to be_empty
       end

data/spec/rubocop/cops/method_length_spec.rb

@@ -9,136 +9,136 @@ module Rubocop
       before { MethodLength.config = { 'Max' => 5, 'CountComments' => false } }
 
       it 'rejects a method with more than 5 lines' do
-        inspect_source(method_length, '', ['def m()',
-                                           '  a = 1',
-                                           '  a = 2',
-                                           '  a = 3',
-                                           '  a = 4',
-                                           '  a = 5',
-                                           '  a = 6',
-                                           'end'])
+        inspect_source(method_length, ['def m()',
+                                       '  a = 1',
+                                       '  a = 2',
+                                       '  a = 3',
+                                       '  a = 4',
+                                       '  a = 5',
+                                       '  a = 6',
+                                       'end'])
         expect(method_length.offences.size).to eq(1)
         expect(method_length.offences.map(&:line_number).sort).to eq([1])
       end
 
       it 'accepts a method with less than 5 lines' do
-        inspect_source(method_length, '', ['def m()',
-                                           '  a = 1',
-                                           '  a = 2',
-                                           '  a = 3',
-                                           '  a = 4',
-                                           'end'])
+        inspect_source(method_length, ['def m()',
+                                       '  a = 1',
+                                       '  a = 2',
+                                       '  a = 3',
+                                       '  a = 4',
+                                       'end'])
         expect(method_length.offences).to be_empty
       end
 
       it 'does not count blank lines' do
-        inspect_source(method_length, '', ['def m()',
-                                           '  a = 1',
-                                           '  a = 2',
-                                           '  a = 3',
-                                           '  a = 4',
-                                           '',
-                                           '',
-                                           '  a = 7',
-                                           'end'])
+        inspect_source(method_length, ['def m()',
+                                       '  a = 1',
+                                       '  a = 2',
+                                       '  a = 3',
+                                       '  a = 4',
+                                       '',
+                                       '',
+                                       '  a = 7',
+                                       'end'])
         expect(method_length.offences).to be_empty
       end
 
       it 'accepts empty methods' do
-        inspect_source(method_length, '', ['def m()',
-                                           'end'])
+        inspect_source(method_length, ['def m()',
+                                       'end'])
         expect(method_length.offences).to be_empty
       end
 
       it 'is not fooled by one-liner methods, syntax #1' do
-        inspect_source(method_length, '', ['def one_line; 10 end',
-                                           'def self.m()',
-                                           '  a = 1',
-                                           '  a = 2',
-                                           '  a = 4',
-                                           '  a = 5',
-                                           '  a = 6',
-                                           'end'])
+        inspect_source(method_length, ['def one_line; 10 end',
+                                       'def self.m()',
+                                       '  a = 1',
+                                       '  a = 2',
+                                       '  a = 4',
+                                       '  a = 5',
+                                       '  a = 6',
+                                       'end'])
         expect(method_length.offences).to be_empty
       end
 
       it 'is not fooled by one-liner methods, syntax #2' do
-        inspect_source(method_length, '', ['def one_line(test) 10 end',
-                                           'def self.m()',
-                                           '  a = 1',
-                                           '  a = 2',
-                                           '  a = 4',
-                                           '  a = 5',
-                                           '  a = 6',
-                                           'end'])
+        inspect_source(method_length, ['def one_line(test) 10 end',
+                                       'def self.m()',
+                                       '  a = 1',
+                                       '  a = 2',
+                                       '  a = 4',
+                                       '  a = 5',
+                                       '  a = 6',
+                                       'end'])
         expect(method_length.offences).to be_empty
       end
 
       it 'checks class methods, syntax #1' do
-        inspect_source(method_length, '', ['def self.m()',
-                                           '  a = 1',
-                                           '  a = 2',
-                                           '  a = 3',
-                                           '  a = 4',
-                                           '  a = 5',
-                                           '  a = 6',
-                                           'end'])
+        inspect_source(method_length, ['def self.m()',
+                                       '  a = 1',
+                                       '  a = 2',
+                                       '  a = 3',
+                                       '  a = 4',
+                                       '  a = 5',
+                                       '  a = 6',
+                                       'end'])
         expect(method_length.offences.size).to eq(1)
         expect(method_length.offences.map(&:line_number).sort).to eq([1])
       end
 
       it 'checks class methods, syntax #2' do
-        inspect_source(method_length, '', ['class K',
-                                           '  class << self',
-                                           '    def m()',
-                                           '      a = 1',
-                                           '      a = 2',
-                                           '      a = 3',
-                                           '      a = 4',
-                                           '      a = 5',
-                                           '      a = 6',
-                                           '    end',
-                                           '  end',
-                                           'end'])
+        inspect_source(method_length, ['class K',
+                                       '  class << self',
+                                       '    def m()',
+                                       '      a = 1',
+                                       '      a = 2',
+                                       '      a = 3',
+                                       '      a = 4',
+                                       '      a = 5',
+                                       '      a = 6',
+                                       '    end',
+                                       '  end',
+                                       'end'])
         expect(method_length.offences.size).to eq(1)
         expect(method_length.offences.map(&:line_number).sort).to eq([3])
       end
 
       it 'properly counts lines when method ends with block' do
-        inspect_source(method_length, '', ['def m()',
-                                           '  something do',
-                                           '    a = 2',
-                                           '    a = 3',
-                                           '    a = 4',
-                                           '    a = 5',
-                                           '  end',
-                                           'end'])
+        inspect_source(method_length, ['def m()',
+                                       '  something do',
+                                       '    a = 2',
+                                       '    a = 3',
+                                       '    a = 4',
+                                       '    a = 5',
+                                       '  end',
+                                       'end'])
         expect(method_length.offences.size).to eq(1)
         expect(method_length.offences.map(&:line_number).sort).to eq([1])
       end
 
       it 'does not count commented lines by default' do
-        inspect_source(method_length, '', ['def m()',
-                                           '  a = 1',
-                                           '  #a = 2',
-                                           '  a = 3',
-                                           '  #a = 4',
-                                           '  a = 5',
-                                           '  a = 6',
-                                           'end'])
+        inspect_source(method_length, ['def m()',
+                                       '  a = 1',
+                                       '  #a = 2',
+                                       '  a = 3',
+                                       '  #a = 4',
+                                       '  a = 5',
+                                       '  a = 6',
+                                       'end'])
         expect(method_length.offences).to be_empty
       end
 
       it 'has the option of counting commented lines' do
         MethodLength.config['CountComments'] = true
-        inspect_source(method_length, '', ['def m()',
-                                           '  a = 1',
-                                           '  #a = 2',
-                                           '  a = 3',
-                                           '  #a = 4',
-                                           '  a = 5',
-                                           '  a = 6',
-                                           'end'])
+        inspect_source(method_length, ['def m()',
+                                       '  a = 1',
+                                       '  #a = 2',
+                                       '  a = 3',
+                                       '  #a = 4',
+                                       '  a = 5',
+                                       '  a = 6',
+                                       'end'])
         expect(method_length.offences.size).to eq(1)
         expect(method_length.offences.map(&:line_number).sort).to eq([1])
       end

data/spec/rubocop/cops/multiline_if_then_spec.rb

@@ -10,25 +10,25 @@ module Rubocop
       # 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 # bad',
-                                 'end'])
+        inspect_source(mit, ['if cond then',
+                             'end',
+                             "if cond then\t",
+                             'end',
+                             'if cond then  ',
+                             'end',
+                             'if cond then # bad',
+                             'end'])
         expect(mit.offences.map(&:line_number)).to eq([1, 3, 5, 7])
       end
 
       it 'accepts multiline if without then' do
-        inspect_source(mit, '', ['if cond',
-                                          'end'])
+        inspect_source(mit, ['if cond',
+                             'end'])
         expect(mit.offences.map(&:message)).to be_empty
       end
 
       it 'accepts table style if/then/elsif/ends' do
-        inspect_source(mit, '',
+        inspect_source(mit,
                        ['if    @io == $stdout then str << "$stdout"',
                         'elsif @io == $stdin  then str << "$stdin"',
                         'elsif @io == $stderr then str << "$stderr"',
@@ -40,15 +40,15 @@ module Rubocop
       # unless
 
       it 'registers an offence for then in multiline unless' do
-        inspect_source(mit, '', ['unless cond then',
-                                 'end'])
+        inspect_source(mit, ['unless cond then',
+                             'end'])
         expect(mit.offences.map(&:message)).to eq(
           ['Never use then for multi-line if/unless.'])
       end
 
       it 'accepts multiline unless without then' do
-        inspect_source(mit, '', ['unless cond',
-                                 'end'])
+        inspect_source(mit, ['unless cond',
+                             'end'])
         expect(mit.offences.map(&:message)).to be_empty
       end
     end

data/spec/rubocop/cops/new_lambda_literal_spec.rb

@@ -8,13 +8,13 @@ module Rubocop
       let(:lambda_literal) { NewLambdaLiteral.new }
 
       it 'registers an offence for an old lambda call' do
-        inspect_source(lambda_literal, 'file.rb', ['f = lambda { |x| x }'])
+        inspect_source(lambda_literal, ['f = lambda { |x| x }'])
         expect(lambda_literal.offences.size).to eq(1)
       end
 
       it 'accepts the new lambda literal' do
-        inspect_source(lambda_literal, 'file.rb', ['lambda = ->(x) { x }',
-                                              'lambda.(1)'])
+        inspect_source(lambda_literal, ['lambda = ->(x) { x }',
+                                   'lambda.(1)'])
         expect(lambda_literal.offences).to be_empty
       end
     end

data/spec/rubocop/cops/not_spec.rb

@@ -9,23 +9,20 @@ module Rubocop
 
       it 'registers an offence for not' do
         inspect_source(a,
-                       'file.rb',
                        ['not test'])
         expect(a.offences.size).to eq(1)
         expect(a.offences.map(&:message))
-          .to eq([Not::ERROR_MESSAGE])
+          .to eq([Not::MSG])
       end
 
       it 'does not register an offence for !' do
         inspect_source(a,
-                       'file.rb',
                        ['!test'])
         expect(a.offences).to be_empty
       end
 
       it 'does not register an offence for :not' do
         inspect_source(a,
-                       'file.rb',
                        ['[:not, :if, :else]'])
         expect(a.offences).to be_empty
       end

data/spec/rubocop/cops/numeric_literals_spec.rb

@@ -8,40 +8,40 @@ module Rubocop
       let(:num) { NumericLiterals.new }
 
       it 'registers an offence for a long integer without underscores' do
-        inspect_source(num, 'file.rb', ['a = 123456'])
+        inspect_source(num, ['a = 123456'])
         expect(num.offences.map(&:message)).to eq(
           ['Add underscores to large numeric literals to improve their ' +
            'readability.'])
       end
 
       it 'registers an offence for an integer with not enough underscores' do
-        inspect_source(num, 'file.rb', ['a = 123456_789000'])
+        inspect_source(num, ['a = 123456_789000'])
         expect(num.offences.map(&:message)).to eq(
           ['Add underscores to large numeric literals to improve their ' +
            'readability.'])
       end
 
-      it 'registers an offence for a long float without underscores' do
-        inspect_source(num, 'file.rb', ['a = 1.234567'])
-        expect(num.offences.map(&:message)).to eq(
-          ['Add underscores to large numeric literals to improve their ' +
-           'readability.'])
-      end
+      # it 'registers an offence for a long float without underscores' do
+      #   inspect_source(num, ['a = 1.234567'])
+      #   expect(num.offences.map(&:message)).to eq(
+      #     ['Add underscores to large numeric literals to improve their ' +
+      #      'readability.'])
+      # end
 
       it 'accepts long numbers with underscore' do
-        inspect_source(num, 'file.rb', ['a = 123_456',
-                                       'b = 1.234_56'])
+        inspect_source(num, ['a = 123_456',
+                             'b = 1.234_56'])
         expect(num.offences.map(&:message)).to be_empty
       end
 
       it 'accepts a short integer without underscore' do
-        inspect_source(num, 'file.rb', ['a = 123'])
+        inspect_source(num, ['a = 123'])
         expect(num.offences.map(&:message)).to be_empty
       end
 
       it 'accepts short numbers without underscore' do
-        inspect_source(num, 'file.rb', ['a = 123',
-                                       'b = 123.456'])
+        inspect_source(num, ['a = 123',
+                             'b = 123.456'])
         expect(num.offences.map(&:message)).to be_empty
       end
     end