rubocop 0.1.0 → 0.2.0

data/lib/rubocop/cop/encoding.rb

@@ -9,7 +9,7 @@ module Rubocop
       def inspect(file, source, tokens, sexp)
         unless source[0] =~ /#.*coding: (UTF|utf)-8/
           message = sprintf(ERROR_MESSAGE)
-          add_offence(:convention, 0, 0, message)
+          add_offence(:convention, 1, message)
         end
       end
     end

data/lib/rubocop/cop/end_of_line.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class EndOfLine < Cop
+      ERROR_MESSAGE = 'Carriage return character detected.'
+
+      def inspect(file, source, tokens, sexp)
+        source.each_with_index do |line, index|
+          if line =~ /\r$/
+            add_offence(:convention, index + 1, ERROR_MESSAGE)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/grammar.rb

@@ -1,13 +1,61 @@
+# encoding: utf-8
+
 module Rubocop
   module Cop
     class Grammar
       def initialize(tokens)
-        @tokens_without_pos = tokens.map { |tok| tok[1..-1] }
+        @tokens_without_pos = tokens.map { |t| [t.type, t.text] }
+        process_embedded_expressions
+        @token_indexes = {}
+        @tokens_without_pos.each_with_index { |t, i|
+          @token_indexes[t] ||= []
+          @token_indexes[t] << i
+        }
         @ix = 0
         @table = {}
-        token_positions = tokens.map { |tok| tok[0] }
+        token_positions = tokens.map { |t| [t.pos.lineno, t.pos.column] }
         @index_by_pos = Hash[*token_positions.each_with_index.to_a.flatten(1)]
-        @special = { assign: '=' }
+        @special = {
+          assign:      [:on_op,     '='],
+          brace_block: [:on_lbrace, '{']
+        }
+      end
+
+      # The string "#{x}" will give the tokens
+      # [:on_tstring_beg, '"'], [:on_embexpr_beg, '#{'], [:on_ident, 'x'],
+      # [:on_rbrace, '}'], [:on_tstring_end, '"']
+      # which is not so good for us. We want to distinguish between a
+      # right brace that ends an embedded expression inside a string
+      # and an ordinary right brace. So we replace :on_rbrace with the
+      # made up :on_embexpr_end.
+      def process_embedded_expressions
+        state = :outside
+        brace_depth = 0
+        @tokens_without_pos.each_with_index do |(type, _), ix|
+          case state
+          when :outside
+            state = :inside_string if type == :on_tstring_beg
+          when :inside_string
+            case type
+            when :on_tstring_end
+              state = :outside
+            when :on_embexpr_beg
+              brace_depth = 1
+              state = :inside_expr
+            end
+          when :inside_expr
+            case type
+            when :on_lbrace
+              brace_depth += 1
+            when :on_rbrace
+              if brace_depth == 1
+                @tokens_without_pos[ix][0] = :on_embexpr_end
+                state = :inside_string
+              end
+              brace_depth -= 1
+            end
+          end
+        end
       end
 
       # Returns a hash mapping indexes in the token array to grammar
@@ -28,14 +76,15 @@ module Rubocop
           when /^@/
             # Leaves in the grammar have a corresponding token with a
             # position, which we search for and advance @ix.
-            @ix = @index_by_pos[sexp[-1]]
+            @ix = @index_by_pos[[sexp[-1].lineno, sexp[-1].column]]
+            fail "#{sexp}\n#{@index_by_pos}" unless @ix
             @table[@ix] = path + [sexp[0]]
             @ix += 1
           when *@special.keys
             # Here we don't advance @ix because there may be other
             # tokens inbetween the current one and the one we get from
             # @special.
-            find(path, sexp, [:on_op, @special[sexp[0]]])
+            find(path, sexp, @special[sexp[0]])
           when :block_var # "{ |...|" or "do |...|"
             @ix = find(path, sexp, [:on_op, '|']) + 1
             find(path, sexp, [:on_op, '|'])
@@ -44,7 +93,7 @@ module Rubocop
           # Compensate for reverse order of if modifier
           children = (sexp[0] == :if_mod) ? sexp.reverse : sexp
 
-          children.each { |elem|
+          children.each do |elem|
             case elem
             when Array
               correlate(elem, path) # Dive deeper
@@ -56,7 +105,7 @@ module Rubocop
                 find(path, [elem], [:on_op, elem.to_s.chomp('@')])
               end
             end
-          }
+          end
         end
         @table
       end
