rubocop 0.67.2 → 0.68.0

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

@@ -36,10 +36,8 @@ module RuboCop
         end
 
         def on_class(node)
-          _name, superclass, _body = *node
-
-          @class_or_module_def_first_line = if superclass
-                                              superclass.first_line
+          @class_or_module_def_first_line = if node.parent_class
+                                              node.parent_class.first_line
                                             else
                                               node.source_range.first_line
                                             end
@@ -52,10 +50,10 @@ module RuboCop
         end
 
         def on_sclass(node)
-          self_node, _body = *node
-
-          @class_or_module_def_first_line = self_node.source_range.first_line
-          @class_or_module_def_last_line = self_node.source_range.last_line
+          @class_or_module_def_first_line =
+            node.identifier.source_range.first_line
+          @class_or_module_def_last_line =
+            node.source_range.last_line
         end
 
         def on_block(node)

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

@@ -70,16 +70,13 @@ module RuboCop
         KIND = 'class'.freeze
 
         def on_class(node)
-          _name, superclass, body = *node
+          first_line = node.parent_class.first_line if node.parent_class
 
-          adjusted_first_line = superclass.first_line if superclass
-
-          check(node, body, adjusted_first_line: adjusted_first_line)
+          check(node, node.body, adjusted_first_line: first_line)
         end
 
         def on_sclass(node)
-          _obj, body = *node
-          check(node, body)
+          check(node, node.body)
         end
 
         def autocorrect(node)

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

@@ -50,8 +50,7 @@ module RuboCop
         KIND = 'module'.freeze
 
         def on_module(node)
-          _name, body = *node
-          check(node, body)
+          check(node, node.body)
         end
 
         def autocorrect(node)

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

@@ -44,6 +44,7 @@ module RuboCop
           check_method_line_break(node, args)
         end
         alias on_csend on_send
+        alias on_super on_send
 
         def autocorrect(node)
           EmptyLineCorrector.insert_before(node)

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

