rubocop 0.7.2 → 0.8.0

data/lib/rubocop/cop/blocks.rb

@@ -2,57 +2,21 @@
 
 module Rubocop
   module Cop
-    module Blocks
-      def inspect(file, source, tokens, sexp)
-        @file = file
+    class Blocks < Cop
+      MULTI_LINE_MSG = 'Avoid using {...} for multi-line blocks.'
+      SINGLE_LINE_MSG = 'Prefer {...} over do...end for single-line blocks.'
 
-        # The @reverse_correlations maps grammar path object ids to
-        # token indexes, so we can use it to find the corresponding }
-        # for each {.
-        @reverse_correlations = Hash.new([])
-        @correlations.each do |ix, path|
-          @reverse_correlations[path.object_id] += [ix]
-        end
-
-        tokens.each_index { |ix| check(tokens, ix) }
-      end
-    end
-
-    class MultilineBlocks < Cop
-      include Blocks
-      ERROR_MESSAGE = 'Avoid using {...} for multi-line blocks.'
+      def on_block(node)
+        block_length = Util.block_length(node)
+        block_begin = node.loc.begin.source
 
-      def check(tokens, ix)
-        t = tokens[ix]
-        if [t.type, t.text] == [:on_lbrace, '{']
-          path = @correlations[ix] or return
-          if path.last == :brace_block
-            rbrace_ix = @reverse_correlations[path.object_id] - [ix]
-            if rbrace_ix.empty?
-              fail "\n#{@file}:#{t.pos.lineno}:#{t.pos.column}: " +
-                'Matching brace not found'
-            end
-            if tokens[*rbrace_ix].pos.lineno > t.pos.lineno
-              add_offence(:convention, t.pos.lineno, ERROR_MESSAGE)
-            end
-          end
+        if block_length > 0 && block_begin == '{'
+          add_offence(:convention, node.loc.line, MULTI_LINE_MSG)
+        elsif block_length == 0 && block_begin != '{'
+          add_offence(:convention, node.loc.line, SINGLE_LINE_MSG)
         end
-      end
-    end
 
-    class SingleLineBlocks < Cop
-      include Blocks
-      ERROR_MESSAGE = 'Prefer {...} over do...end for single-line blocks.'
-
-      def check(tokens, ix)
-        t = tokens[ix]
-        if [t.type, t.text] == [:on_kw, 'do']
-          end_offset = tokens[ix..-1].index { |t2| t2.text == 'end' } or return
-          end_token_ix = ix + end_offset
-          if tokens[end_token_ix].pos.lineno == t.pos.lineno
-            add_offence(:convention, t.pos.lineno, ERROR_MESSAGE)
-          end
-        end
+        super
       end
     end
   end

data/lib/rubocop/cop/case_indentation.rb

@@ -3,41 +3,19 @@
 module Rubocop
   module Cop
     class CaseIndentation < Cop
-      ERROR_MESSAGE = 'Indent when as deep as case.'
+      MSG = 'Indent when as deep as case.'
 
-      def inspect(file, source, tokens, sexp)
-        case_tokens = find_keywords(tokens, 'case')
-        when_tokens = find_keywords(tokens, 'when')
-        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 on_case(case_node)
+        _condition, *whens, _else = *case_node
 
-      def find_keywords(tokens, keyword)
-        indexes = tokens.each_index.select do |ix|
-          keyword?(tokens, ix, keyword)
-        end
-        tokens.values_at(*indexes)
-      end
+        case_column = case_node.location.keyword.column
 
-      def keyword?(tokens, ix, keyword)
-        [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)
-        if sexp[0] == :case
-          @total_case_ix = (@total_case_ix || -1) + 1
-          each_when(sexp[2], @total_case_ix, &block)
-        else
-          yield case_ix if sexp[0] == :when
-          sexp.grep(Array).each { |s| each_when(s, case_ix, &block) }
+        whens.each do |when_node|
+          pos = when_node.loc.keyword
+          add_offence(:convention, pos.line, MSG) if pos.column != case_column
         end
