rubocop 0.67.2 → 0.68.0

data/lib/rubocop/cop/lint/non_local_exit_from_iterator.rb

@@ -49,16 +49,14 @@ module RuboCop
           return_node.each_ancestor(:block, :def, :defs) do |node|
             break if scoped_node?(node)
 
-            send_node, args_node, _body_node = *node
-
             # if a proc is passed to `Module#define_method` or
             # `Object#define_singleton_method`, `return` will not cause a
             # non-local exit error
-            break if define_method?(send_node)
+            break if define_method?(node.send_node)
 
-            next if args_node.children.empty?
+            next unless node.arguments?
 
-            if chained_send?(send_node)
+            if chained_send?(node.send_node)
               add_offense(return_node, location: :keyword)
               break
             end

data/lib/rubocop/cop/lint/underscore_prefixed_variable_name.rb

@@ -6,7 +6,11 @@ module RuboCop
       # This cop checks for underscore-prefixed variables that are actually
       # used.
       #
-      # @example
+      # Since block keyword arguments cannot be arbitrarily named at call
+      # sites, the `AllowKeywordBlockArguments` will allow use of underscore-
+      # prefixed block keyword arguments.
+      #
+      # @example AllowKeywordBlockArguments: false (default)
       #
       #   # bad
       #
@@ -14,7 +18,9 @@ module RuboCop
       #     do_something(_num)
       #   end
       #
-      # @example
+      #   query(:sales) do |_id:, revenue:, cost:|
+      #     {_id: _id, profit: revenue - cost}
+      #   end
       #
       #   # good
       #
@@ -22,13 +28,18 @@ module RuboCop
       #     do_something(num)
       #   end
       #
-      # @example
+      #   [1, 2, 3].each do |_num|
+      #     do_something # not using `_num`
+      #   end
+      #
+      # @example AllowKeywordBlockArguments: true
       #
       #   # good
       #
-      #   [1, 2, 3].each do |_num|
-      #     do_something # not using `_num`
+      #   query(:sales) do |_id:, revenue:, cost:|
+      #     {_id: _id, profit: revenue - cost}
       #   end
+      #
       class UnderscorePrefixedVariableName < Cop
         MSG = 'Do not use prefix `_` for a variable that is used.'.freeze
 
@@ -45,6 +56,7 @@ module RuboCop
         def check_variable(variable)
           return unless variable.should_be_unused?
           return if variable.references.none?(&:explicit?)
+          return if allowed_keyword_block_argument?(variable)
 
           node = variable.declaration_node
 
@@ -56,6 +68,14 @@ module RuboCop
 
           add_offense(nil, location: location)
         end
+
+        private
+
+        def allowed_keyword_block_argument?(variable)
+          variable.block_argument? &&
+            variable.keyword_argument? &&
+            cop_config['AllowKeywordBlockArguments']
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/useless_assignment.rb

@@ -111,10 +111,7 @@ module RuboCop
 
         def collect_variable_like_names(scope)
           names = scope.each_node.with_object(Set.new) do |node, set|
-            if variable_like_method_invocation?(node)
-              _receiver, method_name, = *node
-              set << method_name
-            end
+            set << node.method_name if variable_like_method_invocation?(node)
           end
 
           variable_names = scope.variables.each_value.map(&:name)
@@ -124,8 +121,7 @@ module RuboCop
         def variable_like_method_invocation?(node)
           return false unless node.send_type?
 
-          receiver, _method_name, *args = *node
-          receiver.nil? && args.empty?
+          node.receiver.nil? && !node.arguments?
         end
       end
     end

data/lib/rubocop/cop/lint/useless_setter_call.rb

@@ -155,8 +155,7 @@ module RuboCop
             return true if node.literal?
             return false unless node.send_type?
 
-            _receiver, method = *node
-            method == :new
+            node.method_name == :new
           end
         end
       end

data/lib/rubocop/cop/message_annotator.rb

@@ -106,6 +106,7 @@ module RuboCop
         return true if debug?
         return false if options[:display_cop_names] == false
         return true if options[:display_cop_names]
+        return false if options[:format] == 'json'
 
         config.for_all_cops['DisplayCopNames']
       end

data/lib/rubocop/cop/metrics/line_length.rb

@@ -2,6 +2,7 @@
 
 require 'uri'
 
+# rubocop:disable Metrics/ClassLength
 module RuboCop
   module Cop
     module Metrics
@@ -9,22 +10,95 @@ module RuboCop
       # The maximum length is configurable.
       # The tab size is configured in the `IndentationWidth`
       # of the `Layout/Tab` cop.
