rubocop 0.1.0 → 0.2.0

data/spec/rubocop/cops/end_of_line_spec.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe EndOfLine do
+      let (:eol) { EndOfLine.new }
+
+      it 'registers an offence for CR+LF' do
+        inspect_source(eol, 'file.rb', ["x=0\r", ''])
+        eol.offences.map(&:message).should ==
+          ['Carriage return character detected.']
+      end
+    end
+  end
+end

data/spec/rubocop/cops/grammar_spec.rb

@@ -1,22 +1,62 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 module Rubocop
   module Cop
     describe Grammar do
-      EXAMPLE = '3.times { |i| x = i }'
-      let (:grammar) { Grammar.new(Ripper.lex(EXAMPLE)) }
+      EXAMPLE = '3.times { |i| x = "#{y}#{z}}" }'
+      tokens = Ripper.lex(EXAMPLE).map { |t| Token.new(*t) }
+      let (:grammar) { Grammar.new(tokens) }
 
       it "correlates token indices to grammar paths" do
         method_block = [:program, :method_add_block]
-        grammar.correlate(Ripper.sexp(EXAMPLE)).should == {
-          0  => method_block + [:call, :@int],
-          2  => method_block + [:call, :@ident],
-          6  => method_block + [:brace_block, :block_var],
-          7  => method_block + [:brace_block, :block_var, :params, :@ident],
-          8  => method_block + [:brace_block, :block_var],
-          10 => method_block + [:brace_block, :assign, :var_field, :@ident],
-          12 => method_block + [:brace_block, :assign],
-          14 => method_block + [:brace_block, :assign, :var_ref, :@ident],
+        brace_block = method_block + [:brace_block]
+        Ripper.lex(EXAMPLE).should ==
+          [[[1, 0], :on_int, "3"],
+           [[1, 1], :on_period, "."],
+           [[1, 2], :on_ident, "times"],
+           [[1, 7], :on_sp, " "],
+           [[1, 8], :on_lbrace, "{"],
+           [[1, 9], :on_sp, " "], # 5
+           [[1, 10], :on_op, "|"],
+           [[1, 11], :on_ident, "i"],
+           [[1, 12], :on_op, "|"],
+           [[1, 13], :on_sp, " "],
+           [[1, 14], :on_ident, "x"], # 10
+           [[1, 15], :on_sp, " "],
+           [[1, 16], :on_op, "="],
+           [[1, 17], :on_sp, " "],
+           [[1, 18], :on_tstring_beg, "\""],
+           [[1, 19], :on_embexpr_beg, "\#{"], # 15
+           [[1, 21], :on_ident, "y"],
+           [[1, 22], :on_rbrace, "}"],
+           [[1, 23], :on_embexpr_beg, "\#{"],
+           [[1, 25], :on_ident, "z"],
+           [[1, 26], :on_rbrace, "}"], # 20
+           [[1, 27], :on_tstring_content, "}"],
+           [[1, 28], :on_tstring_end, "\""],
+           [[1, 29], :on_sp, " "],
+           [[1, 30], :on_rbrace, "}"]]
+
+        sexp = Ripper.sexp(EXAMPLE)
+        Position.make_position_objects(sexp)
+        grammar.correlate(sexp).should == {
+          0  => method_block + [:call, :@int],                    # 3
+          2  => method_block + [:call, :@ident],                  # times
+          4  => brace_block,                                      # {
+          6  => brace_block + [:block_var],                       # |
+          7  => brace_block + [:block_var, :params, :@ident],     # i
+          8  => brace_block + [:block_var],                       # |
+          10 => brace_block + [:assign, :var_field, :@ident],     # x
+          12 => brace_block + [:assign],                          # =
+          16 => brace_block + [:assign, :string_literal, :string_content,
+                               :string_embexpr, :vcall, :@ident], # y
+          19 => brace_block + [:assign, :string_literal, :string_content,
+                               :string_embexpr, :vcall, :@ident], # z
+          21 => brace_block + [:assign, :string_literal, :string_content,
+                               :@tstring_content],                # }
+          24 => brace_block,                                      # }
         }
       end
     end

data/spec/rubocop/cops/hash_syntax_spec.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe HashSyntax do
+      let (:hash_syntax) { HashSyntax.new }
+
+      it 'registers an offence for hash rocket syntax when new is possible' do
+        inspect_source(hash_syntax, "", ['x = { :a => 0 }'])
+        hash_syntax.offences.map(&:message).should ==
+          ['Ruby 1.8 hash syntax detected']
+      end
+
+      it 'registers an offence for mixed syntax when new is possible' do
+        inspect_source(hash_syntax, "", ['x = { :a => 0, b: 1 }'])
+        hash_syntax.offences.map(&:message).should ==
+          ['Ruby 1.8 hash syntax detected']
+      end
+
+      it 'registers an offence for hash rockets in method calls' do
+        inspect_source(hash_syntax, "", ['func(3, :a => 0)'])
+        hash_syntax.offences.map(&:message).should ==
+          ['Ruby 1.8 hash syntax detected']
+      end
+
+      it 'accepts hash rockets when keys have different types' do
+        inspect_source(hash_syntax, "", ['x = { :a => 0, "b" => 1 }'])
+        hash_syntax.offences.map(&:message).should == []
+      end
+
+      it 'accepts new syntax in a hash literal' do
+        inspect_source(hash_syntax, "", ['x = { a: 0, b: 1 }'])
+        hash_syntax.offences.map(&:message).should == []
+      end
+
+      it 'accepts new syntax in method calls' do
+        inspect_source(hash_syntax, "", ['func(3, a: 0)'])
+        hash_syntax.offences.map(&:message).should == []
+      end
+    end
+  end
+end

data/spec/rubocop/cops/if_then_else_spec.rb

@@ -0,0 +1,74 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe IfThenElse do
+      let (:if_then_else) { IfThenElse.new }
+
+      # if
+
+      it 'registers an offence for then in multiline if' do
+        inspect_source(if_then_else, '', ['if cond then',
+                                          'end',
+                                          "if cond then\t",
+                                          'end',
+                                          "if cond then  ",
+                                          'end',
+                                          'if cond then # bad',
+                                          'end'])
+        if_then_else.offences.size.should == 4
+      end
+
+      it 'accepts multiline if without then' do
+        inspect_source(if_then_else, '', ['if cond',
+                                          'end'])
+        if_then_else.offences.map(&:message).sort.should == []
+      end
+
+      it 'registers an offence for one line if/then/end' do
+        inspect_source(if_then_else, '', ['if cond then run else dont end'])
+        if_then_else.offences.map(&:message).sort.should ==
+          ['Favor the ternary operator (?:) over if/then/else/end constructs.']
+      end
+
+      it 'registers an offence for one line if/;/end' do
+        inspect_source(if_then_else, '', ['if cond; run else dont end'])
+        if_then_else.offences.map(&:message).sort.should ==
+          ['Never use if x; Use the ternary operator instead.']
+      end
+
+      it 'accepts table style if/then/elsif/ends' do
+        inspect_source(if_then_else, '',
+                       ['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'])
+        if_then_else.offences.map(&:message).sort.should == []
+      end
+
+      # unless
+
+      it 'registers an offence for then in multiline unless' do
+        inspect_source(if_then_else, '', ['unless cond then',
+                                          'end'])
+        if_then_else.offences.map(&:message).sort.should ==
+          ['Never use then for multi-line if/unless.']
+      end
+
+      it 'accepts multiline unless without then' do
+        inspect_source(if_then_else, '', ['unless cond',
+                                          'end'])
+        if_then_else.offences.map(&:message).sort.should == []
+      end
+
+      it 'registers an offence for one line unless/then/ends' do
+        inspect_source(if_then_else, '', ['unless cond then run end'])
+        if_then_else.offences.map(&:message).sort.should ==
+          ['Favor the ternary operator (?:) over if/then/else/end constructs.']
+      end
+    end
+  end
+end

data/spec/rubocop/cops/indentation_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 module Rubocop
@@ -12,7 +14,7 @@ module Rubocop
                   '         when 1 then return',
                   '        end',
                   'end']
