rubocop 0.7.2 → 0.8.0

data/lib/rubocop/cop/single_line_methods.rb

@@ -3,57 +3,41 @@
 module Rubocop
   module Cop
     class SingleLineMethods < Cop
-      ERROR_MESSAGE = 'Avoid single-line methods.'
+      MSG = 'Avoid single-line method definitions.'
 
-      def inspect(file, source, tokens, sexp)
-        if SingleLineMethods.config['AllowIfMethodIsEmpty']
-          is_empty = empty_methods(sexp)
-        end
+      def allow_empty?
+        SingleLineMethods.config['AllowIfMethodIsEmpty']
+      end
 
-        lineno_of_def = nil
-        possible_offence = false
-
-        tokens.each_with_index do |token, ix|
-          if possible_offence
-            if token.pos.lineno > lineno_of_def
-              possible_offence = false
-            elsif [token.type, token.text] == [:on_kw, 'end']
-              add_offence(:convention, lineno_of_def, ERROR_MESSAGE)
-            end
-          end
-
-          if [token.type, token.text] == [:on_kw, 'def']
-            lineno_of_def = token.pos.lineno
-            name_token = tokens[ix..-1].find do |t|
-              [:on_ident, :on_const].include?(t.type)
-            end
-            possible_offence =
-              if SingleLineMethods.config['AllowIfMethodIsEmpty']
-                !is_empty[name_token.pos]
-              else
-                true
-              end
-          end
-        end
+      def on_def(node)
+        check(node)
+
+        super
+      end
+
+      def on_defs(node)
+        check(node)
+
+        super
       end
 
       private
 
-      # Returns a hash mapping positions of method names to booleans
-      # saying whether or not the method is empty.
-      def empty_methods(sexp)
-        is_empty = {}
-        # Since def is a keyword, def: can confuse the editor. Hence
-        # Ruby 1.8 hash syntax is used here.
-        # rubocop:disable HashSyntax
-        { :def => [1, 3], :defs => [3, 5] }.each do |key, offsets|
-          each(key, sexp) do |d|
-            method_name_pos = d[offsets.first][-1]
-            is_empty[method_name_pos] =
-              (d[offsets.last] == [:bodystmt, [[:void_stmt]], nil, nil, nil])
-          end
+      def check(node)
+        start_line = node.loc.keyword.line
+        end_line = node.loc.end.line
+
+        if node.type == :def
+          empty_body = node.children[2].type == :nil
+        else
+          empty_body = node.children[3].type == :nil
+        end
+
+        if start_line == end_line && !(allow_empty? && empty_body)
+          add_offence(:convention,
+                      start_line,
+                      MSG)
         end
-        is_empty
       end
     end
   end

data/lib/rubocop/cop/space_after_comma_etc.rb

@@ -1,40 +1,60 @@
 # encoding: utf-8
 
+# rubocop:disable SymbolName
+
 module Rubocop
   module Cop
     module SpaceAfterCommaEtc
-      ERROR_MESSAGE = 'Space missing after %s.'
+      MSG = 'Space missing after %s.'
 
-      def inspect(file, source, tokens, sexp)
+      def inspect(source, tokens, ast, comments)
         tokens.each_cons(2) do |t1, t2|
-          if kind(t1) && !whitespace?(t2)
-            add_offence(:convention, t1.pos.lineno,
-                        sprintf(ERROR_MESSAGE, kind(t1)))
+          if kind(t1) && t1.pos.line == t2.pos.line &&
+              t2.pos.column == t1.pos.column + offset(t1)
+            add_offence(:convention, t1.pos.line, sprintf(MSG, kind(t1)))
           end
         end
       end
+
+      # The normal offset, i.e., the distance from the punctuation
+      # token where a space should be, is 1.
+      def offset(token)
+        1
+      end
     end
 
     class SpaceAfterComma < Cop
       include SpaceAfterCommaEtc
+
       def kind(token)
-        'comma' if token.type == :on_comma
+        'comma' if token.type == :tCOMMA
       end
     end
 
     class SpaceAfterSemicolon < Cop
       include SpaceAfterCommaEtc
+
       def kind(token)
-        'semicolon' if token.type == :on_semicolon
+        'semicolon' if token.type == :tSEMI
       end
     end
 
     class SpaceAfterColon < Cop
       include SpaceAfterCommaEtc
