rubocop 0.4.0 → 0.8.0

data/lib/rubocop/cop/single_line_methods.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class SingleLineMethods < Cop
+      MSG = 'Avoid single-line method definitions.'
+
+      def allow_empty?
+        SingleLineMethods.config['AllowIfMethodIsEmpty']
+      end
+
+      def on_def(node)
+        check(node)
+
+        super
+      end
+
+      def on_defs(node)
+        check(node)
+
+        super
+      end
+
+      private
+
+      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
+      end
+    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)
-        tokens.each_index do |ix|
-          t = tokens[ix]
-          if kind(t) && !whitespace?(tokens[ix + 1])
-            add_offence(:convention, t.pos.lineno, ERROR_MESSAGE % kind(t))
+      def inspect(source, tokens, ast, comments)
+        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.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

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class SpaceAfterControlKeyword < Cop
+      MSG = 'Use space after control keywords.'
+      # elsif and unless are handled by on_if.
+      KEYWORDS = %w(if case when while until)
+
+      def on_keyword(node)
+        return if node.loc.is_a?(Parser::Source::Map::Ternary)
+
+        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
+
+      KEYWORDS.each do |keyword|
+        define_method(:"on_#{keyword}") do |node|
+          on_keyword(node)
+          super(node)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/string_literals.rb

@@ -3,32 +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_tstring_end]
-                    add_offence(:convention, t.pos.lineno, ERROR_MESSAGE)
-                    :outside
-
-                  when [:embedded_expression, :on_rbrace]
-                    :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,140 +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| not 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
+
+      # 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 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.")
+      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 check_unwanted_space(tokens, ix)
+      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
+
+          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)
-        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 '}'.")
+      def get_positions_not_to_check(tokens, sexp)
+        positions_not_to_check = []
+
+        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 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
+
+      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, value|
-            value_pos = all_positions(value).first or next
-            if param[-1].lineno == value_pos.lineno
-              if value_pos.column - (param[-1].column + param[1].length) <= 2
-                add_offence(:convention, param[-1].lineno,
-                            'Surrounding space missing in default value ' +
-                            'assignment.')
-              end
-            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

data/lib/rubocop/cop/symbol_array.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class SymbolArray < Cop
+      MSG = 'Use %i or %I for array of symbols.'
+
+      def inspect(source, tokens, ast, comments)
+        # %i and %I were introduced in Ruby 2.0
+        unless RUBY_VERSION < '2.0.0'
+          on_node(:array, ast) do |s|
+            next unless s.loc.begin && s.loc.begin.source == '['
+
+            array_elems = s.children
+
+            # no need to check empty arrays
+            next unless array_elems && array_elems.size > 1
+
+            symbol_array = array_elems.all? { |e| e.type == :sym }
+
+            if symbol_array
+              add_offence(:convention,
+                          s.loc.line,
+                          MSG)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/symbol_name.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class SymbolName < Cop
+      MSG = 'Use snake_case for symbols.'
+      SNAKE_CASE = /^[\da-z_]+[!?=]?$/
+      CAMEL_CASE = /^[A-Z][A-Za-z\d]*$/
+
+      def allow_camel_case?
+        self.class.config['AllowCamelCase']
+      end
+
+      def on_sym(node)
+        sym_name = node.to_a[0]
+        return unless sym_name =~ /^[a-zA-Z]/
+        return if sym_name =~ SNAKE_CASE
+        return if allow_camel_case? && sym_name =~ CAMEL_CASE
+        add_offence(:convention, node.loc.line, MSG)
+      end
+    end
+  end
+end

data/lib/rubocop/cop/syntax.rb

@@ -5,13 +5,43 @@ require 'open3'
 module Rubocop
   module Cop
     class Syntax < Cop
-      def inspect(file, source, tokens, sexp)
-        _, stderr, _ =
-          Open3.capture3('ruby -wc', stdin_data: source.join("\n"))
+      def inspect_file(file)
+        # Starting JRuby processes would be extremely slow
+        # We need to check if rbx returns nice warning messages
+        return unless RUBY_ENGINE == 'ruby'
+
+        stderr = nil
+
+        # it's extremely important to run the syntax check in a
+        # clean environment - otherwise it will be extremely slow
+        if defined? Bundler
+          Bundler.with_clean_env do
+            _, stderr, _ = Open3.capture3("ruby -wc #{file}")
+          end
+        else
+          _, stderr, _ = Open3.capture3("ruby -wc #{file}")
+        end
 
         stderr.each_line do |line|
-          line_no, warning = line.match(/.+:(\d+): warning: (.+)/).captures
-          add_offence(:warning, line_no.to_i, warning.capitalize) if line_no
+          # discard lines that are not containing relevant info
+          if line =~ /.+:(\d+): (.+)/
+            # Assignment to unused variables beginning with underscore
+            # is reported by Ruby 1.9, but not 2.0. Make 1.9 behave
+            # like 2.0.
+            unless line =~ /assigned but unused variable - _\w+/
+              line_no, severity, message = process_line(line)
+              add_offence(severity, line_no, message)
+            end
+          end
+        end
+      end
+
+      def process_line(line)
+        line_no, message = line.match(/.+:(\d+): (.+)/).captures
+        if message.start_with?('warning: ')
+          [line_no.to_i, :warning, message.sub(/warning: /, '').capitalize]
+        else
+          [line_no.to_i, :error, message.capitalize]
         end
       end
     end

data/lib/rubocop/cop/tab.rb

@@ -3,11 +3,11 @@
 module Rubocop
   module Cop
     class Tab < Cop
-      ERROR_MESSAGE = 'Tab detected.'
+      MSG = 'Tab detected.'
 
-      def inspect(file, source, tokens, sexp)
+      def inspect(source, tokens, ast, comments)
         source.each_with_index do |line, index|
-          add_offence(:convention, index + 1, ERROR_MESSAGE) if line =~ /^ *\t/
+          add_offence(:convention, index + 1, MSG) if line =~ /^ *\t/
         end
       end
     end