rubocop 0.8.3 → 0.9.0

data/lib/rubocop/cop/style/access_control.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # A couple of checks related to the use method visibility modifiers.
+      # Modifiers should be indented as deeps are method definitions and
+      # surrounded by blank lines.
+      class AccessControl < Cop
+        INDENT_MSG = 'Indent %s as deep as method definitions.'
+        BLANK_MSG = 'Keep a blank line before and after %s.'
+
+        PRIVATE_NODE = s(:send, nil, :private)
+        PROTECTED_NODE = s(:send, nil, :protected)
+        PUBLIC_NODE = s(:send, nil, :public)
+
+        def inspect(source_buffer, source, tokens, ast, comments)
+          return unless ast
+          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 modifier_node?(send_node)
+                  send_start_col = send_node.loc.expression.column
+                  selector = send_node.loc.selector.source
+
+                  if send_start_col - 2 != class_start_col
+                    add_offence(:convention,
+                                send_node.loc.expression,
+                                format(INDENT_MSG, selector))
+                  end
+
+                  send_line = send_node.loc.line
+
+                  unless source[send_line].chomp.empty? &&
+                      source[send_line - 2].chomp.empty?
+                    add_offence(:convention,
+                                send_node.loc.expression,
+                                format(BLANK_MSG, selector))
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        private
+
+        def modifier_node?(node)
+          [PRIVATE_NODE, PROTECTED_NODE, PUBLIC_NODE].include?(node)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/alias.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # The purpose of the this cop is advise the use of
+      # alias_method over the alias keyword whenever possible.
+      class Alias < Cop
+        MSG = 'Use alias_method instead of alias.'
+
+        # TODO make this check context aware - alias_method is not
+        # available outside of classes/modules.
+        def on_alias(node)
+          # alias_method can't be used with global variables
+          new, old = *node
+
+          return if new.type == :gvar && old.type == :gvar
+
+          add_offence(:convention,
+                      node.loc.keyword,
+                      MSG)
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/align_parameters.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # Here we check if the parameters on a multi-line method call are
+      # aligned.
+      class AlignParameters < Cop
+        MSG = 'Align the parameters of a method call if they span ' +
+          'more than one line.'
+
+        def on_send(node)
+          _receiver, method, *args = *node
+
+          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
+
+            args.each do |arg|
+              cur_arg_line = arg.loc.expression.line
+              cur_arg_col = arg.loc.expression.column
+
+              if cur_arg_line != prev_arg_line &&
+                  cur_arg_col != first_arg_col
+                add_offence(:convention, arg.loc.expression, MSG)
+              end
+
+              prev_arg_col = cur_arg_col
+              prev_arg_line = cur_arg_line
+            end
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/and_or.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for uses of *and* and *or*.
+      class AndOr < Cop
+        MSG = 'Use %s instead of %s.'
+
+        OPS = { 'and' => '&&', 'or' => '||' }
+
+        def on_and(node)
+          process_logical_op(node)
+
+          super
+        end
+
+        def on_or(node)
+          process_logical_op(node)
+
+          super
+        end
+
+        private
+
+        def process_logical_op(node)
+          op = node.loc.operator.source
+          op_type = node.type.to_s
+
+          if op == op_type
+            add_offence(:convention,
+                        node.loc.operator,
+                        sprintf(MSG, OPS[op], op))
+            do_autocorrect(node)
+          end
+        end
+
+        def autocorrect_action(node)
+          replacement = (node.type == :and ? '&&' : '||')
+          replace(node.loc.operator, replacement)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/ascii_comments.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for non-ascii (non-English) characters
+      # in comments.
+      class AsciiComments < Cop
+        MSG = 'Use only ascii symbols in comments.'
+
+        def inspect(source_buffer, source, tokens, ast, comments)
+          comments.each do |comment|
+            if comment.text =~ /[^\x00-\x7f]/
+              add_offence(:convention, comment.loc, MSG)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/ascii_identifiers.rb

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

data/lib/rubocop/cop/style/attr.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for uses of Module#attr.
+      class Attr < Cop
+        MSG = 'Do not use `attr`. Use `attr_reader` instead.'
+
+        def on_send(node)
+          if command?(:attr, node)
+            add_offence(:convention, node.loc.selector, MSG)
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/avoid_class_vars.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for uses of class variables. Offences
+      # are signaled only on assignment to class variables to
+      # reduced the number of offences that would be reported.
+      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, sprintf(MSG, class_var))
+          super
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/avoid_for.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop looks for uses of the *for* keyword.
+      class AvoidFor < Cop
+        MSG = 'Prefer *each* over *for*.'
+
+        def on_for(node)
+          add_offence(:convention, node.loc.keyword, MSG)
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/avoid_global_vars.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cops looks for uses of global variables.
+      # It does not report offences for built-in global variables.
+      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,
+                        MSG)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/avoid_perl_backrefs.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop looks for uses of Perl-style regexp match
+      # backreferences like $1, $2, etc.
+      class AvoidPerlBackrefs < Cop
+        def on_nth_ref(node)
+          backref, = *node
+
+          add_offence(:convention,
+                      node.loc.expression,
+                      "Prefer the use of MatchData over $#{backref}.")
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/avoid_perlisms.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop looks for uses of Perl-style global variables.
+      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.expression,
+              "Prefer #{PREFERRED_VARS[global_var]} over #{global_var}."
+            )
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/begin_block.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for BEGIN blocks.
+      class BeginBlock < Cop
+        MSG = 'Avoid the use of BEGIN blocks.'
+
+        def on_preexe(node)
+          add_offence(:convention, node.loc.keyword, MSG)
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/block_comments.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop looks for uses of block comments (=begin...=end).
+      class BlockComments < Cop
+        MSG = 'Do not use block comments.'
+
+        def inspect(source_buffer, source, tokens, ast, comments)
+          comments.each do |comment|
+            if comment.text.start_with?('=begin')
+              add_offence(:convention, comment.loc, MSG)
+            end
+          end
+        end
+      end
+    end
+  end
+end