rubocop-grantbirki 1.75.2

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

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks for extra/unnecessary whitespace.
+      #
+      # @example
+      #
+      #   # good if AllowForAlignment is true
+      #   name      = "RuboCop"
+      #   # Some comment and an empty line
+      #
+      #   website  += "/rubocop/rubocop" unless cond
+      #   puts        "rubocop"          if     debug
+      #
+      #   # bad for any configuration
+      #   set_app("RuboCop")
+      #   website  = "https://github.com/rubocop/rubocop"
+      #
+      #   # good only if AllowBeforeTrailingComments is true
+      #   object.method(arg)  # this is a comment
+      #
+      #   # good even if AllowBeforeTrailingComments is false or not set
+      #   object.method(arg) # this is a comment
+      #
+      #   # good with either AllowBeforeTrailingComments or AllowForAlignment
+      #   object.method(arg)         # this is a comment
+      #   another_object.method(arg) # this is another comment
+      #   some_object.method(arg)    # this is some comment
+      class ExtraSpacing < Base
+        extend AutoCorrector
+        include PrecedingFollowingAlignment
+        include RangeHelp
+
+        MSG_UNNECESSARY = 'Unnecessary spacing detected.'
+        MSG_UNALIGNED_ASGN = '`=` is not aligned with the %<location>s assignment.'
+
+        def on_new_investigation
+          return if processed_source.blank?
+
+          @aligned_comments = aligned_locations(processed_source.comments.map(&:loc))
+          @corrected = Set.new if force_equal_sign_alignment?
+
+          processed_source.tokens.each_cons(2) do |token1, token2|
+            check_tokens(processed_source.ast, token1, token2)
+          end
+        end
+
+        private
+
+        def aligned_locations(locs)
+          return [] if locs.empty?
+
+          aligned = Set.new
+          locs.each_cons(2) do |loc1, loc2|
+            aligned << loc1.line << loc2.line if loc1.column == loc2.column
+          end
+          aligned
+        end
+
+        def check_tokens(ast, token1, token2)
+          return if token2.type == :tNL
+
+          if force_equal_sign_alignment? && assignment_tokens.include?(token2)
+            check_assignment(token2)
+          else
+            check_other(token1, token2, ast)
+          end
+        end
+
+        def check_assignment(token)
+          return unless aligned_with_preceding_equals_operator(token) == :no
+
+          message = format(MSG_UNALIGNED_ASGN, location: 'preceding')
+          add_offense(token.pos, message: message) do |corrector|
+            align_equal_signs(token.pos, corrector)
+          end
+        end
+
+        def check_other(token1, token2, ast)
+          return false if allow_for_trailing_comments? && token2.text.start_with?('#')
+
+          extra_space_range(token1, token2) do |range|
+            next if ignored_range?(ast, range.begin_pos)
+
+            add_offense(range, message: MSG_UNNECESSARY) { |corrector| corrector.remove(range) }
+          end
+        end
+
+        def extra_space_range(token1, token2)
+          return if token1.line != token2.line
+
+          start_pos = token1.end_pos
+          end_pos = token2.begin_pos - 1
+          return if end_pos <= start_pos
+
+          return if allow_for_alignment? && aligned_tok?(token2)
+
+          yield range_between(start_pos, end_pos)
+        end
+
+        def aligned_tok?(token)
+          if token.comment?
+            @aligned_comments.include?(token.line)
+          else
+            aligned_with_something?(token.pos)
+          end
+        end
+
+        def ignored_range?(ast, start_pos)
+          ignored_ranges(ast).any? { |r| r.include?(start_pos) }
+        end
+
+        # Returns an array of ranges that should not be reported. It's the
+        # extra spaces between the keys and values in a multiline hash,
+        # since those are handled by the Layout/HashAlignment cop.
+        def ignored_ranges(ast)
+          return [] unless ast
+
+          @ignored_ranges ||= begin
+            ranges = []
+            on_node(:pair, ast) do |pair|
+              next if pair.parent.single_line?
+
+              key, value = *pair
+              ranges << (key.source_range.end_pos...value.source_range.begin_pos)
+            end
+            ranges
+          end
+        end
+
+        def force_equal_sign_alignment?
+          cop_config['ForceEqualSignAlignment']
+        end
+
+        def align_equal_signs(range, corrector)
+          lines  = all_relevant_assignment_lines(range.line)
+          tokens = assignment_tokens.select { |t| lines.include?(t.line) }
+
+          columns  = tokens.map { |t| align_column(t) }
+          align_to = columns.max
+
+          tokens.each { |token| align_equal_sign(corrector, token, align_to) }
+        end
+
+        def align_equal_sign(corrector, token, align_to)
+          return unless @corrected.add?(token)
+
+          diff = align_to - token.pos.last_column
+
+          if diff.positive?
+            corrector.insert_before(token.pos, ' ' * diff)
+          elsif diff.negative?
+            corrector.remove_preceding(token.pos, -diff)
+          end
+        end
+
+        def all_relevant_assignment_lines(line_number)
+          last_line_number = processed_source.lines.size
+
+          (
+            relevant_assignment_lines(line_number.downto(1)) +
+            relevant_assignment_lines(line_number.upto(last_line_number))
+          )
+            .uniq
+            .sort
+        end
+
+        def align_column(asgn_token)
+          # if we removed unneeded spaces from the beginning of this =,
+          # what column would it end from?
+          line    = processed_source.lines[asgn_token.line - 1]
+          leading = line[0...asgn_token.column]
+          spaces  = leading.size - (leading =~ / *\Z/)
+          asgn_token.pos.last_column - spaces + 1
+        end
+
+        def allow_for_trailing_comments?
+          cop_config['AllowBeforeTrailingComments']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks the indentation of the first argument in a method call.
+      # Arguments after the first one are checked by `Layout/ArgumentAlignment`,
+      # not by this cop.
+      #
+      # For indenting the first parameter of method _definitions_, check out
+      # `Layout/FirstParameterIndentation`.
+      #
+      # This cop will respect `Layout/ArgumentAlignment` and will not work when
+      # `EnforcedStyle: with_fixed_indentation` is specified for `Layout/ArgumentAlignment`.
+      #
+      # @example
+      #
+      #   # bad
+      #   some_method(
+      #   first_param,
+      #   second_param)
+      #
+      #   foo = some_method(
+      #   first_param,
+      #   second_param)
+      #
+      #   foo = some_method(nested_call(
+      #   nested_first_param),
+      #   second_param)
+      #
+      #   foo = some_method(
+      #   nested_call(
+      #   nested_first_param),
+      #   second_param)
+      #
+      #   some_method nested_call(
+      #   nested_first_param),
+      #   second_param
+      #
+      # @example EnforcedStyle: special_for_inner_method_call_in_parentheses (default)
+      #   # Same as `special_for_inner_method_call` except that the special rule
+      #   # only applies if the outer method call encloses its arguments in
+      #   # parentheses.
+      #
+      #   # good
+      #   some_method(
+      #     first_param,
+      #   second_param)
+      #
+      #   foo = some_method(
+      #     first_param,
+      #   second_param)
+      #
+      #   foo = some_method(nested_call(
+      #                       nested_first_param),
+      #   second_param)
+      #
+      #   foo = some_method(
+      #     nested_call(
+      #       nested_first_param),
+      #   second_param)
+      #
+      #   some_method nested_call(
+      #     nested_first_param),
+      #   second_param
+      #
+      # @example EnforcedStyle: consistent
+      #   # The first argument should always be indented one step more than the
+      #   # preceding line.
+      #
+      #   # good
+      #   some_method(
+      #     first_param,
+      #   second_param)
+      #
+      #   foo = some_method(
+      #     first_param,
+      #   second_param)
+      #
+      #   foo = some_method(nested_call(
+      #     nested_first_param),
+      #   second_param)
+      #
+      #   foo = some_method(
+      #     nested_call(
+      #       nested_first_param),
+      #   second_param)
+      #
+      #   some_method nested_call(
+      #     nested_first_param),
+      #   second_param
+      #
+      # @example EnforcedStyle: consistent_relative_to_receiver
+      #   # The first argument should always be indented one level relative to
+      #   # the parent that is receiving the argument
+      #
+      #   # good
+      #   some_method(
+      #     first_param,
+      #   second_param)
+      #
+      #   foo = some_method(
+      #           first_param,
+      #   second_param)
+      #
+      #   foo = some_method(nested_call(
+      #                       nested_first_param),
+      #   second_param)
+      #
+      #   foo = some_method(
+      #           nested_call(
+      #             nested_first_param),
+      #   second_param)
+      #
+      #   some_method nested_call(
+      #                 nested_first_param),
+      #   second_params
+      #
+      # @example EnforcedStyle: special_for_inner_method_call
+      #   # The first argument should normally be indented one step more than
+      #   # the preceding line, but if it's an argument for a method call that
+      #   # is itself an argument in a method call, then the inner argument
+      #   # should be indented relative to the inner method.
+      #
+      #   # good
+      #   some_method(
+      #     first_param,
+      #   second_param)
+      #
+      #   foo = some_method(
+      #     first_param,
+      #   second_param)
+      #
+      #   foo = some_method(nested_call(
+      #                       nested_first_param),
+      #   second_param)
+      #
+      #   foo = some_method(
+      #     nested_call(
+      #       nested_first_param),
+      #   second_param)
+      #
+      #   some_method nested_call(
+      #                 nested_first_param),
+      #   second_param
+      #
+      class FirstArgumentIndentation < Base
+        include Alignment
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Indent the first argument one step more than %<base>s.'
+
+        def on_send(node)
+          return unless should_check?(node)
+          return if same_line?(node, node.first_argument)
+          return if style != :consistent && enforce_first_argument_with_fixed_indentation? &&
+                    !enable_layout_first_method_argument_line_break?
+
+          indent = base_indentation(node) + configured_indentation_width
+
+          check_alignment([node.first_argument], indent)
+        end
+        alias on_csend on_send
+        alias on_super on_send
+
+        private
+
+        def should_check?(node)
+          node.arguments? && !bare_operator?(node) && !node.setter_method?
+        end
+
+        def autocorrect(corrector, node)
+          AlignmentCorrector.correct(corrector, processed_source, node, column_delta)
+        end
+
+        def bare_operator?(node)
+          node.operator_method? && !node.dot?
+        end
+
+        def message(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
+          base = if !text.include?("\n") && special_inner_call_indentation?(send_node)
+                   "`#{text}`"
+                 elsif comment_line?(text.lines.reverse_each.first)
+                   'the start of the previous line (not counting the comment)'
+                 else
+                   'the start of the previous line'
+                 end
+
+          format(MSG, base: base)
+        end
+
+        def base_indentation(node)
+          if special_inner_call_indentation?(node)
+            column_of(base_range(node, node.first_argument))
+          else
+            previous_code_line(node.first_argument.first_line) =~ /\S/
+          end
+        end
+
+        def special_inner_call_indentation?(node)
+          return false if style == :consistent
+          return true  if style == :consistent_relative_to_receiver
+
+          parent = node.parent
+
+          return false unless eligible_method_call?(parent)
+          return false if !parent.parenthesized? &&
+                          style == :special_for_inner_method_call_in_parentheses
+
+          # The node must begin inside the parent, otherwise node is the first
+          # part of a chained method call.
+          node.source_range.begin_pos > parent.source_range.begin_pos
+        end
+
+        # @!method eligible_method_call?(node)
+        def_node_matcher :eligible_method_call?, <<~PATTERN
+          (send _ !:[]= ...)
+        PATTERN
+
+        def base_range(send_node, arg_node)
+          parent = send_node.parent
+          start_node = if parent&.type?(:splat, :kwsplat)
+                         send_node.parent
+                       else
+                         send_node
+                       end
+          range_between(start_node.source_range.begin_pos, arg_node.source_range.begin_pos)
+        end
+
+        # Returns the column of the given range. For single line ranges, this
+        # is simple. For ranges with line breaks, we look a the last code line.
+        def column_of(range)
+          source = range.source.strip
+          if source.include?("\n")
+            previous_code_line(range.line + source.count("\n") + 1) =~ /\S/
+          else
+            display_column(range)
+          end
+        end
+
+        # Takes the line number of a given code line and returns a string
+        # containing the previous line that's not a comment line or a blank
+        # line.
+        def previous_code_line(line_number)
+          line = ''
+          while line.blank? || comment_lines.include?(line_number)
+            line_number -= 1
+            line = processed_source.lines[line_number - 1]
+          end
+          line
+        end
+
+        def comment_lines
+          @comment_lines ||=
+            processed_source
+            .comments
+            .select { |c| begins_its_line?(c.source_range) }
+            .map { |c| c.loc.line }
+        end
+
+        def on_new_investigation
+          @comment_lines = nil
+        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
+
+        def enable_layout_first_method_argument_line_break?
+          config.cop_enabled?('Layout/FirstMethodArgumentLineBreak')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks the indentation of the first element in an array literal
+      # where the opening bracket and the first element are on separate lines.
+      # The other elements' indentations are handled by `Layout/ArrayAlignment` cop.
+      #
+      # This cop will respect `Layout/ArrayAlignment` and will not work when
+      # `EnforcedStyle: with_fixed_indentation` is specified for `Layout/ArrayAlignment`.
+      #
+      # By default, array literals that are arguments in a method call with
+      # parentheses, and where the opening square bracket of the array is on the
+      # same line as the opening parenthesis of the method call, shall have
+      # their first element indented one step (two spaces) more than the
+      # position inside the opening parenthesis.
+      #
+      # Other array literals shall have their first element indented one step
+      # more than the start of the line where the opening square bracket is.
+      #
+      # This default style is called 'special_inside_parentheses'. Alternative
+      # styles are 'consistent' and 'align_brackets'. Here are examples:
+      #
+      # @example EnforcedStyle: special_inside_parentheses (default)
+      #   # The `special_inside_parentheses` style enforces that the first
+      #   # element in an array literal where the opening bracket and first
+      #   # element are on separate lines is indented one step (two spaces) more
+      #   # than the position inside the opening parenthesis.
+      #
+      #   # bad
+      #   array = [
+      #     :value
+      #   ]
+      #   and_in_a_method_call([
+      #     :no_difference
+      #                        ])
+      #
+      #   # good
+      #   array = [
+      #     :value
+      #   ]
+      #   but_in_a_method_call([
+      #                          :its_like_this
+      #                        ])
+      #
+      # @example EnforcedStyle: consistent
+      #   # The `consistent` style enforces that the first element in an array
+      #   # literal where the opening bracket and the first element are on
+      #   # separate lines is indented the same as an array literal which is not
+      #   # defined inside a method call.
+      #
+      #   # bad
+      #   array = [
+      #     :value
+      #   ]
+      #   but_in_a_method_call([
+      #                          :its_like_this
+      #   ])
+      #
+      #   # good
+      #   array = [
+      #     :value
+      #   ]
+      #   and_in_a_method_call([
+      #     :no_difference
+      #   ])
+      #
+      # @example EnforcedStyle: align_brackets
+      #   # The `align_brackets` style enforces that the opening and closing
+      #   # brackets are indented to the same position.
+      #
+      #   # bad
+      #   and_now_for_something = [
+      #                             :completely_different
+      #   ]
+      #
+      #   # good
+      #   and_now_for_something = [
+      #                             :completely_different
+      #                           ]
+      class FirstArrayElementIndentation < Base
+        include Alignment
+        include ConfigurableEnforcedStyle
+        include MultilineElementIndentation
+        extend AutoCorrector
+
+        MSG = 'Use %<configured_indentation_width>d spaces for indentation ' \
+              'in an array, relative to %<base_description>s.'
+
+        def on_array(node)
+          return if style != :consistent && enforce_first_argument_with_fixed_indentation?
+
+          check(node, nil) if node.loc.begin
+        end
+
+        def on_send(node)
+          return if style != :consistent && enforce_first_argument_with_fixed_indentation?
+
+          each_argument_node(node, :array) do |array_node, left_parenthesis|
+            check(array_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_brackets
+        end
+
+        def check(array_node, left_parenthesis)
+          return if ignored_node?(array_node)
+
+          left_bracket = array_node.loc.begin
+          first_elem = array_node.values.first
+          if first_elem
+            return if same_line?(first_elem, left_bracket)
+
+            check_first(first_elem, left_bracket, left_parenthesis, 0)
+          end
+
+          check_right_bracket(array_node.loc.end, first_elem, left_bracket, left_parenthesis)
+        end
+
+        def check_right_bracket(right_bracket, first_elem, left_bracket, left_parenthesis)
+          # if the right bracket is on the same line as the last value, accept
+          return if /\S/.match?(right_bracket.source_line[0...right_bracket.column])
+
+          expected_column, indent_base_type = indent_base(left_bracket, first_elem,
+                                                          left_parenthesis)
+          @column_delta = expected_column - right_bracket.column
+          return if @column_delta.zero?
+
+          msg = message_for_right_bracket(indent_base_type)
+          add_offense(right_bracket, message: msg) do |corrector|
+            autocorrect(corrector, right_bracket)
+          end
+        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 bracket'
+          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 square bracket is'
+          end
+        end
+
+        def message(base_description)
+          format(
+            MSG,
+            configured_indentation_width: configured_indentation_width,
+            base_description: base_description
+          )
+        end
+
+        def message_for_right_bracket(indent_base_type)
+          case indent_base_type
+          when :left_brace_or_bracket
+            'Indent the right bracket the same as the left bracket.'
+          when :first_column_after_left_parenthesis
+            'Indent the right bracket the same as the first position ' \
+            'after the preceding left parenthesis.'
+          when :parent_hash_key
+            'Indent the right bracket the same as the parent hash key.' \
+          else
+            'Indent the right bracket the same as the start of the line ' \
+            'where the left bracket is.'
+          end
+        end
+
+        def enforce_first_argument_with_fixed_indentation?
+          argument_alignment_config = config.for_enabled_cop('Layout/ArrayAlignment')
+          argument_alignment_config['EnforcedStyle'] == 'with_fixed_indentation'
+        end
+      end
+    end
+  end
+end