+
+        super
       end
     end
   end

data/lib/rubocop/cop/class_and_module_camel_case.rb

@@ -3,17 +3,26 @@
 module Rubocop
   module Cop
     class ClassAndModuleCamelCase < Cop
-      ERROR_MESSAGE = 'Use CamelCase for classes and modules.'
-
-      def inspect(file, source, tokens, sexp)
-        [:class, :module].each do |keyword|
-          each(keyword, sexp) do |s|
-            if s[1][0] == :const_ref && s[1][1][0] == :@const &&
-                s[1][1][1] =~ /_/
-              add_offence(:convention, s[1][1][2].lineno, ERROR_MESSAGE)
-            end
-          end
-        end
+      MSG = 'Use CamelCase for classes and modules.'
+
+      def on_class(node)
+        check_name(node)
+
+        super
+      end
+
+      def on_module(node)
+        check_name(node)
+
+        super
+      end
+
+      private
+
+      def check_name(node)
+        name = node.loc.name.source
+
+        add_offence(:convention, node.loc.line, MSG) if name =~ /_/
       end
     end
   end

data/lib/rubocop/cop/class_methods.rb

@@ -3,17 +3,12 @@
 module Rubocop
   module Cop
     class ClassMethods < Cop
-      ERROR_MESSAGE = 'Prefer self over class/module for class/module methods.'
+      MSG = 'Prefer self over class/module for class/module methods.'
 
-      def inspect(file, source, tokens, sexp)
-        # defs nodes correspond to class & module methods
-        each(:defs, sexp) do |s|
-          if s[1][0] == :var_ref && s[1][1][0] == :@const
-            add_offence(:convention,
-                        s[1][1][2].lineno,
-                        ERROR_MESSAGE)
-          end
-        end
+      def on_defs(node)
+        definee, _name, _args, _body = *node
+
+        add_offence(:convention, node.loc.line, MSG) if definee.type == :const
       end
     end
   end

data/lib/rubocop/cop/collection_methods.rb

@@ -3,25 +3,25 @@
 module Rubocop
   module Cop
     class CollectionMethods < Cop
+      MSG = 'Prefer %s over %s.'
+
       PREFERRED_METHODS = {
-        'collect' => 'map',
-        'inject' => 'reduce',
-        'detect' => 'find',
-        'find_all' => 'select',
+        collect: 'map',
+        inject: 'reduce',
+        detect: 'find',
+        find_all: 'select'
       }
 
-      def inspect(file, source, tokens, sexp)
-        each(:call, sexp) do |s|
-          s.drop(2).each_slice(2) do |m|
-            method_name = m[1][1]
-            if PREFERRED_METHODS[method_name]
-              add_offence(
-                :convention,
-                m[1][2].lineno,
-                "Prefer #{PREFERRED_METHODS[method_name]} over #{method_name}."
-              )
-            end
-          end
+      def on_send(node)
+        receiver, method_name, *_args = *node
+
+        # a simple(but flawed way) to reduce false positives
+        if receiver && PREFERRED_METHODS[method_name]
+          add_offence(
+            :convention,
+            node.loc.line,
+            sprintf(MSG, PREFERRED_METHODS[method_name], method_name)
+          )
         end
       end
     end

data/lib/rubocop/cop/colon_method_call.rb

@@ -3,41 +3,17 @@
 module Rubocop
   module Cop
     class ColonMethodCall < Cop
-      ERROR_MESSAGE = 'Do not use :: for method invocation.'
+      MSG = 'Do not use :: for method invocation.'
 
-      def inspect(file, source, tokens, sexp)
-        state = :outside
-        tokens.each do |t|
-          state = case [state, t.type]
-                  when [:outside, :on_const]
-                    :const
+      def on_send(node)
+        receiver, _method_name, *_args = *node
 
