rubocop-grantbirki 1.75.2

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

@@ -0,0 +1,398 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Check that the keys, separators, and values of a multi-line hash
+      # literal are aligned according to configuration. The configuration
+      # options are:
+      #
+      # * key (left align keys, one space before hash rockets and values)
+      # * separator (align hash rockets and colons, right align keys)
+      # * table (left align keys, hash rockets, and values)
+      #
+      # The treatment of hashes passed as the last argument to a method call
+      # can also be configured. The options are:
+      #
+      # * always_inspect
+      # * always_ignore
+      # * ignore_implicit (without curly braces)
+      #
+      # Alternatively you can specify multiple allowed styles. That's done by
+      # passing a list of styles to EnforcedHashRocketStyle and EnforcedColonStyle.
+      #
+      # @example EnforcedHashRocketStyle: key (default)
+      #   # bad
+      #   {
+      #     :foo => bar,
+      #      :ba => baz
+      #   }
+      #   {
+      #     :foo => bar,
+      #     :ba  => baz
+      #   }
+      #
+      #   # good
+      #   {
+      #     :foo => bar,
+      #     :ba => baz
+      #   }
+      #
+      # @example EnforcedHashRocketStyle: separator
+      #   # bad
+      #   {
+      #     :foo => bar,
+      #     :ba => baz
+      #   }
+      #   {
+      #     :foo => bar,
+      #     :ba  => baz
+      #   }
+      #
+      #   # good
+      #   {
+      #     :foo => bar,
+      #      :ba => baz
+      #   }
+      #
+      # @example EnforcedHashRocketStyle: table
+      #   # bad
+      #   {
+      #     :foo => bar,
+      #      :ba => baz
+      #   }
+      #
+      #   # good
+      #   {
+      #     :foo => bar,
+      #     :ba  => baz
+      #   }
+      #
+      # @example EnforcedColonStyle: key (default)
+      #   # bad
+      #   {
+      #     foo: bar,
+      #      ba: baz
+      #   }
+      #   {
+      #     foo: bar,
+      #     ba:  baz
+      #   }
+      #
+      #   # good
+      #   {
+      #     foo: bar,
+      #     ba: baz
+      #   }
+      #
+      # @example EnforcedColonStyle: separator
+      #   # bad
+      #   {
+      #     foo: bar,
+      #     ba: baz
+      #   }
+      #
+      #   # good
+      #   {
+      #     foo: bar,
+      #      ba: baz
+      #   }
+      #
+      # @example EnforcedColonStyle: table
+      #   # bad
+      #   {
+      #     foo: bar,
+      #     ba: baz
+      #   }
+      #
+      #   # good
+      #   {
+      #     foo: bar,
+      #     ba:  baz
+      #   }
+      #
+      # @example EnforcedLastArgumentHashStyle: always_inspect (default)
+      #   # Inspect both implicit and explicit hashes.
+      #
+      #   # bad
+      #   do_something(foo: 1,
+      #     bar: 2)
+      #
+      #   # bad
+      #   do_something({foo: 1,
+      #     bar: 2})
+      #
+      #   # good
+      #   do_something(foo: 1,
+      #                bar: 2)
+      #
+      #   # good
+      #   do_something(
+      #     foo: 1,
+      #     bar: 2
+      #   )
+      #
+      #   # good
+      #   do_something({foo: 1,
+      #                 bar: 2})
+      #
+      #   # good
+      #   do_something({
+      #     foo: 1,
+      #     bar: 2
+      #   })
+      #
+      # @example EnforcedLastArgumentHashStyle: always_ignore
+      #   # Ignore both implicit and explicit hashes.
+      #
+      #   # good
+      #   do_something(foo: 1,
+      #     bar: 2)
+      #
+      #   # good
+      #   do_something({foo: 1,
+      #     bar: 2})
+      #
+      # @example EnforcedLastArgumentHashStyle: ignore_implicit
+      #   # Ignore only implicit hashes.
+      #
+      #   # bad
+      #   do_something({foo: 1,
+      #     bar: 2})
+      #
+      #   # good
+      #   do_something(foo: 1,
+      #     bar: 2)
+      #
+      # @example EnforcedLastArgumentHashStyle: ignore_explicit
+      #   # Ignore only explicit hashes.
+      #
+      #   # bad
+      #   do_something(foo: 1,
+      #     bar: 2)
+      #
+      #   # good
+      #   do_something({foo: 1,
+      #     bar: 2})
+      #
+      class HashAlignment < Base
+        include HashAlignmentStyles
+        include RangeHelp
+        extend AutoCorrector
+
+        MESSAGES = {
+          KeyAlignment => 'Align the keys of a hash literal if they span more than one line.',
+          SeparatorAlignment => 'Align the separators of a hash literal if they span more than ' \
+                                'one line.',
+          TableAlignment => 'Align the keys and values of a hash literal if they span more than ' \
+                            'one line.',
+          KeywordSplatAlignment => 'Align keyword splats with the rest of the hash if it spans ' \
+                                   'more than one line.'
+        }.freeze
+
+        SEPARATOR_ALIGNMENT_STYLES = %w[EnforcedColonStyle EnforcedHashRocketStyle].freeze
+
+        def on_send(node)
+          return if double_splat?(node)
+          return unless node.arguments?
+
+          last_argument = node.last_argument
+
+          return unless last_argument.hash_type? && ignore_hash_argument?(last_argument)
+
+          ignore_node(last_argument)
+        end
+        alias on_csend on_send
+        alias on_super on_send
+        alias on_yield on_send
+
+        def on_hash(node)
+          return if autocorrect_incompatible_with_other_cops?(node) || ignored_node?(node) ||
+                    node.pairs.empty? || node.single_line?
+
+          proc = ->(a) { a.checkable_layout?(node) }
+          return unless alignment_for_hash_rockets.any?(proc) && alignment_for_colons.any?(proc)
+
+          check_pairs(node)
+        end
+
+        attr_accessor :offenses_by, :column_deltas
+
+        private
+
+        def autocorrect_incompatible_with_other_cops?(node)
+          return false unless enforce_first_argument_with_fixed_indentation? &&
+                              node.pairs.any? &&
+                              node.parent&.call_type?
+
+          left_sibling = argument_before_hash(node)
+          parent_loc = node.parent.loc
+          selector = left_sibling || parent_loc.selector || parent_loc.expression
+
+          same_line?(selector, node.pairs.first)
+        end
+
+        def argument_before_hash(hash_node)
+          hash_node.left_sibling.respond_to?(:loc) ? hash_node.left_sibling : nil
+        end
+
+        def reset!
+          self.offenses_by = {}
+          self.column_deltas = Hash.new { |hash, key| hash[key] = {} }
+        end
+
+        def double_splat?(node)
+          node.children.last.is_a?(Symbol)
+        end
+
+        def check_pairs(node)
+          first_pair = node.pairs.first
+          reset!
+
+          alignment_for(first_pair).each do |alignment|
+            delta = alignment.deltas_for_first_pair(first_pair, node)
+            check_delta delta, node: first_pair, alignment: alignment
+          end
+
+          node.children.each do |current|
+            alignment_for(current).each do |alignment|
+              delta = alignment.deltas(first_pair, current)
+              check_delta delta, node: current, alignment: alignment
+            end
+          end
+
+          add_offenses
+        end
+
+        def add_offenses
+          kwsplat_offenses = offenses_by.delete(KeywordSplatAlignment)
+          register_offenses_with_format(kwsplat_offenses, KeywordSplatAlignment)
+
+          format, offenses = offenses_by.min_by { |_, v| v.length }
+          register_offenses_with_format(offenses, format)
+        end
+
+        def register_offenses_with_format(offenses, format)
+          (offenses || []).each do |offense|
+            add_offense(offense, message: MESSAGES[format]) do |corrector|
+              delta = column_deltas[alignment_for(offense).first.class][offense]
+
+              correct_node(corrector, offense, delta) unless delta.nil?
+            end
+          end
+        end
+
+        def check_delta(delta, node:, alignment:)
+          offenses_by[alignment.class] ||= []
+          return if good_alignment? delta
+
+          column_deltas[alignment.class][node] = delta
+          offenses_by[alignment.class].push(node)
+        end
+
+        def ignore_hash_argument?(node)
+          case cop_config['EnforcedLastArgumentHashStyle']
+          when 'always_inspect'  then false
+          when 'always_ignore'   then true
+          when 'ignore_explicit' then node.braces?
+          when 'ignore_implicit' then !node.braces?
+          end
+        end
+
+        def alignment_for(pair)
+          if pair.kwsplat_type?
+            [KeywordSplatAlignment.new]
+          elsif pair.hash_rocket?
+            alignment_for_hash_rockets
+          else
+            alignment_for_colons
+          end
+        end
+
+        def alignment_for_hash_rockets
+          @alignment_for_hash_rockets ||= new_alignment('EnforcedHashRocketStyle')
+        end
+
+        def alignment_for_colons
+          @alignment_for_colons ||= new_alignment('EnforcedColonStyle')
+        end
+
+        def correct_node(corrector, node, delta)
+          # We can't use the instance variable inside the lambda. That would
+          # just give each lambda the same reference and they would all get the
+          # last value of each. A local variable fixes the problem.
+
+          if node.value && node.respond_to?(:value_omission?) && !node.value_omission?
+            correct_key_value(corrector, delta, node.key.source_range,
+                              node.value.source_range,
+                              node.loc.operator)
+          else
+            delta_value = delta[:key] || 0
+            correct_no_value(corrector, delta_value, node.source_range)
+          end
+        end
+
+        def correct_no_value(corrector, key_delta, key)
+          adjust(corrector, key_delta, key)
+        end
+
+        def correct_key_value(corrector, delta, key, value, separator)
+          # We can't use the instance variable inside the lambda. That would
+          # just give each lambda the same reference and they would all get the
+          # last value of each. Some local variables fix the problem.
+          separator_delta = delta[:separator] || 0
+          value_delta     = delta[:value]     || 0
+          key_delta       = delta[:key]       || 0
+
+          key_column = key.column
+          key_delta = -key_column if key_delta < -key_column
+
+          adjust(corrector, key_delta, key)
+          adjust(corrector, separator_delta, separator)
+          adjust(corrector, value_delta, value)
+        end
+
+        def new_alignment(key)
+          formats = cop_config[key]
+          formats = [formats] if formats.is_a? String
+
+          formats.uniq.map do |format|
+            case format
+            when 'key'
+              KeyAlignment.new
+            when 'table'
+              TableAlignment.new
+            when 'separator'
+              SeparatorAlignment.new
+            else
+              raise "Unknown #{key}: #{formats}"
+            end
+          end
+        end
+
+        def adjust(corrector, delta, range)
+          if delta.positive?
+            corrector.insert_before(range, ' ' * delta)
+          elsif delta.negative?
+            range = range_between(range.begin_pos - delta.abs, range.begin_pos)
+            corrector.remove(range)
+          end
+        end
+
+        def good_alignment?(column_deltas)
+          column_deltas.values.all?(&:zero?)
+        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 same_line?(node1, node2)
+          # Override `Util#same_line?`
+          super || node1.last_line == line(node2)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,312 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # 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 < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Put the closing parenthesis for a method call with a ' \
+              'HEREDOC parameter on the same line as the HEREDOC opening.'
+
+        def self.autocorrect_incompatible_with
+          [Style::TrailingCommaInArguments]
+        end
+
+        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 if end_keyword_before_closing_parenthesis?(node)
+          return if subsequent_closing_parentheses_in_same_line?(outermost_send)
+          return if exist_argument_between_heredoc_end_and_closing_parentheses?(node)
+
+          add_offense(outermost_send.loc.end) do |corrector|
+            autocorrect(corrector, outermost_send)
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        # 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(corrector, node)
+          fix_closing_parenthesis(node, corrector)
+
+          remove_internal_trailing_comma(node, corrector) if internal_trailing_comma?(node)
+
+          fix_external_trailing_comma(node, corrector) if external_trailing_comma?(node)
+        end
+
+        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)
+          parent&.call_type? &&
+            parent.arguments.include?(child) &&
+            parent.loc.begin &&
+            parent.loc.end.line != heredoc.last_line
+        end
+
+        def extract_heredoc_argument(node)
+          node.arguments.find { |arg_node| extract_heredoc(arg_node) }
+        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.respond_to?(:heredoc?) && 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 end_keyword_before_closing_parenthesis?(parenthesized_send_node)
+          parenthesized_send_node.ancestors.any? do |ancestor|
+            ancestor.loc_is?(:end, 'end')
+          end
+        end
+
+        def subsequent_closing_parentheses_in_same_line?(outermost_send)
+          last_arg_of_outer_send = outermost_send.last_argument
+          return false unless last_arg_of_outer_send&.loc.respond_to?(:end) &&
+                              (end_of_last_arg_of_outer_send = last_arg_of_outer_send.loc.end)
+
+          end_of_outer_send = outermost_send.loc.end
+
+          same_line?(end_of_outer_send, end_of_last_arg_of_outer_send) &&
+            end_of_outer_send.column == end_of_last_arg_of_outer_send.column + 1
+        end
+
+        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.last_argument, ')')
+        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
+
+        def exist_argument_between_heredoc_end_and_closing_parentheses?(node)
+          return true unless node.loc.end
+          return false unless (heredoc_end = find_most_bottom_of_heredoc_end(node.arguments))
+
+          heredoc_end < node.loc.end.begin_pos &&
+            range_between(heredoc_end, node.loc.end.begin_pos).source.strip != ''
+        end
+
+        def find_most_bottom_of_heredoc_end(arguments)
+          arguments.filter_map do |argument|
+            argument.loc.heredoc_end.end_pos if argument.loc.respond_to?(:heredoc_end)
+          end.max
+        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.last_argument, ',')
+        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