rubocop 0.31.0 → 0.35.0

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

@@ -17,23 +17,31 @@ module RuboCop
         PROC_NODE = s(:send, s(:const, nil, :Proc), :new)
 
         def on_block(node)
-          block_send, block_args, block_body = *node
+          block_send_or_super, block_args, block_body = *node
 
-          _breceiver, bmethod_name, bargs = *block_send
+          if super?(block_send_or_super)
+            bmethod_name = :super
+          else
+            _breceiver, bmethod_name, _bargs = *block_send_or_super
+          end
 
           # TODO: Rails-specific handling that we should probably make
           # configurable - https://github.com/bbatsov/rubocop/issues/1485
           # we should ignore lambdas & procs
-          return if block_send == PROC_NODE
+          return if block_send_or_super == PROC_NODE
           return if [:lambda, :proc].include?(bmethod_name)
           return if ignored_method?(bmethod_name)
-          # File.open(file) { |f| f.readlines }
-          return if bargs
           return unless can_shorten?(block_args, block_body)
 
           _receiver, method_name, _args = *block_body
+
+          sb = node.loc.expression.source_buffer
+          block_start = node.loc.begin.begin_pos
+          block_end = node.loc.end.end_pos
+          range = Parser::Source::Range.new(sb, block_start, block_end)
+
           add_offense(node,
-                      :expression,
+                      range,
                       format(MSG,
                              method_name,
                              bmethod_name))
@@ -41,16 +49,52 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            _block_method, _block_args, block_body = *node
+            block_send_or_super, _block_args, block_body = *node
             _receiver, method_name, _args = *block_body
 
-            block_range =
-              Parser::Source::Range.new(node.loc.expression.source_buffer,
-                                        node.loc.begin.begin_pos,
-                                        node.loc.end.end_pos)
+            if super?(block_send_or_super)
+              args = *block_send_or_super
+              autocorrect_method(corrector, node, args, method_name)
+            else
+              _breceiver, _bmethod_name, *args = *block_send_or_super
+              autocorrect_method(corrector, node, args, method_name)
+            end
+          end
+        end
 
-            corrector.replace(range_with_surrounding_space(block_range, :left),
-                              "(&:#{method_name})")
+        def autocorrect_method(corrector, node, args, method_name)
+          if args.empty?
+            autocorrect_no_args(corrector, node, method_name)
+          else
+            autocorrect_with_args(corrector, node, args, method_name)
+          end
+        end
+
+        def autocorrect_no_args(corrector, node, method_name)
+          corrector.replace(block_range_with_space(node), "(&:#{method_name})")
+        end
+
+        def autocorrect_with_args(corrector, node, args, method_name)
+          corrector.insert_after(args.last.loc.expression, ", &:#{method_name}")
+          corrector.remove(block_range_with_space(node))
+        end
+
+        def block_range_with_space(node)
+          block_range =
+            Parser::Source::Range.new(node.loc.expression.source_buffer,
+                                      begin_pos_for_replacement(node),
+                                      node.loc.end.end_pos)
+          range_with_surrounding_space(block_range, :left)
+        end
+
+        def begin_pos_for_replacement(node)
+          block_send_or_super, _block_args, _block_body = *node
+          expr = block_send_or_super.loc.expression
+
+          if (paren_pos = (expr.source =~ /\(\s*\)$/))
+            expr.begin_pos + paren_pos
+          else
+            node.loc.begin.begin_pos
           end
         end
 
@@ -65,6 +109,7 @@ module RuboCop
         def can_shorten?(block_args, block_body)
           # something { |x, y| ... }
           return false unless block_args.children.size == 1
+          return false if block_args.children.first.blockarg_type?
           return false unless block_body && block_body.type == :send
 
           receiver, _method_name, args = *block_body
@@ -78,6 +123,10 @@ module RuboCop
 
           block_arg_name == receiver_name
         end
+
+        def super?(node)
+          [:super, :zsuper].include?(node.type)
+        end
       end
     end
   end

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

@@ -24,10 +24,18 @@ module RuboCop
 
           return unless blank_lines != wanted_blank_lines
 
+          offense_detected(sb, wanted_blank_lines, blank_lines,
+                           whitespace_at_end)
+        end
+
+        private
+
+        def offense_detected(sb, wanted_blank_lines, blank_lines,
+                             whitespace_at_end)
           begin_pos = sb.source.length - whitespace_at_end.length
           autocorrect_range = Parser::Source::Range.new(sb, begin_pos,
                                                         sb.source.length)
