rubocop-grantbirki 1.75.2

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks for a line break before the first element in a
+      # multi-line array.
+      #
+      # @example
+      #
+      #   # bad
+      #   [ :a,
+      #     :b]
+      #
+      #   # good
+      #   [
+      #     :a,
+      #     :b]
+      #
+      #   # good
+      #   [:a, :b]
+      #
+      # @example AllowMultilineFinalElement: false (default)
+      #
+      #   # bad
+      #   [ :a, {
+      #     :b => :c
+      #   }]
+      #
+      #   # good
+      #   [
+      #     :a, {
+      #     :b => :c
+      #   }]
+      #
+      # @example AllowMultilineFinalElement: true
+      #
+      #   # good
+      #   [:a, {
+      #     :b => :c
+      #   }]
+      #
+      class FirstArrayElementLineBreak < Base
+        include FirstElementLineBreak
+        extend AutoCorrector
+
+        MSG = 'Add a line break before the first element of a multi-line array.'
+
+        def on_array(node)
+          return if !node.loc.begin && !assignment_on_same_line?(node)
+
+          check_children_line_break(node, node.children, ignore_last: ignore_last_element?)
+        end
+
+        private
+
+        def assignment_on_same_line?(node)
+          source = node.source_range.source_line[0...node.loc.column]
+          /\s*=\s*$/.match?(source)
+        end
+
+        def ignore_last_element?
+          !!cop_config['AllowMultilineFinalElement']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks the indentation of the first key in a hash literal
+      # where the opening brace and the first key are on separate lines. The
+      # other keys' indentations are handled by the HashAlignment cop.
+      #
+      # By default, `Hash` literals that are arguments in a method call with
+      # parentheses, and where the opening curly brace of the hash is on the
+      # same line as the opening parenthesis of the method call, shall have
+      # their first key indented one step (two spaces) more than the position
+      # inside the opening parenthesis.
+      #
+      # Other hash literals shall have their first key indented one step more
+      # than the start of the line where the opening curly brace is.
+      #
+      # This default style is called 'special_inside_parentheses'. Alternative
+      # styles are 'consistent' and 'align_braces'. Here are examples:
+      #
+      # @example EnforcedStyle: special_inside_parentheses (default)
+      #   # The `special_inside_parentheses` style enforces that the first key
+      #   # in a hash literal where the opening brace and the first key are on
+      #   # separate lines is indented one step (two spaces) more than the
+      #   # position inside the opening parentheses.
+      #
+      #   # bad
+      #   hash = {
+      #     key: :value
+      #   }
+      #   and_in_a_method_call({
+      #     no: :difference
+      #                        })
+      #   takes_multi_pairs_hash(x: {
+      #     a: 1,
+      #     b: 2
+      #   },
+      #                          y: {
+      #                            c: 1,
+      #                            d: 2
+      #                          })
+      #
+      #   # good
+      #   special_inside_parentheses
+      #   hash = {
+      #     key: :value
+      #   }
+      #   but_in_a_method_call({
+      #                          its_like: :this
+      #                        })
+      #   takes_multi_pairs_hash(x: {
+      #                            a: 1,
+      #                            b: 2
+      #                          },
+      #                          y: {
+      #                            c: 1,
+      #                            d: 2
+      #                          })
+      #
+      # @example EnforcedStyle: consistent
+      #   # The `consistent` style enforces that the first key in a hash
+      #   # literal where the opening brace and the first key are on
+      #   # separate lines is indented the same as a hash literal which is not
+      #   # defined inside a method call.
+      #
+      #   # bad
+      #   hash = {
+      #     key: :value
+      #   }
+      #   but_in_a_method_call({
+      #                          its_like: :this
+      #                         })
+      #
+      #   # good
+      #   hash = {
+      #     key: :value
+      #   }
+      #   and_in_a_method_call({
+      #     no: :difference
+      #   })
+      #
+      #
+      # @example EnforcedStyle: align_braces
+      #   # The `align_brackets` style enforces that the opening and closing
+      #   # braces are indented to the same position.
+      #
+      #   # bad
+      #   and_now_for_something = {
+      #                             completely: :different
+      #   }
+      #   takes_multi_pairs_hash(x: {
+      #     a: 1,
+      #     b: 2
+      #   },
+      #                           y: {
+      #                                c: 1,
+      #                                d: 2
+      #                              })
+      #
+      #   # good
+      #   and_now_for_something = {
+      #                             completely: :different
+      #                           }
+      #   takes_multi_pairs_hash(x: {
+      #                               a: 1,
+      #                               b: 2
+      #                             },
+      #                          y: {
+      #                               c: 1,
+      #                               d: 2
+      #                             })
+      class FirstHashElementIndentation < Base
+        include Alignment
+        include ConfigurableEnforcedStyle
+        include MultilineElementIndentation
+        extend AutoCorrector
+
+        MSG = 'Use %<configured_indentation_width>d spaces for indentation ' \
+              'in a hash, relative to %<base_description>s.'
+
+        def on_hash(node)
+          check(node, nil) if node.loc.begin
+        end
+
+        def on_send(node)
+          return if enforce_first_argument_with_fixed_indentation?
+
+          each_argument_node(node, :hash) do |hash_node, left_parenthesis|
+            check(hash_node, left_parenthesis)
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def autocorrect(corrector, node)
+          AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
+        end
+
+        def brace_alignment_style
+          :align_braces
+        end
+
+        def check(hash_node, left_parenthesis)
+          return if ignored_node?(hash_node)
+
+          left_brace = hash_node.loc.begin
+          first_pair = hash_node.pairs.first
+
+          if first_pair
+            return if same_line?(first_pair, left_brace)
+
+            if separator_style?(first_pair)
+              check_based_on_longest_key(hash_node, left_brace, left_parenthesis)
+            else
+              check_first(first_pair, left_brace, left_parenthesis, 0)
+            end
+          end
+
+          check_right_brace(hash_node.loc.end, first_pair, left_brace, left_parenthesis)
+        end
+
+        def check_right_brace(right_brace, first_pair, left_brace, left_parenthesis)
+          # if the right brace is on the same line as the last value, accept
+          return if /\S/.match?(right_brace.source_line[0...right_brace.column])
+
+          expected_column, indent_base_type = indent_base(left_brace, first_pair, left_parenthesis)
+          @column_delta = expected_column - right_brace.column
+          return if @column_delta.zero?
+
+          message = message_for_right_brace(indent_base_type)
+          add_offense(right_brace, message: message) do |corrector|
+            autocorrect(corrector, right_brace)
+          end
+        end
+
+        def separator_style?(first_pair)
+          separator = first_pair.loc.operator
+          key = "Enforced#{separator.is?(':') ? 'Colon' : 'HashRocket'}Style"
+          config.for_cop('Layout/HashAlignment')[key] == 'separator'
+        end
+
+        def check_based_on_longest_key(hash_node, left_brace, left_parenthesis)
+          key_lengths = hash_node.keys.map { |key| key.source_range.length }
+          check_first(hash_node.pairs.first, left_brace, left_parenthesis,
+                      key_lengths.max - key_lengths.first)
+        end
+
+        # Returns the description of what the correct indentation is based on.
+        def base_description(indent_base_type)
+          case indent_base_type
+          when :left_brace_or_bracket
+            'the position of the opening brace'
+          when :first_column_after_left_parenthesis
+            'the first position after the preceding left parenthesis'
+          when :parent_hash_key
+            'the parent hash key'
+          else
+            'the start of the line where the left curly brace is'
+          end
+        end
+
+        def message(base_description)
+          format(
+            MSG,
+            configured_indentation_width: configured_indentation_width,
+            base_description: base_description
+          )
+        end
+
+        def message_for_right_brace(indent_base_type)
+          case indent_base_type
+          when :left_brace_or_bracket
+            'Indent the right brace the same as the left brace.'
+          when :first_column_after_left_parenthesis
+            'Indent the right brace the same as the first position ' \
+            'after the preceding left parenthesis.'
+          when :parent_hash_key
+            'Indent the right brace the same as the parent hash key.'
+          else
+            'Indent the right brace the same as the start of the line ' \
+            'where the left brace is.'
+          end
+        end
+
+        def enforce_first_argument_with_fixed_indentation?
+          argument_alignment_config = config.for_enabled_cop('Layout/ArgumentAlignment')
+          argument_alignment_config['EnforcedStyle'] == 'with_fixed_indentation'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks for a line break before the first element in a
+      # multi-line hash.
+      #
+      # @example
+      #
+      #     # bad
+      #     { a: 1,
+      #       b: 2}
+      #
+      #     # good
+      #     {
+      #       a: 1,
+      #       b: 2 }
+      #
+      #     # good
+      #     {
+      #       a: 1, b: {
+      #       c: 3
+      #     }}
+      #
+      # @example AllowMultilineFinalElement: false (default)
+      #
+      #     # bad
+      #     { a: 1, b: {
+      #       c: 3
+      #     }}
+      #
+      # @example AllowMultilineFinalElement: true
+      #
+      #     # bad
+      #     { a: 1,
+      #       b: {
+      #       c: 3
+      #     }}
+      #
+      #     # good
+      #     { a: 1, b: {
+      #       c: 3
+      #     }}
+      #
+      class FirstHashElementLineBreak < Base
+        include FirstElementLineBreak
+        extend AutoCorrector
+
+        MSG = 'Add a line break before the first element of a multi-line hash.'
+
+        def on_hash(node)
+          # node.loc.begin tells us whether the hash opens with a {
+          # If it doesn't, Layout/FirstMethodArgumentLineBreak will handle it
+          return unless node.loc.begin
+
+          check_children_line_break(node, node.children, ignore_last: ignore_last_element?)
+        end
+
+        private
+
+        def ignore_last_element?
+          !!cop_config['AllowMultilineFinalElement']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks for a line break before the first argument in a
+      # multi-line method call.
+      #
+      # @example
+      #
+      #   # bad
+      #   method(foo, bar,
+      #     baz)
+      #
+      #   # good
+      #   method(
+      #     foo, bar,
+      #     baz)
+      #
+      #     # ignored
+      #     method foo, bar,
+      #       baz
+      #
+      # @example AllowMultilineFinalElement: false (default)
+      #
+      #   # bad
+      #   method(foo, bar, {
+      #     baz: "a",
+      #     qux: "b",
+      #   })
+      #
+      #   # good
+      #   method(
+      #     foo, bar, {
+      #     baz: "a",
+      #     qux: "b",
+      #   })
+      #
+      # @example AllowMultilineFinalElement: true
+      #
+      #   # bad
+      #   method(foo,
+      #     bar,
+      #     {
+      #       baz: "a",
+      #       qux: "b",
+      #     }
+      #   )
+      #
+      #   # good
+      #   method(foo, bar, {
+      #     baz: "a",
+      #     qux: "b",
+      #   })
+      #
+      #   # good
+      #   method(
+      #     foo,
+      #     bar,
+      #     {
+      #       baz: "a",
+      #       qux: "b",
+      #     }
+      #   )
+      #
+      # @example AllowedMethods: ['some_method']
+      #
+      #   # good
+      #   some_method(foo, bar,
+      #     baz)
+      class FirstMethodArgumentLineBreak < Base
+        include FirstElementLineBreak
+        include AllowedMethods
+        extend AutoCorrector
+
+        MSG = 'Add a line break before the first argument of a multi-line method argument list.'
+
+        def on_send(node)
+          return if allowed_method?(node.method_name)
+
+          args = node.arguments.dup
+
+          # 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.
+          last_arg = args.last
+          args.concat(args.pop.children) if last_arg&.hash_type? && !last_arg&.braces?
+
+          check_method_line_break(node, args, ignore_last: ignore_last_element?)
+        end
+        alias on_csend on_send
+        alias on_super on_send
+
+        private
+
+        def ignore_last_element?
+          !!cop_config['AllowMultilineFinalElement']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks for a line break before the first parameter in a
+      # multi-line method parameter definition.
+      #
+      # @example
+      #
+      #   # bad
+      #   def method(foo, bar,
+      #       baz)
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   def method(
+      #       foo, bar,
+      #       baz)
+      #     do_something
+      #   end
+      #
+      #   # ignored
+      #   def method foo,
+      #       bar
+      #     do_something
+      #   end
+      #
+      # @example AllowMultilineFinalElement: false (default)
+      #
+      #   # bad
+      #   def method(foo, bar, baz = {
+      #     :a => "b",
+      #   })
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   def method(
+      #     foo, bar, baz = {
+      #     :a => "b",
+      #   })
+      #     do_something
+      #   end
+      #
+      # @example AllowMultilineFinalElement: true
+      #
+      #   # good
+      #   def method(foo, bar, baz = {
+      #     :a => "b",
+      #   })
+      #     do_something
+      #   end
+      #
+      class FirstMethodParameterLineBreak < Base
+        include FirstElementLineBreak
+        extend AutoCorrector
+
+        MSG = 'Add a line break before the first parameter of a multi-line method parameter list.'
+
+        def on_def(node)
+          check_method_line_break(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/first_parameter_indentation.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks the indentation of the first parameter in a method
+      # definition. Parameters after the first one are checked by
+      # `Layout/ParameterAlignment`, not by this cop.
+      #
+      # For indenting the first argument of method _calls_, check out
+      # `Layout/FirstArgumentIndentation`, which supports options related to
+      # nesting that are irrelevant for method _definitions_.
+      #
+      # @example
+      #
+      #   # bad
+      #   def some_method(
+      #   first_param,
+      #   second_param)
+      #     123
+      #   end
+      #
+      # @example EnforcedStyle: consistent (default)
+      #   # 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 FirstParameterIndentation < Base
+        include Alignment
+        include ConfigurableEnforcedStyle
+        include MultilineElementIndentation
+        extend AutoCorrector
+
+        MSG = 'Use %<configured_indentation_width>d spaces for indentation ' \
+              'in method args, relative to %<base_description>s.'
+
+        def on_def(node)
+          return if node.arguments.empty?
+          return if node.arguments.loc.begin.nil?
+
+          check(node)
+        end
+        alias on_defs on_def
+
+        private
+
+        def autocorrect(corrector, node)
+          AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
+        end
+
+        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.first_argument
+          return unless first_elem
+          return if same_line?(first_elem, left_parenthesis)
+
+          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