+
+      # The colon following a label will not appear in the token
+      # array. Instad we get a tLABEL token, whose length we use to
+      # calculate where we expect a space.
+      def offset(token)
+        case token.type
+        when :tLABEL then token.text.length + 1
+        when :tCOLON then 1
+        end
+      end
+
       def kind(token)
         case token.type
-        when :on_label then 'colon'
-        when :on_op    then 'colon' if token.text == ':'
+        when :tLABEL, :tCOLON then 'colon'
         end
       end
     end

data/lib/rubocop/cop/space_after_control_keyword.rb

@@ -3,24 +3,25 @@
 module Rubocop
   module Cop
     class SpaceAfterControlKeyword < Cop
-      ERROR_MESSAGE = 'Use space after control keywords.'
+      MSG = 'Use space after control keywords.'
+      # elsif and unless are handled by on_if.
+      KEYWORDS = %w(if case when while until)
 
-      KEYWORDS = %w(if elsif case when while until unless)
+      def on_keyword(node)
+        return if node.loc.is_a?(Parser::Source::Map::Ternary)
 
-      def inspect(file, source, tokens, sexp)
-        # we need to keep track of the previous token to
-        # avoid confusing symbols like :if with real keywords
-        prev = Token.new(0, :init, '')
-
-        tokens.each_cons(2) do |t1, t2|
-          if prev.type != :on_symbeg && t1.type == :on_kw &&
-              KEYWORDS.include?(t1.text) && t2.type != :on_sp
-            add_offence(:convention,
-                        t1.pos.lineno,
-                        ERROR_MESSAGE)
-          end
+        exp = node.loc.expression
+        kw = node.loc.keyword
+        kw_offset = kw.begin_pos - exp.begin_pos
+        if exp.source[kw_offset..-1].start_with?(kw.source + '(')
+          add_offence(:convention, kw.line, MSG)
+        end
+      end
 
-          prev = t1
+      KEYWORDS.each do |keyword|
+        define_method(:"on_#{keyword}") do |node|
+          on_keyword(node)
+          super(node)
         end
       end
     end

data/lib/rubocop/cop/string_literals.rb

@@ -3,44 +3,18 @@
 module Rubocop
   module Cop
     class StringLiterals < Cop
-      ERROR_MESSAGE = "Prefer single-quoted strings when you don't need " +
+      MSG = "Prefer single-quoted strings when you don't need " +
         'string interpolation or special symbols.'
 
-      def inspect(file, source, tokens, sexp)
-        state = :outside
-        tokens.each do |t|
-          state = case [state, t.type]
-                  when [:outside, :on_tstring_beg]
-                    :double_quote if t.text == '"'
+      def inspect(source, tokens, ast, comments)
+        on_node(:str, ast, :dstr) do |s|
+          text = s.to_a[0]
 
-                  when [:double_quote, :on_tstring_content]
-                    :valid_double_quote if t.text =~ /'|\\[ntrx]/
-
-                  when [:double_quote, :on_embexpr_beg]
-                    :embedded_expression
-
-                  when [:double_quote, :on_embvar]
-                    :embedded_variable
-
-                  when [:double_quote, :on_tstring_end]
-                    add_offence(:convention, t.pos.lineno, ERROR_MESSAGE)
-                    :outside
-
-                  when [:embedded_expression, :on_rbrace]
-                    :valid_double_quote
-
-                  when [:embedded_variable, :on_ivar]
-                    :valid_double_quote
-
-                  when [:embedded_variable, :on_cvar]
-                    :valid_double_quote
-
-                  when [:embedded_variable, :on_gvar]
-                    :valid_double_quote
-
-                  when [:valid_double_quote, :on_tstring_end]
-                    :outside
-            end || state
+          if text !~ /['\n\t\r]/ && s.loc.expression.source[0] == '"'
+            add_offence(:convention,
+                        s.loc.line,
+                        MSG)
+          end
         end
       end
     end

data/lib/rubocop/cop/surrounding_space.rb

@@ -1,179 +1,280 @@
 # encoding: utf-8
 
+# rubocop:disable SymbolName
+
 module Rubocop
   module Cop
     module SurroundingSpace
-      def inspect(file, source, tokens, sexp)
-        @correlations.sort.each do |ix, grammar_path|
-          check_missing_space(tokens, ix, grammar_path)
+      def space_between?(t1, t2)
+        char_preceding_2nd_token =
+          @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]
         end
