rubocop 0.4.0 → 0.8.0

data/lib/rubocop/cop/cop.rb

@@ -2,37 +2,24 @@
 
 module Rubocop
   module Cop
-    class Position < Struct.new :lineno, :column
-      # Does a recursive search and replaces each [lineno, column] array
-      # in the sexp with a Position object.
-      def self.make_position_objects(sexp)
-        if sexp[0] =~ /^@/
-          sexp[2] = Position.new(*sexp[2])
-        else
-          sexp.grep(Array).each { |s| make_position_objects(s) }
-        end
-      end
-
-      # The point of this class is to provide named attribute access.
-      # So we don't want backwards compatibility with array indexing.
-      undef_method :[]
-    end
-
     class Token
       attr_reader :pos, :type, :text
 
       def initialize(pos, type, text)
-        @pos, @type, @text = Position.new(*pos), type, text
+        @pos, @type, @text = pos, type, text
       end
 
       def to_s
-        "[[#{@pos.lineno}, #{@pos.column}], #@type, #{@text.inspect}]"
+        "[[#{@pos.line}, #{@pos.column}], #{@type}, #{@text.inspect}]"
       end
     end
 
-    class Cop
+    class Cop < Parser::AST::Processor
+      extend AST::Sexp
+
       attr_accessor :offences
-      attr_writer :correlations
+      attr_accessor :debug
+      attr_writer :disabled_lines
 
       @all = []
       @config = {}
@@ -46,50 +33,50 @@ module Rubocop
         all << subclass
       end
 
+      def self.cop_name
+        name.to_s.split('::').last
+      end
+
       def initialize
         @offences = []
+        @debug = false
       end
 
       def has_report?
         !@offences.empty?
       end
 
-      def add_offence(severity, line_number, message)
-        @offences << Offence.new(severity, line_number, message)
+      def inspect(source, tokens, ast, comments)
+        process(ast)
+        comments.each { |c| on_comment(c) }
       end
 
-      private
-
-      def each_parent_of(sym, sexp)
-        parents = []
-        sexp.each do |elem|
-          if Array === elem
-            if elem[0] == sym
-              parents << sexp unless parents.include?(sexp)
-              elem = elem[1..-1]
-            end
-            each_parent_of(sym, elem) do |parent|
-              parents << parent unless parents.include?(parent)
-            end
-          end
-        end
-        parents.each { |parent| yield parent }
+      def on_comment(comment)
       end
 
-      def each(sym, sexp)
-        yield sexp if sexp[0] == sym
-        sexp.each do |elem|
-          each(sym, elem) { |s| yield s } if Array === elem
+      def add_offence(severity, line_number, message)
+        unless @disabled_lines && @disabled_lines.include?(line_number)
+          message = debug ? "#{name}: #{message}" : message
+          @offences << Offence.new(severity, line_number, message)
         end
       end
 
-      def whitespace?(token)
-        [:on_sp, :on_ignored_nl, :on_nl].include?(token.type)
+      def name
+        self.class.cop_name
       end
 
-      def all_positions(sexp)
-        return [sexp[2]] if sexp[0] =~ /^@/
-        sexp.grep(Array).reduce([]) { |memo, s| memo + all_positions(s) }
+      private
+
+      def on_node(syms, sexp, excludes = [])
+        yield sexp if Array(syms).include?(sexp.type)
+
+        return if Array(excludes).include?(sexp.type)
+
+        sexp.children.each do |elem|
+          if Parser::AST::Node === elem
+            on_node(syms, elem, excludes) { |s| yield s }
+          end
+        end
       end
     end
   end

data/lib/rubocop/cop/def_parentheses.rb

@@ -2,52 +2,60 @@
 
 module Rubocop
   module Cop
-    module DefParentheses
-      EMPTY_PARAMS = [:params, nil, nil, nil,
-        nil, nil, nil, nil] if RUBY_VERSION >= '2.0.0'
-      EMPTY_PARAMS = [:params, nil, nil, nil,
-        nil, nil] if RUBY_VERSION < '2.0.0'
-
-      def inspect(file, source, tokens, sexp)
-        each(:def, sexp) { |def_sexp| check(tokens, def_sexp) }
-      end
-    end
-
     class DefWithParentheses < Cop