@@ -0,0 +1,292 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # This cop checks for the placement of the closing parenthesis
+      # in a method call that passes a HEREDOC string as an argument.
+      # It should be placed at the end of the line containing the
+      # opening HEREDOC tag.
+      #
+      # @example
+      #   # bad
+      #
+      #      foo(<<-SQL
+      #        bar
+      #      SQL
+      #      )
+      #
+      #      foo(<<-SQL, 123, <<-NOSQL,
+      #        bar
+      #      SQL
+      #        baz
+      #      NOSQL
+      #      )
+      #
+      #      foo(
+      #        bar(<<-SQL
+      #          baz
+      #        SQL
+      #        ),
+      #        123,
+      #      )
+      #
+      #   # good
+      #
+      #      foo(<<-SQL)
+      #        bar
+      #      SQL
+      #
+      #      foo(<<-SQL, 123, <<-NOSQL)
+      #        bar
+      #      SQL
+      #        baz
+      #      NOSQL
+      #
+      #      foo(
+      #        bar(<<-SQL),
+      #          baz
+      #        SQL
+      #        123,
+      #      )
+      #
+      class HeredocArgumentClosingParenthesis < Cop
+        include RangeHelp
+
+        MSG = 'Put the closing parenthesis for a method call with a ' \
+        'HEREDOC parameter on the same line as the HEREDOC opening.'.freeze
+
+        STRING_TYPES = %i[str dstr xstr].freeze
+        def on_send(node)
+          heredoc_arg = extract_heredoc_argument(node)
+          return unless heredoc_arg
+
+          outermost_send = outermost_send_on_same_line(heredoc_arg)
+          return unless outermost_send
+          return unless outermost_send.loc.end
+          return unless heredoc_arg.first_line != outermost_send.loc.end.line
+
+          add_offense(outermost_send, location: :end)
+        end
+
+        # Autocorrection note:
+        #
+        # Commas are a bit tricky to handle when the method call is
+        # embedded in another expression. Here's an example:
+        #
+        # [
+        #   first_array_value,
+        #   foo(<<-SQL, 123, 456,
+        #     SELECT * FROM db
+        #   SQL
+        #   ),
+        #   third_array_value,
+        # ]
+        #
+        # The "internal" trailing comma is after `456`.
+        # The "external" trailing comma is after `)`.
+        #
+        # To autocorrect, we remove the latter, and move the former up:
+        #
+        # [
+        #   first_array_value,
+        #   foo(<<-SQL, 123, 456),
+        #     SELECT * FROM db
+        #   SQL
+        #   third_array_value,
+        # ]
+        def autocorrect(node)
+          lambda do |corrector|
+            fix_closing_parenthesis(node, corrector)
+
+            if internal_trailing_comma?(node)
+              remove_internal_trailing_comma(node, corrector)
+            end
+
+            if external_trailing_comma?(node)
+              fix_external_trailing_comma(node, corrector)
+            end
+          end
+        end
+
+        private
+
+        def outermost_send_on_same_line(heredoc)
+          previous = heredoc
+          current = previous.parent
+          until send_missing_closing_parens?(current, previous, heredoc)
+            previous = current
+            current = current.parent
+            return unless previous && current
+          end
+          current
+        end
+
+        def send_missing_closing_parens?(parent, child, heredoc)
+          send_node?(parent) &&
+            parent.arguments.include?(child) &&
+            parent.loc.begin &&
+            parent.loc.end.line != heredoc.last_line
+        end
+
+        def send_node?(node)
+          return nil unless node
+
+          node.send_type? || node.csend_type?
+        end
+
+        def extract_heredoc_argument(node)
+          node.arguments.find do |arg_node|
+            extract_heredoc(arg_node)
+          end
+        end
+
+        def extract_heredoc(node)
+          return node if heredoc_node?(node)
+          return node.receiver if single_line_send_with_heredoc_receiver?(node)
+
+          return unless node.hash_type?
+
+          node.values.find do |v|
+            heredoc = extract_heredoc(v)
+            return heredoc if heredoc
+          end
+        end
+
+        def heredoc_node?(node)
+          node && STRING_TYPES.include?(node.type) && node.heredoc?
+        end
+
+        def single_line_send_with_heredoc_receiver?(node)
+          return false unless node.send_type?
+          return false unless heredoc_node?(node.receiver)
+
+          node.receiver.location.heredoc_end.end_pos > node.source_range.end_pos
+        end
+
+        # Closing parenthesis helpers.
+
+        def fix_closing_parenthesis(node, corrector)
+          remove_incorrect_closing_paren(node, corrector)
+          add_correct_closing_paren(node, corrector)
+        end
+
+        def add_correct_closing_paren(node, corrector)
+          corrector.insert_after(node.arguments.last.source_range, ')')
+        end
+
+        def remove_incorrect_closing_paren(node, corrector)
+          corrector.remove(
+            range_between(
+              incorrect_parenthesis_removal_begin(node),
+              incorrect_parenthesis_removal_end(node)
+            )
+          )
+        end
+
+        def incorrect_parenthesis_removal_begin(node)
+          end_pos = node.source_range.end_pos
+          if safe_to_remove_line_containing_closing_paren?(node)
+            last_line_length = node.source.scan(/\n(.*)$/).last[0].size
+            end_pos - last_line_length - 1 # Add one for the line break itself.
+          else
+            end_pos - 1 # Just the `)` at the end of the string
+          end
+        end
+
+        def safe_to_remove_line_containing_closing_paren?(node)
+          last_line = processed_source[node.loc.end.line - 1]
+          # Safe to remove if last line only contains `)`, `,`, and whitespace.
+          last_line.match(/^[ ]*\)[ ]{0,20},{0,1}[ ]*$/)
+        end
+
+        def incorrect_parenthesis_removal_end(node)
+          end_pos = node.source_range.end_pos
+          if processed_source.buffer.source[end_pos] == ','
+            end_pos + 1
+          else
+            end_pos
+          end
+        end
+
+        # Internal trailing comma helpers.
+
+        def remove_internal_trailing_comma(node, corrector)
+          offset = internal_trailing_comma_offset_from_last_arg(node)
+          last_arg_end_pos = node.children.last.source_range.end_pos
+          corrector.remove(
+            range_between(
+              last_arg_end_pos,
+              last_arg_end_pos + offset
+            )
+          )
+        end
+
+        def internal_trailing_comma?(node)
+          !internal_trailing_comma_offset_from_last_arg(node).nil?
+        end
+
+        # Returns nil if no trailing internal comma.
+        def internal_trailing_comma_offset_from_last_arg(node)
+          source_after_last_arg = range_between(
+            node.children.last.source_range.end_pos,
+            node.loc.end.begin_pos
+          ).source
+
+          first_comma_offset = source_after_last_arg.index(',')
+          first_new_line_offset = source_after_last_arg.index("\n")
+          return if first_comma_offset.nil?
+          return if first_new_line_offset.nil?
+          return if first_comma_offset > first_new_line_offset
+
+          first_comma_offset + 1
+        end
+
+        # External trailing comma helpers.
+
+        def fix_external_trailing_comma(node, corrector)
+          remove_incorrect_external_trailing_comma(node, corrector)
+          add_correct_external_trailing_comma(node, corrector)
+        end
+
+        def add_correct_external_trailing_comma(node, corrector)
+          return unless external_trailing_comma?(node)
+
+          corrector.insert_after(node.arguments.last.source_range, ',')
+        end
+
+        def remove_incorrect_external_trailing_comma(node, corrector)
+          end_pos = node.source_range.end_pos
+          return unless external_trailing_comma?(node)
+
+          corrector.remove(
+            range_between(
+              end_pos,
+              end_pos + external_trailing_comma_offset_from_loc_end(node)
+            )
+          )
+        end
+
+        def external_trailing_comma?(node)
+          !external_trailing_comma_offset_from_loc_end(node).nil?
+        end
+
+        # Returns nil if no trailing external comma.
+        def external_trailing_comma_offset_from_loc_end(node)
+          end_pos = node.source_range.end_pos
+          offset = 0
+          limit = 20
+          offset += 1 while offset < limit && space?(end_pos + offset)
+          char = processed_source.buffer.source[end_pos + offset]
+          return unless char == ','
+
+          offset + 1 # Add one to include the comma.
+        end
+
+        def space?(pos)
+          processed_source.buffer.source[pos] == ' '
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/layout/{first_parameter_indentation.rb → indent_first_argument.rb}