-        tokens.each_index { |ix| check_unwanted_space(tokens, ix) }
-      end
-
-      private
-
-      def previous_non_space(tokens, ix)
-        tokens[0...ix].reverse.find { |t| !whitespace?(t) }
+        t2.pos.line > t1.pos.line || char_preceding_2nd_token == ' '
       end
 
-      def ok_without_spaces?(grammar_path)
-        parent, child = grammar_path.values_at(-2, -1)
-        return true if [:unary, :symbol, :defs, :def, :call].include?(parent)
-        return true if [:**, :block_var].include?(child)
-        parent == :command_call && child == :'::'
+      def index_of_first_token(node, tokens)
+        @token_table ||= build_token_table(tokens)
+        b = node.loc.expression.begin
+        @token_table[[b.line, b.column]]
       end
 
-      def surrounded_by_whitespace?(nearby_tokens)
-        left, _, right = nearby_tokens
-        whitespace?(left) && whitespace?(right)
+      def index_of_last_token(node, tokens)
+        @token_table ||= build_token_table(tokens)
+        e = node.loc.expression.end
+        (0...e.column).to_a.reverse.find do |c|
+          ix = @token_table[[e.line, c]]
+          return ix if ix
+        end
       end
 
-      # Default implementation for classes that don't need it.
-      def check_missing_space(tokens, ix, grammar_path)
+      def build_token_table(tokens)
+        table = {}
+        tokens.each_with_index do |t, ix|
+          table[[t.pos.line, t.pos.column]] = ix
+        end
+        table
       end
     end
 
     class SpaceAroundOperators < Cop
       include SurroundingSpace
-      ERROR_MESSAGE = 'Surrounding space missing for operator '
-
-      def check_missing_space(tokens, ix, grammar_path)
-        t = tokens[ix]
-        if t.type == :on_op
-          unless surrounded_by_whitespace?(tokens[ix - 1, 3])
-            unless ok_without_spaces?(grammar_path)
-              add_offence(:convention, t.pos.lineno,
-                          ERROR_MESSAGE + "'#{t.text}'.")
+      MSG_MISSING = "Surrounding space missing for operator '%s'."
+      MSG_DETECTED = 'Space around operator ** detected.'
+
+      BINARY_OPERATORS =
+        [:tEQL,    :tAMPER2,  :tPIPE,  :tCARET, :tPLUS,  :tMINUS, :tSTAR2,
+         :tDIVIDE, :tPERCENT, :tEH,    :tCOLON, :tANDOP, :tOROP,  :tMATCH,
+         :tNMATCH, :tEQ,      :tNEQ,   :tGT,    :tRSHFT, :tGEQ,   :tLT,
+         :tLSHFT,  :tLEQ,     :tASSOC, :tEQQ,   :tCMP,   :tOP_ASGN]
+
+      def inspect(source, tokens, sexp, comments)
+        @source = source
+        positions_not_to_check = get_positions_not_to_check(tokens, sexp)
+
+        tokens.each_cons(3) do |token_before, token, token_after|
+          next if token_before.type == :kDEF # TODO: remove?
+          next if positions_not_to_check.include?(token.pos)
+
+          case token.type
+          when :tPOW
+            if has_space?(token_before, token, token_after)
+              add_offence(:convention, token.pos.line, MSG_DETECTED)
             end
+          when *BINARY_OPERATORS
+            check_missing_space(token_before, token, token_after)
           end
         end
       end
 
