rubocop 0.9.1 → 0.10.0

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

@@ -0,0 +1,83 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for redundant uses of `self`. It is only needed when
+      # calling a write accessor on self.
+      #
+      # Special cases:
+      #
+      # We allow uses of `self` with operators because it would be awkward
+      # otherwise.
+      class RedundantSelf < Cop
+        MSG = 'Redundant `self` detected.'
+
+        def initialize
+          super
+          @allowed_send_nodes = []
+          @local_variables = []
+        end
+
+        # Assignment of self.x
+
+        def on_or_asgn(node)
+          lhs, _rhs = *node
+          allow_self(lhs)
+        end
+
+        alias_method :on_and_asgn, :on_or_asgn
+
+        def on_op_asgn(node)
+          lhs, _op, _rhs = *node
+          allow_self(lhs)
+        end
+
+        # Using self.x to distinguish from local variable x
+
+        def on_def(node)
+          @local_variables = []
+        end
+
+        def on_defs(node)
+          @local_variables = []
+        end
+
+        def on_lvasgn(node)
+          lhs, _rhs = *node
+          @local_variables << lhs
+        end
+
+        # Detect offences
+
+        def on_send(node)
+          receiver, method_name, *_args = *node
+          if receiver && receiver.type == :self
+            unless operator?(method_name) || keyword?(method_name) ||
+                @allowed_send_nodes.include?(node) ||
+                @local_variables.include?(method_name)
+              add_offence(:convention, receiver.loc.expression, MSG)
+            end
+          end
+        end
+
+        private
+
+        def operator?(method_name)
+          method_name.to_s =~ /\W/
+        end
+
+        def keyword?(method_name)
+          [:class, :for].include?(method_name)
+        end
+
+        def allow_self(node)
+          if node.type == :send
+            receiver, _method_name, *_args = *node
+            @allowed_send_nodes << node if receiver && receiver.type == :self
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -16,8 +16,6 @@ module Rubocop
                   error_message('only ') if slashes <= max
                 end
           add_offence(:convention, node.loc.expression, msg) if msg
-
-          super
         end
 
         def self.max_slashes

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

@@ -7,48 +7,40 @@ module Rubocop
       class RescueModifier < Cop
         MSG = 'Avoid using rescue in its modifier form.'
 
+        def on_rescue(node)
+          return if ignored_node?(node)
+
+          add_offence(:convention, node.loc.expression, MSG)
+        end
+
         def on_kwbegin(node)
           body, *_ = *node
-          return if normal_rescue?(body)
-          super
+          check_rescue(body)
         end
 
         def on_def(node)
           _method_name, _args, body = *node
-          return if normal_rescue?(body)
-          super
+          check_rescue(body)
         end
 
         def on_defs(node)
           _receiver, _method_name, _args, body = *node
-          return if normal_rescue?(body)
-          super
+          check_rescue(body)
         end
 
-        def normal_rescue?(node)
-          return false unless node
+        def check_rescue(node)
+          return unless node
 
           case node.type
           when :rescue
-            # Skip only the rescue node and continue processing its children.
-            process_regular_node(node)
-            true
+            ignore_node(node)
           when :ensure
             first_child = node.children.first
             if first_child && first_child.type == :rescue
-              process_regular_node(first_child)
-              true
-            else
-              false
+              ignore_node(first_child)
             end
-          else
-            false
           end
         end
-
-        def on_rescue(node)
-          add_offence(:convention, node.loc.expression, MSG)
-        end
       end
     end
   end

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

@@ -8,10 +8,10 @@ module Rubocop
       class Semicolon < Cop
         MSG = 'Do not use semicolons to terminate expressions.'
 
-        def inspect(source_buffer, source, tokens, ast, comments)
-          return unless ast
+        def investigate(processed_source)
+          return unless processed_source.ast
 
