rubocop-grantbirki 1.75.2

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

@@ -0,0 +1,263 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks the indentation of the method name part in method calls
+      # that span more than one line.
+      #
+      # @example EnforcedStyle: aligned (default)
+      #   # bad
+      #   while myvariable
+      #   .b
+      #     # do something
+      #   end
+      #
+      #   # good
+      #   while myvariable
+      #         .b
+      #     # do something
+      #   end
+      #
+      #   # good
+      #   Thing.a
+      #        .b
+      #        .c
+      #
+      # @example EnforcedStyle: indented
+      #   # good
+      #   while myvariable
+      #     .b
+      #
+      #     # do something
+      #   end
+      #
+      # @example EnforcedStyle: indented_relative_to_receiver
+      #   # good
+      #   while myvariable
+      #           .a
+      #           .b
+      #
+      #     # do something
+      #   end
+      #
+      #   # good
+      #   myvariable = Thing
+      #                  .a
+      #                  .b
+      #                  .c
+      class MultilineMethodCallIndentation < Base
+        include ConfigurableEnforcedStyle
+        include Alignment
+        include MultilineExpressionIndentation
+        extend AutoCorrector
+
+        def validate_config
+          return unless style == :aligned && cop_config['IndentationWidth']
+
+          raise ValidationError,
+                'The `Layout/MultilineMethodCallIndentation` ' \
+                'cop only accepts an `IndentationWidth` ' \
+                'configuration parameter when ' \
+                '`EnforcedStyle` is `indented`.'
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
+        end
+
+        def relevant_node?(send_node)
+          send_node.loc.dot # Only check method calls with dot operator
+        end
+
+        def right_hand_side(send_node)
+          dot = send_node.loc.dot
+          selector = send_node.loc.selector
+          if (send_node.dot? || send_node.safe_navigation?) && selector && same_line?(dot, selector)
+            dot.join(selector)
+          elsif selector
+            selector
+          elsif send_node.implicit_call?
+            dot.join(send_node.loc.begin)
+          end
+        end
+
+        def offending_range(node, lhs, rhs, given_style)
+          return false unless begins_its_line?(rhs)
+          return false if not_for_this_cop?(node)
+
+          @base = alignment_base(node, rhs, given_style)
+          correct_column = if @base
+                             @base.column + extra_indentation(given_style, node.parent)
+                           else
+                             indentation(lhs) + correct_indentation(node)
+                           end
+          @column_delta = correct_column - rhs.column
+          rhs if @column_delta.nonzero?
+        end
+
+        def extra_indentation(given_style, parent)
+          if given_style == :indented_relative_to_receiver
+            if parent&.type?(:splat, :kwsplat)
+              configured_indentation_width - parent.loc.operator.length
+            else
+              configured_indentation_width
+            end
+          else
+            0
+          end
+        end
+
+        def message(node, lhs, rhs)
+          if should_indent_relative_to_receiver?
+            relative_to_receiver_message(rhs)
+          elsif should_align_with_base?
+            align_with_base_message(rhs)
+          else
+            no_base_message(lhs, rhs, node)
+          end
+        end
+
+        def should_indent_relative_to_receiver?
+          @base && style == :indented_relative_to_receiver
+        end
+
+        def should_align_with_base?
+          @base && style != :indented_relative_to_receiver
+        end
+
+        def relative_to_receiver_message(rhs)
+          "Indent `#{rhs.source}` #{configured_indentation_width} spaces " \
+            "more than `#{base_source}` on line #{@base.line}."
+        end
+
+        def align_with_base_message(rhs)
+          "Align `#{rhs.source}` with `#{base_source}` on line #{@base.line}."
+        end
+
+        def base_source
+          @base.source[/[^\n]*/]
+        end
+
+        def no_base_message(lhs, rhs, node)
+          used_indentation = rhs.column - indentation(lhs)
+          what = operation_description(node, rhs)
+
+          "Use #{correct_indentation(node)} (not #{used_indentation}) " \
+            "spaces for indenting #{what} spanning multiple lines."
+        end
+
+        def alignment_base(node, rhs, given_style)
+          case given_style
+          when :aligned
+            semantic_alignment_base(node, rhs) || syntactic_alignment_base(node, rhs)
+          when :indented
+            nil
+          when :indented_relative_to_receiver
+            receiver_alignment_base(node)
+          end
+        end
+
+        def syntactic_alignment_base(lhs, rhs)
+          # a if b
+          #      .c
+          kw_node_with_special_indentation(lhs) do |base|
+            return indented_keyword_expression(base).source_range
+          end
+
+          # a = b
+          #     .c
+          part_of_assignment_rhs(lhs, rhs) { |base| return assignment_rhs(base).source_range }
+
+          # a + b
+          #     .c
+          operation_rhs(lhs) { |base| return base.source_range }
+        end
+
+        # a.b
+        #  .c
+        def semantic_alignment_base(node, rhs)
+          return unless rhs.source.start_with?('.', '&.')
+
+          node = semantic_alignment_node(node)
+          return unless node&.loc&.selector && node.loc.dot
+
+          node.loc.dot.join(node.loc.selector)
+        end
+
+        # a
+        #   .b
+        #   .c
+        def receiver_alignment_base(node)
+          node = node.receiver while node.receiver
+          node = node.parent
+          node = node.parent until node.loc.dot
+
+          node&.receiver&.source_range
+        end
+
+        def semantic_alignment_node(node)
+          return if argument_in_method_call(node, :with_parentheses)
+
+          dot_right_above = get_dot_right_above(node)
+          return dot_right_above if dot_right_above
+
+          if (multiline_block_chain_node = find_multiline_block_chain_node(node))
+            return multiline_block_chain_node
+          end
+
+          node = first_call_has_a_dot(node)
+          return if node.loc.dot.line != node.first_line
+
+          node
+        end
+
+        def get_dot_right_above(node)
+          node.each_ancestor.find do |a|
+            dot = a.loc.dot if a.loc?(:dot)
+            next unless dot
+
+            dot.line == node.loc.dot.line - 1 && dot.column == node.loc.dot.column
+          end
+        end
+
+        def find_multiline_block_chain_node(node)
+          return unless (block_node = node.each_descendant(:any_block).first)
+          return unless block_node.multiline? && block_node.parent.call_type?
+
+          if node.receiver.call_type?
+            node.receiver
+          else
+            block_node.parent
+          end
+        end
+
+        def first_call_has_a_dot(node)
+          # descend to root of method chain
+          node = node.receiver while node.receiver
+          # ascend to first call which has a dot
+          node = node.parent
+          node = node.parent until node.loc?(:dot)
+
+          node
+        end
+
+        def operation_rhs(node)
+          operation_rhs = node.receiver.each_ancestor(:send).find do |rhs|
+            operator_rhs?(rhs, node.receiver)
+          end
+
+          return unless operation_rhs
+
+          yield operation_rhs.first_argument
+        end
+
+        def operator_rhs?(node, receiver)
+          node.operator_method? && node.arguments? && within_node?(receiver, node.first_argument)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks that the closing brace in a method definition is either
+      # on the same line as the last method parameter, or a new line.
+      #
+      # When using the `symmetrical` (default) style:
+      #
+      # If a method definition's opening brace is on the same line as the
+      # first parameter of the definition, then the closing brace should be
+      # on the same line as the last parameter of the definition.
+      #
+      # If a method definition's opening brace is on the line above the first
+      # parameter of the definition, then the closing brace should be on the
+      # line below the last parameter of the definition.
+      #
+      # When using the `new_line` style:
+      #
+      # The closing brace of a multi-line method definition must be on the line
+      # after the last parameter of the definition.
+      #
+      # When using the `same_line` style:
+      #
+      # The closing brace of a multi-line method definition must be on the same
+      # line as the last parameter of the definition.
+      #
+      # @example EnforcedStyle: symmetrical (default)
+      #   # bad
+      #   def foo(a,
+      #     b
+      #   )
+      #   end
+      #
+      #   # bad
+      #   def foo(
+      #     a,
+      #     b)
+      #   end
+      #
+      #   # good
+      #   def foo(a,
+      #     b)
+      #   end
+      #
+      #   # good
+      #   def foo(
+      #     a,
+      #     b
+      #   )
+      #   end
+      #
+      # @example EnforcedStyle: new_line
+      #   # bad
+      #   def foo(
+      #     a,
+      #     b)
+      #   end
+      #
+      #   # bad
+      #   def foo(a,
+      #     b)
+      #   end
+      #
+      #   # good
+      #   def foo(a,
+      #     b
+      #   )
+      #   end
+      #
+      #   # good
+      #   def foo(
+      #     a,
+      #     b
+      #   )
+      #   end
+      #
+      # @example EnforcedStyle: same_line
+      #   # bad
+      #   def foo(a,
+      #     b
+      #   )
+      #   end
+      #
+      #   # bad
+      #   def foo(
+      #     a,
+      #     b
+      #   )
+      #   end
+      #
+      #   # good
+      #   def foo(
+      #     a,
+      #     b)
+      #   end
+      #
+      #   # good
+      #   def foo(a,
+      #     b)
+      #   end
+      class MultilineMethodDefinitionBraceLayout < Base
+        include MultilineLiteralBraceLayout
+        extend AutoCorrector
+
+        SAME_LINE_MESSAGE = 'Closing method definition brace must be on the ' \
+                            'same line as the last parameter when opening brace is on the same ' \
+                            'line as the first parameter.'
+
+        NEW_LINE_MESSAGE = 'Closing method definition brace must be on the ' \
+                           'line after the last parameter when opening brace is on a separate ' \
+                           'line from the first parameter.'
+
+        ALWAYS_NEW_LINE_MESSAGE = 'Closing method definition brace must be ' \
+                                  'on the line after the last parameter.'
+
+        ALWAYS_SAME_LINE_MESSAGE = 'Closing method definition brace must be ' \
+                                   'on the same line as the last parameter.'
+
+        def on_def(node)
+          check_brace_layout(node.arguments)
+        end
+        alias on_defs on_def
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Ensures that each parameter in a multi-line method definition
+      # starts on a separate line.
+      #
+      # NOTE: This cop does not move the first argument, if you want that to
+      # be on a separate line, see `Layout/FirstMethodParameterLineBreak`.
+      #
+      # @example
+      #
+      #   # bad
+      #   def foo(a, b,
+      #     c
+      #   )
+      #   end
+      #
+      #   # good
+      #   def foo(
+      #     a,
+      #     b,
+      #     c
+      #   )
+      #   end
+      #
+      #   # good
+      #   def foo(
+      #     a,
+      #     b = {
+      #       foo: "bar",
+      #     }
+      #   )
+      #   end
+      #
+      #   # good
+      #   def foo(a, b, c)
+      #   end
+      #
+      # @example AllowMultilineFinalElement: false (default)
+      #
+      #   # bad
+      #   def foo(a, b = {
+      #     foo: "bar",
+      #   })
+      #   end
+      #
+      # @example AllowMultilineFinalElement: true
+      #
+      #   # good
+      #   def foo(a, b = {
+      #     foo: "bar",
+      #   })
+      #   end
+      #
+      class MultilineMethodParameterLineBreaks < Base
+        include MultilineElementLineBreaks
+        extend AutoCorrector
+
+        MSG = 'Each parameter in a multi-line method definition must start on a separate line.'
+
+        def on_def(node)
+          return if node.arguments.empty?
+
+          check_line_breaks(node, node.arguments, ignore_last: ignore_last_element?)
+        end
+        alias on_defs on_def
+
+        private
+
+        def ignore_last_element?
+          !!cop_config['AllowMultilineFinalElement']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks the indentation of the right hand side operand in binary operations that
+      # span more than one line.
+      #
+      # The `aligned` style checks that operators are aligned if they are part of an `if` or `while`
+      # condition, an explicit `return` statement, etc. In other contexts, the second operand should
+      # be indented regardless of enforced style.
+      #
+      # @example EnforcedStyle: aligned (default)
+      #   # bad
+      #   if a +
+      #       b
+      #     something &&
+      #     something_else
+      #   end
+      #
+      #   # good
+      #   if a +
+      #      b
+      #     something &&
+      #       something_else
+      #   end
+      #
+      # @example EnforcedStyle: indented
+      #   # bad
+      #   if a +
+      #      b
+      #     something &&
+      #     something_else
+      #   end
+      #
+      #   # good
+      #   if a +
+      #       b
+      #     something &&
+      #       something_else
+      #   end
+      #
+      class MultilineOperationIndentation < Base
+        include ConfigurableEnforcedStyle
+        include Alignment
+        include MultilineExpressionIndentation
+        extend AutoCorrector
+
+        def on_and(node)
+          check_and_or(node)
+        end
+
+        def on_or(node)
+          check_and_or(node)
+        end
+
+        def validate_config
+          return unless style == :aligned && cop_config['IndentationWidth']
+
+          raise ValidationError, 'The `Layout/MultilineOperationIndentation` ' \
+                                 'cop only accepts an `IndentationWidth` ' \
+                                 'configuration parameter when ' \
+                                 '`EnforcedStyle` is `indented`.'
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
+        end
+
+        def relevant_node?(node)
+          return false if node.send_type? && node.unary_operation?
+
+          !node.loc.dot # Don't check method calls with dot operator.
+        end
+
+        def check_and_or(node)
+          range = offending_range(node, node.lhs, node.rhs.source_range, style)
+          check(range, node, node.lhs, node.rhs.source_range)
+        end
+
+        def offending_range(node, lhs, rhs, given_style)
+          return false unless begins_its_line?(rhs)
+          return false if not_for_this_cop?(node)
+
+          correct_column = if should_align?(node, rhs, given_style)
+                             node.loc.column
+                           else
+                             indentation(lhs) + correct_indentation(node)
+                           end
+          @column_delta = correct_column - rhs.column
+          rhs if @column_delta.nonzero?
+        end
+
+        def should_align?(node, rhs, given_style)
+          assignment_node = part_of_assignment_rhs(node, rhs)
+          if assignment_node
+            assignment_rhs = CheckAssignment.extract_rhs(assignment_node)
+            return true if begins_its_line?(assignment_rhs.source_range)
+          end
+
+          given_style == :aligned &&
+            (kw_node_with_special_indentation(node) ||
+             assignment_node ||
+             argument_in_method_call(node, :with_or_without_parentheses))
+        end
+
+        def message(node, lhs, rhs)
+          what = operation_description(node, rhs)
+          if should_align?(node, rhs, style)
+            "Align the operands of #{what} spanning multiple lines."
+          else
+            used_indentation = rhs.column - indentation(lhs)
+            "Use #{correct_indentation(node)} (not #{used_indentation}) " \
+              "spaces for indenting #{what} spanning multiple lines."
+          end
+        end
+
+        def right_hand_side(send_node)
+          send_node.first_argument&.source_range
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Check that the parameters on a multi-line method call or definition are aligned.
+      #
+      # To set the alignment of the first argument, use the
+      # `Layout/FirstParameterIndentation` cop.
+      #
+      # @example EnforcedStyle: with_first_parameter (default)
+      #   # good
+      #
+      #   def foo(bar,
+      #           baz)
+      #     123
+      #   end
+      #
+      #   def foo(
+      #     bar,
+      #     baz
+      #   )
+      #     123
+      #   end
+      #
+      #   # bad
+      #
+      #   def foo(bar,
+      #        baz)
+      #     123
+      #   end
+      #
+      #   # bad
+      #
+      #   def foo(
+      #     bar,
+      #        baz)
+      #     123
+      #   end
+      #
+      # @example EnforcedStyle: with_fixed_indentation
+      #   # good
+      #
+      #   def foo(bar,
+      #     baz)
+      #     123
+      #   end
+      #
+      #   def foo(
+      #     bar,
+      #     baz
+      #   )
+      #     123
+      #   end
+      #
+      #   # bad
+      #
+      #   def foo(bar,
+      #           baz)
+      #     123
+      #   end
+      #
+      #   # bad
+      #
+      #   def foo(
+      #     bar,
+      #        baz)
+      #     123
+      #   end
+      class ParameterAlignment < Base
+        include Alignment
+        extend AutoCorrector
+
+        ALIGN_PARAMS_MSG = 'Align the parameters of a method definition if ' \
+                           'they span more than one line.'
+
+        FIXED_INDENT_MSG = 'Use one level of indentation for parameters ' \
+                           'following the first line of a multi-line method definition.'
+
+        def on_def(node)
+          return if node.arguments.size < 2
+
+          check_alignment(node.arguments, base_column(node, node.arguments))
+        end
+        alias on_defs on_def
+
+        private
+
+        def autocorrect(corrector, node)
+          AlignmentCorrector.correct(corrector, processed_source, node, column_delta)
+        end
+
+        def message(_node)
+          fixed_indentation? ? FIXED_INDENT_MSG : ALIGN_PARAMS_MSG
+        end
+
+        def fixed_indentation?
+          cop_config['EnforcedStyle'] == 'with_fixed_indentation'
+        end
+
+        def base_column(node, args)
+          if fixed_indentation?
+            lineno = target_method_lineno(node)
+            line = node.source_range.source_buffer.source_line(lineno)
+            indentation_of_line = /\S.*/.match(line).begin(0)
+            indentation_of_line + configured_indentation_width
+          else
+            display_column(args.first.source_range)
+          end
+        end
+
+        def target_method_lineno(node)
+          node.loc.keyword.line
+        end
+      end
+    end
+  end
+end