-        ind.inspect_source('file.rb', source)
+        inspect_source(ind, 'file.rb', source)
         ind.offences.size.should == 2
       end
 
@@ -29,7 +31,7 @@ module Rubocop
                   'when 2 then encoding',
                   'end',
                   '']
-        ind.inspect_source('file.rb', source)
+        inspect_source(ind, 'file.rb', source)
         ind.offences.size.should == 0
       end
 
@@ -39,7 +41,7 @@ module Rubocop
                   'when 0',
                   'end',
                   '']
-        ind.inspect_source('file.rb', source)
+        inspect_source(ind, 'file.rb', source)
         ind.offences.map(&:message).should == []
       end
 
@@ -52,7 +54,30 @@ module Rubocop
                   '  MethodCallNode',
                   'end',
                   '']
-        ind.inspect_source('file.rb', source)
+        inspect_source(ind, 'file.rb', source)
+        ind.offences.map(&:message).should == []
+      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, 'file.rb', source)
         ind.offences.map(&:message).should == []
       end
     end

data/spec/rubocop/cops/line_length_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 module Rubocop
@@ -6,13 +8,13 @@ module Rubocop
       let (:ll) { LineLength.new }
 
       it "registers an offence for a line that's 80 characters wide" do
-        ll.inspect('file.rb', ['#' * 80])
+        ll.inspect('file.rb', ['#' * 80], nil, nil)
         ll.offences.size.should == 1
         ll.offences.first.message.should == 'Line is too long. [80/79]'
       end
 
       it "accepts a line that's 79 characters wide" do
