rubocop 0.4.0 → 0.8.0

data/lib/rubocop/cop/hash_syntax.rb

@@ -3,22 +3,37 @@
 module Rubocop
   module Cop
     class HashSyntax < Cop
-      ERROR_MESSAGE = 'Ruby 1.8 hash syntax detected'
-
-      def inspect(file, source, tokens, sexp)
-        each(:assoclist_from_args, sexp) do |assoclist_from_args|
-          keys = assoclist_from_args[1].map { |assoc_new| assoc_new[1][0] }
-          # If at least one of the keys in the hash is neither a symbol (:a)
-          # nor a label (a:), we can't require the new syntax.
-          return if keys.find do |key|
-            not [:symbol_literal, :@label].include?(key)
+      MSG = 'Ruby 1.8 hash syntax detected'
+
+      def on_hash(node)
+        pairs = *node
+
+        sym_indices = pairs.all? { |p| word_symbol_pair?(p) }
+
+        if sym_indices
+          pairs.each do |pair|
+            if pair.loc.operator && pair.loc.operator.source == '=>'
+              add_offence(:convention,
+                          pair.loc.line,
+                          MSG)
+            end
           end
         end
-        each(:assoc_new, sexp) do |assoc_new|
-          if assoc_new[1][0] == :symbol_literal
-            add_offence(:convention, assoc_new[1][1][1][-1].lineno,
-                        ERROR_MESSAGE)
-          end
+
+        super
+      end
+
+      private
+
+      def word_symbol_pair?(pair)
+        key, _value = *pair
+
+        if key.type == :sym
+          sym_name = key.to_a[0]
+
+          sym_name =~ /\A\w+\z/
+        else
+          false
         end
       end
     end

data/lib/rubocop/cop/if_then_else.rb

@@ -3,43 +3,34 @@
 module Rubocop
   module Cop
     module IfThenElse
-      def inspect(file, source, tokens, sexp)
-        tokens.each_with_index do |t, ix|
-          if t.type == :on_kw && ['if', 'unless'].include?(t.text)
-            if kind_of_if(tokens, ix + 1) == self.class
-              add_offence(:convention, t.pos.lineno, error_message)
-            end
-          end
-        end
+      def on_if(node)
+        check(node)
+        super
+      end
+
+      def on_unless(node)
+        check(node)
+        super
       end
 
-      def kind_of_if(tokens, ix)
-        then_found = false
-        tokens[ix..-1].each do |t|
-          case t.type
-          when :on_kw
-            case t.text
-            when 'then' then then_found = true
-            when 'end'  then return OneLineConditional
-            end
-          when :on_ignored_nl, :on_nl
-            break
-          when :on_semicolon
-            return IfWithSemicolon
-          when :on_comment
-            break if t.text =~ /\n/
-          when :on_sp
-            nil
-          else
-            then_found = false
-          end
+      def check(node)
+        # We won't check modifier or ternary conditionals.
+        if node.loc.expression.source =~ /\A(if|unless)\b/
+          line = offending_line(node)
+          add_offence(:convention, line, error_message) if line
         end
-        then_found ? MultilineIfThen : nil
       end
     end
 
     class IfWithSemicolon < Cop
       include IfThenElse
+
+      def offending_line(node)
+        if node.loc.begin && node.loc.begin.source == ';'
+          node.loc.begin.line
+        end
+      end
+
       def error_message
         'Never use if x; Use the ternary operator instead.'
       end
@@ -47,6 +38,13 @@ module Rubocop
 
     class MultilineIfThen < Cop
       include IfThenElse
