rubocop 0.4.0 → 0.8.0

data/spec/rubocop/cops/method_length_spec.rb

@@ -0,0 +1,147 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe MethodLength do
+      let(:method_length) { MethodLength.new }
+      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'])
+        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'])
+        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'])
+        expect(method_length.offences).to be_empty
+      end
+
+      it 'accepts empty methods' do
+        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'])
+        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'])
+        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'])
+        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'])
+        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'])
+        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'])
+        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'])
+        expect(method_length.offences.size).to eq(1)
+        expect(method_length.offences.map(&:line_number).sort).to eq([1])
+      end
+    end
+  end
+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,15 +8,14 @@ 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 }'])
-        expect(lambda_literal.offences.map(&:message)).to eq(
-          ['The new lambda literal syntax is preferred in Ruby 1.9.'])
+        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)'])
-        expect(lambda_literal.offences.map(&:message)).to be_empty
+        inspect_source(lambda_literal, ['lambda = ->(x) { x }',
+                                   'lambda.(1)'])
+        expect(lambda_literal.offences).to be_empty
       end
     end
   end

data/spec/rubocop/cops/not_spec.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe Not do
+      let(:a) { Not.new }
+
+      it 'registers an offence for not' do
+        inspect_source(a,
+                       ['not test'])
+        expect(a.offences.size).to eq(1)
+        expect(a.offences.map(&:message))
+          .to eq([Not::MSG])
+      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 :not' do
+        inspect_source(a,
+                       ['[:not, :if, :else]'])
+        expect(a.offences).to be_empty
+      end
+    end
+  end
+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

data/spec/rubocop/cops/offence_spec.rb

@@ -18,6 +18,19 @@ module Rubocop
 
         expect(offence.to_s).to eq('C:  1: message')
       end
+
+      it 'does not blow up if a message contains %' do
+        offence = Offence.new(:convention, 1, 'message % test')
+
+        expect(offence.to_s).to eq('C:  1: message % test')
+      end
+
+      it 'redefines == to compare offences based on their contents' do
+        o1 = Offence.new(:test, 1, 'message')
+        o2 = Offence.new(:test, 1, 'message')
+
+        expect(o1 == o2).to be_true
+      end
     end
   end
 end

data/spec/rubocop/cops/one_line_conditional_spec.rb

@@ -8,7 +8,7 @@ module Rubocop
       let(:olc) { OneLineConditional.new }
 
       it 'registers an offence for one line if/then/end' do
-        inspect_source(olc, '', ['if cond then run else dont end'])
+        inspect_source(olc, ['if cond then run else dont end'])
         expect(olc.offences.map(&:message)).to eq([olc.error_message])
       end
     end

data/spec/rubocop/cops/op_method_spec.rb

