rubocop 0.67.2 → 0.68.0

data/lib/rubocop/cop/layout/indent_first_parameter.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks the indentation of the first parameter in a method call.
+      # Parameters after the first one are checked by Layout/AlignParameters,
+      # not by this cop.
+      #
+      # @example
+      #
+      #   # bad
+      #   def some_method(
+      #   first_param,
+      #   second_param)
+      #     123
+      #   end
+      #
+      # @example EnforcedStyle: consistent
+      #   # The first parameter should always be indented one step more than the
+      #   # preceding line.
+      #
+      #   # good
+      #   def some_method(
+      #     first_param,
+      #   second_param)
+      #     123
+      #   end
+      #
+      # @example EnforcedStyle: align_parentheses
+      #   # The first parameter should always be indented one step more than the
+      #   # opening parenthesis.
+      #
+      #   # good
+      #   def some_method(
+      #                    first_param,
+      #   second_param)
+      #     123
+      #   end
+      class IndentFirstParameter < Cop
+        include Alignment
+        include ConfigurableEnforcedStyle
+        include MultilineElementIndentation
+
+        MSG = 'Use %<configured_indentation_width>d spaces for indentation ' \
+             'in method args, relative to %<base_description>s.'.freeze
+
+        def on_def(node)
+          return if node.arguments.empty?
+          return if node.arguments.loc.begin.nil?
+
+          check(node)
+        end
+        alias on_defs on_def
+
+        def autocorrect(node)
+          AlignmentCorrector.correct(processed_source, node, @column_delta)
+        end
+
+        private
+
+        def brace_alignment_style
+          :align_parentheses
+        end
+
+        def check(def_node)
+          return if ignored_node?(def_node)
+
+          left_parenthesis = def_node.arguments.loc.begin
+          first_elem = def_node.arguments.first
+          return unless first_elem
+          return if first_elem.source_range.line == left_parenthesis.line
+
+          check_first(first_elem, left_parenthesis, nil, 0)
+        end
+
+        # Returns the description of what the correct indentation is based on.
+        def base_description(_)
+          if style == brace_alignment_style
+            'the position of the opening parenthesis'
+          else
+            'the start of the line where the left parenthesis is'
+          end
+        end
+
+        def message(base_description)
+          format(
+            MSG,
+            configured_indentation_width: configured_indentation_width,
+            base_description: base_description
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/layout/indentation_width.rb

@@ -90,28 +90,16 @@ module RuboCop
           check_members(end_loc, [node.body])
         end
 
-        def on_module(node)
-          _module_name, *members = *node
-          check_members(node.loc.keyword, members)
-        end
-
         def on_class(node)
-          _class_name, _base_class, *members = *node
-          check_members(node.loc.keyword, members)
-        end
-
-        def on_sclass(node)
-          _class_name, *members = *node
-
-          check_members(node.loc.keyword, members)
+          check_members(node.loc.keyword, [node.body])
         end
+        alias on_sclass on_class
+        alias on_module on_class
 
         def on_send(node)
           super
           return unless node.adjacent_def_modifier?
 
-          *_, body = *node.first_argument
-
           def_end_config = config.for_cop('Layout/DefEndAlignment')
           style = def_end_config['EnforcedStyleAlignWith'] || 'start_of_line'
           base = if style == 'def'
@@ -120,7 +108,7 @@ module RuboCop
                    leftmost_modifier_of(node) || node
                  end
 
-          check_indentation(base.source_range, body)
+          check_indentation(base.source_range, node.first_argument.body)
           ignore_node(node.first_argument)
         end
         alias on_csend on_send

data/lib/rubocop/cop/layout/multiline_method_call_indentation.rb

@@ -201,10 +201,8 @@ module RuboCop
         end
 
         def operation_rhs(node)
-          receiver, = *node
-
-          operation_rhs = receiver.each_ancestor(:send).find do |rhs|
-            operator_rhs?(rhs, receiver)
+          operation_rhs = node.receiver.each_ancestor(:send).find do |rhs|
+            operator_rhs?(rhs, node.receiver)
           end
 
           return unless operation_rhs

data/lib/rubocop/cop/layout/space_in_lambda_literal.rb

@@ -23,7 +23,6 @@ module RuboCop
         include ConfigurableEnforcedStyle
         include RangeHelp
 
-        ARROW = '->'.freeze
         MSG_REQUIRE_SPACE = 'Use a space between `->` and ' \
                             '`(` in lambda literals.'.freeze
         MSG_REQUIRE_NO_SPACE = 'Do not use spaces between `->` and ' \
@@ -59,21 +58,7 @@ module RuboCop
         private
 
         def arrow_lambda_with_args?(node)
-          lambda_node?(node) && arrow_form?(node) && args?(node)
-        end
-
-        def lambda_node?(node)
-          receiver, call = *node
-          receiver.nil? && call == :lambda
-        end
-
-        def arrow_form?(lambda_node)
-          lambda_node.loc.selector.source == ARROW
-        end
-
-        def args?(lambda_node)
-          _call, args, _body = *lambda_node.parent
-          !args.children.empty?
+          node.lambda_literal? && node.parent.arguments?
         end
 
         def space_after_arrow?(lambda_node)

data/lib/rubocop/cop/layout/space_inside_reference_brackets.rb

@@ -108,8 +108,7 @@ module RuboCop
         end
 
         def bracket_method?(node)
-          _, method, = *node
-          BRACKET_METHODS.include?(method)
+          BRACKET_METHODS.include?(node.method_name)
         end
 
         def left_ref_bracket(node, tokens)

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

@@ -64,20 +64,18 @@ module RuboCop
           return if node.ancestors.any?(&:if_type?)
           return if possible_dsl?(node)
 
-          name, = *node
-          found_instance_method(node, name)
+          found_instance_method(node, node.method_name)
         end
 
         def on_defs(node)
           return if node.ancestors.any?(&:if_type?)
           return if possible_dsl?(node)
 
-          receiver, name, = *node
-          if receiver.const_type?
-            _, const_name = *receiver
-            check_const_receiver(node, name, const_name)
-          elsif receiver.self_type?
-            check_self_receiver(node, name)
+          if node.receiver.const_type?
+            _, const_name = *node.receiver
+            check_const_receiver(node, node.method_name, const_name)
+          elsif node.receiver.self_type?
+            check_self_receiver(node, node.method_name)
           end
         end
 

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

@@ -61,14 +61,10 @@ module RuboCop
           end
         end
 
-        def called_on_string?(node)
-          receiver_node, _method, format_string, = *node
-          if receiver_node.nil? || receiver_node.const_type?
-            format_string && format_string.str_type?
-          else
-            receiver_node.str_type?
-          end
-        end
+        def_node_matcher :called_on_string?, <<-PATTERN
+          {(send {nil? const_type?} _ (str _) ...)
+           (send (str ...) ...)}
+        PATTERN
 
         def method_with_format_args?(node)
           sprintf?(node) || format?(node) || percent?(node)

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

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for the ordering of a method call where
+      # the receiver of the call is a HEREDOC.
+      #
+      # @example
+      #   # bad
+      #
+      #      <<-SQL
+      #        bar
+      #      SQL
+      #      .strip_indent
+      #
+      #      <<-SQL
+      #        bar
+      #      SQL
+      #      .strip_indent
+      #      .trim
+      #
+      #   # good
+      #
+      #      <<-SQL.strip_indent
+      #        bar
+      #      SQL
+      #
+      #      <<-SQL.strip_indent.trim
+      #        bar
+      #      SQL
+      #
+      class HeredocMethodCallPosition < Cop
+        include RangeHelp
+
+        MSG = 'Put a method call with a HEREDOC receiver on the ' \
+        'same line as the HEREDOC opening.'.freeze
+
+        STRING_TYPES = %i[str dstr xstr].freeze
+        def on_send(node)
+          heredoc = heredoc_node_descendent_receiver(node)
+          return unless heredoc
+          return if correctly_positioned?(node, heredoc)
+
+          add_offense(node, location: call_after_heredoc_range(heredoc))
+        end
+        alias on_csend on_send
+
+        def autocorrect(node)
+          heredoc = heredoc_node_descendent_receiver(node)
+
+          lambda do |corrector|
+            call_range = call_range_to_safely_reposition(node, heredoc)
+            return if call_range.nil?
+
+            call_source = call_range.source.strip
+            corrector.remove(call_range)
+            corrector.insert_after(heredoc_begin_line_range(node), call_source)
+          end
+        end
+
+        private
+
+        def heredoc_node_descendent_receiver(node)
+          while send_node?(node)
+            return node.receiver if heredoc_node?(node.receiver)
+
+            node = node.receiver
+          end
+        end
+
+        def send_node?(node)
+          return nil unless node
+
+          node.send_type? || node.csend_type?
+        end
+
+        def heredoc_node?(node)
+          node && STRING_TYPES.include?(node.type) && node.heredoc?
+        end
+
+        def call_after_heredoc_range(heredoc)
+          pos = heredoc_end_pos(heredoc)
+          range_between(pos + 1, pos + 2)
+        end
+
+        def correctly_positioned?(node, heredoc)
+          heredoc_end_pos(heredoc) > call_end_pos(node)
+        end
+
+        def calls_on_multiple_lines?(node, _heredoc)
+          last_line = node.last_line
+          while send_node?(node)
+            return true unless last_line == node.last_line
+            return true unless all_on_same_line?(node.arguments)
+
+            node = node.receiver
+          end
+          false
+        end
+
+        def all_on_same_line?(nodes)
+          return true if nodes.empty?
+
+          nodes.first.first_line == nodes.last.last_line
+        end
+
+        def heredoc_end_pos(heredoc)
+          heredoc.location.heredoc_end.end_pos
+        end
+
+        def call_end_pos(node)
+          node.source_range.end_pos
+        end
+
+        def heredoc_begin_line_range(heredoc)
+          pos = heredoc.source_range.begin_pos
+          range_by_whole_lines(range_between(pos, pos))
+        end
+
+        def call_line_range(node)
+          pos = node.source_range.end_pos
+          range_by_whole_lines(range_between(pos, pos))
+        end
+
+        # Returns nil if no range can be safely repositioned.
+        def call_range_to_safely_reposition(node, heredoc)
+          return nil if calls_on_multiple_lines?(node, heredoc)
+
+          heredoc_end_pos = heredoc_end_pos(heredoc)
+          call_end_pos = call_end_pos(node)
+
+          call_range = range_between(heredoc_end_pos, call_end_pos)
+          call_line_range = call_line_range(node)
+
+          call_source = call_range.source.strip
+          call_line_source = call_line_range.source.strip
+
+          return call_range if call_source == call_line_source
+
+          if trailing_comma?(call_source, call_line_source)
+            # If there's some on the last line other than the call, e.g.
+            # a trailing comma, then we leave the "\n" following the
+            # heredoc_end in place.
+            return range_between(heredoc_end_pos, call_end_pos + 1)
+          end
+
+          nil
+        end
+
+        def trailing_comma?(call_source, call_line_source)
+          call_source + ',' == call_line_source
+        end
+      end
+    end
+  end
+end

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

@@ -48,11 +48,10 @@ module RuboCop
         ].freeze
 
         def on_class(node)