-      def check_unwanted_space(tokens, ix)
-        prev, t, nxt = tokens.values_at(ix - 1, ix, ix + 1)
-        if t.type == :on_op && t.text == '**' &&
-            (whitespace?(prev) || whitespace?(nxt))
-          add_offence(:convention, t.pos.lineno,
-                      "Space around operator #{t.text} detected.")
+      # 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
+      end
+
+      def do_not_check_block_arg_pipes(sexp, positions_not_to_check)
+        # each { |a| }
+        #        ^ ^
+        on_node(:block, sexp) do |b|
+          on_node(:args, b) do |a|
+            positions_not_to_check << a.loc.begin << a.loc.end if a.loc.begin
+          end
+        end
+      end
+
+      def do_not_check_param_default(tokens, sexp, positions_not_to_check)
+        # func(a, b=nil)
+        #          ^
+        on_node(:optarg, sexp) do |optarg|
+          _arg, equals, _value = tokens[index_of_first_token(optarg, tokens),
+                                        3]
+          positions_not_to_check << equals.pos
+        end
+      end
+
+      def do_not_check_class_lshift_self(tokens, sexp, positions_not_to_check)
+        # class <<self
+        #       ^
+        on_node(:sclass, sexp) do |sclass|
+          ix = index_of_first_token(sclass, tokens)
+          if tokens[ix, 2].map(&:type) == [:kCLASS, :tLSHFT]
+            positions_not_to_check << tokens[ix + 1].pos
+          end
+        end
+      end
+
+      def do_not_check_def_things(tokens, sexp, positions_not_to_check)
+        # def +(other)
+        #     ^
+        on_node(:def, sexp) 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
+          end
+          positions_not_to_check <<
+            tokens[index_of_first_token(def_node, tokens) + 1].pos
+        end
+      end
+
+      def do_not_check_singleton_operator_defs(tokens, sexp,
+                                               positions_not_to_check)
+        # def self.===(other)
+        #          ^
+        on_node(:defs, sexp) do |defs_node|
+          _receiver, name, _args = *defs_node
+          ix = index_of_first_token(defs_node, tokens)
+          name_token = tokens[ix..-1].find { |t| t.text == name.to_s }
+          positions_not_to_check << name_token.pos
+        end
+      end
+
+      def check_missing_space(token_before, token, token_after)
+        unless has_space?(token_before, token, token_after)
+          text = token.text.to_s + (token.type == :tOP_ASGN ? '=' : '')
+          add_offence(:convention, token.pos.line, MSG_MISSING % text)
         end
       end
+
+      def has_space?(token_before, token, token_after)
+        space_between?(token_before, token) && space_between?(token,
+                                                              token_after)
+      end
     end
 
     class SpaceAroundBraces < Cop
       include SurroundingSpace
+      MSG_LEFT = "Surrounding space missing for '{'."
+      MSG_RIGHT = "Space missing to the left of '}'."
+
+      def inspect(source, tokens, sexp, comments)
+        @source = source
+        positions_not_to_check = get_positions_not_to_check(tokens, sexp)
+        tokens.each_cons(2) do |t1, t2|
+          next if ([t1.pos, t2.pos] - positions_not_to_check).size < 2
 
-      def check_unwanted_space(tokens, ix)
+          type1, type2 = t1.type, t2.type
+          # :tLBRACE in hash literals, :tLCURLY otherwise.
+          next if [:tLCURLY, :tLBRACE].include?(type1) && type2 == :tRCURLY
+          check(t1, t2, MSG_LEFT) if type1 == :tLCURLY || type2 == :tLCURLY
+          check(t1, t2, MSG_RIGHT) if type2 == :tRCURLY
+        end
       end
 
-      def check_missing_space(tokens, ix, grammar_path)
-        # Checked by SpaceInsideHashLiteralBraces and not here.
-        return if grammar_path.last == :hash
+      def get_positions_not_to_check(tokens, sexp)
+        positions_not_to_check = []
 
-        t = tokens[ix]
-        case t.type
-        when :on_lbrace
-          unless surrounded_by_whitespace?(tokens[ix - 1, 3])
-            add_offence(:convention, t.pos.lineno,
-                        "Surrounding space missing for '{'.")
-          end
-        when :on_rbrace
-          unless whitespace?(tokens[ix - 1])
-            add_offence(:convention, t.pos.lineno,
-                        "Space missing to the left of '}'.")
+        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
+
+        # 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
           end
         end
+
+        positions_not_to_check
+      end
+
+      def check(t1, t2, msg)
+        unless space_between?(t1, t2)
+          add_offence(:convention, t1.pos.line, msg)
+        end
       end
     end
 
     module SpaceInside
       include SurroundingSpace
+      MSG = 'Space inside %s detected.'
 