-          on_node(:begin, ast) do |node|
+          on_node(:begin, processed_source.ast) do |node|
             exprs = node.children
 
             next if exprs.size < 2
@@ -26,20 +26,26 @@ module Rubocop
                 # TODO: Find the correct position of the semicolon. We don't
                 # know if the first semicolon on the line is a separator of
                 # expressions. It's just a guess.
-                column = source[line - 1].index(';')
+                column = processed_source[line - 1].index(';')
                 add_offence(:convention,
-                            source_range(source_buffer, source[0...(line - 1)],
+                            source_range(processed_source.buffer,
+                                         processed_source[0...(line - 1)],
                                          column, 1),
                             MSG)
               end
             end
           end
 
-          tokens.group_by { |t| t.pos.line }.each do |line, line_tokens|
-            if line_tokens.last.type == :tSEMI # rubocop:disable SymbolName
-              column = line_tokens.last.pos.column
+          tokens_for_lines = processed_source.tokens.group_by do |token|
+            token.pos.line
+          end
+
+          tokens_for_lines.each do |line, tokens|
+            if tokens.last.type == :tSEMI # rubocop:disable SymbolName
+              column = tokens.last.pos.column
               add_offence(:convention,
-                          source_range(source_buffer, source[0...(line - 1)],
+                          source_range(processed_source.buffer,
+                                       processed_source[0...(line - 1)],
                                        column, 1),
                           MSG)
             end

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

@@ -14,14 +14,10 @@ module Rubocop
 
         def on_def(node)
           check(node)
-
-          super
         end
 
         def on_defs(node)
           check(node)
-
-          super
         end
 
         private

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

@@ -10,8 +10,8 @@ module Rubocop
       module SpaceAfterCommaEtc
         MSG = 'Space missing after %s.'
 
-        def inspect(source_buffer, source, tokens, ast, comments)
-          tokens.each_cons(2) do |t1, t2|
+        def investigate(processed_source)
+          processed_source.tokens.each_cons(2) do |t1, t2|
             if kind(t1) && t1.pos.line == t2.pos.line &&
                 t2.pos.column == t1.pos.column + offset(t1)
               add_offence(:convention, t1.pos, sprintf(MSG, kind(t1)))

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

@@ -23,7 +23,6 @@ module Rubocop
         KEYWORDS.each do |keyword|
           define_method(:"on_#{keyword}") do |node|
             on_keyword(node)
-            super(node)
           end
         end
       end

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

@@ -12,6 +12,7 @@ module Rubocop
           # Constants like __FILE__ are handled as strings,
           # but don't respond to begin.
           return unless node.loc.respond_to?(:begin)
+          return if part_of_ignored_node?(node)
 
           # regex matches IF there is a ' or there is a \\ in the string that
           # is not preceeded/followed by another \\ (e.g. "\\x34") but not
@@ -27,8 +28,10 @@ module Rubocop
         alias_method :on_regexp, :ignore_node
 
         def autocorrect_action(node)
-          replace(node.loc.begin, "'")
-          replace(node.loc.end, "'")
+          @corrections << lambda do |corrector|
+            corrector.replace(node.loc.begin, "'")
+            corrector.replace(node.loc.end, "'")
+          end
         end
       end
     end

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

@@ -9,36 +9,36 @@ module Rubocop
       module SurroundingSpace
         def space_between?(t1, t2)
           char_preceding_2nd_token =
-            @source[t2.pos.line - 1][t2.pos.column - 1]
+            @processed_source[t2.pos.line - 1][t2.pos.column - 1]
           if char_preceding_2nd_token == '+' && t1.type != :tPLUS
             # Special case. A unary plus is not present in the tokens.
             char_preceding_2nd_token =
-              @source[t2.pos.line - 1][t2.pos.column - 2]
+              @processed_source[t2.pos.line - 1][t2.pos.column - 2]
           end
           t2.pos.line > t1.pos.line || char_preceding_2nd_token == ' '
         end
 
-        def index_of_first_token(node, tokens)
-          @token_table ||= build_token_table(tokens)
+        def index_of_first_token(node)
           b = node.loc.expression.begin
-          @token_table[[b.line, b.column]]
+          token_table[[b.line, b.column]]
         end
 
-        def index_of_last_token(node, tokens)
-          @token_table ||= build_token_table(tokens)
+        def index_of_last_token(node)
           e = node.loc.expression.end
           (0...e.column).to_a.reverse.find do |c|
-            ix = @token_table[[e.line, c]]
+            ix = token_table[[e.line, c]]
             return ix if ix
           end
         end
 
-        def build_token_table(tokens)
-          table = {}
-          tokens.each_with_index do |t, ix|
-            table[[t.pos.line, t.pos.column]] = ix
+        def token_table
+          @token_table ||= begin
+            table = {}
+            @processed_source.tokens.each_with_index do |t, ix|
+              table[[t.pos.line, t.pos.column]] = ix
+            end
+            table
           end
-          table
         end
       end
 
@@ -55,12 +55,10 @@ module Rubocop
            :tNMATCH, :tEQ,      :tNEQ,   :tGT,    :tRSHFT, :tGEQ,   :tLT,
            :tLSHFT,  :tLEQ,     :tASSOC, :tEQQ,   :tCMP,   :tOP_ASGN]
 
-        def inspect(source_buffer, source, tokens, sexp, comments)
-          return unless sexp
-
-          @source = source
-          positions_not_to_check = get_positions_not_to_check(tokens, sexp)
-
+        def investigate(processed_source)
+          return unless processed_source.ast
+          @processed_source = processed_source
+          tokens = processed_source.tokens
           tokens.each_cons(3) do |token_before, token, token_after|
             next if token_before.type == :kDEF # TODO: remove?
             next if token_before.type == :tDOT # Called as method.
@@ -80,77 +78,87 @@ module Rubocop
         # Returns an array of positions marking the tokens that this cop
         # should not check, either because the token is not an operator
         # or because another cop does the check.
-        def get_positions_not_to_check(tokens, sexp)
-          positions_not_to_check = []
-          do_not_check_block_arg_pipes(sexp, positions_not_to_check)
-          do_not_check_param_default(tokens, sexp, positions_not_to_check)
-          do_not_check_class_lshift_self(tokens, sexp, positions_not_to_check)
-          do_not_check_def_things(tokens, sexp, positions_not_to_check)
-          do_not_check_singleton_operator_defs(tokens, sexp,
-                                               positions_not_to_check)
-          positions_not_to_check
+        def positions_not_to_check
+          @positions_not_to_check ||= begin
+            positions = []
+            positions.concat(do_not_check_block_arg_pipes)
+            positions.concat(do_not_check_param_default)
+            positions.concat(do_not_check_class_lshift_self)
+            positions.concat(do_not_check_def_things)
+            positions.concat(do_not_check_singleton_operator_defs)
+            positions
+          end
         end
 
-        def do_not_check_block_arg_pipes(sexp, positions_not_to_check)
+        def do_not_check_block_arg_pipes
           # each { |a| }
           #        ^ ^
-          on_node(:block, sexp) do |b|
+          positions = []
+          on_node(:block, @processed_source.ast) do |b|
             on_node(:args, b) do |a|
-              positions_not_to_check << a.loc.begin << a.loc.end if a.loc.begin
+              positions << a.loc.begin << a.loc.end if a.loc.begin
             end
           end
+          positions
         end
 
-        def do_not_check_param_default(tokens, sexp, positions_not_to_check)
+        def do_not_check_param_default
           # func(a, b=nil)
           #          ^
-          on_node(:optarg, sexp) do |optarg|
-            _arg, equals, _value = tokens[index_of_first_token(optarg, tokens),
+          positions = []
+          tokens = @processed_source.tokens
+          on_node(:optarg, @processed_source.ast) do |optarg|
+            _arg, equals, _value = tokens[index_of_first_token(optarg),
                                           3]
-            positions_not_to_check << equals.pos
+            positions << equals.pos
           end
+          positions
         end
 
-        def do_not_check_class_lshift_self(tokens,
-                                           sexp,
-                                           positions_not_to_check)
+        def do_not_check_class_lshift_self
           # class <<self
           #       ^
-          on_node(:sclass, sexp) do |sclass|
-            ix = index_of_first_token(sclass, tokens)
+          positions = []
+          tokens = @processed_source.tokens
+          on_node(:sclass, @processed_source.ast) do |sclass|
+            ix = index_of_first_token(sclass)
             if tokens[ix, 2].map(&:type) == [:kCLASS, :tLSHFT]
-              positions_not_to_check << tokens[ix + 1].pos
+              positions << tokens[ix + 1].pos
             end
           end
+          positions
         end
 
-        def do_not_check_def_things(tokens, sexp, positions_not_to_check)
+        def do_not_check_def_things
           # def +(other)
           #     ^
-          on_node(:def, sexp) do |def_node|
+          positions = []
+          tokens = @processed_source.tokens
+          on_node(:def, @processed_source.ast) do |def_node|
             # def each &block
             #          ^
             # def each *args
             #          ^
             on_node([:blockarg, :restarg], def_node) do |arg_node|
-              positions_not_to_check <<
-                tokens[index_of_first_token(arg_node, tokens)].pos
+              positions << tokens[index_of_first_token(arg_node)].pos
             end
-            positions_not_to_check <<
-              tokens[index_of_first_token(def_node, tokens) + 1].pos
+            positions << tokens[index_of_first_token(def_node) + 1].pos
           end
+          positions
         end
 
-        def do_not_check_singleton_operator_defs(tokens, sexp,
-                                                 positions_not_to_check)
+        def do_not_check_singleton_operator_defs
           # def self.===(other)
           #          ^
-          on_node(:defs, sexp) do |defs_node|
+          positions = []
+          tokens = @processed_source.tokens
+          on_node(:defs, @processed_source.ast) do |defs_node|
             _receiver, name, _args = *defs_node
-            ix = index_of_first_token(defs_node, tokens)
+            ix = index_of_first_token(defs_node)
             name_token = tokens[ix..-1].find { |t| t.text == name.to_s }
-            positions_not_to_check << name_token.pos
+            positions << name_token.pos
           end
+          positions
         end
 
         def check_missing_space(token_before, token, token_after)
@@ -172,11 +180,11 @@ module Rubocop
         MSG_LEFT = "Surrounding space missing for '{'."
         MSG_RIGHT = "Space missing to the left of '}'."
 
-        def inspect(source_buffer, source, tokens, sexp, comments)
-          return unless sexp
-          @source = source
-          positions_not_to_check = get_positions_not_to_check(tokens, sexp)
-          tokens.each_cons(2) do |t1, t2|
+        def investigate(processed_source)
+          return unless processed_source.ast
+          @processed_source = processed_source
+
+          processed_source.tokens.each_cons(2) do |t1, t2|
             next if ([t1.pos, t2.pos] - positions_not_to_check).size < 2
 
             type1, type2 = t1.type, t2.type
@@ -187,25 +195,30 @@ module Rubocop
           end
         end
 
-        def get_positions_not_to_check(tokens, sexp)
-          positions_not_to_check = []
+        def positions_not_to_check
+          @positions_not_to_check ||= begin
+            positions = []
+            ast = @processed_source.ast
+            tokens = @processed_source.tokens
 
-          on_node(:hash, sexp) do |hash|
-            b_ix = index_of_first_token(hash, tokens)
-            e_ix = index_of_last_token(hash, tokens)
-            positions_not_to_check << tokens[b_ix].pos << tokens[e_ix].pos
-          end
+            on_node(:hash, ast) do |hash|
+              b_ix = index_of_first_token(hash)
+              e_ix = index_of_last_token(hash)
+              positions << tokens[b_ix].pos << tokens[e_ix].pos
+            end
 
-          # TODO: Check braces inside string/symbol/regexp/xstr interpolation.
-          on_node([:dstr, :dsym, :regexp, :xstr], sexp) do |s|
-            b_ix = index_of_first_token(s, tokens)
-            e_ix = index_of_last_token(s, tokens)
-            tokens[b_ix..e_ix].each do |t|
-              positions_not_to_check << t.pos if t.type == :tRCURLY
+            # TODO: Check braces inside string/symbol/regexp/xstr
+            #   interpolation.
+            on_node([:dstr, :dsym, :regexp, :xstr], ast) do |s|
+              b_ix = index_of_first_token(s)
+              e_ix = index_of_last_token(s)
+              tokens[b_ix..e_ix].each do |t|
+                positions << t.pos if t.type == :tRCURLY
+              end
             end
-          end
 
-          positions_not_to_check
+            positions
+          end
         end
 
         def check(t1, t2, msg)
@@ -222,16 +235,16 @@ module Rubocop
         include SurroundingSpace
         MSG = 'Space inside %s detected.'
 
-        def inspect(source_buffer, source, tokens, sexp, comments)
-          @source = source
+        def investigate(processed_source)
+          @processed_source = processed_source
           left, right, kind = specifics
-          tokens.each_cons(2) do |t1, t2|
+          processed_source.tokens.each_cons(2) do |t1, t2|
             if t1.type == left || t2.type == right
               if t2.pos.line == t1.pos.line && space_between?(t1, t2)
-                space_range = Parser::Source::Range.new(source_buffer,
-                                                        t1.pos.end_pos,
-                                                        t2.pos.begin_pos)
-                add_offence(:convention, space_range, format(MSG, kind))
+                range = Parser::Source::Range.new(processed_source.buffer,
+                                                  t1.pos.end_pos,
+                                                  t2.pos.begin_pos)
+                add_offence(:convention, range, format(MSG, kind))
               end
             end
           end
@@ -262,12 +275,14 @@ module Rubocop
         include SurroundingSpace
         MSG = 'Space inside hash literal braces %s.'
 
-        def inspect(source_buffer, source, tokens, sexp, comments)
-          return unless sexp
-          @source = source
-          on_node(:hash, sexp) do |hash|
-            b_ix = index_of_first_token(hash, tokens)
-            e_ix = index_of_last_token(hash, tokens)
+        def investigate(processed_source)
+          return unless processed_source.ast
+          @processed_source = processed_source
+          tokens = processed_source.tokens
+
+          on_node(:hash, processed_source.ast) do |hash|
+            b_ix = index_of_first_token(hash)
+            e_ix = index_of_last_token(hash)
             if tokens[b_ix].type == :tLBRACE # Hash literal with braces?
               check(tokens[b_ix], tokens[b_ix + 1])
               check(tokens[e_ix - 1], tokens[e_ix])
@@ -297,12 +312,12 @@ module Rubocop
         include SurroundingSpace
         MSG = 'Surrounding space missing in default value assignment.'
 
-        def inspect(source_buffer, source, tokens, sexp, comments)
-          return unless sexp
-          @source = source
-          on_node(:optarg, sexp) do |optarg|
-            index = index_of_first_token(optarg, tokens)
-            arg, equals, value = tokens[index, 3]
+        def investigate(processed_source)
+          return unless processed_source.ast
+          @processed_source = processed_source
+          on_node(:optarg, processed_source.ast) do |optarg|
+            index = index_of_first_token(optarg)
+            arg, equals, value = processed_source.tokens[index, 3]
             unless space_between?(arg, equals) && space_between?(equals, value)
               add_offence(:convention, equals.pos, MSG)
             end