rubocop 0.7.2 → 0.8.0

data/lib/rubocop/cop/favor_unless_over_negated_if.rb

@@ -3,17 +3,17 @@
 module Rubocop
   module Cop
     module FavorOtherKeywordOverNegation
-      private
-      def check(grammar_part, sexp)
-        each(grammar_part, sexp) do |s|
-          # Don't complain about negative if/else. We don't want unless/else.
-          next if s[3] && [:else, :elsif].include?(s[3][0])
+      def check(node)
+        condition, _body, _rest = *node
 
-          condition = s[1]
-          condition = condition[1][0] while condition[0] == :paren
+        # Look at last expression of contents if there's a parenthesis
+        # around condition.
+        *_, condition = *condition while condition.type == :begin
 
-          if condition[0] == :unary && [:!, :not].include?(condition[1])
-            add_offence(:convention, all_positions(s).first.lineno,
+        if condition.type == :send
+          _object, method = *condition
+          if method == :! && !(node.loc.respond_to?(:else) && node.loc.else)
+            add_offence(:convention, node.loc.expression.line,
                         error_message)
           end
         end
@@ -23,24 +23,26 @@ module Rubocop
     class FavorUnlessOverNegatedIf < Cop
       include FavorOtherKeywordOverNegation
 
-      def error_message
-        'Favor unless (or control flow or) over if for negative conditions.'
+      def on_if(node)
+        check(node)
+        super
       end
 
-      def inspect(file, source, tokens, sexp)
-        [:if, :if_mod].each { |grammar_part| check(grammar_part, sexp) }
+      def error_message
+        'Favor unless (or control flow or) over if for negative conditions.'
       end
     end
 
     class FavorUntilOverNegatedWhile < Cop
       include FavorOtherKeywordOverNegation
 
-      def error_message
-        'Favor until over while for negative conditions.'
+      def on_while(node)
+        check(node)
+        super
       end
 
-      def inspect(file, source, tokens, sexp)
-        [:while, :while_mod].each { |grammar_part| check(grammar_part, sexp) }
+      def error_message
+        'Favor until over while for negative conditions.'
       end
     end
   end

data/lib/rubocop/cop/handle_exceptions.rb

@@ -3,18 +3,14 @@
 module Rubocop
   module Cop
     class HandleExceptions < Cop
-      ERROR_MESSAGE = 'Do not suppress exceptions.'
+      MSG = 'Do not suppress exceptions.'
 
-      def inspect(file, source, tokens, sexp)
-        each(:begin, sexp) do |s|
-          each(:rescue, s) do |rs|
-            if rs[3] == [[:void_stmt]]
-              add_offence(:warning,
-                          all_positions(s)[-1].lineno + 1,
-                          ERROR_MESSAGE)
-            end
-          end
-        end
+      def on_resbody(node)
+        _exc_list_node, _exc_var_node, body_node = *node
+
+        add_offence(:warning, node.loc.line, MSG) if body_node.type == :nil
+
+        super
       end
     end
   end

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.any? do |key|
-            ![: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 && %w(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

@@ -3,15 +3,12 @@
 module Rubocop
   module Cop
     class LeadingCommentSpace < Cop
-      ERROR_MESSAGE = 'Missing space after #.'
+      MSG = 'Missing space after #.'
 
-      def inspect(file, source, tokens, sexp)
-        tokens.each_index do |ix|
-          t = tokens[ix]
-          if t.type == :on_comment && t.text =~ /^#+[^#\s]/
-            unless t.text.start_with?('#!') && t.pos.lineno == 1
-              add_offence(:convention, t.pos.lineno, ERROR_MESSAGE)
-            end
+      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

data/lib/rubocop/cop/line_continuation.rb

@@ -3,14 +3,11 @@
 module Rubocop
   module Cop
     class LineContinuation < Cop
-      ERROR_MESSAGE = 'Avoid the use of the line continuation character(/).'
+      MSG = 'Avoid the use of the line continuation character(\).'
 
-      def inspect(file, source, tokens, sexp)
-        tokens.each_index do |ix|
-          t = tokens[ix]
-          if t.type == :on_sp && t.text == "\\\n"
-            add_offence(:convention, t.pos.lineno, ERROR_MESSAGE)
-          end
+      def inspect(source, tokens, ast, comments)
+        source.each_with_index do |line, index|
+          add_offence(:convention, index, MSG) if line =~ /.*\\\z/
         end
       end
     end

data/lib/rubocop/cop/line_length.rb

@@ -3,13 +3,13 @@
 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

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,29 +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_]+[!?=]?$/
-      CONSTANT = /^[A-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]) unless s[1][1][1] =~ CONSTANT
-          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(type, name, pos)
-        if [:@ivar, :@ident, :@const].include?(type) && name !~ SNAKE_CASE
-          add_offence(:convention, pos.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

@@ -3,52 +3,49 @@
 module Rubocop
   module Cop
     class MethodLength < Cop
-      ERROR_MESSAGE = 'Method has too many lines. [%d/%d]'
-
-      def inspect(file, source, tokens, sexp)
-        def_token_indices(tokens, source).each do |t_ix|
-          def_lineno, end_lineno = def_and_end_lines(tokens, t_ix)
-          length = calculate_length(def_lineno, end_lineno, source)
-
-          max = MethodLength.config['Max']
-          if length > max
-            message = sprintf(ERROR_MESSAGE, length, max)
-            add_offence(:convention, def_lineno, message)
-          end
-        end
+      MSG = 'Method has too many lines. [%d/%d]'
+
+      def on_def(node)
+        check(node)
+
+        super
       end
 
-      private
+      def on_defs(node)
+        check(node)
 
-      def calculate_length(def_lineno, end_lineno, source)
-        lines = source[def_lineno..(end_lineno - 2)].reject(&:empty?)
-        unless MethodLength.config['CountComments']
-          lines = lines.reject { |line| line =~ /^\s*#/ }
-        end
-        lines.size
+        super
       end
 
-      def def_token_indices(tokens, source)
-        tokens.each_index.select do |ix|
-          t = tokens[ix]
+      def max_length
+        MethodLength.config['Max']
+      end
 
-          # Need to check:
-          # 1. if the previous character is a ':' to prevent matching ':def'
-          # 2. if the method is a one line, which we will ignore
-          [t.type, t.text] == [:on_kw, 'def'] &&
-            source[t.pos.lineno - 1][t.pos.column - 1] != ':' &&
-            source[t.pos.lineno - 1] !~ /^\s*def.*(?:\(.*\)|;).*end\s*$/
-        end
+      def count_comments?
+        MethodLength.config['CountComments']
       end
 
-      # Find the matching 'end' based on the indentation of 'def'
-      # Fall back to last token if indentation cannot be matched
-      def def_and_end_lines(tokens, t_ix)
-        t1 = tokens[t_ix]
-        t2 = tokens[(t_ix + 1)..-1].find(-> { tokens[-1] }) do |t|
-          [t1.pos.column, t.type, t.text] == [t.pos.column, :on_kw, '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
-        [t1.pos.lineno, t2.pos.lineno]
+      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