rubocop 0.7.2 → 0.8.0

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

@@ -3,12 +3,18 @@
 module Rubocop
   module Cop
     class Not < Cop
-      ERROR_MESSAGE = 'Use ! instead of not.'
+      MSG = 'Use ! instead of not.'
 
-      def inspect(file, source, tokens, sexp)
-        each_keyword('not', tokens) do |t|
-          add_offence(:convention, t.pos.lineno, ERROR_MESSAGE)
+      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

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

@@ -24,7 +24,7 @@ module Rubocop
       end
 
       def ==(other)
-        severity == other.severity and line_number == other.line_number and
+        severity == other.severity && line_number == other.line_number &&
           message == other.message
       end
 

data/lib/rubocop/cop/op_method.rb

@@ -3,33 +3,23 @@
 module Rubocop
   module Cop
     class OpMethod < Cop
-      ERROR_MESSAGE = 'When defining the %s operator, name its argument other.'
+      MSG = 'When defining the %s operator, name its argument other.'
 
-      def inspect(file, source, tokens, sexp)
-        each(:def, sexp) do |s|
-          if binary_operator?(s) && !%w([] []= <<).include?(s[1][1])
-            params = parameters(s[2])
-            unless params[0][1] == 'other'
-              add_offence(:convention,
-                          params[0][2].lineno,
-                          sprintf(ERROR_MESSAGE, s[1][1]))
-            end
-          end
-        end
-      end
+      BLACKLISTED = [:+@, :-@, :[], :[]=, :<<]
 
-      private
+      TARGET_ARGS = s(:args, s(:arg, :other))
 
-      def binary_operator?(def_sexp)
-        def_sexp[1][0] == :@op && parameters(def_sexp[2]).size == 1
-      end
+      def on_def(node)
+        name, args, _body = *node
 
-      def parameters(param_sexp)
-        if param_sexp[0] == :paren # param is surrounded by braces?
-          parameters(param_sexp[1])
-        else
-          param_sexp[1] || []
+        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

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

@@ -3,16 +3,16 @@
 module Rubocop
   module Cop
     class PercentR < Cop
-      ERROR_MESSAGE = 'Use %r only for regular expressions matching more ' +
+      MSG = 'Use %r only for regular expressions matching more ' +
         "than one '/' character."
 
-      def inspect(file, source, tokens, sexp)
-        tokens.each_cons(2) do |t1, t2|
-          if t1.type == :on_regexp_beg && t1.text =~ /^%r/ &&
-              t2.text !~ %r(/.*/)
-            add_offence(:convention, t1.pos.lineno, ERROR_MESSAGE)
-          end
+      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

data/lib/rubocop/cop/reduce_arguments.rb

@@ -3,64 +3,26 @@
 module Rubocop
   module Cop
     class ReduceArguments < Cop
-      ERROR_MESSAGE = 'Name reduce arguments |a, e| (accumulator, element)'
+      MSG = 'Name reduce arguments |a, e| (accumulator, element)'
 
-      def inspect(file, source, tokens, sexp)
-        find_reduce_blocks(tokens).each do |reduce_block|
-          l_ix, r_ix = reduce_block
-          unless arguments_named_properly?(l_ix, r_ix, tokens)
-            add_offence(:convention, tokens[l_ix].pos.lineno, ERROR_MESSAGE)
-          end
-        end
-      end
-
-      private
-
-      def arguments_named_properly?(l_ix, r_ix, tokens)
-        a, e = false, false
-        tokens[l_ix..r_ix].each do |t|
-          if a == true && [t.type, t.text] == [:on_ident, 'e']
-            e = true
-          elsif [t.type, t.text] == [:on_ident, 'a']
-            a = true
-          end
-        end
-        a && e
-      end
+      ARGS_NODE = s(:args, s(:arg, :a), s(:arg, :e))
 
-      def find_reduce_blocks(tokens)
-        blocks = []
-        tokens.each_with_index do |t, ix|
-          if [t.type, t.text] == [:on_ident, 'reduce']
-            # Make sure we didn't select a :reduce symbol
-            next if tokens[ix - 1].text == ':'
+      def on_block(node)
+        # we care only for single line blocks
+        return unless Util.block_length(node) == 0
 
-            block = find_brace_block(tokens, ix)
-            blocks << block if block
-          end
-        end
-        blocks
-      end
+        method_node, args_node, _body_node = *node
+        receiver, method_name, _method_args = *method_node
 
-      def find_brace_block(tokens, reduce_ix)
-        stack = []
-        block = false
+        # discard other scenarios
+        return unless receiver
+        return unless [:reduce, :inject].include?(method_name)
 
-        # When we find the braces we need to add reduce_ix in order to
-        # find the real tokens index, since we're looping through a subset
-        tokens[reduce_ix..-1].each_with_index do |t, ix|
-          break if t.pos.lineno != tokens[reduce_ix].pos.lineno
-          if [:on_lbrace, :on_tlambeg].include? t.type
-            stack.push ix + reduce_ix
-          elsif t.type == :on_rbrace
-            left_ix = stack.pop
-            ix += reduce_ix
-            block = [left_ix, ix] if (stack.empty? &&
-                                      tokens[left_ix].type != :on_tlambeg)
-          end
+        unless args_node == ARGS_NODE
+          add_offence(:convention, node.loc.line, MSG)
         end
 
-        block
+        super
       end
     end
   end

