rubocop 0.14.1 → 0.15.0

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

@@ -9,14 +9,6 @@ module Rubocop
         MSG = 'Separate every 3 digits in the integer portion of a number' \
           'with underscores(_).'
 
-        def min_digits
-          cop_config['MinDigits']
-        end
-
-        def enough_digits?(number)
-          number.to_s.size >= min_digits
-        end
-
         def on_int(node)
           check(node)
         end
@@ -25,15 +17,15 @@ module Rubocop
           check(node)
         end
 
-        def check(node)
-          value, = *node
+        private
 
-          if enough_digits?(value)
-            int = integer_part(node)
+        def check(node)
+          int = integer_part(node)
 
-            # TODO: handle non-decimal literals as well
-            return if int.start_with?('0')
+          # TODO: handle non-decimal literals as well
+          return if int.start_with?('0')
 
+          if int.size >= min_digits
             if int =~ /\d{4}/ || int =~ /_\d{1,2}_/
               convention(node, :expression)
             end
@@ -41,7 +33,11 @@ module Rubocop
         end
 
         def integer_part(node)
-          node.loc.expression.source.split('.').first
+          node.loc.expression.source.sub(/^[+-]/, '').split('.').first
+        end
+
+        def min_digits
+          cop_config['MinDigits']
         end
       end
     end

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

@@ -39,10 +39,13 @@ module Rubocop
 
         def autocorrect(node)
           @corrections << lambda do |corrector|
-            expr = node.loc.expression
-            replacement = expr.source.sub(/return\s*/, '')
-            replacement = "[#{replacement}]" if node.children.size > 1
-            corrector.replace(expr, replacement)
+            if node.children.size > 1
+              kids = node.children.map { |child| child.loc.expression }
+              corrector.insert_before(kids.first, '[')
+              corrector.insert_after(kids.last, ']')
+            end
+            return_kw = range_with_surrounding_space(node.loc.keyword, :right)
+            corrector.remove(return_kw)
           end
         end
 

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

@@ -102,9 +102,10 @@ module Rubocop
         end
 
         def autocorrect(node)
+          receiver, _method_name, *_args = *node
           @corrections << lambda do |corrector|
-            corrector.replace(node.loc.expression,
-                              node.loc.expression.source.gsub(/self\./, ''))
+            corrector.remove(receiver.loc.expression)
+            corrector.remove(node.loc.dot)
           end
         end
 
@@ -133,7 +134,6 @@ module Rubocop
             @allowed_send_nodes << node if receiver && receiver.type == :self
           end
         end
-
       end
     end
   end

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

@@ -69,8 +69,10 @@ module Rubocop
 
           if style == :semantic
             each_command(method_name, node) do |send_node|
-              convention(send_node, :selector, message(method_name))
-              ignore_node(send_node)
+              unless ignored_node?(send_node)
+                convention(send_node, :selector, message(method_name))
+                ignore_node(send_node)
+              end
             end
           else
             _receiver, selector, _args = *node

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

@@ -14,7 +14,7 @@ module Rubocop
           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)
-              convention(nil, t1.pos, sprintf(MSG, kind(t1)))
+              convention(t1, t1.pos, sprintf(MSG, kind(t1)))
             end
           end
         end
@@ -24,6 +24,12 @@ module Rubocop
         def offset(token)
           1
         end
+
+        def autocorrect(token)
+          @corrections << lambda do |corrector|
+            corrector.insert_after(token.pos, ' ')
+          end
+        end
       end
 
       # Checks for comma (,) not follwed by some kind of space.

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

@@ -25,6 +25,12 @@ module Rubocop
             on_keyword(node)
           end
         end
+
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            corrector.insert_after(node.loc.keyword, ' ')
+          end
+        end
       end
     end
   end

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

@@ -25,7 +25,13 @@ module Rubocop
                                                             expr.begin_pos - 1,
                                                             expr.begin_pos)
           if pos_before_left_paren.source =~ /\s/
-            convention(nil, pos_before_left_paren)
+            convention(pos_before_left_paren, pos_before_left_paren)
+          end
+        end
+
+        def autocorrect(pos_before_left_paren)
+          @corrections << lambda do |corrector|
+            corrector.remove(pos_before_left_paren)
           end
         end
       end

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