-          begin_pos += "\n".length unless whitespace_at_end.length == 0
+          begin_pos += 1 unless whitespace_at_end.length == 0
           report_range = Parser::Source::Range.new(sb, begin_pos,
                                                    sb.source.length)
           add_offense(autocorrect_range, report_range,

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

@@ -68,18 +68,17 @@ module RuboCop
                 node.loc.end.begin_pos)
         end
 
-        # rubocop:disable Metrics/MethodLength
         def check(node, items, kind, begin_pos, end_pos)
           sb = items.first.loc.expression.source_buffer
+
           after_last_item = Parser::Source::Range.new(sb, begin_pos, end_pos)
 
           return if heredoc?(after_last_item.source)
 
           comma_offset = after_last_item.source =~ /,/
-          should_have_comma =
-            [:comma, :consistent_comma].include?(style) && multiline?(node)
+
           if comma_offset && !inside_comment?(after_last_item, comma_offset)
-            unless should_have_comma
+            unless should_have_comma?(style, node, items)
               extra_info = case style
                            when :comma
                              ', unless each item is on its own line'
@@ -91,11 +90,16 @@ module RuboCop
               avoid_comma(kind, after_last_item.begin_pos + comma_offset, sb,
                           extra_info)
             end
-          elsif should_have_comma
+          elsif should_have_comma?(style, node, items)
             put_comma(items, kind, sb)
           end
         end
-        # rubocop:enable Metrics/MethodLength
+
+        def should_have_comma?(style, node, items)
+          [:comma, :consistent_comma].include?(style) &&
+            multiline?(node) &&
+            (items.size > 1 || items.last.hash_type?)
+        end
 
         def inside_comment?(range, comma_offset)
           processed_source.comments.any? do |comment|
@@ -119,10 +123,16 @@ module RuboCop
         def multiline?(node)
           elements = if node.type == :send
                        _receiver, _method_name, *args = *node
-                       args
+                       args.flat_map { |a| a.type == :hash ? a.children : a }
                      else
                        node.children
                      end
+
+          # Without this check, Foo.new({}) is considered multiline, which
+          # it should not be. Essentially, if there are no elements, the
+          # expression can not be multiline.
+          return if elements.empty?
+
           items = elements.map { |e| e.loc.expression }
           if style == :consistent_comma
             items.each_cons(2).any? { |a, b| !on_same_line?(a, b) }

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

@@ -15,10 +15,13 @@ module RuboCop
       #   #good
       #   a, b, = foo()
       #   a, = foo()
+      #   *a, b, _ = foo()  => We need to know to not include 2 variables in a
+      #   a, *b, _ = foo()  => The correction `a, *b, = foo()` is a syntax error
       class TrailingUnderscoreVariable < Cop
         include SurroundingSpace
 
-        MSG = 'Do not use trailing `_`s in parallel assignment.'
+        MSG = 'Do not use trailing `_`s in parallel assignment.'.freeze
+        UNDERSCORE = '_'.freeze
 
         def on_masgn(node)
           left, = *node
@@ -60,12 +63,30 @@ module RuboCop
           first_offense = nil
 
           variables.reverse_each do |variable|
-            break unless variable.children.first == :_
+            var, = *variable
+            var, = *var
+            if allow_named_underscore_variables
+              break unless var == :_
+            else
+              break unless var.to_s.start_with?(UNDERSCORE)
+            end
             first_offense = variable
           end
 
+          return nil if first_offense.nil?
+
+          first_offense_index = variables.index(first_offense)
+          0.upto(first_offense_index - 1).each do |index|
+            return nil if variables[index].splat_type?
+          end
+
           first_offense
         end
+
+        def allow_named_underscore_variables
+          @allow_named_underscore_variables ||=
+            cop_config['AllowNamedUnderscoreVariables']
+        end
       end
     end
   end

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

@@ -9,11 +9,13 @@ module RuboCop
         MSG = 'Use `attr_%s` to define trivial %s methods.'
 
         def on_def(node)
+          return if in_module?(node)
           method_name, args, body = *node
           on_method_def(node, method_name, args, body)
         end
 
         def on_defs(node)
+          return if in_module?(node)
           return if ignore_class_methods?
           _scope, method_name, args, body = *node
           on_method_def(node, method_name, args, body)
@@ -21,6 +23,12 @@ module RuboCop
 
         private
 