@@ -64,11 +113,22 @@ module Rubocop
       private
 
       def find(path, sexp, token_to_find)
-        offset = @tokens_without_pos[@ix..-1].index(token_to_find) or return
-        ix = @ix + offset
+        indices = @token_indexes[token_to_find] or return
+        ix = indices.find { |i| i >= @ix } or return
         @table[ix] = path + [sexp[0]]
+        add_matching_rbrace(ix) if token_to_find == [:on_lbrace, '{']
         ix
       end
+
+      def add_matching_rbrace(ix)
+        brace_depth = 0
+        rbrace_offset = @tokens_without_pos[@ix..-1].index do |t|
+          brace_depth += 1 if t == [:on_lbrace, '{']
+          brace_depth -= 1 if t == [:on_rbrace, '}']
+          brace_depth == 0 && t == [:on_rbrace, '}']
+        end
+        @table[@ix + rbrace_offset] = @table[ix] if rbrace_offset
+      end
     end
   end
 end

data/lib/rubocop/cop/hash_syntax.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class HashSyntax < Cop
+      ERROR_MESSAGE = 'Ruby 1.8 hash syntax detected'
+
+      def inspect(file, source, tokens, sexp)
+        each(:assoclist_from_args, sexp) do |assoclist_from_args|
+          keys = assoclist_from_args[1].map { |assoc_new| assoc_new[1][0] }
+          # If at least one of the keys in the hash is neither a symbol (:a)
+          # nor a label (a:), we can't require the new syntax.
+          return if keys.find do |key|
+            not [:symbol_literal, :@label].include?(key)
+          end
+        end
+        each(:assoc_new, sexp) do |assoc_new|
+          if assoc_new[1][0] == :symbol_literal
+            add_offence(:convention, assoc_new[1][1][1][-1].lineno,
+                        ERROR_MESSAGE)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/if_then_else.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class IfThenElse < Cop
+      ERROR_MESSAGE = {
+        multiline_if_then:
+        'Never use then for multi-line if/unless.',
+        one_liner:
+        'Favor the ternary operator (?:) over if/then/else/end constructs.',
+        semicolon:
+        'Never use if x; Use the ternary operator instead.'
+      }
+
+      def inspect(file, source, tokens, sexp)
+        tokens.each_with_index do |t, ix|
+          if t.type == :on_kw && ['if', 'unless'].include?(t.text)
+            error = ERROR_MESSAGE[kind_of_if(tokens, ix + 1)]
+            add_offence(:convention, t.pos.lineno, error) if error
+          end
+        end
+      end
+
+      def kind_of_if(tokens, ix)
+        then_found = false
+        tokens[ix..-1].each do |t|
+          case t.type
+          when :on_kw
+            case t.text
+            when 'then' then then_found = true
+            when 'end'  then return :one_liner
+            end
+          when :on_ignored_nl, :on_nl
+            break
+          when :on_semicolon
+            return :semicolon
+          when :on_comment
+            break if t.text =~ /\n/
+          when :on_sp
+            nil
+          else
+            then_found = false
+          end
+        end
+        then_found ? :multiline_if_then : nil
+      end
+    end
+  end
+end

data/lib/rubocop/cop/indentation.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 module Rubocop
   module Cop
     class Indentation < Cop
@@ -6,49 +8,36 @@ module Rubocop
       def inspect(file, source, tokens, sexp)
         case_tokens = find_keywords(tokens, 'case')
         when_tokens = find_keywords(tokens, 'when')
-        each_when(sexp) { |case_ix|
-          when_pos = when_tokens.shift[0]
-          if when_pos[1] != case_tokens[case_ix][0][1]
-            index = when_pos[0] - 1
-            add_offence(:convention, index, source[index], ERROR_MESSAGE)
+        each_when(sexp) do |case_ix|
+          when_pos = when_tokens.shift.pos
+          if when_pos.column != case_tokens[case_ix].pos.column
+            add_offence(:convention, when_pos.lineno, ERROR_MESSAGE)
           end
-        }
+        end
       end
 
       def find_keywords(tokens, keyword)