data/lib/rubocop/cop/rescue_exception.rb

@@ -3,39 +3,23 @@
 module Rubocop
   module Cop
     class RescueException < Cop
-      ERROR_MESSAGE = 'Avoid rescuing the Exception class.'
+      MSG = 'Avoid rescuing the Exception class.'
 
-      def inspect(file, source, tokens, sexp)
-        each(:rescue, sexp) do |s|
-          # TODO Improve handling of rescue One, Two => e
-          if valid_case?(s)
-            target_class = s[1][0][1][1]
-
-            lineno = s[1][0][1][2].lineno
-
-            add_offence(:warning,
-                        lineno,
-                        ERROR_MESSAGE) if target_class == 'Exception'
-          end
+      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 valid_case?(s)
-        if s[1].nil?
-          # rescue with no args
-          false
-        elsif s[1][0] == :mrhs_new_from_args
-          # rescue One, Two => e
-          false
-        elsif s[1][0][0] == :const_path_ref
-          # rescue Module::Class
-          false
-        elsif s[1][0] == :mrhs_add_star
-          # rescue *ERRORS
-          false
-        else
-          true
-        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

data/lib/rubocop/cop/rescue_modifier.rb

@@ -3,16 +3,13 @@
 module Rubocop
   module Cop
     class RescueModifier < Cop
-      ERROR_MESSAGE = 'Avoid using rescue in its modifier form.'
-
-      def inspect(file, source, tokens, sexp)
-        each(:rescue_mod, sexp) do |s|
-          ident = find_first(:@ident, s)
-          lineno = ident ? ident[2].lineno : nil
+      MSG = 'Avoid using rescue in its modifier form.'
 
+      def inspect(source, tokens, ast, comments)
+        on_node(:rescue, ast, :begin) do |s|
           add_offence(:convention,
-                      lineno,
-                      ERROR_MESSAGE) if lineno
+                      s.loc.line,
+                      MSG)
         end
       end
     end

data/lib/rubocop/cop/semicolon.rb

@@ -3,86 +3,27 @@
 module Rubocop
   module Cop
     class Semicolon < Cop
-      ERROR_MESSAGE = 'Do not use semicolons to terminate expressions.'
+      MSG = 'Do not use semicolons to terminate expressions.'
 
-      def inspect(file, source, tokens, sexp)
-        @tokens = tokens
-        already_checked_line = nil
-        tokens.each_with_index do |t, ix|
-          if t.type == :on_semicolon
-            next if t.pos.lineno == already_checked_line # fast-forward
-            token_1_ix = index_of_first_token_on_line(ix, t.pos.lineno)
-            if %w(def class module).include?(tokens[token_1_ix].text)
-              handle_exceptions_to_the_rule(token_1_ix)
-              if source[t.pos.lineno - 1] =~ /;\s*(#.*)?$/
-                # Semicolons at end of a lines are always reported.
-                add_offence(:convention, t.pos.lineno, ERROR_MESSAGE)
-              end
-              # When dealing with these one line definitions, we check
-              # the whole line at once. That's why we use the variable
-              # already_checked_line to know when to fast-forward past
-              # the current line.
-              already_checked_line = t.pos.lineno
-            else
-              add_offence(:convention, t.pos.lineno, ERROR_MESSAGE)
-            end
-          end
-        end
-      end
+      def inspect(source, tokens, ast, comments)
+        on_node(:begin, ast) do |node|
+          exprs = node.children
 
-      def index_of_first_token_on_line(ix, lineno)
-        # Index of last token on the previous line
-        prev_line_ix =
-          @tokens[0...ix].rindex { |t| t.pos.lineno < lineno } || -1
-        first = prev_line_ix + 1
-        # Index of first non-whitespace token on the current line.
-        first + @tokens[first..ix].index { |t| !whitespace?(t) }
-      end
+          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 }
 
-      def handle_exceptions_to_the_rule(token_1_ix)
-        # We only do further checking of the def case, which means
-        # that there are some cases of semicolon usage within
-        # non-empty one-line class or method definitions that we don't
-        # catch, but these should be rare.
-        if @tokens[token_1_ix].text == 'def'
-          state = :initial
-          @tokens[token_1_ix..-1].each do |t|
-            state = next_state(state, t) || state
-            break if t.text == 'end'
+          # 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
-      end
-
-      def next_state(state, token)
-        return nil if whitespace?(token) # no state change for whitespace
 
-        case state
-        when :initial
-          :def_kw if token.type == :on_kw
-        when :def_kw
-          :method_name if token.type == :on_ident
-        when :method_name
-          case token.type
-          when :on_lparen then :inside_param_list
-          when :on_semicolon then :method_body
-          end
-        when :inside_param_list
-          :right_after_param_list if token.type == :on_rparen
-        when :right_after_param_list
-          if token.type == :on_semicolon
-            unless Semicolon.config['AllowAfterParameterListInOneLineMethods']
-              add_offence(:convention, token.pos.lineno, ERROR_MESSAGE)
-            end
-          end
-          :method_body
-        when :method_body
-          :semicolon_used if token.type == :on_semicolon
-        when :semicolon_used
-          if token.text != 'end' ||
-              !Semicolon.config['AllowBeforeEndInOneLineMethods']
-            add_offence(:convention, token.pos.lineno, ERROR_MESSAGE)
-          end
-          :method_body
+        # 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