-          _class, base_class, _body = *node
+          return unless node.parent_class &&
+                        illegal_class_name?(node.parent_class)
 
-          return unless base_class && illegal_class_name?(base_class)
-
-          add_offense(base_class)
+          add_offense(node.parent_class)
         end
 
         def autocorrect(node)

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

@@ -18,6 +18,7 @@ module RuboCop
       #   "result is 10"
       class LiteralInInterpolation < Cop
         include RangeHelp
+        include PercentLiteral
 
         MSG = 'Literal interpolation detected.'.freeze
         COMPOSITE = %i[array hash pair irange erange].freeze
@@ -55,14 +56,24 @@ module RuboCop
           when :float
             node.children.last.to_f.to_s
           when :str
-            node.children.last
+            autocorrected_value_for_string(node)
           when :sym
             autocorrected_value_for_symbol(node)
+          when :array
+            autocorrected_value_for_array(node)
           else
             node.source.gsub('"', '\"')
           end
         end
 
+        def autocorrected_value_for_string(node)
+          if node.source.start_with?("'", '%q')
+            node.children.last.inspect[1..-2]
+          else
+            node.children.last
+          end
+        end
+
         def autocorrected_value_for_symbol(node)
           end_pos =
             node.loc.end ? node.loc.end.begin_pos : node.loc.expression.end_pos
@@ -70,6 +81,12 @@ module RuboCop
           range_between(node.loc.begin.end_pos, end_pos).source
         end
 
+        def autocorrected_value_for_array(node)
+          return node.source.gsub('"', '\"') unless node.percent_literal?
+
+          contents_range(node).source.split(' ').to_s.gsub('"', '\"')
+        end
+
         # Does node print its own source when converted to a string?
         def prints_as_self?(node)
           node.basic_literal? ||