-      Paren = Struct.new :left, :right, :kind
-
-      def check_unwanted_space(tokens, ix)
-        paren = get_paren
-        prev, t, nxt = tokens.values_at(ix - 1, ix, ix + 1)
-        offence_detected = case t.type
-                           when paren.left
-                             nxt.type == :on_sp
-                           when paren.right
-                             if prev.type == :on_sp
-                               prev_ns = previous_non_space(tokens, ix)
-                               prev_ns &&
-                                 prev_ns.pos.lineno == tokens[ix].pos.lineno &&
-                                 # Avoid double reporting
-                                 prev_ns.type != paren.left
-                             end
-                           end
-        if offence_detected
-          add_offence(:convention, t.pos.lineno,
-                      "Space inside #{paren.kind} detected.")
+      def inspect(source, tokens, sexp, comments)
+        @source = source
+        left, right, kind = specifics
+        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)
+              add_offence(:convention, t1.pos.line, MSG % kind)
+            end
+          end
         end
       end
     end
 
     class SpaceInsideParens < Cop
       include SpaceInside
-      def get_paren
-        Paren.new(:on_lparen, :on_rparen, 'parentheses')
+
+      def specifics
+        [:tLPAREN2, :tRPAREN, 'parentheses']
       end
     end
 
     class SpaceInsideBrackets < Cop
       include SpaceInside
-      def get_paren
-        Paren.new(:on_lbracket, :on_rbracket, 'square brackets')
+
+      def specifics
+        [:tLBRACK, :tRBRACK, 'square brackets']
       end
     end
 
     class SpaceInsideHashLiteralBraces < Cop
       include SurroundingSpace
+      MSG = 'Space inside hash literal braces %s.'
 
-      def check_missing_space(tokens, ix, grammar_path)
-        if self.class.config['EnforcedStyleIsWithSpaces']
-          check_space(tokens, ix, grammar_path, 'missing') do |t|
-            !(whitespace?(t) || [:on_lbrace, :on_rbrace].include?(t.type))
-          end
-        end
-      end
-
-      def check_unwanted_space(tokens, ix)
-        unless self.class.config['EnforcedStyleIsWithSpaces']
-          grammar_path = @correlations[ix] or return
-          check_space(tokens, ix, grammar_path, 'detected') do |t|
-            whitespace?(t)
-          end
+      def inspect(source, tokens, sexp, comments)
+        @source = source
+        on_node(:hash, sexp) do |hash|
+          b_ix = index_of_first_token(hash, tokens)
+          e_ix = index_of_last_token(hash, tokens)
+          check(tokens[b_ix], tokens[b_ix + 1])
+          check(tokens[e_ix - 1], tokens[e_ix])
         end
       end
 
-      private
-
-      def check_space(tokens, ix, grammar_path, word)
-        if grammar_path[-1] == :hash
-          is_offence = case tokens[ix].type
-                       when :on_lbrace then yield tokens[ix + 1]
-                       when :on_rbrace then yield tokens[ix - 1]
-                       else false
-                       end
-          if is_offence
-            add_offence(:convention, tokens[ix].pos.lineno,
-                        "Space inside hash literal braces #{word}.")
-          end
-        end
+      def check(t1, t2)
+        types = [t1, t2].map(&:type)
+        braces = [:tLBRACE, :tRCURLY]
+        return if types == braces || (braces - types).size == 2
+        has_space = space_between?(t1, t2)
+        is_offence, word = if self.class.config['EnforcedStyleIsWithSpaces']
+                             [!has_space, 'missing']
+                           else
+                             [has_space, 'detected']
+                           end
+        add_offence(:convention, t1.pos.line, MSG % word) if is_offence
       end
     end
 
     class SpaceAroundEqualsInParameterDefault < Cop
-      def inspect(file, source, tokens, sexp)
-        each(:params, sexp) do |s|
-          (s[2] || []).each do |param, _|
-            param_pos = param.last
-            ix = tokens.index { |t| t.pos == param_pos }
-            unless whitespace?(tokens[ix + 1]) && whitespace?(tokens[ix + 3])
-              add_offence(:convention, param[-1].lineno,
-                          'Surrounding space missing in default value ' +
-                          'assignment.')
-            end
+      include SurroundingSpace
+      MSG = 'Surrounding space missing in default value assignment.'
+
+      def inspect(source, tokens, sexp, comments)
+        @source = source
+        on_node(:optarg, sexp) do |optarg|
+          arg, equals, value = tokens[index_of_first_token(optarg, tokens), 3]
+          unless space_between?(arg, equals) && space_between?(equals, value)
+            add_offence(:convention, equals.pos.line, MSG)
           end
         end
       end