@@ -0,0 +1,78 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe OpMethod do
+      let(:om) { OpMethod.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.offences.map(&:message))
+          .to eq([sprintf(OpMethod::MSG, '+')])
+      end
+
+      it 'works properly even if the argument is not surrounded with braces' do
+        inspect_source(om,
+                       ['def + another',
+                        '  another',
+                        'end'])
+        expect(om.offences.size).to eq(1)
+        expect(om.offences.map(&:message))
+          .to eq([sprintf(OpMethod::MSG, '+')])
+      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 []' 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(om,
+                       ['def []=(index, value)',
+                        '  other',
+                        'end'])
+        expect(om.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 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
+end

data/spec/rubocop/cops/parameter_lists_spec.rb

@@ -8,16 +8,16 @@ module Rubocop
       let(:list) { ParameterLists.new }
 
       it 'registers an offence for a method def with 5 parameters' do
-        inspect_source(list, 'file.rb', ['def meth(a, b, c, d, e)',
-                                         'end'])
-        expect(list.offences.map(&:message)).to eq(
-          ['Avoid parameter lists longer than four parameters.'])
+        inspect_source(list, ['def meth(a, b, c, d, e)',
+                              'end'])
+        expect(list.messages).to eq(
+          ['Avoid parameter lists longer than 4 parameters.'])
       end
 
       it 'accepts a method def with 4 parameters' do
-        inspect_source(list, 'file.rb', ['def meth(a, b, c, d)',
-                                         'end'])
-        expect(list.offences.map(&:message)).to be_empty
+        inspect_source(list, ['def meth(a, b, c, d)',
+                              'end'])
+        expect(list.offences).to be_empty
       end
     end
   end

data/spec/rubocop/cops/parentheses_around_condition_spec.rb

@@ -8,57 +8,54 @@ module Rubocop
       let(:pac) { ParenthesesAroundCondition.new }
 
       it 'registers an offence for parentheses around condition' do
-        inspect_source(pac, 'file.rb', ['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(pac.offences.map(&:message)).to eq(
-          ["Don't use parentheses around the condition of an if/unless/" +
-           'while/until, unless the condition contains an assignment.'] * 9)
+        inspect_source(pac, ['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(pac.offences.size).to eq(9)
       end
 
       it 'accepts condition without parentheses' do
-        inspect_source(pac, 'file.rb', ['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(pac.offences.map(&:message)).to be_empty
+        inspect_source(pac, ['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(pac.offences).to be_empty
       end
 
-      # Parentheses are sometimes used to help the editor make nice
-      # indentation of conditions spanning several lines.
-      it 'accepts parentheses around multiline conditions' do
-        inspect_source(pac, 'file.rb', ['if (@lex_state != EXPR_BEG &&',
-                                        '    @lex_state != EXPR_FNAME &&',
-                                        '    trans[1])',
-                                        'end'])
-        expect(pac.offences.map(&:message)).to be_empty
+      it 'is not confused by leading brace in subexpression' do
+        inspect_source(pac, ['(a > b) && other ? one : two'])
+        expect(pac.offences).to be_empty
       end
 
-      it 'accepts parentheses around assignment' do
-        inspect_source(pac, 'file.rb', ['if (x = self.next_value)',
-                                        'end'])
-        expect(pac.offences.map(&:message)).to be_empty
-      end
+      # Parentheses are sometimes used to help the editor make nice
+      # indentation of conditions spanning several lines.
+      # it 'accepts parentheses around multiline conditions' do
+      #   inspect_source(pac, ['if (@lex_state != EXPR_BEG &&',
+      #                        '    @lex_state != EXPR_FNAME &&',
+      #                        '    trans[1])',
+      #                        'end'])
+      #   expect(pac.offences.map(&:message)).to be_empty
+      # end
     end
   end
 end

data/spec/rubocop/cops/percent_r_spec.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe PercentR do
+      let(:apr) { PercentR.new }
+
+      it 'registers an offence for %r with zero or one slash in regexp' do
+        inspect_source(apr, ['x =~ %r(/home)',
+                             'y =~ %r(etc)'])
+        expect(apr.offences.map(&:message))
+          .to eq([PercentR::MSG] * 2)
+      end
+
+      it 'accepts %r with at least two slashes in regexp' do
+        inspect_source(apr, ['x =~ %r(/home/)',
+                             'y =~ %r(/////)'])
+        expect(apr.offences.map(&:message)).to be_empty
+      end
+
+      it 'accepts slash delimiters for regexp' do
+        inspect_source(apr, ['x =~ /\/home/'])
+        expect(apr.offences.map(&:message)).to be_empty
+      end
+    end
+  end
+end

data/spec/rubocop/cops/reduce_arguments_spec.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe ReduceArguments do
+      let(:reduce_arguments) { ReduceArguments.new }
+
+      it 'find wrong argument names in calls with different syntax' do
+        inspect_source(reduce_arguments,
+                       ['def m',
+                        '  [0, 1].reduce { |c, d| c + d }',
+                        '  [0, 1].reduce{ |c, d| c + d }',
+                        '  [0, 1].reduce(5) { |c, d| c + d }',
+                        '  [0, 1].reduce(5){ |c, d| c + d }',
+                        '  [0, 1].reduce (5) { |c, d| c + d }',
+                        '  [0, 1].reduce(5) { |c, d| c + d }',
+                        'end'])
+        expect(reduce_arguments.offences.size).to eq(6)
+        expect(reduce_arguments.offences
+                               .map(&:line_number).sort).to eq((2..7).to_a)
+      end
+
+      it 'allows calls with proper argument names' do
+        inspect_source(reduce_arguments,
+                       ['def m',
+                        '  [0, 1].reduce { |a, e| a + e }',
+                        '  [0, 1].reduce{ |a, e| a + e }',
+                        '  [0, 1].reduce(5) { |a, e| a + e }',
+                        '  [0, 1].reduce(5){ |a, e| a + e }',
+                        '  [0, 1].reduce (5) { |a, e| a + e }',
+                        '  [0, 1].reduce(5) { |a, e| a + e }',
+                        'end'])
+        expect(reduce_arguments.offences).to be_empty
+      end
+
+      it 'ignores do..end blocks' do
+        inspect_source(reduce_arguments,
+                       ['def m',
+                        '  [0, 1].reduce do |c, d|',
+                        '    c + d',
+                        '  end',
+                        'end'])
+        expect(reduce_arguments.offences).to be_empty
+      end
+
+      it 'ignores :reduce symbols' do
+        inspect_source(reduce_arguments,
+                       ['def m',
+                        '  call_method(:reduce) { |a, b| a + b}',
+                        'end'])
+        expect(reduce_arguments.offences).to be_empty
+      end
+    end
+  end
+end