-        ll.inspect('file.rb', ['#' * 79])
+        ll.inspect('file.rb', ['#' * 79], nil, nil)
         ll.offences.size.should == 0
       end
     end

data/spec/rubocop/cops/numeric_literals_spec.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe NumericLiterals do
+      let (:num) { NumericLiterals.new }
+
+      it "registers an offence for a long integer without underscores" do
+        inspect_source(num, 'file.rb', ['a = 123456'])
+        num.offences.map(&:message).should ==
+          ['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'])
+        num.offences.map(&:message).should ==
+          ['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'])
+        num.offences.map(&:message).should ==
+          ['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'])
+        num.offences.map(&:message).should == []
+      end
+
+      it "accepts a short integer without underscore" do
+        inspect_source(num, 'file.rb', ['a = 123'])
+        num.offences.map(&:message).should == []
+      end
+
+      it "accepts short numbers without underscore" do
+        inspect_source(num, 'file.rb', ['a = 123',
+                                       'b = 123.456'])
+        num.offences.map(&:message).should == []
+      end
+    end
+  end
+end

data/spec/rubocop/cops/offence_spec.rb

@@ -1,19 +1,20 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 module Rubocop
   module Cop
     describe Offence do
       it 'has a few required attributes' do
-        offence = Offence.new(:convention, 1, 'line', 'message')
+        offence = Offence.new(:convention, 1, 'message')
 
         offence.severity.should == :convention
         offence.line_number.should == 1
-        offence.line.should == 'line'
         offence.message.should == 'message'
       end
 
       it 'overrides #to_s' do
-        offence = Offence.new(:convention, 1, 'line', 'message')
+        offence = Offence.new(:convention, 1, 'message')
 
         offence.to_s.should == 'C:  1: message'
       end

data/spec/rubocop/cops/space_after_comma_etc_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 module Rubocop
@@ -6,30 +8,30 @@ module Rubocop
       let (:space) { SpaceAfterCommaEtc.new }
 
       it 'registers an offence for block argument commas' do
-        space.inspect_source('file.rb', ['each { |s,t| }'])
+        inspect_source(space, 'file.rb', ['each { |s,t| }'])
         space.offences.map(&:message).should ==
           ['Space missing after comma.']
       end
 
       it 'registers an offence for colon without space after it' do
-        space.inspect_source('file.rb', ['x = w ? {a:3}:4'])
+        inspect_source(space, 'file.rb', ['x = w ? {a:3}:4'])
         space.offences.map(&:message).should ==
           ['Space missing after colon.'] * 2
       end
 
       it 'registers an offence for semicolon without space after it' do
-        space.inspect_source('file.rb', ['x = 1;y = 2'])
+        inspect_source(space, 'file.rb', ['x = 1;y = 2'])
         space.offences.map(&:message).should ==
           ['Space missing after semicolon.']
       end
 
       it 'allows the colons in symbols' do
