rubocop 0.4.0 → 0.8.0

data/lib/rubocop/cop/alias.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class Alias < Cop
+      MSG = 'Use alias_method instead of alias.'
+
+      def on_alias(node)
+        add_offence(:convention,
+                    node.loc.keyword.line,
+                    MSG)
+
+        super
+      end
+    end
+  end
+end

data/lib/rubocop/cop/align_parameters.rb

@@ -3,109 +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])
-
-        args_add_block = arg_paren[1]
-        unless args_add_block[0] == :args_add_block
-          fail "\n#{@file}: #{method_add_arg}"
-        end
-        args_add_block[1].empty? ? [args_add_block[2]] : args_add_block[1]
-      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| not 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

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class AsciiComments < Cop
+      MSG = 'Use only ascii symbols in comments.'
+
+      def on_comment(c)
+        add_offence(:convention, c.loc.line, MSG) if c.text =~ /[^\x00-\x7f]/
+      end
+    end
+  end
+end

data/lib/rubocop/cop/ascii_identifiers.rb

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

data/lib/rubocop/cop/avoid_class_vars.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class AvoidClassVars < Cop
+      MSG = 'Replace class var %s with a class instance var.'
+
+      def on_cvasgn(node)
+        class_var, = *node
+        add_offence(:convention, node.loc.name.line, sprintf(MSG, class_var))
+        super
+      end
+    end
+  end
+end

data/lib/rubocop/cop/avoid_for.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class AvoidFor < Cop
+      MSG = 'Prefer *each* over *for*.'
+
+      def on_for(node)
+        add_offence(:convention,
+                    node.loc.keyword.line,
+                    MSG)
+
+        super
+      end
+    end
+  end
+end

data/lib/rubocop/cop/avoid_global_vars.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class AvoidGlobalVars < Cop
+      MSG = 'Do not introduce global variables.'
+
+      # predefined global variables their English aliases
+      # http://www.zenspider.com/Languages/Ruby/QuickRef.html
+      BUILT_IN_VARS = %w(
+        $: $LOAD_PATH
+        $" $LOADED_FEATURES
+        $0 $PROGRAM_NAME
+        $! $ERROR_INFO
+        $@ $ERROR_POSITION
+        $; $FS $FIELD_SEPARATOR
+        $, $OFS $OUTPUT_FIELD_SEPARATOR
+        $/ $RS $INPUT_RECORD_SEPARATOR
+        $\\ $ORS $OUTPUT_RECORD_SEPARATOR
+        $. $NR $INPUT_LINE_NUMBER
+        $_ $LAST_READ_LINE
+        $> $DEFAULT_OUTPUT
+        $< $DEFAULT_INPUT
+        $$ $PID $PROCESS_ID
+        $? $CHILD_STATUS
+        $~ $LAST_MATCH_INFO
+        $= $IGNORECASE
+        $* $ARGV
+        $& $MATCH
+        $` $PREMATCH
+        $' $POSTMATCH
+        $+ $LAST_PAREN_MATCH
+        $stdin $stdout $stderr
+        $DEBUG $FILENAME $VERBOSE
+        $-0 $-a $-d $-F $-i $-I $-l $-p $-v $-w
+      )
+
+      def on_gvar(node)
+        check(node)
+
+        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
+  end
+end

data/lib/rubocop/cop/avoid_perl_backrefs.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class AvoidPerlBackrefs < Cop
+      def on_nth_ref(node)
+        backref, = *node
+
+        add_offence(:convention,
+                    node.loc.line,
+                    "Prefer the use of MatchData over $#{backref}.")
+
+        super
+      end
+    end
+  end
+end

data/lib/rubocop/cop/avoid_perlisms.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class AvoidPerlisms < Cop
+      PREFERRED_VARS = {
+        '$:' => '$LOAD_PATH',
+        '$"' => '$LOADED_FEATURES',
+        '$0' => '$PROGRAM_NAME',
+        '$!' => '$ERROR_INFO from English library',
+        '$@' => '$ERROR_POSITION from English library',
+        '$;' => '$FS or $FIELD_SEPARATOR from English library',
+        '$,' => '$OFS or $OUTPUT_FIELD_SEPARATOR from English library',
+        '$/' => '$RS or $INPUT_RECORD_SEPARATOR from English library',
+        '$\\' => '$ORS or $OUTPUT_RECORD_SEPARATOR from English library',
+        '$.' => '$NR or $INPUT_LINE_NUMBER from English library',
+        '$_' => '$LAST_READ_LINE from English library',
+        '$>' => '$DEFAULT_OUTPUT from English library',
+        '$<' => '$DEFAULT_INPUT from English library',
+        '$$' => '$PID or $PROCESS_ID from English library',
+        '$?' => '$CHILD_STATUS from English library',
+        '$~' => '$LAST_MATCH_INFO from English library',
+        '$=' => '$IGNORECASE from English library',
+        '$*' => '$ARGV from English library or ARGV constant',
+        '$&' => '$MATCH from English library',
+        '$`' => '$PREMATCH from English library',
+        '$\'' => '$POSTMATCH from English library',
+        '$+' => '$LAST_PAREN_MATCH from English library'
+      }
+
+      def on_gvar(node)
+        global_var, = *node
+        global_var = global_var.to_s
+
+        if PREFERRED_VARS[global_var]
+          add_offence(
+            :convention,
+            node.loc.line,
+            "Prefer #{PREFERRED_VARS[global_var]} over #{global_var}."
+          )
+        end
+
+        super
+      end
+    end
+  end
+end

data/lib/rubocop/cop/block_comments.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class BlockComments < Cop
+      MSG = 'Do not use block comments.'
+
+      def on_comment(comment)
+        if comment.text.start_with?('=begin')
+          add_offence(:convention, comment.loc.line, MSG)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class CaseIndentation < Cop
+      MSG = 'Indent when as deep as case.'
+
+      def on_case(case_node)
+        _condition, *whens, _else = *case_node
+
+        case_column = case_node.location.keyword.column
+
+        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
+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

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class ClassMethods < Cop
+      MSG = 'Prefer self over class/module for class/module methods.'
+
+      def on_defs(node)
+        definee, _name, _args, _body = *node
+
+        add_offence(:convention, node.loc.line, MSG) if definee.type == :const
+      end
+    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

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class ColonMethodCall < Cop
+      MSG = 'Do not use :: for method invocation.'
+
+      def on_send(node)
+        receiver, _method_name, *_args = *node
+
+        # 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
+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