-      include DefParentheses
-      def error_message
-        "Omit the parentheses in defs when the method doesn't accept any " +
-          'arguments.'
+      MSG = "Omit the parentheses in defs when the method doesn't accept " +
+          'any arguments.'
+
+      def on_def(node)
+        start_line = node.loc.keyword.line
+        end_line = node.loc.end.line
+
+        return if start_line == end_line
+
+        _, args = *node
+        if args.children == [] && args.loc.begin
+          add_offence(:convention, node.loc.line, MSG)
+        end
+
+        super
       end
 
-      def check(tokens, def_sexp)
-        if def_sexp[2][0] == :paren && def_sexp[2][1] == EMPTY_PARAMS
-          pos = def_sexp[1][-1]
-          method_name_ix = tokens.index { |t| t.pos == pos }
-          start = method_name_ix + 1
-          rparen_ix = start + tokens[start..-1].index { |t| t.text == ')' }
-          first_body_token = tokens[(rparen_ix + 1)..-1].find do |t|
-            not whitespace?(t)
-          end
-          if first_body_token.pos.lineno > pos.lineno
-            # Only report offence if there's a line break after
-            # the empty parens.
-            add_offence(:convention, pos.lineno, error_message)
-          end
+      def on_defs(node)
+        start_line = node.loc.keyword.line
+        end_line = node.loc.end.line
+
+        return if start_line == end_line
+
+        _, _, args = *node
+        if args.children == [] && args.loc.begin
+          add_offence(:convention, node.loc.line, MSG)
         end
+
+        super
       end
     end
 
     class DefWithoutParentheses < Cop
-      include DefParentheses
-      def error_message
-        'Use def with parentheses when there are arguments.'
+      MSG = 'Use def with parentheses when there are arguments.'
+
+      def on_def(node)
+        _, args = *node
+
+        if args.children.size > 0 && args.loc.begin.nil?
+          add_offence(:convention, node.loc.line, MSG)
+        end
+
+        super
       end
 
-      def check(tokens, def_sexp)
-        if def_sexp[2][0] == :params && def_sexp[2] != EMPTY_PARAMS
-          add_offence(:convention, def_sexp[1][-1].lineno, error_message)
+      def on_defs(node)
+        _, _, args = *node
+
+        if args.children.size > 0 && args.loc.begin.nil?
+          add_offence(:convention, node.loc.line, MSG)
         end
+
+        super
       end
     end
   end

data/lib/rubocop/cop/empty_line_between_defs.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class EmptyLineBetweenDefs < Cop
+      MSG = 'Use empty lines between defs.'
+
+      def on_def(s)
+        def_start = s.loc.keyword.line
+        def_end = s.loc.end.line
+
+        if @prev_def_end && (def_start - @prev_def_end) < 2
+          add_offence(:convention, def_start, MSG)
+        end
+
+        @prev_def_end = def_end
+
+        super
+      end
+    end
+  end
+end

data/lib/rubocop/cop/empty_lines.rb

@@ -3,22 +3,30 @@
 module Rubocop
   module Cop
     class EmptyLines < Cop
-      ERROR_MESSAGE = 'Use empty lines between defs.'
+      MSG = 'Extra blank line detected.'
+      LINE_OFFSET = 2
 
-      def inspect(file, source, tokens, sexp)
-        each_parent_of(:def, sexp) do |parent|
-          defs = parent.select { |child| child[0] == :def }
-          identifier_of_first_def = defs[0][1]
-          current_row_ix = identifier_of_first_def[-1].lineno - 1
-          # The first def doesn't need to have an empty line above it,
-          # so we iterate starting at index 1.
-          defs[1..-1].each do |child|
-            next_row_ix = child[1][-1].lineno - 1
-            if source[current_row_ix..next_row_ix].grep(/^[ \t]*$/).empty?
-              add_offence(:convention, next_row_ix + 1, ERROR_MESSAGE)
+      def inspect(source, tokens, ast, comments)
+        return if tokens.empty?
+
+        prev_line = 1
+
+        tokens.each do |token|
+          cur_line = token.pos.line
+          line_diff = cur_line - prev_line
+
+          if line_diff > LINE_OFFSET
+            # we need to be wary of comments since they
+            # don't show up in the tokens
+            ((prev_line + 1)...cur_line).each do |line|
+              # we check if the prev and current lines are empty
+              if source[line - 2].empty? && source[line - 1].empty?
+                add_offence(:convention, line, MSG)
+              end
             end