+      #
+      # This cop has some autocorrection capabilities.
+      # It can programmatically shorten certain long lines by
+      # inserting line breaks into expressions that can be safely
+      # split across lines. These include arrays, hashes, and
+      # method calls with argument lists.
+      #
+      # If autocorrection is enabled, the following Layout cops
+      # are recommended to further format the broken lines.
+      #
+      #   - AlignArray
+      #   - AlignHash
+      #   - AlignParameters
+      #   - ClosingParenthesisIndentation
+      #   - IndentFirstArgument
+      #   - IndentFirstArrayElement
+      #   - IndentFirstHashElement
+      #   - IndentFirstParameter
+      #   - MultilineArrayLineBreaks
+      #   - MultilineHashBraceLayout
+      #   - MultilineHashKeyLineBreaks
+      #   - MultilineMethodArgumentLineBreaks
+      #
+      # Together, these cops will pretty print hashes, arrays,
+      # method calls, etc. For example, let's say the max columns
+      # is 25:
+      #
+      # @example
+      #
+      #   # bad
+      #   {foo: "0000000000", bar: "0000000000", baz: "0000000000"}
+      #
+      #   # good
+      #   {foo: "0000000000",
+      #   bar: "0000000000", baz: "0000000000"}
+      #
+      #   # good (with recommended cops enabled)
+      #   {
+      #     foo: "0000000000",
+      #     bar: "0000000000",
+      #     baz: "0000000000",
+      #   }
       class LineLength < Cop
+        include CheckLineBreakable
         include ConfigurableMax
         include IgnoredPattern
         include RangeHelp
 
         MSG = 'Line is too long. [%<length>d/%<max>d]'.freeze
 
-        def investigate(processed_source)
-          heredocs = extract_heredocs(processed_source.ast) if allow_heredoc?
-          processed_source.lines.each_with_index do |line, index|
-            check_line(line, index, heredocs)
+        def on_potential_breakable_node(node)
+          check_for_breakable_node(node)
+        end
+        alias on_array on_potential_breakable_node
+        alias on_hash on_potential_breakable_node
+        alias on_send on_potential_breakable_node
+
+        def investigate_post_walk(processed_source)
+          processed_source.lines.each_with_index do |line, line_index|
+            check_line(line, line_index)
+          end
+        end
+
+        def autocorrect(range)
+          return if range.nil?
+
+          lambda do |corrector|
+            corrector.insert_before(range, "\n")
           end
         end
 
         private
 
+        def check_for_breakable_node(node)
+          breakable_node = extract_breakable_node(node, max)
+          return if breakable_node.nil?
+
+          line_index = breakable_node.first_line - 1
+          breakable_nodes_by_line_index[line_index] = breakable_node
+        end
+
+        def breakable_nodes_by_line_index
+          @breakable_nodes_by_line_index ||= {}
+        end
+
+        def heredocs
+          @heredocs ||= extract_heredocs(processed_source.ast)
+        end
+
         def tab_indentation_width
           config.for_cop('Layout/Tab')['IndentationWidth']
         end
@@ -39,49 +113,72 @@ module RuboCop
           line.length + indentation_difference(line)
         end
 
-        def highligh_start(line)
+        def highlight_start(line)
           max - indentation_difference(line)
         end
 
-        def check_line(line, index, heredocs)
+        def check_line(line, line_index)
           return if line_length(line) <= max
-          return if ignored_line?(line, index, heredocs)
+          return if ignored_line?(line, line_index)
 
-          if ignore_cop_directives? && directive_on_source_line?(index)
-            return check_directive_line(line, index)
+          if ignore_cop_directives? && directive_on_source_line?(line_index)
+            return check_directive_line(line, line_index)
           end
-          return check_uri_line(line, index) if allow_uri?
+          return check_uri_line(line, line_index) if allow_uri?
 
           register_offense(
             source_range(
-              processed_source.buffer, index,
-              highligh_start(line)...line_length(line)
+              processed_source.buffer, line_index,
+              highlight_start(line)...line_length(line)
             ),
-            line
+            line,
+            line_index
           )
         end
 
-        def ignored_line?(line, index, heredocs)
+        def ignored_line?(line, line_index)
           matches_ignored_pattern?(line) ||
-            heredocs && line_in_permitted_heredoc?(heredocs, index.succ)
+            heredocs && line_in_permitted_heredoc?(line_index.succ)
         end
 
-        def register_offense(loc, line)
+        def register_offense(loc, line, line_index)
           message = format(MSG, length: line_length(line), max: max)
 
-          add_offense(nil, location: loc, message: message) do
+          breakable_range = breakable_range(line, line_index)
+          add_offense(breakable_range, location: loc, message: message) do
             self.max = line_length(line)
           end
         end
 