+
+      def offending_line(node)
+        if node.loc.expression.source =~ /\bthen\s*(#.*)?\s*$/
+          node.loc.begin.line
+        end
+      end
+
       def error_message
         'Never use then for multi-line if/unless.'
       end
@@ -54,6 +52,11 @@ module Rubocop
 
     class OneLineConditional < Cop
       include IfThenElse
+
+      def offending_line(node)
+        node.loc.expression.line unless node.loc.expression.source =~ /\n/
+      end
+
       def error_message
         'Favor the ternary operator (?:) over if/then/else/end constructs.'
       end

data/lib/rubocop/cop/leading_comment_space.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class LeadingCommentSpace < Cop
+      MSG = 'Missing space after #.'
+
+      def on_comment(c)
+        if c.text =~ /^#+[^#\s]/
+          unless c.text.start_with?('#!') && c.loc.line == 1
+            add_offence(:convention, c.loc.line, MSG)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/line_continuation.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class LineContinuation < Cop
+      MSG = 'Avoid the use of the line continuation character(\).'
+
+      def inspect(source, tokens, ast, comments)
+        source.each_with_index do |line, index|
+          add_offence(:convention, index, MSG) if line =~ /.*\\\z/
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/line_length.rb

@@ -3,20 +3,20 @@
 module Rubocop
   module Cop
     class LineLength < Cop
-      ERROR_MESSAGE = 'Line is too long. [%d/%d]'
+      MSG = 'Line is too long. [%d/%d]'
 
-      def inspect(file, source, tokens, sexp)
+      def inspect(source, tokens, ast, comments)
         source.each_with_index do |line, index|
           max = LineLength.max
           if line.length > max
-            message = sprintf(ERROR_MESSAGE, line.length, max)
+            message = sprintf(MSG, line.length, max)
             add_offence(:convention, index + 1, message)
           end
         end
       end
 
       def self.max
-        LineLength.config ? LineLength.config['Max'] || 79 : 79
+        LineLength.config['Max']
       end
     end
   end

data/lib/rubocop/cop/loop.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class Loop < Cop
+      MSG = 'Use Kernel#loop with break rather than begin/end/until(or while).'
+
+      def on_while(node)
+        check(node)
+
+        super
+      end
+
+      def on_until(node)
+        check(node)
+
+        super
+      end
+
+      private
+
+      def check(node)
+        _cond, body = *node
+        type = node.type.to_s
+
+        if body.type == :begin &&
+            !node.loc.expression.source.start_with?(type)
+          add_offence(:warning, node.loc.keyword.line, MSG)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/method_and_variable_snake_case.rb

@@ -3,28 +3,52 @@
 module Rubocop
   module Cop
     class MethodAndVariableSnakeCase < Cop
-      ERROR_MESSAGE = 'Use snake_case for methods and variables.'
+      MSG = 'Use snake_case for methods and variables.'
       SNAKE_CASE = /^@?[\da-z_]+[!?=]?$/
 
-      def inspect(file, source, tokens, sexp)
-        each(:def, sexp) { |s| check(s[1]) }
-
-        each(:assign, sexp) do |s|
-          case s[1][0]
-          when :var_field
-            check(s[1][1])
-          when :field
-            if s[1][1][0] == :var_ref && s[1][1][1][0..1] == [:@kw, 'self']
-              check(s[1][3])
-            end
-          end
+      # http://phrogz.net/programmingruby/language.html#table_18.4
+      OPERATOR_METHODS = %w(
+        | ^ & <=> == === =~ > >= < <= << >>
+        + - * / % ** ~ +@ -@ [] []= ` ! != !~
+      ).map(&:to_sym)
+
+      def inspect(source, tokens, node, comments)
+        on_node([:def, :defs, :lvasgn, :ivasgn, :send], node) do |n|
+          name = case n.type
+                 when :def
+                   name_of_instance_method(n)
+                 when :defs
+                   name_of_singleton_method(n)
+                 when :lvasgn, :ivasgn
+                   name_of_variable(n)
+                 when :send
+                   name_of_setter(n)
+                 end
+
+          next unless name
+          next if name =~ SNAKE_CASE || OPERATOR_METHODS.include?(name)
+
+          add_offence(:convention, n.location.line, MSG)
         end
       end
 
-      def check(sexp)
-        if [:@ivar, :@ident].include?(sexp[0]) && sexp[1] !~ SNAKE_CASE
-          add_offence(:convention, sexp[2].lineno, ERROR_MESSAGE)
-        end
+      def name_of_instance_method(def_node)
+        def_node.children.first
+      end
+
+      def name_of_singleton_method(defs_node)
+        defs_node.children[1]
+      end
+
+      def name_of_variable(vasgn_node)
+        vasgn_node.children.first
+      end
+
+      def name_of_setter(send_node)
+        receiver, method_name = *send_node
+        return nil unless receiver && receiver.type == :self
+        return nil unless method_name.to_s.end_with?('=')
+        method_name
       end
     end
   end

data/lib/rubocop/cop/method_length.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class MethodLength < Cop
+      MSG = 'Method has too many lines. [%d/%d]'
+
+      def on_def(node)
+        check(node)
+
+        super
+      end
+
+      def on_defs(node)
+        check(node)
+
+        super
+      end
+
+      def max_length
+        MethodLength.config['Max']
+      end
+
+      def count_comments?
+        MethodLength.config['CountComments']
+      end
+
+      private
+
+      def check(node)
+        method_length = calculate_length(node.loc.expression.source)
+
+        if method_length > max_length
+          message = sprintf(MSG, method_length, max_length)
+          add_offence(:convention, node.loc.keyword.line, message)
+        end
+      end
+
+      def calculate_length(source)
+        lines = source.lines.to_a[1...-1]
+
+        return 0 unless lines
+
+        lines.map!(&:strip).reject!(&:empty?)
+
+        lines.reject! { |line| line =~ /^\s*#/ } unless count_comments?
+
+        lines.size
+      end
+    end
+  end
+end

data/lib/rubocop/cop/new_lambda_literal.rb

@@ -3,14 +3,16 @@
 module Rubocop
   module Cop
     class NewLambdaLiteral < Cop
-      ERROR_MESSAGE = 'The new lambda literal syntax is preferred in Ruby 1.9.'
+      MSG = 'Use the new lambda literal syntax ->(params) {...}.'
 
-      def inspect(file, source, tokens, sexp)
-        each(:fcall, sexp) do |s|
-          if s[1][0..1] == [:@ident, 'lambda']
-            add_offence(:convention, s[1][-1].lineno, ERROR_MESSAGE)
-          end
+      TARGET = s(:send, nil, :lambda)
+
+      def on_send(node)
+        if node == TARGET && node.loc.selector.source != '->'
+          add_offence(:convention, node.loc.line, MSG)
         end
+
+        super
       end
     end
   end

data/lib/rubocop/cop/not.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class Not < Cop
+      MSG = 'Use ! instead of not.'
+
+      def on_send(node)
+        _receiver, method_name, *args = *node
+
+        # not does not take any arguments
+        if args.empty? && method_name == :! &&
+            node.loc.selector.source == 'not'
+          add_offence(:convention, node.loc.line, MSG)
+        end
+
+        super
+      end
+    end
+  end
+end

data/lib/rubocop/cop/numeric_literals.rb

@@ -3,17 +3,19 @@
 module Rubocop
   module Cop
     class NumericLiterals < Cop
-      ERROR_MESSAGE = 'Add underscores to large numeric literals to ' +
+      MSG = 'Add underscores to large numeric literals to ' +
         'improve their readability.'
 
-      def inspect(file, source, tokens, sexp)
-        tokens.each do |t|
-          if [:on_int, :on_float].include?(t.type) &&
-              t.text.split('.').grep(/\d{6}/).any?
-            add_offence(:convention, t.pos.lineno, ERROR_MESSAGE)
-          end
+      def on_int(node)
+        value, = *node
+
+        if value > 10000 &&
+            node.loc.expression.source.split('.').grep(/\d{6}/).any?
+          add_offence(:convention, node.loc.expression.line, MSG)
         end
       end
+
+      alias_method :on_float, :on_int
     end
   end
 end

data/lib/rubocop/cop/offence.rb

@@ -14,12 +14,23 @@ module Rubocop
       end
 
       def to_s
-        "#{encode_severity}:%3d: #{message}" % [line_number]
+        # we must be wary of messages containing % in them
+        sprintf("#{encode_severity}:%3d: #{message.gsub(/%/, '%%')}",
+                line_number)
       end
 
       def encode_severity
         @severity.to_s[0].upcase
       end
+
+      def ==(other)
+        severity == other.severity && line_number == other.line_number &&
+          message == other.message
+      end
+
+      def explode
+        [severity, line_number, message]
+      end
     end
   end
 end

data/lib/rubocop/cop/op_method.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class OpMethod < Cop
+      MSG = 'When defining the %s operator, name its argument other.'
+
+      BLACKLISTED = [:+@, :-@, :[], :[]=, :<<]
+
+      TARGET_ARGS = s(:args, s(:arg, :other))
+
+      def on_def(node)
+        name, args, _body = *node
+
+        if name !~ /\A\w/ && !BLACKLISTED.include?(name) &&
+            args.children.size == 1 && args != TARGET_ARGS
+          add_offence(:convention,
+                      node.loc.line,
+                      sprintf(MSG, name))
+        end
+
+        super
+      end
+    end
+  end
+end

data/lib/rubocop/cop/parameter_lists.rb

@@ -3,14 +3,20 @@
 module Rubocop
   module Cop
     class ParameterLists < Cop
-      ERROR_MESSAGE = 'Avoid parameter lists longer than four parameters.'
+      MSG = 'Avoid parameter lists longer than %d parameters.'
 
-      def inspect(file, source, tokens, sexp)
-        each(:params, sexp) do |params|
-          if params[1] && params[1].size > 4
-            add_offence(:convention, params[1][0][-1].lineno, ERROR_MESSAGE)
-          end
+      def on_args(node)
+        args_count = node.children.size
+
+        if args_count > max_params
+          add_offence(:convention, node.loc.line, sprintf(MSG, max_params))
         end
+
+        super
+      end
+
+      def max_params
+        ParameterLists.config['Max']
       end
     end
   end

data/lib/rubocop/cop/parentheses_around_condition.rb

@@ -3,19 +3,19 @@
 module Rubocop
   module Cop
     class ParenthesesAroundCondition < Cop
-      ERROR_MESSAGE = "Don't use parentheses around the condition of an " +
+      MSG = "Don't use parentheses around the condition of an " +
         'if/unless/while/until, unless the condition contains an assignment.'
 
-      def inspect(file, source, tokens, sexp)
-        [:if, :elsif, :unless, :while, :until,
-         :if_mod, :unless_mod, :while_mod, :until_mod].each do |keyword|
-          each(keyword, sexp) do |s|
-            if s[1][0] == :paren && s[1][1][0][0] != :assign
-              positions = all_positions(s[1])
-              if positions.first.lineno == positions.last.lineno
-                add_offence(:convention, positions.first.lineno, ERROR_MESSAGE)
-              end
-            end
+      def inspect(source, tokens, ast, comments)
+        on_node([:if, :while, :until], ast) do |node|
+          cond, _body = *node
+
+          cond_source = cond.loc.expression.source
+
+          if cond_source.start_with?('(') && cond_source.end_with?(')')
+            add_offence(:convetion,
+                        cond.loc.line,
+                        MSG)
           end
         end
       end

data/lib/rubocop/cop/percent_r.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class PercentR < Cop
+      MSG = 'Use %r only 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/reduce_arguments.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class ReduceArguments < Cop
+      MSG = 'Name reduce arguments |a, e| (accumulator, element)'
+
+      ARGS_NODE = s(:args, s(:arg, :a), s(:arg, :e))
+
+      def on_block(node)
+        # we care only for single line blocks
+        return unless Util.block_length(node) == 0
+
+        method_node, args_node, _body_node = *node
+        receiver, method_name, _method_args = *method_node
+
+        # discard other scenarios
+        return unless receiver
+        return unless [:reduce, :inject].include?(method_name)
+
+        unless args_node == ARGS_NODE
+          add_offence(:convention, node.loc.line, MSG)
+        end
+
+        super
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rescue_exception.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class RescueException < Cop
+      MSG = 'Avoid rescuing the Exception class.'
+
+      def on_resbody(node)
+        return unless node.children.first
+        rescue_args = node.children.first.children
+        if rescue_args.any? { |a| targets_exception?(a) }
+          add_offence(:warning, node.location.line, MSG)
+        end
+
+        super
+      end
+
+      def targets_exception?(rescue_arg_node)
+        return false unless rescue_arg_node.type == :const
+        namespace, klass_name = *rescue_arg_node
+        return false unless namespace.nil? || namespace.type == :cbase
+        klass_name == :Exception
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rescue_modifier.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class RescueModifier < Cop
+      MSG = 'Avoid using rescue in its modifier form.'
+
+      def inspect(source, tokens, ast, comments)
+        on_node(:rescue, ast, :begin) do |s|
+          add_offence(:convention,
+                      s.loc.line,
+                      MSG)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/semicolon.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class Semicolon < Cop
+      MSG = 'Do not use semicolons to terminate expressions.'
+
+      def inspect(source, tokens, ast, comments)
+        on_node(:begin, ast) do |node|
+          exprs = node.children
+
+          next if exprs.size < 2
+
+          # create a map matching lines to the number of expressions on them
+          exprs_lines = exprs.map { |e| e.loc.expression.line }
+          lines = exprs_lines.group_by { |i| i }
+
+          # every line with more than 1 expression on it is an offence
+          lines.each do |line, expr_on_line|
+            add_offence(:convention, line, MSG) if expr_on_line.size > 1
+          end
+        end
+
+        # not pretty reliable, but the best we can do for now
+        source.each_with_index do |line, index|
+          add_offence(:convention, index, MSG) if line =~ /;\s*\z/
+        end
+      end
+    end
+  end
+end