@@ -27,8 +27,12 @@ module Rubocop
 
         def autocorrect(node)
           @corrections << lambda do |corrector|
-            corrector.replace(node.loc.expression,
-                              node.loc.expression.source.gsub(/\A!\s+/, '!'))
+            receiver, _method_name, *_args = *node
+            space_range =
+              Parser::Source::Range.new(node.loc.selector.source_buffer,
+                                        node.loc.selector.end_pos,
+                                        receiver.loc.expression.begin_pos)
+            corrector.remove(space_range)
           end
         end
       end

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

@@ -0,0 +1,149 @@
+# encoding: utf-8
+
+# rubocop:disable SymbolName
+
+module Rubocop
+  module Cop
+    module Style
+      # Checks that block braces have or don't have surrounding space depending
+      # on configuration. For blocks taking parameters, it checks that the left
+      # brace has or doesn't have trailing space depending on configuration.
+      class SpaceAroundBlockBraces < Cop
+        include SurroundingSpace
+
+        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
+            if [:tLCURLY, :tRCURLY].include?(type2)
+              check(t1, t2)
+            elsif type1 == :tLCURLY
+              if type2 == :tPIPE
+                check_pipe(t1, t2)
+              else
+                check(t1, t2)
+              end
+            end
+          end
+        end
+
+        def positions_not_to_check
+          @positions_not_to_check ||= begin
+            positions = []
+            ast = @processed_source.ast
+            tokens = @processed_source.tokens
+
+            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], 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
+
+            positions
+          end
+        end
+
+        def check(t1, t2)
+          if t2.text == '{'
+            check_space_outside_left_brace(t1, t2)
+          elsif t1.text == '{' && t2.text == '}'
+            check_empty_braces(t1, t2)
+          elsif cop_config['EnforcedStyle'] == 'space_inside_braces'
+            check_space_inside_braces(t1, t2)
+          else
+            check_no_space_inside_braces(t1, t2)
+          end
+        end
+
+        def check_empty_braces(t1, t2)
+          if cop_config['EnforcedStyleForEmptyBraces'] == 'space'
+            check_space_inside_braces(t1, t2)
+          else
+            check_no_space_inside_braces(t1, t2)
+          end
+        end
+
+        def check_space_inside_braces(t1, t2)
+          unless space_between?(t1, t2)
+            token, what = problem_details(t1, t2)
+            convention(token.pos, token.pos, "Space missing inside #{what}.")
+          end
+        end
+
+        def check_no_space_inside_braces(t1, t2)
+          if space_between?(t1, t2)
+            token, what = problem_details(t1, t2)
+            s = space_range(token)
+            convention(s, s, "Space inside #{what} detected.")
+          end
+        end
+
+        def problem_details(t1, t2)
+          if t1.text == '{'
+            token = t1
+            what = t2.text == '}' ? 'empty braces' : '{'
+          else
+            token = t2
+            what = '}'
+          end
+          [token, what]
+        end
+
+        def check_space_outside_left_brace(t1, t2)
+          if t2.text == '{' && !space_between?(t1, t2)
+            convention(t1.pos, t2.pos, 'Space missing to the left of {.')
+          end
+        end
+
+        def check_pipe(t1, t2)
+          if cop_config['SpaceBeforeBlockParameters']
+            unless space_between?(t1, t2)
+              convention(t2.pos, t1.pos, 'Space between { and | missing.')
+            end
+          elsif space_between?(t1, t2)
+            s = space_range(t1)
+            convention(s, s, 'Space between { and | detected.')
+          end
+        end
+
+        def space_range(token)
+          src = @processed_source.buffer.source
+          if token.text == '{'
+            b = token.pos.begin_pos + 1
+            e = b + 1
+            e += 1 while src[e] =~ /\s/
+          else
+            e = token.pos.begin_pos
+            b = e - 1
+            b -= 1 while src[b - 1] =~ /\s/
+          end
+          Parser::Source::Range.new(@processed_source.buffer, b, e)
+        end
+
+        def autocorrect(range)
+          @corrections << lambda do |corrector|
+            case range.source
+            when '}', '|' then corrector.insert_before(range, ' ')
+            when ' '      then corrector.remove(range)
+            else               corrector.insert_after(range, ' ')
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # Checks that the equals signs in parameter default assignments
+      # have surrounding space.
+      class SpaceAroundEqualsInParameterDefault < Cop
+        include SurroundingSpace
+        MSG = 'Surrounding space missing in default value assignment.'
+
+        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)
+              convention(equals.pos, equals.pos)
+            end
+          end
+        end
+
+        def autocorrect(range)
+          @corrections << lambda do |corrector|
+            corrector.insert_before(range, ' ')
+            corrector.insert_after(range, ' ')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,169 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # Checks that operators have space around them, except for **
+      # which should not have surrounding space.
+      class SpaceAroundOperators < Cop
+        include SurroundingSpace
+        MSG_MISSING = "Surrounding space missing for operator '%s'."
+        MSG_DETECTED = 'Space around operator ** detected.'
+
+        # rubocop:disable SymbolName
+        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 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.
+            next if positions_not_to_check.include?(token.pos)
+
+            case token.type
+            when :tPOW, :tDSTAR
+              if space_on_any_side?(token_before, token, token_after)
+                convention(token_with_surrounding_space(token), token.pos,
+                           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 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
+          # each { |a| }
+          #        ^ ^
+          positions = []
+          on_node(:block, @processed_source.ast) do |b|
+            on_node(:args, b) do |a|
+              positions << a.loc.begin << a.loc.end if a.loc.begin
+            end
+          end
+          positions
+        end
+
+        def do_not_check_param_default
+          # func(a, b=nil)
+          #          ^
+          positions = []
+          tokens = @processed_source.tokens
+          on_node(:optarg, @processed_source.ast) do |optarg|
+            _arg, equals, _value = tokens[index_of_first_token(optarg),
+                                          3]
+            positions << equals.pos
+          end
+          positions
+        end
+
+        def do_not_check_class_lshift_self
+          # class <<self
+          #       ^
+          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 << tokens[ix + 1].pos
+            end
+          end
+          positions
+        end
+
+        def do_not_check_def_things
+          # def +(other)
+          #     ^
+          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 << tokens[index_of_first_token(arg_node)].pos
+            end
+            positions << tokens[index_of_first_token(def_node) + 1].pos
+          end
+          positions
+        end
+
+        def do_not_check_singleton_operator_defs
+          # def self.===(other)
+          #          ^
+          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)
+            name_token = tokens[ix..-1].find { |t| t.text == name.to_s }
+            positions << name_token.pos
+          end
+          positions
+        end
+
+        def check_missing_space(token_before, token, token_after)
+          unless space_on_both_sides?(token_before, token, token_after)
+            text = token.text.to_s + (token.type == :tOP_ASGN ? '=' : '')
+            convention(token_with_surrounding_space(token), token.pos,
+                       MSG_MISSING.format(text))
+          end
+        end
+
+        def token_with_surrounding_space(token)
+          src = @processed_source.buffer.source
+          begin_pos = token.pos.begin_pos
+          begin_pos -= 1 while src[begin_pos - 1] =~ /[ \t]/
+          end_pos = token.pos.end_pos
+          end_pos += 1 while src[end_pos] =~ /[ \t]/
+          Parser::Source::Range.new(@processed_source.buffer, begin_pos,
+                                    end_pos)
+        end
+
+        def space_on_both_sides?(token_before, token, token_after)
+          space_between?(token_before, token) && space_between?(token,
+                                                                token_after)
+        end
+
+        def space_on_any_side?(token_before, token, token_after)
+          space_between?(token_before, token) || space_between?(token,
+                                                                token_after)
+        end
+
+        def autocorrect(range)
+          @corrections << lambda do |corrector|
+            case range.source
+            when /\*\*/
+              corrector.replace(range, '**')
+            else
+              corrector.insert_before(range, ' ') unless range.source =~ /^\s/
+              corrector.insert_after(range, ' ') unless range.source =~ /\s$/
+            end
+          end
+        end
+      end
+    end
+  end
+end