-        indexes = tokens.each_index.find_all { |ix|
+        indexes = tokens.each_index.find_all do |ix|
           keyword?(tokens, ix, keyword)
-        }
+        end
         tokens.values_at(*indexes)
       end
 
       def keyword?(tokens, ix, keyword)
-        tokens[ix][1..-1] == [:on_kw, keyword] &&
-          tokens[ix - 1][1] != :on_symbeg
+        [tokens[ix].type, tokens[ix].text] == [:on_kw, keyword] &&
+          tokens[ix - 1].type != :on_symbeg
       end
 
       # Does a depth first search for :when, yielding the index of the
       # corresponding :case for each one.
       def each_when(sexp, case_ix = -1, &block)
-        case sexp[0]
-        when :case
-          case_ix += 1
-          case_ix = next_when(sexp, case_ix, &block)
-        when :when
-          yield case_ix
-          all_except_when = sexp.grep(Array).find_all { |s| s[0] != :when }
-          case_ix_deep = each_when(all_except_when, case_ix, &block)
-          case_ix_next = next_when(sexp, case_ix, &block)
-          case_ix = (case_ix_next == case_ix) ? case_ix_deep : case_ix_next
+        if sexp[0] == :case
+          @total_case_ix = (@total_case_ix || -1) + 1
+          each_when(sexp[2], @total_case_ix, &block)
         else
-          sexp.grep(Array).each { |s| case_ix = each_when(s, case_ix, &block) }
+          yield case_ix if sexp[0] == :when
+          sexp.grep(Array).each { |s| each_when(s, case_ix, &block) }
         end
-        case_ix
-      end
-
-      def next_when(sexp, case_ix, &block)
-        nxt = sexp.grep(Array).find { |s| s[0] == :when } or return case_ix
-        each_when(nxt, case_ix, &block)
       end
     end
   end

data/lib/rubocop/cop/line_length.rb

@@ -6,11 +6,11 @@ module Rubocop
       ERROR_MESSAGE = 'Line is too long. [%d/%d]'
       MAX_LINE_LENGTH = 79
 
-      def inspect(file, source)
+      def inspect(file, source, tokens, sexp)
         source.each_with_index do |line, index|
           if line.length > MAX_LINE_LENGTH
             message = sprintf(ERROR_MESSAGE, line.length, MAX_LINE_LENGTH)
-            add_offence(:convention, index, line, message)
+            add_offence(:convention, index + 1, message)
           end
         end
       end

data/lib/rubocop/cop/numeric_literals.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class NumericLiterals < Cop
+      ERROR_MESSAGE = 'Add underscores to large numeric literals to ' +
+        'improve their readability.'
+
+      def inspect(file, source, tokens, sexp)
+        tokens.each do |t|
+          if [:on_int, :on_float].include?(t.type) &&
+              t.text.split('.').grep(/\d{6}/).any?
+            add_offence(:convention, t.pos.lineno, ERROR_MESSAGE)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/offence.rb

@@ -3,14 +3,13 @@
 module Rubocop
   module Cop
     class Offence
-      attr_accessor :severity, :line_number, :line, :message
+      attr_accessor :severity, :line_number, :message
 
       SEVERITIES = [:refactor, :convention, :warning, :error, :fatal]
 
-      def initialize(severity, line_number, line, message)
+      def initialize(severity, line_number, message)
         @severity = severity
         @line_number = line_number
-        @line = line
         @message = message
       end
 

data/lib/rubocop/cop/space_after_comma_etc.rb

@@ -1,23 +1,24 @@
+# encoding: utf-8
+
 module Rubocop
   module Cop
     class SpaceAfterCommaEtc < Cop
       ERROR_MESSAGE = 'Space missing after %s.'
 
       def inspect(file, source, tokens, sexp)
-        tokens.each_index { |ix|
-          pos, name, text = tokens[ix]
-          kind = case name
+        tokens.each_index do |ix|
+          t = tokens[ix]
+          kind = case t.type
                  when :on_comma     then 'comma'
                  when :on_label     then 'colon'
-                 when :on_op        then 'colon' if text == ':'
+                 when :on_op        then 'colon' if t.text == ':'
                  when :on_semicolon then 'semicolon'
                  end
-          if kind and not [:on_sp, :on_ignored_nl].include?(tokens[ix + 1][1])
-            index = pos[0] - 1
-            add_offence(:convention, index, source[index],
-                        ERROR_MESSAGE % kind)
+          if kind and not [:on_sp,
+                           :on_ignored_nl].include?(tokens[ix + 1].type)
+            add_offence(:convention, t.pos.lineno, ERROR_MESSAGE % kind)
           end
-        }
+        end
       end
     end
   end