+        def in_module?(node)
+          pnode = node.parent
+          pnode = pnode.parent if pnode && pnode.type == :begin
+          !pnode.nil? && pnode.type == :module
+        end
+
         def on_method_def(node, method_name, args, body)
           kind = if trivial_reader?(method_name, args, body)
                    'reader'
@@ -100,7 +108,7 @@ module RuboCop
         def names_match?(method_name, body)
           ivar_name, = *body
 
-          method_name.to_s.chomp('=') == ivar_name[1..-1]
+          method_name.to_s.sub(/[=?]$/, '') == ivar_name[1..-1]
         end
 
         def trivial_accessor_kind(method_name, args, body)
@@ -127,6 +135,7 @@ module RuboCop
         def autocorrect_instance(node)
           method_name, args, body = *node
           unless names_match?(method_name, body) &&
+                 !predicate?(method_name) &&
                  (kind = trivial_accessor_kind(method_name, args, body))
             return
           end

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

@@ -7,51 +7,62 @@ module RuboCop
       class UnneededPercentQ < Cop
         MSG = 'Use `%s` only for strings that contain both single quotes and ' \
               'double quotes%s.'
+        DYNAMIC_MSG = ', or for dynamic strings that contain double quotes'
+        SINGLE_QUOTE = "'".freeze
+        QUOTE = '"'.freeze
+        EMPTY = ''.freeze
+        PERCENT_Q = '%q'.freeze
+        PERCENT_CAPITAL_Q = '%Q'.freeze
+        STRING_INTERPOLATION_REGEXP = /#\{.+}/
 
         def on_dstr(node)
-          # Using %Q to avoid escaping inner " is ok.
-          check(node) unless node.loc.expression.source =~ /"/
+          check(node)
         end
 
         def on_str(node)
+          # Interpolated strings that contain more than just interpolation
+          # will call `on_dstr` for the entire string and `on_str` for the
+          # non interpolated portion of the string
+          return unless string_literal?(node)
           check(node)
         end
 
-        # We process regexp nodes because the inner str nodes can cause
-        # confusion in on_str if they start with %( or %Q(.
-        def on_regexp(node)
-          string_parts = node.children.select { |child| child.type == :str }
-          string_parts.each { |s| ignore_node(s) }
-        end
-
         private
 
         def check(node)
-          if node.loc.respond_to?(:heredoc_body)
-            ignore_node(node)
-            return
-          end
-          return if ignored_node?(node) || part_of_ignored_node?(node)
           src = node.loc.expression.source
-          return unless src.start_with?('%q') || src.start_with?('%Q')
-          return if src =~ /'/ && src =~ /"/
+          return unless start_with_percent_q_variant?(src)
+          return if src.include?(SINGLE_QUOTE) && src.include?(QUOTE)
           return if src =~ StringHelp::ESCAPED_CHAR_REGEXP
+          if src.start_with?(PERCENT_Q) && src =~ STRING_INTERPOLATION_REGEXP
+            return
+          end
 
-          extra = if src.start_with?('%Q')
-                    ', or for dynamic strings that contain double quotes'
+          extra = if src.start_with?(PERCENT_CAPITAL_Q)
+                    DYNAMIC_MSG
                   else
-                    ''
+                    EMPTY
                   end
           add_offense(node, :expression, format(MSG, src[0, 2], extra))
         end
 
         def autocorrect(node)