-        def excess_range(uri_range, line, index)
+        def breakable_range(line, line_index)
+          return if line_in_heredoc?(line_index + 1)
+
+          semicolon_range = breakable_semicolon_range(line, line_index)
+          return semicolon_range if semicolon_range
+
+          breakable_node = breakable_nodes_by_line_index[line_index]
+          return breakable_node.source_range if breakable_node
+        end
+
+        def breakable_semicolon_range(line, line_index)
+          semicolon_separated_parts = line.split(';')
+          return if semicolon_separated_parts.length <= 1
+
+          column = semicolon_separated_parts.first.length + 1
+          range = source_range(processed_source.buffer, line_index, column, 1)
+          return if processed_source.commented?(range)
+
+          range
+        end
+
+        def excess_range(uri_range, line, line_index)
           excessive_position = if uri_range && uri_range.begin < max
                                  uri_range.end
                                else
-                                 highligh_start(line)
+                                 highlight_start(line)
                                end
 
-          source_range(processed_source.buffer, index + 1,
+          source_range(processed_source.buffer, line_index + 1,
                        excessive_position...(line_length(line)))
         end
 
@@ -107,13 +204,21 @@ module RuboCop
           end
         end
 
-        def line_in_permitted_heredoc?(heredocs, line_number)
+        def line_in_permitted_heredoc?(line_number)
+          return false unless allowed_heredoc
+
           heredocs.any? do |range, delimiter|
             range.cover?(line_number) &&
               (allowed_heredoc == true || allowed_heredoc.include?(delimiter))
           end
         end
 
+        def line_in_heredoc?(line_number)
+          heredocs.any? do |range, _delimiter|
+            range.cover?(line_number)
+          end
+        end
+
         def allow_uri?
           cop_config['AllowURI']
         end
@@ -161,22 +266,23 @@ module RuboCop
             URI::DEFAULT_PARSER.make_regexp(cop_config['URISchemes'])
         end
 
-        def check_directive_line(line, index)
+        def check_directive_line(line, line_index)
           return if line_length_without_directive(line) <= max
 
           range = max..(line_length_without_directive(line) - 1)
           register_offense(
             source_range(
               processed_source.buffer,
-              index + 1,
+              line_index + 1,
               range
             ),
-            line
+            line,
+            line_index
           )
         end
 
-        def directive_on_source_line?(index)
-          source_line_number = index + processed_source.buffer.first_line
+        def directive_on_source_line?(line_index)
+          source_line_number = line_index + processed_source.buffer.first_line
           comment =
             processed_source
             .comments
@@ -192,13 +298,18 @@ module RuboCop
           before_comment.rstrip.length
         end
 
-        def check_uri_line(line, index)
+        def check_uri_line(line, line_index)
           uri_range = find_excessive_uri_range(line)
           return if uri_range && allowed_uri_position?(line, uri_range)
 
-          register_offense(excess_range(uri_range, line, index), line)
+          register_offense(
+            excess_range(uri_range, line, line_index),
+            line,
+            line_index
+          )
         end
       end
     end
   end
 end
+# rubocop:enable Metrics/ClassLength

data/lib/rubocop/cop/metrics/perceived_complexity.rb

@@ -39,16 +39,15 @@ module RuboCop
         def complexity_score_for(node)
           case node.type
           when :case
-            expression, *whens, _else = *node
             # If cond is nil, that means each when has an expression that
             # evaluates to true or false. It's just an alternative to
             # if/elsif/elsif... so the when nodes count.
-            if expression.nil?
-              whens.length
+            if node.condition.nil?
+              node.when_branches.length
             else
               # Otherwise, the case node gets 0.8 complexity points and each
               # when gets 0.2.
-              (0.8 + 0.2 * whens.length).round
+              (0.8 + 0.2 * node.when_branches.length).round
             end
           when :if
             node.else? && !node.elsif? ? 2 : 1

data/lib/rubocop/cop/mixin/check_line_breakable.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This mixin detects collections that are safe to "break"
+    # by inserting new lines. This is useful for breaking
+    # up long lines.
+    #
+    # Let's look at hashes as an example:
+    #
+    # We know hash keys are safe to break across lines. We can add
+    # linebreaks into hashes on lines longer than the specified maximum.
+    # Then in further passes cops can clean up the multi-line hash.
+    # For example, say the maximum line length is as indicated below:
+    #
+    #                                         |
+    #                                         v
+    # {foo: "0000000000", bar: "0000000000", baz: "0000000000"}
+    #
+    # In a LineLength autocorrection pass, a line is added before
+    # the first key that exceeds the column limit:
+    #
+    # {foo: "0000000000", bar: "0000000000",
+    # baz: "0000000000"}
+    #
+    # In a MultilineHashKeyLineBreaks pass, lines are inserted
+    # before all keys:
+    #
+    # {foo: "0000000000",
+    # bar: "0000000000",
+    # baz: "0000000000"}
+    #
+    # Then in future passes FirstHashElementLineBreak,
+    # MultilineHashBraceLayout, and TrailingCommaInHashLiteral will
+    # manipulate as well until we get:
+    #
+    # {
+    #   foo: "0000000000",
+    #   bar: "0000000000",
+    #   baz: "0000000000",
+    # }
+    #
+    # (Note: Passes may not happen exactly in this sequence.)
+    module CheckLineBreakable
+      def extract_breakable_node(node, max)
+        if node.send_type?
+          args = process_args(node.arguments)
+          return extract_breakable_node_from_elements(node, args, max)
+        elsif node.array_type? || node.hash_type?
+          return extract_breakable_node_from_elements(node, node.children, max)
+        end
+        nil
+      end
+
+      private
+
+      def extract_breakable_node_from_elements(node, elements, max)
+        return unless breakable_collection?(node, elements)
+        return if safe_to_ignore?(node)
+
+        line = processed_source.lines[node.first_line - 1]
+        return if processed_source.commented?(node.loc.begin)
+        return if line.length <= max
+
+        extract_first_element_over_column_limit(node, elements, max)
+      end
+
+      def extract_first_element_over_column_limit(node, elements, max)
+        line = node.first_line
+        i = 0
+        i += 1 while within_column_limit?(elements[i], max, line)
+        return elements.first if i.zero?
+
+        elements[i - 1]
+      end
+
+      def within_column_limit?(element, max, line)
+        element && element.loc.column < max && element.loc.line == line
+      end
+
+      def safe_to_ignore?(node)
+        return true unless max
+        return true if already_on_multiple_lines?(node)
+
+        # If there's a containing breakable collection on the same
+        # line, we let that one get broken first. In a separate pass,
+        # this one might get broken as well, but to avoid conflicting
+        # or redundant edits, we only mark one offense at a time.
+        return true if contained_by_breakable_collection_on_same_line?(node)
+
+        if contained_by_multiline_collection_that_could_be_broken_up?(node)
+          return true
+        end
+
+        false
+      end
+
+      def breakable_collection?(node, elements)
+        # For simplicity we only want to insert breaks in normal
+        # hashes wrapped in a set of curly braces like {foo: 1}.
+        # That is, not a kwargs hash. For method calls, this ensures
+        # the method call is made with parens.
+        starts_with_bracket = node.loc.begin
+
+        # If the call has a second argument, we can insert a line
+        # break before the second argument and the rest of the
+        # argument will get auto-formatted onto separate lines
+        # by other cops.
+        has_second_element = elements.length >= 2
+
+        starts_with_bracket && has_second_element
+      end
+
+      def contained_by_breakable_collection_on_same_line?(node)
+        node.each_ancestor.find do |ancestor|
+          # Ignore ancestors on different lines.
+          break if ancestor.first_line != node.first_line
+
+          if ancestor.hash_type? || ancestor.array_type?
+            elements = ancestor.children
+          elsif ancestor.send_type?
+            elements = process_args(ancestor.arguments)
+          else
+            next
+          end
+
+          return true if breakable_collection?(ancestor, elements)
+        end
+
+        false
+      end
+
+      def contained_by_multiline_collection_that_could_be_broken_up?(node)
+        node.each_ancestor.find do |ancestor|
+          if ancestor.hash_type? || ancestor.array_type?
+            if breakable_collection?(ancestor, ancestor.children)
+              return children_could_be_broken_up?(ancestor.children)
+            end
+          end
+
+          next unless ancestor.send_type?
+
+          args = process_args(ancestor.arguments)
+          if breakable_collection?(ancestor, args)
+            return children_could_be_broken_up?(args)
+          end
+        end
+
+        false
+      end
+
+      def children_could_be_broken_up?(children)
+        return false if all_on_same_line?(children)
+
+        last_seen_line = -1
+        children.each do |child|
+          return true if last_seen_line >= child.first_line
+
+          last_seen_line = child.last_line
+        end
+        false
+      end
+
+      def all_on_same_line?(nodes)
+        return true if nodes.empty?
+
+        nodes.first.first_line == nodes.last.last_line
+      end
+
+      def process_args(args)
+        # If there is a trailing hash arg without explicit braces, like this:
+        #
+        #    method(1, 'key1' => value1, 'key2' => value2)
+        #
+        # ...then each key/value pair is treated as a method 'argument'
+        # when determining where line breaks should appear.
+        if (last_arg = args.last)
+          if last_arg.hash_type? && !last_arg.braces?
+            args = args.concat(args.pop.children)
+          end
+        end
+        args
+      end
+
+      def already_on_multiple_lines?(node)
+        node.first_line != node.last_line
+      end
+    end
+  end
+end