@@ -4,9 +4,8 @@ module RuboCop
   module Cop
     # rubocop:disable Metrics/LineLength
     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.
+      # This cop checks the indentation of the first argument in a method call
+      # or definition.
       #
       # @example
       #
@@ -33,7 +32,7 @@ module RuboCop
       #   second_param
       #
       # @example EnforcedStyle: consistent
-      #   # The first parameter should always be indented one step more than the
+      #   # The first argument should always be indented one step more than the
       #   # preceding line.
       #
       #   # good
@@ -59,8 +58,8 @@ module RuboCop
       #   second_param
       #
       # @example EnforcedStyle: consistent_relative_to_receiver
-      #   # The first parameter should always be indented one level relative to
-      #   # the parent that is receiving the parameter
+      #   # The first argument should always be indented one level relative to
+      #   # the parent that is receiving the argument
       #
       #   # good
       #   some_method(
@@ -85,9 +84,9 @@ module RuboCop
       #   second_params
       #
       # @example EnforcedStyle: special_for_inner_method_call
-      #   # The first parameter should normally be indented one step more than
-      #   # the preceding line, but if it's a parameter for a method call that
-      #   # is itself a parameter in a method call, then the inner parameter
+      #   # The first argument should normally be indented one step more than
+      #   # the preceding line, but if it's a argument for a method call that
+      #   # is itself a argument in a method call, then the inner argument
       #   # should be indented relative to the inner method.
       #
       #   # good
@@ -139,13 +138,13 @@ module RuboCop
       #     nested_first_param),
       #   second_param
       #
-      class FirstParameterIndentation < Cop
+      class IndentFirstArgument < Cop
         # rubocop:enable Metrics/LineLength
         include Alignment
         include ConfigurableEnforcedStyle
         include RangeHelp
 
-        MSG = 'Indent the first parameter one step more than %<base>s.'.freeze
+        MSG = 'Indent the first argument one step more than %<base>s.'.freeze
 
         def on_send(node)
           return if !node.arguments? || node.operator_method?
@@ -163,7 +162,7 @@ module RuboCop
         private
 
         def message(arg_node)
-          return 'Bad indentation of the first parameter.' unless arg_node
+          return 'Bad indentation of the first argument.' unless arg_node
 
           send_node = arg_node.parent
           text = base_range(send_node, arg_node).source.strip

data/lib/rubocop/cop/layout/{indent_array.rb → indent_first_array_element.rb}

@@ -79,10 +79,10 @@ module RuboCop
       #   and_now_for_something = [
       #                             :completely_different
       #                           ]
-      class IndentArray < Cop
+      class IndentFirstArrayElement < Cop
         include Alignment
         include ConfigurableEnforcedStyle
-        include ArrayHashIndentation
+        include MultilineElementIndentation
 
         MSG = 'Use %<configured_indentation_width>d spaces for indentation ' \
               'in an array, relative to %<base_description>s.'.freeze

data/lib/rubocop/cop/layout/{indent_hash.rb → indent_first_hash_element.rb}

@@ -77,10 +77,10 @@ module RuboCop
       #   and_now_for_something = {
       #                             completely: :different
       #                           }
-      class IndentHash < Cop
+      class IndentFirstHashElement < Cop
         include Alignment
         include ConfigurableEnforcedStyle
-        include ArrayHashIndentation
+        include MultilineElementIndentation
 
         MSG = 'Use %<configured_indentation_width>d spaces for indentation ' \
               'in a hash, relative to %<base_description>s.'.freeze