-          delimiter = node.loc.expression.source =~ /^%Q[^"]+$|'/ ? '"' : "'"
+          delimiter =
+            node.loc.expression.source =~ /^%Q[^"]+$|'/ ? QUOTE : SINGLE_QUOTE
           lambda do |corrector|
             corrector.replace(node.loc.begin, delimiter)
             corrector.replace(node.loc.end, delimiter)
           end
         end
+
+        def string_literal?(node)
+          node.loc.respond_to?(:begin) && node.loc.respond_to?(:end) &&
+            node.loc.begin && node.loc.end
+        end
+
+        def start_with_percent_q_variant?(string)
+          string.start_with?(PERCENT_Q) || string.start_with?(PERCENT_CAPITAL_Q)
+        end
       end
     end
   end

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

@@ -23,6 +23,11 @@ module RuboCop
           check_name(node, name, node.loc.name)
         end
 
+        def on_arg(node)
+          name, = *node
+          check_name(node, name, node.loc.name)
+        end
+
         private
 
         def message(style)

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

@@ -16,7 +16,7 @@ module RuboCop
         def handle(node)
           length = node.loc.expression.source.lines.to_a.size
           return unless length > 1
-          return unless  node.loc.begin && node.loc.begin.is?('do')
+          return unless node.loc.begin && node.loc.begin.is?('do')
 
           add_offense(node, :begin, error_message(node.type))
         end

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

@@ -13,6 +13,7 @@ module RuboCop
         include ConfigurableMax
 
         MSG = 'Use `%w` or `%W` for array of words.'
+        QUESTION_MARK_SIZE = '?'.size
 
         def on_array(node)
           array_elems = node.children
@@ -61,7 +62,8 @@ module RuboCop
 
         def autocorrect(node)
           @interpolated = false
-          contents = node.children.map { |n| source_for(n) }.join(' ')
+          contents = autocorrect_words(node.children, node.loc.line)
+
           char = @interpolated ? 'W' : 'w'
 
           lambda do |corrector|
@@ -69,10 +71,21 @@ module RuboCop
           end
         end
 
+        def autocorrect_words(word_nodes, base_line_number)
+          previous_node_line_number = base_line_number
+          word_nodes.map do |node|
+            number_of_line_breaks = node.loc.line - previous_node_line_number
+            line_breaks = "\n" * number_of_line_breaks
+            previous_node_line_number = node.loc.line
+
+            line_breaks + source_for(node)
+          end.join(' ')
+        end
+
         def source_for(str_node)
           if character_literal?(str_node)
             @interpolated = true
-            begin_pos = str_node.loc.expression.begin_pos + '?'.length
+            begin_pos = str_node.loc.expression.begin_pos + QUESTION_MARK_SIZE
             end_pos = str_node.loc.expression.end_pos
           else
             begin_pos = str_node.loc.begin.end_pos

data/lib/rubocop/cop/team.rb

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     # FIXME
     class Team
-      attr_reader :errors, :updated_source_file
+      attr_reader :errors, :warnings, :updated_source_file
 
       alias_method :updated_source_file?, :updated_source_file
 
@@ -13,6 +13,7 @@ module RuboCop
         @config = config
         @options = options || { auto_correct: false, debug: false }
         @errors = []
+        @warnings = []
       end
 
       def autocorrect?
@@ -79,7 +80,14 @@ module RuboCop
           cop.relevant_file?(buffer.name) && cop.corrections.any?
         end
         if cop_with_corrections
-          corrector = Corrector.new(buffer, cop_with_corrections.corrections)
+          corrections = cop_with_corrections.corrections
+          # Be extra careful if there are tabs in the source and just correct
+          # one offense, because inserting or removing space next to a tab has
+          # special implications, and existing ranges can't be used after such
+          # a change.
+          corrections = [corrections.first] if buffer.source =~ /\t/
+
+          corrector = Corrector.new(buffer, corrections)
           corrector.rewrite
         else
           buffer.source
@@ -89,13 +97,25 @@ module RuboCop
       def process_commissioner_errors(file, file_errors)
         file_errors.each do |cop, errors|
           errors.each do |e|
-            handle_error(e,
-                         "An error occurred while #{cop.name}".color(:red) +
-                         " cop was inspecting #{file}.".color(:red))
+            if e.is_a?(Warning)
+              handle_warning(e,
+                             Rainbow("#{e.message} (from file: " \
+                             "#{file})").yellow)
+            else
+              handle_error(e,
+                           Rainbow("An error occurred while #{cop.name}" \
+                           " cop was inspecting #{file}.").red)
+            end
           end
         end
       end
 
+      def handle_warning(e, message)
+        @warnings << message
+        warn message
+        puts e.backtrace if debug?
+      end
+
       def handle_error(e, message)
         @errors << message
         warn message

data/lib/rubocop/cop/util.rb

@@ -1,5 +1,6 @@
 # encoding: utf-8
 
+# rubocop:disable Metrics/ModuleLength
 module RuboCop
   module Cop
     # This module contains a collection of useful utility methods.
@@ -12,6 +13,10 @@ module RuboCop
       SHORTHAND_ASGN_NODES = [:op_asgn, :or_asgn, :and_asgn]
       ASGN_NODES = EQUALS_ASGN_NODES + SHORTHAND_ASGN_NODES
 
+      LITERALS = [:str, :dstr, :int, :float, :sym, :dsym, :array,
+                  :hash, :regexp, :nil, :true, :false]
+      BASIC_LITERALS = LITERALS - [:dstr, :dsym, :array, :hash]
+
       # http://phrogz.net/programmingruby/language.html#table_18.4
       # Backtick is added last just to help editors parse this code.
       OPERATOR_METHODS = %w(
@@ -186,8 +191,8 @@ module RuboCop
       end
 
       def begins_its_line?(range)
-        source_before_end = range.source_buffer.source[0...range.begin_pos]
-        source_before_end =~ /\n\s*\Z/
+        source_before_range = range.source_buffer.source[0...range.begin_pos]
+        source_before_range.rpartition("\n").last.strip.empty?
       end
 
       def within_node?(inner, outer)

data/lib/rubocop/cop/variable_force/locatable.rb

@@ -80,9 +80,9 @@ module RuboCop
           case branch_point_node.type
           when :if                     then if_body_name
           when :case                   then case_body_name
-          when *LOGICAL_OPERATOR_TYPES then logical_operator_body_name
           when RESCUE_TYPE             then rescue_body_name
           when ENSURE_TYPE             then ensure_body_name
+          when *LOGICAL_OPERATOR_TYPES then logical_operator_body_name
           else fail InvalidBranchBodyError
           end
         rescue InvalidBranchBodyError
@@ -133,7 +133,7 @@ module RuboCop
         end
 
         def body_index
-          branch_point_node.children.index(branch_body_node)
+          branch_point_node.children.index { |n| n.equal?(branch_body_node) }
         end
 
         def set_branch_point_and_body_nodes!
@@ -157,14 +157,14 @@ module RuboCop
           child_index = parent_node.children.index(child_node)
 
           case parent_node.type
-          when *BRANCH_TYPES
-            child_index != CONDITION_INDEX_OF_BRANCH_NODE
-          when *LOGICAL_OPERATOR_TYPES
-            child_index != LEFT_SIDE_INDEX_OF_LOGICAL_OPERATOR_NODE
           when RESCUE_TYPE
             true
           when ENSURE_TYPE
             child_index != ENSURE_INDEX_OF_ENSURE_NODE
+          when *BRANCH_TYPES
+            child_index != CONDITION_INDEX_OF_BRANCH_NODE
+          when *LOGICAL_OPERATOR_TYPES
+            child_index != LEFT_SIDE_INDEX_OF_LOGICAL_OPERATOR_NODE
           else
             false
           end

data/lib/rubocop/cop/variable_force.rb

@@ -106,28 +106,28 @@ module RuboCop
       # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
       def dispatch_node(node)
         case node.type
-        when *ARGUMENT_DECLARATION_TYPES
-          process_variable_declaration(node)
         when VARIABLE_ASSIGNMENT_TYPE
           process_variable_assignment(node)
         when REGEXP_NAMED_CAPTURE_TYPE
           process_regexp_named_captures(node)
-        when *OPERATOR_ASSIGNMENT_TYPES
-          process_variable_operator_assignment(node)
         when MULTIPLE_ASSIGNMENT_TYPE
           process_variable_multiple_assignment(node)
         when VARIABLE_REFERENCE_TYPE
           process_variable_referencing(node)
-        when *LOOP_TYPES
-          process_loop(node)
         when RESCUE_TYPE
           process_rescue(node)
         when ZERO_ARITY_SUPER_TYPE
           process_zero_arity_super(node)
-        when *SCOPE_TYPES
-          process_scope(node)
         when SEND_TYPE
           process_send(node)
+        when *ARGUMENT_DECLARATION_TYPES
+          process_variable_declaration(node)
+        when *OPERATOR_ASSIGNMENT_TYPES
+          process_variable_operator_assignment(node)
+        when *LOOP_TYPES
+          process_loop(node)
+        when *SCOPE_TYPES
+          process_scope(node)
         end
       end
       # rubocop:enable Metrics/MethodLength, Metrics/CyclomaticComplexity
@@ -326,13 +326,13 @@ module RuboCop
           case node.type
           when :lvar
             referenced_variable_names_in_loop << node.children.first
+          when :lvasgn
+            assignment_nodes_in_loop << node
           when *OPERATOR_ASSIGNMENT_TYPES
             asgn_node = node.children.first
             if asgn_node.type == :lvasgn
               referenced_variable_names_in_loop << asgn_node.children.first
             end
-          when :lvasgn
-            assignment_nodes_in_loop << node
           end
         end
 

data/lib/rubocop/formatter/base_formatter.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 
-# rubocop:disable Metrics/LineLength, Lint/UnusedMethodArgument
+# rubocop:disable Metrics/LineLength
 
 module RuboCop
   module Formatter