rubocop 0.7.2 → 0.8.0

data/lib/rubocop/config.rb

@@ -87,9 +87,12 @@ module Rubocop
         merge_with_default(config, config_file)
       end
 
+      def default_configuration
+        @default_configuration ||= load_file(DEFAULT_FILE)
+      end
+
       def merge_with_default(config, config_file)
-        default_config = load_file(DEFAULT_FILE)
-        new(merge(default_config, config), config_file)
+        new(merge(default_configuration, config), config_file)
       end
 
       private
@@ -120,17 +123,17 @@ module Rubocop
     end
 
     def warn_unless_valid
-      validate!
+      validate
     rescue Config::ValidationError => e
       puts "Warning: #{e.message}".color(:red)
     end
 
     # TODO: This should be a private method
-    def validate!
+    def validate
       # Don't validate RuboCop's own files. Avoids inifinite recursion.
       return if @loaded_path.start_with?(RUBOCOP_HOME)
 
-      default_config = Config.load_file(DEFAULT_FILE)
+      default_config = self.class.default_configuration
 
       valid_cop_names, invalid_cop_names = @hash.keys.partition do |key|
         default_config.has_key?(key)

data/lib/rubocop/cop/access_control.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class AccessControl < Cop
+      INDENT_MSG = 'Indent private and protected as deep as method defs.'
+      BLANK_MSG = 'Keep a blank line before and after private/protected.'
+
+      PRIVATE_NODE = s(:send, nil, :private)
+      PROTECTED_NODE = s(:send, nil, :protected)
+
+      def inspect(source, tokens, ast, comments)
+        on_node([:class, :module, :sclass], ast) do |class_node|
+          class_start_col = class_node.loc.expression.column
+
+          # we'll have to walk all class children nodes
+          # except other class/module nodes
+          class_node.children.compact.each do |node|
+            on_node(:send, node, [:class, :module, :sclass]) do |send_node|
+              if [PRIVATE_NODE, PROTECTED_NODE].include?(send_node)
+                send_start_col = send_node.loc.expression.column
+
+                if send_start_col - 2 != class_start_col
+                  add_offence(:convention,
+                              send_node.loc.line,
+                              INDENT_MSG)
+                end
+
+                send_line = send_node.loc.line
+
+                unless source[send_line].empty? && source[send_line - 2].empty?
+                  add_offence(:convention, send_line, BLANK_MSG)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/alias.rb

@@ -3,12 +3,14 @@
 module Rubocop
   module Cop
     class Alias < Cop
-      ERROR_MESSAGE = 'Use alias_method instead of alias.'
+      MSG = 'Use alias_method instead of alias.'
 
-      def inspect(file, source, tokens, sexp)
-        each_keyword('alias', tokens) do |t|
-          add_offence(:convention, t.pos.lineno, ERROR_MESSAGE)
-        end
+      def on_alias(node)
+        add_offence(:convention,
+                    node.loc.keyword.line,
+                    MSG)
+
+        super
       end
     end
   end

data/lib/rubocop/cop/align_parameters.rb

@@ -3,110 +3,34 @@
 module Rubocop
   module Cop
     class AlignParameters < Cop
-      ERROR_MESSAGE = 'Align the parameters of a method call if they span ' +
+      MSG = 'Align the parameters of a method call if they span ' +
         'more than one line.'
 
-      def inspect(file, source, tokens, sexp)
-        @file = file
-        @tokens = tokens
-        @token_indexes = {}
-        @tokens.each_with_index { |t, ix| @token_indexes[t.pos] = ix }
+      def on_send(node)
+        _receiver, method, *args = *node
 
-        each(:method_add_arg, sexp) do |method_add_arg|
-          args = get_args(method_add_arg) or next
-          first_arg, rest_of_args = divide_args(args)
-          @first_lparen_ix = get_lparen_ix(method_add_arg)
-          pos_of_1st_arg = position_of(first_arg) or next # Give up.
-          rest_of_args.each do |arg|
-            pos = position_of(arg) or next # Give up if no position found.
-            if pos.lineno != pos_of_1st_arg.lineno
-              if pos.column != pos_of_1st_arg.column
-                add_offence(:convention, pos.lineno, ERROR_MESSAGE)
-              end
-            end
-          end
-        end
-      end
-
-      private
-
-      def get_args(method_add_arg)
-        fcall = method_add_arg[1]
-        return nil if fcall[0] != :fcall
-        return nil if fcall[1][0..1] == [:@ident, 'lambda']
-        arg_paren = method_add_arg[2..-1][0]
-        return nil if arg_paren[0] != :arg_paren || arg_paren[1].nil?
-
-        # A command (call wihtout parentheses) as first parameter
-        # means there's only one parameter.
-        return nil if [:command, :command_call].include?(arg_paren[1][0][0])
-
-        if arg_paren[1][0] == :args_add_block
-          args_add_block = arg_paren[1]
-          args_add_block[1].empty? ? [args_add_block[2]] : args_add_block[1]
-        else
-          arg_paren[1]
-        end
-      end
-
-      def divide_args(args)
-        if args[0] == :args_add_star
-          first_arg = args[1]
-          rest_of_args = args[2..-1]
-        else
-          first_arg = args[0]
-          rest_of_args = args[1..-1]
-        end
-        [first_arg, rest_of_args]
-      end
-
-      def get_lparen_ix(method_add_arg)
-        method_name_pos = method_add_arg[1][1][-1]
-        method_name_ix = @token_indexes[method_name_pos]
-        method_name_ix +
-          @tokens[method_name_ix..-1].map(&:type).index(:on_lparen)
-      end
-
-      def position_of(sexp)
-        # Indentation inside a string literal is irrelevant.
-        return nil if sexp[0] == :string_literal
+        if method != :[]= && args.size > 1
+          first_arg_col = args.first.loc.expression.column
+          prev_arg_line = args.first.loc.expression.line
+          prev_arg_col = first_arg_col
 