-            current_row_ix = next_row_ix
           end
+
+          prev_line = cur_line
         end
       end
     end

data/lib/rubocop/cop/empty_literal.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class EmptyLiteral < Cop
+      ARR_MSG = 'Use array literal [] instead of Array.new.'
+      HASH_MSG = 'Use hash literal {} instead of Hash.new.'
+      STR_MSG = "Use string literal '' instead of String.new."
+
+      # Empty array node
+      #
+      # (send
+      #   (const nil :Array) :new)
+      ARRAY_NODE = s(:send, s(:const, nil, :Array), :new)
+
+      # Empty hash node
+      #
+      # (send
+      #   (const nil :Hash) :new)
+      HASH_NODE = s(:send, s(:const, nil, :Hash), :new)
+
+      # Empty string node
+      #
+      # (send
+      #   (const nil :String) :new)
+      STR_NODE = s(:send, s(:const, nil, :String), :new)
+
+      def inspect(source, tokens, ast, comments)
+        on_node(:send, ast, :block) do |node|
+          if node == ARRAY_NODE
+            add_offence(:convention,
+                        node.loc.line,
+                        ARR_MSG)
+          elsif node == HASH_NODE
+            add_offence(:convention,
+                        node.loc.line,
+                        HASH_MSG)
+          elsif node == STR_NODE
+            add_offence(:convention,
+                        node.loc.line,
+                        STR_MSG)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/encoding.rb

@@ -3,14 +3,14 @@
 module Rubocop
   module Cop
     class Encoding < Cop
-      ERROR_MESSAGE = 'Missing encoding comment.'
+      MSG = 'Missing utf-8 encoding comment.'
 
-      def inspect(file, source, tokens, sexp)
+      def inspect(source, tokens, ast, comments)
         unless RUBY_VERSION >= '2.0.0'
           expected_line = 0
           expected_line += 1 if source[expected_line] =~ /^#!/
           unless source[expected_line] =~ /#.*coding: (UTF|utf)-8/
-            add_offence(:convention, 1, ERROR_MESSAGE)
+            add_offence(:convention, 1, MSG)
           end
         end
       end

data/lib/rubocop/cop/end_of_line.rb

@@ -3,11 +3,11 @@
 module Rubocop
   module Cop
     class EndOfLine < Cop
-      ERROR_MESSAGE = 'Carriage return character detected.'
+      MSG = 'Carriage return character detected.'
 
-      def inspect(file, source, tokens, sexp)
+      def inspect(source, tokens, ast, comments)
         source.each_with_index do |line, index|
-          add_offence(:convention, index + 1, ERROR_MESSAGE) if line =~ /\r$/
+          add_offence(:convention, index + 1, MSG) if line =~ /\r$/
         end
       end
     end

data/lib/rubocop/cop/ensure_return.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class EnsureReturn < Cop
+      MSG = 'Never return from an ensure block.'
+
+      def on_ensure(node)
+        _body, ensure_body = *node
+
+        on_node(:return, ensure_body) do |e|
+          add_offence(:warning, e.loc.line, MSG)
+        end
+
+        super
+      end
+    end
+  end
+end

data/lib/rubocop/cop/eval.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class Eval < Cop
+      MSG = 'The use of eval is a serious security risk.'
+
+      def on_send(node)
+        receiver, method_name, = *node
+
+        if receiver.nil? && method_name == :eval
+          add_offence(:security, node.loc.line, MSG)
+        end
+
+        super
+      end
+    end
+  end
+end

