rubocop-grantbirki 1.75.2

data/lib/rubocop/cop/mixin/multiline_element_line_breaks.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking for a line break before each
+    # element in a multi-line collection.
+    module MultilineElementLineBreaks
+      private
+
+      def check_line_breaks(_node, children, ignore_last: false)
+        return if all_on_same_line?(children, ignore_last: ignore_last)
+
+        last_seen_line = -1
+        children.each do |child|
+          if last_seen_line >= child.first_line
+            add_offense(child) { |corrector| EmptyLineCorrector.insert_before(corrector, child) }
+          else
+            last_seen_line = child.last_line
+          end
+        end
+      end
+
+      def all_on_same_line?(nodes, ignore_last: false)
+        return true if nodes.empty?
+
+        return same_line?(nodes.first, nodes.last) if ignore_last
+
+        nodes.first.first_line == nodes.last.last_line
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/multiline_expression_indentation.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking multiline method calls and binary
+    # operations.
+    module MultilineExpressionIndentation # rubocop:disable Metrics/ModuleLength
+      KEYWORD_ANCESTOR_TYPES  = %i[for if while until return].freeze
+      UNALIGNED_RHS_TYPES     = %i[if while until for return array kwbegin].freeze
+      DEFAULT_MESSAGE_TAIL    = 'an expression'
+      ASSIGNMENT_MESSAGE_TAIL = 'an expression in an assignment'
+      KEYWORD_MESSAGE_TAIL    = 'a %<kind>s in %<article>s `%<keyword>s` statement'
+
+      def on_send(node)
+        return if !node.receiver || node.method?(:[])
+        return unless relevant_node?(node)
+
+        lhs = left_hand_side(node.receiver)
+        rhs = right_hand_side(node)
+        return unless rhs
+
+        range = offending_range(node, lhs, rhs, style)
+        check(range, node, lhs, rhs)
+      end
+      alias on_csend on_send
+
+      private
+
+      # In a chain of method calls, we regard the top call node as the base
+      # for indentation of all lines following the first. For example:
+      # a.
+      #   b c { block }.            <-- b is indented relative to a
+      #   d                         <-- d is indented relative to a
+      def left_hand_side(lhs)
+        while lhs.parent&.call_type? && lhs.parent.loc.dot && !lhs.parent.assignment_method?
+          lhs = lhs.parent
+        end
+        lhs
+      end
+
+      # The correct indentation of `node` is usually `IndentationWidth`, with
+      # one exception: prefix keywords.
+      #
+      # ```
+      # while foo &&  # Here, `while` is called a "prefix keyword"
+      #     bar       # This is called "special indentation"
+      #   baz
+      # end
+      # ```
+      #
+      # Note that *postfix conditionals* do *not* get "special indentation".
+      #
+      # ```
+      # next if foo &&
+      #   bar # normal indentation, not special
+      # ```
+      def correct_indentation(node)
+        kw_node = kw_node_with_special_indentation(node)
+        if kw_node && !postfix_conditional?(kw_node)
+          # This cop could have its own IndentationWidth configuration
+          configured_indentation_width + @config.for_cop('Layout/IndentationWidth')['Width']
+        else
+          configured_indentation_width
+        end
+      end
+
+      def check(range, node, lhs, rhs)
+        if range
+          incorrect_style_detected(range, node, lhs, rhs)
+        else
+          correct_style_detected
+        end
+      end
+
+      def incorrect_style_detected(range, node, lhs, rhs)
+        add_offense(range, message: message(node, lhs, rhs)) do |corrector|
+          autocorrect(corrector, range)
+
+          if supported_styles.size > 2 || offending_range(node, lhs, rhs, alternative_style)
+            unrecognized_style_detected
+          else
+            opposite_style_detected
+          end
+        end
+      end
+
+      def indentation(node)
+        node.source_range.source_line =~ /\S/
+      end
+
+      def operation_description(node, rhs)
+        kw_node_with_special_indentation(node) do |ancestor|
+          return keyword_message_tail(ancestor)
+        end
+
+        part_of_assignment_rhs(node, rhs) { |_node| return ASSIGNMENT_MESSAGE_TAIL }
+
+        DEFAULT_MESSAGE_TAIL
+      end
+
+      def keyword_message_tail(node)
+        keyword = node.loc.keyword.source
+        kind    = keyword == 'for' ? 'collection' : 'condition'
+        article = keyword.start_with?('i', 'u') ? 'an' : 'a'
+
+        format(KEYWORD_MESSAGE_TAIL, kind: kind, article: article, keyword: keyword)
+      end
+
+      def kw_node_with_special_indentation(node)
+        keyword_node =
+          node.each_ancestor(*KEYWORD_ANCESTOR_TYPES).find do |ancestor|
+            next if ancestor.if_type? && ancestor.ternary?
+
+            within_node?(node, indented_keyword_expression(ancestor))
+          end
+
+        if keyword_node && block_given?
+          yield keyword_node
+        else
+          keyword_node
+        end
+      end
+
+      def indented_keyword_expression(node)
+        if node.for_type?
+          node.collection
+        else
+          node.children.first
+        end
+      end
+
+      def argument_in_method_call(node, kind) # rubocop:todo Metrics/CyclomaticComplexity
+        node.each_ancestor(:send, :block).find do |a|
+          # If the node is inside a block, it makes no difference if that block
+          # is an argument in a method call. It doesn't count.
+          break false if a.block_type?
+
+          next if a.setter_method?
+          next unless kind == :with_or_without_parentheses ||
+                      (kind == :with_parentheses && parentheses?(a))
+
+          a.arguments.any? { |arg| within_node?(node, arg) }
+        end
+      end
+
+      def part_of_assignment_rhs(node, candidate)
+        rhs_node = node.each_ancestor.find do |ancestor|
+          break if disqualified_rhs?(candidate, ancestor)
+
+          valid_rhs?(candidate, ancestor)
+        end
+
+        if rhs_node && block_given?
+          yield rhs_node
+        else
+          rhs_node
+        end
+      end
+
+      def disqualified_rhs?(candidate, ancestor)
+        UNALIGNED_RHS_TYPES.include?(ancestor.type) ||
+          (ancestor.block_type? && part_of_block_body?(candidate, ancestor))
+      end
+
+      def valid_rhs?(candidate, ancestor)
+        if ancestor.send_type?
+          valid_method_rhs_candidate?(candidate, ancestor)
+        elsif ancestor.assignment?
+          valid_rhs_candidate?(candidate, assignment_rhs(ancestor))
+        else
+          false
+        end
+      end
+
+      # The []= operator and setters (a.b = c) are parsed as :send nodes.
+      def valid_method_rhs_candidate?(candidate, node)
+        node.setter_method? && valid_rhs_candidate?(candidate, node.last_argument)
+      end
+
+      def valid_rhs_candidate?(candidate, node)
+        !candidate || within_node?(candidate, node)
+      end
+
+      def part_of_block_body?(candidate, block_node)
+        block_node.body && within_node?(candidate, block_node.body)
+      end
+
+      def assignment_rhs(node)
+        case node.type
+        when :casgn, :op_asgn then node.rhs
+        when :send, :csend    then node.last_argument
+        else                       node.children.last
+        end
+      end
+
+      def not_for_this_cop?(node)
+        node.ancestors.any? do |ancestor|
+          grouped_expression?(ancestor) || inside_arg_list_parentheses?(node, ancestor)
+        end
+      end
+
+      def grouped_expression?(node)
+        node.begin_type? && node.loc.respond_to?(:begin) && node.loc.begin
+      end
+
+      def inside_arg_list_parentheses?(node, ancestor)
+        return false unless ancestor.send_type? && ancestor.parenthesized?
+
+        node.source_range.begin_pos > ancestor.loc.begin.begin_pos &&
+          node.source_range.end_pos < ancestor.loc.end.end_pos
+      end
+
+      # Returns true if `node` is a conditional whose `body` and `condition`
+      # begin on the same line.
+      def postfix_conditional?(node)
+        node.if_type? && node.modifier_form?
+      end
+
+      def within_node?(inner, outer)
+        o = outer.is_a?(AST::Node) ? outer.source_range : outer
+        i = inner.is_a?(AST::Node) ? inner.source_range : inner
+        i.begin_pos >= o.begin_pos && i.end_pos <= o.end_pos
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking the closing brace of a literal is
+    # either on the same line as the last contained elements or a new line.
+    module MultilineLiteralBraceLayout
+      include ConfigurableEnforcedStyle
+
+      private
+
+      def check_brace_layout(node)
+        return if ignored_literal?(node)
+
+        # If the last node is or contains a conflicting HEREDOC, we don't want
+        # to adjust the brace layout because this will result in invalid code.
+        return if last_line_heredoc?(node.children.last)
+
+        check(node)
+      end
+
+      # Returns true for the case
+      #   [a,
+      #    b # comment
+      #   ].some_method
+      def new_line_needed_before_closing_brace?(node)
+        last_element_line = last_element_range_with_trailing_comma(node).last_line
+
+        last_element_commented = processed_source.comment_at_line(last_element_line)
+
+        last_element_commented && (node.chained? || node.argument?)
+      end
+
+      def check(node)
+        case style
+        when :symmetrical then check_symmetrical(node)
+        when :new_line then check_new_line(node)
+        when :same_line then check_same_line(node)
+        end
+      end
+
+      def check_new_line(node)
+        return unless closing_brace_on_same_line?(node)
+
+        add_offense(node.loc.end, message: self.class::ALWAYS_NEW_LINE_MESSAGE) do |corrector|
+          MultilineLiteralBraceCorrector.correct(corrector, node, processed_source)
+        end
+      end
+
+      def check_same_line(node)
+        return if closing_brace_on_same_line?(node)
+
+        add_offense(node.loc.end, message: self.class::ALWAYS_SAME_LINE_MESSAGE) do |corrector|
+          MultilineLiteralBraceCorrector.correct(corrector, node, processed_source)
+        end
+      end
+
+      def check_symmetrical(node)
+        if opening_brace_on_same_line?(node)
+          return if closing_brace_on_same_line?(node)
+
+          add_offense(node.loc.end, message: self.class::SAME_LINE_MESSAGE) do |corrector|
+            MultilineLiteralBraceCorrector.correct(corrector, node, processed_source)
+          end
+        else
+          return unless closing_brace_on_same_line?(node)
+
+          add_offense(node.loc.end, message: self.class::NEW_LINE_MESSAGE) do |corrector|
+            MultilineLiteralBraceCorrector.correct(corrector, node, processed_source)
+          end
+        end
+      end
+
+      def empty_literal?(node)
+        children(node).empty?
+      end
+
+      def implicit_literal?(node)
+        !node.loc.begin
+      end
+
+      def ignored_literal?(node)
+        implicit_literal?(node) || empty_literal?(node) || node.single_line?
+      end
+
+      def children(node)
+        node.children
+      end
+
+      # This method depends on the fact that we have guarded
+      # against implicit and empty literals.
+      def opening_brace_on_same_line?(node)
+        same_line?(node.loc.begin, children(node).first)
+      end
+
+      # This method depends on the fact that we have guarded
+      # against implicit and empty literals.
+      def closing_brace_on_same_line?(node)
+        node.loc.end.line == children(node).last.last_line
+      end
+
+      # Starting with the parent node and recursively for the parent node's
+      # children, check if the node is a HEREDOC and if the HEREDOC ends below
+      # or on the last line of the parent node.
+      #
+      # Example:
+      #
+      #   # node is `b: ...` parameter
+      #   # last_line_heredoc?(node) => false
+      #   foo(a,
+      #     b: {
+      #       a: 1,
+      #       c: <<-EOM
+      #         baz
+      #       EOM
+      #     }
+      #   )
+      #
+      #   # node is `b: ...` parameter
+      #   # last_line_heredoc?(node) => true
+      #   foo(a,
+      #     b: <<-EOM
+      #       baz
+      #     EOM
+      #   )
+      def last_line_heredoc?(node, parent = nil)
+        parent ||= node
+
+        if node.respond_to?(:loc) &&
+           node.loc.respond_to?(:heredoc_end) &&
+           node.loc.heredoc_end.last_line >= parent.last_line
+          return true
+        end
+
+        return false unless node.respond_to?(:children)
+
+        node.children.any? { |child| last_line_heredoc?(child, parent) }
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/negative_conditional.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Some common code shared between `NegatedIf` and
+    # `NegatedWhile` cops.
+    module NegativeConditional
+      extend NodePattern::Macros
+
+      MSG = 'Favor `%<inverse>s` over `%<current>s` for negative conditions.'
+
+      private
+
+      # @!method single_negative?(node)
+      def_node_matcher :single_negative?, '(send !(send _ :!) :!)'
+
+      # @!method empty_condition?(node)
+      def_node_matcher :empty_condition?, '(begin)'
+
+      def check_negative_conditional(node, message:, &block)
+        condition = node.condition
+
+        return if empty_condition?(condition)
+
+        condition = condition.children.last while condition.begin_type?
+
+        return unless single_negative?(condition)
+        return if node.if_type? && node.else?
+
+        add_offense(node, message: message, &block)
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/nil_methods.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module provides a list of methods that are:
+    # 1. In the NilClass by default
+    # 2. Added to NilClass by explicitly requiring any standard libraries
+    # 3. Cop's configuration parameter AllowedMethods.
+    module NilMethods
+      include AllowedMethods
+
+      private
+
+      def nil_methods
+        nil.methods + other_stdlib_methods + allowed_methods.map(&:to_sym)
+      end
+
+      def other_stdlib_methods
+        [:to_d]
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/on_normal_if_unless.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for cops checking if and unless expressions.
+    module OnNormalIfUnless
+      def on_if(node)
+        return if node.modifier_form? || node.ternary?
+
+        on_normal_if_unless(node)
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/ordered_gem_node.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for Bundler/OrderedGems and
+    # Gemspec/OrderedDependencies.
+    module OrderedGemNode
+      private
+
+      def get_source_range(node, comments_as_separators)
+        unless comments_as_separators
+          first_comment = processed_source.ast_with_comments[node].first
+          return first_comment.source_range unless first_comment.nil?
+        end
+        node.source_range
+      end
+
+      def gem_canonical_name(name)
+        name = name.tr('-_', '') unless cop_config['ConsiderPunctuation']
+        name.downcase
+      end
+
+      def case_insensitive_out_of_order?(string_a, string_b)
+        gem_canonical_name(string_a) < gem_canonical_name(string_b)
+      end
+
+      def consecutive_lines(previous, current)
+        first_line = get_source_range(current, treat_comments_as_separators).first_line
+        previous.source_range.last_line == first_line - 1
+      end
+
+      def register_offense(previous, current)
+        message = format(
+          self.class::MSG,
+          previous: gem_name(current),
+          current: gem_name(previous)
+        )
+
+        add_offense(current, message: message) do |corrector|
+          OrderedGemCorrector.correct(
+            processed_source,
+            current,
+            previous_declaration(current),
+            treat_comments_as_separators
+          ).call(corrector)
+        end
+      end
+
+      def gem_name(declaration_node)
+        gem_node = declaration_node.first_argument
+
+        find_gem_name(gem_node)
+      end
+
+      def find_gem_name(gem_node)
+        return gem_node.str_content if gem_node.str_type?
+
+        find_gem_name(gem_node.receiver)
+      end
+
+      def treat_comments_as_separators
+        cop_config['TreatCommentsAsGroupSeparators']
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/parentheses.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for handling parentheses.
+    module Parentheses
+      private
+
+      def parens_required?(node)
+        range  = node.source_range
+        source = range.source_buffer.source
+        /[a-z]/.match?(source[range.begin_pos - 1]) || /[a-z]/.match?(source[range.end_pos])
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/percent_array.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for handling percent arrays.
+    module PercentArray
+      private
+
+      # Ruby does not allow percent arrays in an ambiguous block context.
+      #
+      # @example
+      #
+      #   foo %i[bar baz] { qux }
+      def invalid_percent_array_context?(node)
+        parent = node.parent
+
+        parent&.send_type? && parent.arguments.include?(node) &&
+          !parent.parenthesized? && parent.block_literal?
+      end
+
+      # Override to determine values that are invalid in a percent array
+      def invalid_percent_array_contents?(_node)
+        false
+      end
+
+      def allowed_bracket_array?(node)
+        comments_in_array?(node) || below_array_length?(node) ||
+          invalid_percent_array_context?(node)
+      end
+
+      def comments_in_array?(node)
+        line_span = node.source_range.first_line...node.source_range.last_line
+        processed_source.each_comment_in_lines(line_span).any?
+      end
+
+      def check_percent_array(node)
+        array_style_detected(:percent, node.values.size)
+
+        brackets_required = invalid_percent_array_contents?(node)
+        return unless style == :brackets || brackets_required
+
+        # If in percent style but brackets are required due to
+        # string content, the file should be excluded in auto-gen-config
+        no_acceptable_style! if brackets_required
+
+        bracketed_array = build_bracketed_array(node)
+        message = build_message_for_bracketed_array(bracketed_array)
+
+        add_offense(node, message: message) do |corrector|
+          corrector.replace(node, bracketed_array)
+        end
+      end
+
+      # @param [String] preferred_array_code
+      # @return [String]
+      def build_message_for_bracketed_array(preferred_array_code)
+        format(
+          self.class::ARRAY_MSG,
+          prefer: if preferred_array_code.include?("\n")
+                    'an array literal `[...]`'
+                  else
+                    "`#{preferred_array_code}`"
+                  end
+        )
+      end
+
+      def check_bracketed_array(node, literal_prefix)
+        return if allowed_bracket_array?(node)
+
+        array_style_detected(:brackets, node.values.size)
+
+        return unless style == :percent
+
+        add_offense(node, message: self.class::PERCENT_MSG) do |corrector|
+          percent_literal_corrector = PercentLiteralCorrector.new(@config, @preferred_delimiters)
+          percent_literal_corrector.correct(corrector, node, literal_prefix)
+        end
+      end
+
+      # @param [RuboCop::AST::ArrayNode] node
+      # @param [Array<String>] elements
+      # @return [String]
+      def build_bracketed_array_with_appropriate_whitespace(elements:, node:)
+        [
+          '[',
+          whitespace_leading(node),
+          elements.join(",#{whitespace_between(node)}"),
+          whitespace_trailing(node),
+          ']'
+        ].join
+      end
+
+      # Provides whitespace between elements for building a bracketed array.
+      #   %w[  a   b   c    ]
+      #         ^^^
+      # @param [RuboCop::AST::ArrayNode] node
+      # @return [String]
+      def whitespace_between(node)
+        if node.children.length >= 2
+          node.children[0].source_range.end.join(node.children[1].source_range.begin).source
+        else
+          ' '
+        end
+      end
+
+      # Provides leading whitespace for building a bracketed array.
+      #   %w[  a   b   c    ]
+      #      ^^
+      # @param [RuboCop::AST::ArrayNode] node
+      # @return [String]
+      def whitespace_leading(node)
+        node.loc.begin.end.join(node.children[0].source_range.begin).source
+      end
+
+      # Provides trailing whitespace for building a bracketed array.
+      #   %w[  a   b   c    ]
+      #                 ^^^^
+      # @param [RuboCop::AST::ArrayNode] node
+      # @return [String]
+      def whitespace_trailing(node)
+        node.children[-1].source_range.end.join(node.loc.end.begin).source
+      end
+    end
+  end
+end