-                  when [:outside, :on_ident]
-                    :ident
-
-                  when [:const, :on_op]
-                    t.text == '::' ? :const_colon : :outside
-
-                  when [:ident, :on_op]
-                    t.text == '::' ? :ident_colon : :outside
-
-                  when [:ident_colon, :on_ident]
-                    add_offence(:convention, t.pos.lineno, ERROR_MESSAGE)
-                    :ident
-
-                  when [:const_colon, :on_ident]
-                    add_offence(:convention, t.pos.lineno, ERROR_MESSAGE)
-                    :ident
-
-                  when [:ident_colon, :on_const]
-                    :const
-
-                  when [:const_colon, :on_const]
-                    :const
-                  else
-                    :outside
-            end || state
+        # discard methods with nil receivers and op methods(like [])
+        if receiver && node.loc.dot && node.loc.dot.source == '::'
+          add_offence(:convention, node.loc.line, MSG)
         end
+
+        super
       end
     end
   end

data/lib/rubocop/cop/constant_name.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class ConstantName < Cop
+      MSG = 'Use SCREAMING_SNAKE_CASE for constants.'
+      SNAKE_CASE = /^[\dA-Z_]+$/
+
+      def on_casgn(node)
+        _scope, const_name, value = *node
+
+        # we cannot know the result of method calls line
+        # NewClass = something_that_returns_a_class
+        if value.type != :send && const_name !~ SNAKE_CASE
+          add_offence(:convention,
+                      node.loc.line,
+                      MSG)
+        end
+
+        super
+      end
+    end
+  end
+end

data/lib/rubocop/cop/cop.rb

@@ -2,38 +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_accessor :debug
-      attr_writer :correlations, :disabled_lines
+      attr_writer :disabled_lines
 
       @all = []
       @config = {}
@@ -60,6 +46,14 @@ module Rubocop
         !@offences.empty?
       end
 
+      def inspect(source, tokens, ast, comments)
+        process(ast)
+        comments.each { |c| on_comment(c) }
+      end
+
+      def on_comment(comment)
+      end
+
       def add_offence(severity, line_number, message)
         unless @disabled_lines && @disabled_lines.include?(line_number)
           message = debug ? "#{name}: #{message}" : message
@@ -73,68 +67,16 @@ module Rubocop
 
       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 }
-      end
-
-      def each(sym, sexp)
-        yield sexp if sexp[0] == sym
-        sexp.each do |elem|
-          each(sym, elem) { |s| yield s } if Array === elem
-        end
-      end
+      def on_node(syms, sexp, excludes = [])
+        yield sexp if Array(syms).include?(sexp.type)
 
-      def find_all(sym, sexp)
-        result = []
-        each(sym, sexp) { |s| result << s }
-        result
-      end
+        return if Array(excludes).include?(sexp.type)
 
-      def find_first(sym, sexp)
-        find_all(sym, sexp).first
-      end
-
-      def whitespace?(token)
-        [:on_sp, :on_ignored_nl, :on_nl].include?(token.type)
-      end
-
-      def all_positions(sexp)
-        return [sexp[2]] if sexp[0] =~ /^@/
-        sexp.grep(Array).reduce([]) { |a, e| a + all_positions(e) }
-      end
-
-      def keywords(tokens)
-        # We need to keep track of the previous token to avoid
-        # interpreting :some_keyword as the keyword some_keyword.
-        prev = Token.new(0, :init, '')
-        # Same goes for defs so we need to track those as well.
-        keywords = []
-
-        tokens.reject { |t| whitespace?(t) }.each do |t|
-          if prev.type != :on_symbeg && t.type == :on_kw &&
-              [prev.type, prev.text] != [:on_kw, 'def']
-            keywords << t
+        sexp.children.each do |elem|
+          if Parser::AST::Node === elem
+            on_node(syms, elem, excludes) { |s| yield s }
           end
-          prev = t
         end
-
-        keywords
-      end
-
-      def each_keyword(keyword, tokens)
-        keywords(tokens).select { |t| t.text == keyword }.each { |t| yield t }
       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|
-            !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