-        pos = find_pos_in_sexp(sexp) or return nil # Nil means not found.
-        ix = find_first_non_whitespace_token(pos) or return nil
-        @tokens[ix].pos
-      end
+          args.each do |arg|
+            cur_arg_line = arg.loc.expression.line
+            cur_arg_col = arg.loc.expression.column
 
-      def find_pos_in_sexp(sexp)
-        return sexp[2] if Position === sexp[2]
-        sexp.grep(Array).each do |s|
-          pos = find_pos_in_sexp(s) and return pos
-        end
-        nil
-      end
-
-      def find_first_non_whitespace_token(pos)
-        ix = @token_indexes[pos]
-        newline_found = false
-        start_ix = ix.downto(0) do |i|
-          case @tokens[i].text
-          when '('
-            break i + 1 if i == @first_lparen_ix
-          when "\n"
-            newline_found = true
-          when /\t/
-            # Bail out if tabs are used. Too difficult to calculate column.
-            return nil
-          when ','
-            if newline_found
-              break i + 1
-            else
-              # Bail out if there's a preceding comma on the same line.
-              return nil
+            if cur_arg_line != prev_arg_line &&
+                cur_arg_col != first_arg_col
+              add_offence(:convetion,
+                          cur_arg_line,
+                          MSG)
             end
+
+            prev_arg_col = cur_arg_col
+            prev_arg_line = cur_arg_line
           end
         end
-        offset = @tokens[start_ix..-1].index { |t| !whitespace?(t) }
-        start_ix + offset
+
+        super
       end
     end
   end

data/lib/rubocop/cop/and_or.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class AndOr < Cop
+      MSG = 'Use %s instead of %s.'
+
+      OPS = { 'and' => '&&', 'or' => '||' }
+
+      def on_and(node)
+        op = node.loc.operator.source
+        op_type = node.type.to_s
+
+        if op == op_type
+          add_offence(:convention,
+                      node.loc.operator.line,
+                      sprintf(MSG, OPS[op], op))
+        end
+
+        super
+      end
+
+      alias_method :on_or, :on_and
+    end
+  end
+end

data/lib/rubocop/cop/ascii_comments.rb

@@ -3,15 +3,10 @@
 module Rubocop
   module Cop
     class AsciiComments < Cop
-      ERROR_MESSAGE = 'Use only ascii symbols in comments.'
+      MSG = 'Use only ascii symbols in comments.'
 
-      def inspect(file, source, tokens, sexp)
-        tokens.each do |t|
-          if t.type == :on_comment &&
-              t.text =~ /[^\x00-\x7f]/
-            add_offence(:convention, t.pos.lineno, ERROR_MESSAGE)
-          end
-        end
+      def on_comment(c)
+        add_offence(:convention, c.loc.line, MSG) if c.text =~ /[^\x00-\x7f]/
       end
     end
   end

data/lib/rubocop/cop/ascii_identifiers.rb

@@ -1,15 +1,16 @@
 # encoding: utf-8
 
+# rubocop:disable SymbolName
+
 module Rubocop
   module Cop
     class AsciiIdentifiers < Cop
-      ERROR_MESSAGE = 'Use only ascii symbols in identifiers.'
+      MSG = 'Use only ascii symbols in identifiers.'
 
-      def inspect(file, source, tokens, sexp)
+      def inspect(source, tokens, ast, comments)
         tokens.each do |t|
-          if t.type == :on_ident &&
-              t.text =~ /[^\x00-\x7f]/
-            add_offence(:convention, t.pos.lineno, ERROR_MESSAGE)
+          if t.type == :tIDENTIFIER && t.text =~ /[^\x00-\x7f]/
+            add_offence(:convention, t.pos.line, MSG)
           end
         end
       end