-        space.inspect_source('file.rb', ['x = :a'])
+        inspect_source(space, 'file.rb', ['x = :a'])
         space.offences.map(&:message).should == []
       end
 
       it 'allows colons in strings' do
-        space.inspect_source('file.rb', ["str << ':'"])
+        inspect_source(space, 'file.rb', ["str << ':'"])
         space.offences.map(&:message).should == []
       end
     end

data/spec/rubocop/cops/surrounding_space_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 module Rubocop
@@ -6,63 +8,107 @@ module Rubocop
       let (:space) { SurroundingSpace.new }
 
       it 'registers an offence for assignment without space on both sides' do
-        space.inspect_source('file.rb', ['x=0', 'y= 0', 'z =0'])
+        inspect_source(space, 'file.rb', ['x=0', 'y= 0', 'z =0'])
         space.offences.size.should == 3
         space.offences.first.message.should ==
           "Surrounding space missing for operator '='."
       end
 
       it 'registers an offence for binary operators that could be unary' do
-        space.inspect_source('file.rb', ['a-3', 'x&0xff', 'z+0'])
+        inspect_source(space, 'file.rb', ['a-3', 'x&0xff', 'z+0'])
         space.offences.map(&:message).should ==
           ["Surrounding space missing for operator '-'.",
            "Surrounding space missing for operator '&'.",
            "Surrounding space missing for operator '+'."]
       end
 
+      it 'registers an offence for left brace without spaces' do
+        inspect_source(space, 'file.rb', ['each{ puts }'])
+        space.offences.map(&:message).should ==
+          ["Surrounding space missing for '{'."]
+      end
+
+      it 'registers an offence for right brace without inner space' do
+        inspect_source(space, 'file.rb', ['each { puts}'])
+        space.offences.map(&:message).should ==
+          ["Space missing to the left of '}'."]
+      end
+
+      it 'accepts an empty hash literal with no space inside' do
+        inspect_source(space, 'file.rb',
+                       ['view_hash.each do |view_key|',
+                        'end',
+                        '@views = {}',
+                        ''])
+        space.offences.map(&:message).should == []
+      end
+
       it 'registers an offence for arguments to a method' do
-        space.inspect_source('file.rb', ['puts 1+2'])
+        inspect_source(space, 'file.rb', ['puts 1+2'])
         space.offences.map(&:message).should ==
           ["Surrounding space missing for operator '+'."]
       end
 
+      it 'registers an offence for an array literal with spaces inside' do
+        inspect_source(space, 'file.rb', ['a = [1, 2 ]',
+                                         'b = [ 1, 2]'])
+        space.offences.map(&:message).should ==
+          ['Space inside square brackets detected.',
+           'Space inside square brackets detected.']
+      end
+
+      it 'accepts space inside square brackets if on its own row' do
+        inspect_source(space, 'file.rb', ['a = [',
+                                         '     1, 2',
+                                         '    ]'])
+        space.offences.map(&:message).should == []
+      end
+
+      it 'registers an offence for spaces inside parens' do
+        inspect_source(space, 'file.rb', ['f( 3)',
+                                         'g(3 )'])
+        space.offences.map(&:message).should ==
+          ['Space inside parentheses detected.',
+           'Space inside parentheses detected.']
+      end
+
       it 'accepts parentheses in block parameter list' do
-        space.inspect_source('file.rb',
-                             ['list.inject(Tms.new) { |sum, (label, item)|',
-                              '}'])
+        inspect_source(space, 'file.rb',
+                       ['list.inject(Tms.new) { |sum, (label, item)|',
+                        '}'])
         space.offences.map(&:message).should == []
       end
 
       it 'accepts operator symbols' do
-        space.inspect_source('file.rb', ['func(:-)'])
+        inspect_source(space, 'file.rb', ['func(:-)'])
         space.offences.map(&:message).should == []
       end
 
       it 'accepts ranges' do
-        space.inspect_source('file.rb', ['a, b = (1..2), (1...3)'])
+        inspect_source(space, 'file.rb', ['a, b = (1..2), (1...3)'])
         space.offences.map(&:message).should == []
       end
 
       it 'accepts scope operator' do
         source = ['@io.class == Zlib::GzipWriter']