data/lib/rubocop/cop/surrounding_space.rb

@@ -1,32 +1,85 @@
+# encoding: utf-8
+
 require_relative 'grammar'
 
 module Rubocop
   module Cop
     class SurroundingSpace < Cop
-      ERROR_MESSAGE = 'Surrounding space missing for operator'
+      ERROR_MESSAGE = 'Surrounding space missing for '
 
       def inspect(file, source, tokens, sexp)
-        Grammar.new(tokens).correlate(sexp).sort.each { |ix, grammar_path|
-          pos, name, text = tokens[ix]
-          if name == :on_op
+        Grammar.new(tokens).correlate(sexp).sort.each do |ix, grammar_path|
+          t = tokens[ix]
+          case t.type
+          when :on_op
             unless surrounded_by_whitespace?(tokens[ix - 1, 3])
               unless ok_without_spaces?(grammar_path)
-                index = pos[0] - 1
-                add_offence(:convention, index, source[index],
-                            ERROR_MESSAGE + " '#{text}'.")
+                add_offence(:convention, t.pos.lineno,
+                            ERROR_MESSAGE + "operator '#{t.text}'.")
               end
             end
+          when :on_lbrace
+            unless surrounded_by_whitespace?(tokens[ix - 1, 3])
+              add_offence(:convention, t.pos.lineno, ERROR_MESSAGE + "'{'.")
+            end
+          when :on_rbrace
+            unless whitespace?(tokens[ix - 1])
+              add_offence(:convention, t.pos.lineno,
+                          "Space missing to the left of '}'.")
+            end
+          end
+        end
+        tokens.each_index do |ix|
+          t = tokens[ix]
+          prev, nxt = tokens.values_at(ix - 1, ix + 1)
+          offence_detected = case t.type
+                             when :on_lbracket, :on_lparen
+                               nxt.type == :on_sp
+                             when :on_rbracket, :on_rparen
+                               if prev.type == :on_sp
+                                 prev_ns = previous_non_space(tokens, ix)
+                                 prev_ns && tokens_on_same_row?(prev_ns,
+                                                                tokens[ix]) &&
+                                   # Avoid double repoting of [ ] and ( )
+                                   prev_ns.type != :on_lbracket &&
+                                   prev_ns.type != :on_lparen
+                               end
+                             when :on_op
+                               t.text == '**' &&
+                                 (whitespace?(prev) || whitespace?(nxt))
+                             end
+          if offence_detected
+            kind = case t.type
+                   when :on_lparen, :on_rparen
+                     'inside parentheses'
+                   when :on_lbracket, :on_rbracket
+                     'inside square brackets'
+                   when :on_op
+                     "around operator #{t.text}"
+                   end
+            add_offence(:convention, t.pos.lineno, "Space #{kind} detected.")
           end
-        }
+        end
+      end
+
+      private
+
+      def tokens_on_same_row?(t1, t2)
+        t1.pos.lineno == t2.pos.lineno
+      end
+
+      def previous_non_space(tokens, ix)
+        (ix - 1).downto(0) do |i|
+          t = tokens[i]
+          return t unless whitespace?(t)
+        end
+        nil
       end
 
       def ok_without_spaces?(grammar_path)
-        grandparent, parent, child = grammar_path.values_at(-3, -2, -1)
+        parent, child = grammar_path.values_at(-2, -1)
         return true if [:unary, :symbol, :defs, :def, :call].include?(parent)
-        return true if [:rest_param, :blockarg, :block_var, :args_add_star,
-                        :args_add_block, :const_path_ref, :dot2,
-                        :dot3].include?(child)
-        return true if grandparent == :unary && parent == :vcall
+        return true if [:**, :block_var].include?(child)
         return true if parent == :command_call && child == :'::'
         false
       end
@@ -35,10 +88,6 @@ module Rubocop
         left, _, right = nearby_tokens
         whitespace?(left) && whitespace?(right)
       end
-
-      def whitespace?(token)
-        [:on_sp, :on_ignored_nl, :on_nl].include?(token[1])
-      end
     end
   end
 end