data/lib/rubocop/cop/avoid_class_vars.rb

@@ -3,17 +3,12 @@
 module Rubocop
   module Cop
     class AvoidClassVars < Cop
-      def inspect(file, source, tokens, sexp)
-        each(:@cvar, sexp) do |s|
-          class_var = s[1]
-          lineno = s[2].lineno
+      MSG = 'Replace class var %s with a class instance var.'
 
-          add_offence(
-            :convention,
-            lineno,
-            "Replace class var #{class_var} with a class instance var."
-          )
-        end
+      def on_cvasgn(node)
+        class_var, = *node
+        add_offence(:convention, node.loc.name.line, sprintf(MSG, class_var))
+        super
       end
     end
   end

data/lib/rubocop/cop/avoid_for.rb

@@ -3,12 +3,14 @@
 module Rubocop
   module Cop
     class AvoidFor < Cop
-      ERROR_MESSAGE = 'Prefer *each* over *for*.'
+      MSG = 'Prefer *each* over *for*.'
 
-      def inspect(file, source, tokens, sexp)
-        each_keyword('for', tokens) do |t|
-          add_offence(:convention, t.pos.lineno, ERROR_MESSAGE)
-        end
+      def on_for(node)
+        add_offence(:convention,
+                    node.loc.keyword.line,
+                    MSG)
+
+        super
       end
     end
   end

data/lib/rubocop/cop/avoid_global_vars.rb

@@ -3,7 +3,7 @@
 module Rubocop
   module Cop
     class AvoidGlobalVars < Cop
-      ERROR_MESSAGE = 'Do not introduce global variables.'
+      MSG = 'Do not introduce global variables.'
 
       # predefined global variables their English aliases
       # http://www.zenspider.com/Languages/Ruby/QuickRef.html
@@ -35,13 +35,25 @@ module Rubocop
         $-0 $-a $-d $-F $-i $-I $-l $-p $-v $-w
       )
 
-      def inspect(file, source, tokens, sexp)
-        each(:@gvar, sexp) do |s|
-          global_var = s[1]
+      def on_gvar(node)
+        check(node)
 
-          unless BUILT_IN_VARS.include?(global_var)
-            add_offence(:convention, s[2].lineno, ERROR_MESSAGE)
-          end
+        super
+      end
+
+      def on_gvasgn(node)
+        check(node)
+
+        super
+      end
+
+      def check(node)
+        global_var, = *node
+
+        unless BUILT_IN_VARS.include?(global_var.to_s)
+          add_offence(:convention,
+                      node.loc.name.line,
+                      MSG)
         end
       end
     end

data/lib/rubocop/cop/avoid_perl_backrefs.rb

@@ -3,17 +3,14 @@
 module Rubocop
   module Cop
     class AvoidPerlBackrefs < Cop
-      def inspect(file, source, tokens, sexp)
-        each(:@backref, sexp) do |s|
-          backref = s[1]
-          lineno = s[2].lineno
+      def on_nth_ref(node)
+        backref, = *node
 
-          add_offence(
-            :convention,
-            lineno,
-            "Prefer the use of MatchData over #{backref}."
-          )
-        end
+        add_offence(:convention,
+                    node.loc.line,
+                    "Prefer the use of MatchData over $#{backref}.")
+
+        super
       end
     end
   end

data/lib/rubocop/cop/avoid_perlisms.rb

@@ -28,18 +28,19 @@ module Rubocop
         '$+' => '$LAST_PAREN_MATCH from English library'
       }
 
-      def inspect(file, source, tokens, sexp)
-        each(:@gvar, sexp) do |s|
-          global_var = s[1]
+      def on_gvar(node)
+        global_var, = *node
+        global_var = global_var.to_s
 
-          if PREFERRED_VARS[global_var]
-            add_offence(
-              :convention,
-              s[2].lineno,
-              "Prefer #{PREFERRED_VARS[global_var]} over #{global_var}."
-            )
-          end
+        if PREFERRED_VARS[global_var]
+          add_offence(
+            :convention,
+            node.loc.line,
+            "Prefer #{PREFERRED_VARS[global_var]} over #{global_var}."
+          )
         end
+
+        super
       end
     end
   end

data/lib/rubocop/cop/block_comments.rb

@@ -3,13 +3,11 @@
 module Rubocop
   module Cop
     class BlockComments < Cop
-      ERROR_MESSAGE = 'Do not use block comments.'
+      MSG = 'Do not use block comments.'
 
-      def inspect(file, source, tokens, sexp)
-        tokens.each do |t|
-          if t.type == :on_embdoc_beg
-            add_offence(:convention, t.pos.lineno, ERROR_MESSAGE)
-          end
+      def on_comment(comment)
+        if comment.text.start_with?('=begin')
+          add_offence(:convention, comment.loc.line, MSG)
         end
       end
     end