-        space.inspect_source('file.rb', source)
+        inspect_source(space, 'file.rb', source)
         space.offences.map(&:message).should == []
       end
 
       it 'accepts ::Kernel::raise' do
         source = ['::Kernel::raise IllegalBlockError.new']
-        space.inspect_source('file.rb', source)
+        inspect_source(space, 'file.rb', source)
         space.offences.map(&:message).should == []
       end
 
       it 'accepts exclamation point negation' do
-        space.inspect_source('file.rb', ['x = !a&&!b'])
+        inspect_source(space, 'file.rb', ['x = !a&&!b'])
         space.offences.map(&:message).should ==
           ["Surrounding space missing for operator '&&'."]
       end
 
       it 'accepts exclamation point definition' do
-        space.inspect_source('file.rb', ['  def !',
+        inspect_source(space, 'file.rb', ['  def !',
                                          '    !__getobj__',
                                          '  end'])
         space.offences.should == []
@@ -70,59 +116,76 @@ module Rubocop
       end
 
       it 'accepts a unary' do
-        space.inspect_source('file.rb',
-                             ['  def bm(label_width = 0, *labels, &blk)',
-                              '    benchmark(CAPTION, label_width, FORMAT,',
-                              '              *labels, &blk)',
-                              '  end',
-                              ''])
+        inspect_source(space, 'file.rb',
+                       ['  def bm(label_width = 0, *labels, &blk)',
+                        '    benchmark(CAPTION, label_width, FORMAT,',
+                        '              *labels, &blk)',
+                        '  end',
+                        ''])
         space.offences.map(&:message).should == []
       end
 
       it 'accepts splat operator' do
-        space.inspect_source('file.rb', ['return *list if options'])
+        inspect_source(space, 'file.rb', ['return *list if options'])
         space.offences.map(&:message).should == []
       end
 
       it 'accepts square brackets as method name' do
-        space.inspect_source('file.rb', ['def Vector.[](*array)',
+        inspect_source(space, 'file.rb', ['def Vector.[](*array)',
                                          'end'])
         space.offences.map(&:message).should == []
       end
 
       it 'accepts def of operator' do
-        space.inspect_source('file.rb', ['def +(other); end'])
+        inspect_source(space, 'file.rb', ['def +(other); end'])
         space.offences.map(&:message).should == []
       end
 
       it 'accepts an assignment with spaces' do
-        space.inspect_source('file.rb', ['x = 0'])
+        inspect_source(space, 'file.rb', ['x = 0'])
         space.offences.size.should == 0
       end
 
       it "accepts some operators that are exceptions and don't need spaces" do
-        space.inspect_source('file.rb', ['(1..3)',
+        inspect_source(space, 'file.rb', ['(1..3)',
                                          'ActionController::Base',
                                          'each { |s, t| }'])
         space.offences.map(&:message).should == []
       end
 
       it 'accepts an assignment followed by newline' do
-        space.inspect_source('file.rb', ['x =\n  0'])
+        inspect_source(space, 'file.rb', ['x =\n  0'])
+        space.offences.size.should == 0
+      end
+
+      it 'registers an offences for exponent operator with spaces' do
+        inspect_source(space, 'file.rb', ['x = a * b ** 2'])
+        space.offences.map(&:message).should ==
+          ["Space around operator ** detected."]
+      end
+
+      it 'accepts exponent operator without spaces' do
+        inspect_source(space, 'file.rb', ['x = a * b**2'])
         space.offences.size.should == 0
       end
 
       it 'accepts unary operators without space' do
-        space.inspect_source('file.rb', ['[].map(&:size)',
+        inspect_source(space, 'file.rb', ['[].map(&:size)',
                                          '-3',
                                          'x = +2'])
         space.offences.map(&:message).should == []
       end
 
       it 'accepts square brackets called with method call syntax' do
-        space.inspect_source('file.rb', ['subject.[](0)'])
+        inspect_source(space, 'file.rb', ['subject.[](0)'])
         space.offences.map(&:message).should == []
       end
+
+      it 'only reports a single space once' do
+        inspect_source(space, 'file.rb', ['[ ]'])
+        space.offences.map(&:message).should ==
+          ['Space inside square brackets detected.']
+      end
     end
   end
 end