data/lib/rubocop/cop/favor_join.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class FavorJoin < Cop
+      MSG = 'Favor Array#join over Array#*.'
+
+      def on_send(node)
+        receiver_node, method_name, *arg_nodes = *node
+
+        if receiver_node && receiver_node.type == :array &&
+            method_name == :* && arg_nodes[0].type == :str
+          add_offence(:convention,
+                      node.loc.expression.line,
+                      MSG)
+        end
+
+        super
+      end
+    end
+  end
+end

data/lib/rubocop/cop/favor_modifier.rb

@@ -3,53 +3,36 @@
 module Rubocop
   module Cop
     module FavorModifier
-      def check(kind, tokens, sexp)
-        token_positions = tokens.map(&:pos)
-        token_texts = tokens.map(&:text)
-        each(kind, sexp) do |s|
-          # If it contains an else, it can't be written as a modifier.
-          next if s[3] && s[3][0] == :else
+      # TODO extremely ugly solution that needs lots of polish
+      def check(sexp)
+        # discard if/then/else
+        return false if sexp.loc.respond_to?(:else) && sexp.loc.else
 
-          sexp_positions = all_positions(s)
-          ix = token_positions.index(sexp_positions.first)
-          if_ix = token_texts[0..ix].rindex(kind.to_s) # index of if/unless/...
-          ix = token_positions.index(sexp_positions.last)
-          end_ix = ix + token_texts[ix..-1].index('end')
+        if %w(if while).include?(sexp.loc.keyword.source)
+          cond, body = *sexp
+        else
+          cond, _else, body = *sexp
+        end
 
-          # If there's a comment anywhere between
-          # if/unless/while/until and end, we don't report. It's
-          # possible that the comment will be less clear if put above
-          # a one liner rather than inside.
-          next if tokens[if_ix...end_ix].map(&:type).include?(:on_comment)
+        if length(sexp) > 3
+          false
+        else
+          cond_length = sexp.loc.keyword.size + cond.loc.expression.size + 1
+          body_length = body_length(body)
 
-          if token_positions[end_ix].lineno - token_positions[if_ix].lineno > 2
-            next # not a single-line body
-          end
-          # The start ix is the index of the leftmost token on the
-          # line of the if/unless, i.e. the index of if/unless itself,
-          # or of the indentation space.
-          start_ix = if_ix.downto(0).find do |block_ix|
-            block_ix == 0 || tokens[block_ix - 1].text =~ /\n/
-          end
-          # The stop index is the index of the token just before
-          # 'end', not counting whitespace tokens.
-          stop_ix = (end_ix - 1).downto(0).find do |block_ix|
-            tokens[block_ix].text !~ /\s/
-          end
-          if length(tokens, start_ix, stop_ix) <= LineLength.max
-            add_offence(:convention, token_positions[if_ix].lineno,
-                        error_message)
-          end
+          (cond_length + body_length) <= LineLength.max
         end
       end
 
-      def length(tokens, start_ix, stop_ix)
-        (start_ix..stop_ix).reduce(0) do |acc, ix|
-          acc + if ix > start_ix && tokens[ix - 1].text =~ /\n/
-                  0
-                else
-                  tokens[ix].text.length
-                end
+      def length(sexp)
+        sexp.loc.expression.source.split("\n").size
+      end
+
+      def body_length(body)
+        if body
+          body.loc.expression.column + body.loc.expression.size
+        else
+          0
         end
       end
     end
@@ -59,23 +42,30 @@ module Rubocop
 
       def error_message
         'Favor modifier if/unless usage when you have a single-line body. ' +
-          'Another good alternative is the usage of control flow and/or.'
+          'Another good alternative is the usage of control flow &&/||.'
       end
 
-      def inspect(file, source, tokens, sexp)
-        [:if, :unless].each { |kind| check(kind, tokens, sexp) }
+      def on_if(node)
+        # discard ternary ops and modifier if/unless nodes
+        return unless node.loc.respond_to?(:keyword) &&
+          node.loc.respond_to?(:else)
+
+        add_offence(:convention, node.loc.line, error_message) if check(node)
+
+        super
       end
     end
 
     class WhileUntilModifier < Cop
       include FavorModifier
 
-      def error_message
+      MSG =
         'Favor modifier while/until usage when you have a single-line body.'
-      end
 
-      def inspect(file, source, tokens, sexp)
-        [:while, :until].each { |kind| check(kind, tokens, sexp) }
+      def inspect(source, tokens, ast, comments)
+        on_node([:while, :until], ast) do |node|
+          add_offence(:convention, node.loc.line, MSG) if check(node)
+        end
       end
     end
   end

data/lib/rubocop/cop/favor_percent_r.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class FavorPercentR < Cop
+      MSG = 'Use %r for regular expressions matching more ' +
+        "than one '/' character."
+
+      def on_regexp(node)
+        if node.loc.begin.source == '/' &&
+            node.loc.expression.source[1...-1].scan(/\//).size > 1
+          add_offence(:convention, node.loc.line, MSG)
+        end
+
+        super
+      end
+    end
+  end
+end

data/lib/rubocop/cop/favor_sprintf.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class FavorSprintf < Cop
+      MSG = 'Favor sprintf over String#%.'
+
+      def on_send(node)
+        receiver_node, method_name, *arg_nodes = *node
+
+        if method_name == :% &&
+            ([:str, :dstr].include?(receiver_node.type) ||
+             arg_nodes[0].type == :array)
+          add_offence(:convention, node.loc.expression.line, MSG)
+        end
+
+        super
+      end
+    end
+  end
+end

data/lib/rubocop/cop/favor_unless_over_negated_if.rb

@@ -3,17 +3,17 @@
 module Rubocop
   module Cop
     module FavorOtherKeywordOverNegation
-      private
-      def check(grammar_part, sexp)
-        each(grammar_part, sexp) do |s|
-          # Don't complain about negative if/else. We don't want unless/else.
-          next if s[3] && [:else, :elsif].include?(s[3][0])
+      def check(node)
+        condition, _body, _rest = *node
 
-          condition = s[1]
-          condition = condition[1][0] while condition[0] == :paren
+        # Look at last expression of contents if there's a parenthesis
+        # around condition.
+        *_, condition = *condition while condition.type == :begin
 
-          if condition[0] == :unary && [:!, :not].include?(condition[1])
-            add_offence(:convention, all_positions(s).first.lineno,
+        if condition.type == :send
+          _object, method = *condition
+          if method == :! && !(node.loc.respond_to?(:else) && node.loc.else)
+            add_offence(:convention, node.loc.expression.line,
                         error_message)
           end
         end
@@ -23,24 +23,26 @@ module Rubocop
     class FavorUnlessOverNegatedIf < Cop
       include FavorOtherKeywordOverNegation
 
-      def error_message
-        'Favor unless (or control flow or) over if for negative conditions.'
+      def on_if(node)
+        check(node)
+        super
       end
 
-      def inspect(file, source, tokens, sexp)
-        [:if, :if_mod].each { |grammar_part| check(grammar_part, sexp) }
+      def error_message
+        'Favor unless (or control flow or) over if for negative conditions.'
       end
     end
 
     class FavorUntilOverNegatedWhile < Cop
       include FavorOtherKeywordOverNegation
 
-      def error_message
-        'Favor until over while for negative conditions.'
+      def on_while(node)
+        check(node)
+        super
       end
 
-      def inspect(file, source, tokens, sexp)
-        [:while, :while_mod].each { |grammar_part| check(grammar_part, sexp) }
+      def error_message
+        'Favor until over while for negative conditions.'
       end
     end
   end

data/lib/rubocop/cop/handle_exceptions.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class HandleExceptions < Cop
+      MSG = 'Do not suppress exceptions.'
+
+      def on_resbody(node)
+        _exc_list_node, _exc_var_node, body_node = *node
+
+        add_offence(:warning, node.loc.line, MSG) if body_node.type == :nil
+
+        super
+      end
+    end
+  end
+end