rubocop-grantbirki 1.75.2

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module checks for nodes that should be aligned to the left or right.
+    # This amount is determined by the instance variable @column_delta.
+    module Alignment
+      SPACE = ' '
+
+      private
+
+      attr_reader :column_delta
+
+      def configured_indentation_width
+        cop_config['IndentationWidth'] || config.for_cop('Layout/IndentationWidth')['Width'] || 2
+      end
+
+      def indentation(node)
+        offset(node) + (SPACE * configured_indentation_width)
+      end
+
+      def offset(node)
+        SPACE * node.loc.column
+      end
+
+      def check_alignment(items, base_column = nil)
+        base_column ||= display_column(items.first.source_range) unless items.empty?
+
+        each_bad_alignment(items, base_column) do |current|
+          expr = current.source_range
+          if @current_offenses&.any? { |o| within?(expr, o.location) }
+            # If this offense is within a line range that is already being
+            # realigned by autocorrect, we report the offense without
+            # autocorrecting it. Two rewrites in the same area by the same
+            # cop cannot be handled. The next iteration will find the
+            # offense again and correct it.
+            register_offense(expr, nil)
+          else
+            register_offense(current, current)
+          end
+        end
+      end
+
+      # @api private
+      def each_bad_alignment(items, base_column)
+        prev_line = -1
+        items.each do |current|
+          if current.loc.line > prev_line && begins_its_line?(current.source_range)
+            @column_delta = base_column - display_column(current.source_range)
+
+            yield current if @column_delta.nonzero?
+          end
+          prev_line = current.loc.line
+        end
+      end
+
+      # @api public
+      def display_column(range)
+        line = processed_source.lines[range.line - 1]
+        Unicode::DisplayWidth.of(line[0, range.column])
+      end
+
+      # @api public
+      def within?(inner, outer)
+        inner.begin_pos >= outer.begin_pos && inner.end_pos <= outer.end_pos
+      end
+
+      # @deprecated Use processed_source.line_with_comment?(line)
+      def end_of_line_comment(line)
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `end_of_line_comment` is deprecated. Use `processed_source.line_with_comment?` instead.
+        WARNING
+
+        processed_source.line_with_comment?(line)
+      end
+
+      # @api private
+      def register_offense(offense_node, message_node)
+        add_offense(offense_node, message: message(message_node)) do |corrector|
+          autocorrect(corrector, message_node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module encapsulates the ability to allow certain identifiers in a cop.
+    module AllowedIdentifiers
+      SIGILS = '@$' # if a variable starts with a sigil it will be removed
+
+      def allowed_identifier?(name)
+        !allowed_identifiers.empty? && allowed_identifiers.include?(name.to_s.delete(SIGILS))
+      end
+
+      def allowed_identifiers
+        cop_config.fetch('AllowedIdentifiers') { [] }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module encapsulates the ability to allow certain methods when
+    # parsing. Even if the code is in offense, if it contains methods
+    # that are allowed. This module is equivalent to the IgnoredMethods module,
+    # which will be deprecated in RuboCop 2.0.
+    module AllowedMethods
+      private
+
+      # @api public
+      def allowed_method?(name)
+        allowed_methods.include?(name.to_s)
+      end
+
+      # @deprecated Use allowed_method? instead
+      def ignored_method?
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `ignored_method?` is deprecated. Use `allowed_method?` instead.
+        WARNING
+
+        allowed_method?
+      end
+
+      # @api public
+      def allowed_methods
+        if cop_config_deprecated_values.any?(Regexp)
+          cop_config_allowed_methods
+        else
+          cop_config_allowed_methods + cop_config_deprecated_values
+        end
+      end
+
+      def cop_config_allowed_methods
+        @cop_config_allowed_methods ||= Array(cop_config.fetch('AllowedMethods', []))
+      end
+
+      def cop_config_deprecated_values
+        @cop_config_deprecated_values ||=
+          Array(cop_config.fetch('IgnoredMethods', [])) +
+          Array(cop_config.fetch('ExcludedMethods', []))
+      end
+    end
+    # @deprecated IgnoredMethods class has been replaced with AllowedMethods.
+    IgnoredMethods = AllowedMethods
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module encapsulates the ability to ignore certain lines when
+    # parsing.
+    module AllowedPattern
+      private
+
+      def allowed_line?(line)
+        line = if line.respond_to?(:source_line)
+                 line.source_line
+               elsif line.respond_to?(:node)
+                 line.node.source_range.source_line
+               end
+
+        matches_allowed_pattern?(line)
+      end
+
+      # @deprecated Use allowed_line? instead
+      def ignored_line?(line)
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `ignored_line?` is deprecated. Use `allowed_line?` instead.
+        WARNING
+
+        allowed_line?(line)
+      end
+
+      def matches_allowed_pattern?(line)
+        allowed_patterns.any? { |pattern| Regexp.new(pattern).match?(line) }
+      end
+
+      # @deprecated Use matches_allowed_pattern? instead
+      def matches_ignored_pattern?(line)
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `matches_ignored_pattern?` is deprecated. Use `matches_allowed_pattern?` instead.
+        WARNING
+
+        matches_allowed_pattern?(line)
+      end
+
+      def allowed_patterns
+        # Since there could be a pattern specified in the default config, merge the two
+        # arrays together.
+        if cop_config_deprecated_methods_values.any?(Regexp)
+          cop_config_patterns_values + cop_config_deprecated_methods_values
+        else
+          cop_config_patterns_values
+        end
+      end
+
+      def cop_config_patterns_values
+        @cop_config_patterns_values ||=
+          Array(cop_config.fetch('AllowedPatterns', [])) +
+          Array(cop_config.fetch('IgnoredPatterns', []))
+      end
+
+      def cop_config_deprecated_methods_values
+        @cop_config_deprecated_methods_values ||=
+          Array(cop_config.fetch('IgnoredMethods', [])) +
+          Array(cop_config.fetch('ExcludedMethods', []))
+      end
+    end
+
+    # @deprecated IgnoredPattern class has been replaced with AllowedPattern.
+    IgnoredPattern = AllowedPattern
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module encapsulates the ability to allow certain receivers in a cop.
+    module AllowedReceivers
+      def allowed_receiver?(receiver)
+        receiver_name = receiver_name(receiver)
+
+        allowed_receivers.include?(receiver_name)
+      end
+
+      def receiver_name(receiver)
+        if receiver.receiver && !receiver.receiver.const_type?
+          return receiver_name(receiver.receiver)
+        end
+
+        if receiver.send_type?
+          if receiver.receiver
+            "#{receiver_name(receiver.receiver)}.#{receiver.method_name}"
+          else
+            receiver.method_name.to_s
+          end
+        else
+          receiver.source
+        end
+      end
+
+      def allowed_receivers
+        cop_config.fetch('AllowedReceivers', [])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Representation of an annotation comment in source code (eg. `# TODO: blah blah blah`).
+    class AnnotationComment
+      attr_reader :comment, :margin, :keyword, :colon, :space, :note
+
+      # @param [Parser::Source::Comment] comment
+      # @param [Array<String>] keywords
+      def initialize(comment, keywords)
+        @comment = comment
+        @keywords = keywords
+        @margin, @keyword, @colon, @space, @note = split_comment(comment)
+      end
+
+      def annotation?
+        keyword_appearance? && !just_keyword_of_sentence?
+      end
+
+      def correct?(colon:)
+        return false unless keyword && space && note
+        return false unless keyword == keyword.upcase
+
+        self.colon.nil? == !colon
+      end
+
+      # Returns the range bounds for just the annotation
+      def bounds
+        start = comment.source_range.begin_pos + margin.length
+        length = [keyword, colon, space].reduce(0) { |len, elem| len + elem.to_s.length }
+        [start, start + length]
+      end
+
+      private
+
+      attr_reader :keywords
+
+      def split_comment(comment)
+        # Sort keywords by reverse length so that if a keyword is in a phrase
+        # but also on its own, both will match properly.
+        match = comment.text.match(regex)
+        return false unless match
+
+        match.captures
+      end
+
+      KEYWORDS_REGEX_CACHE = {} # rubocop:disable Style/MutableConstant
+      private_constant :KEYWORDS_REGEX_CACHE
+
+      def regex
+        KEYWORDS_REGEX_CACHE[keywords] ||= begin
+          keywords_regex = Regexp.new(
+            Regexp.union(keywords.sort_by { |w| -w.length }).source,
+            Regexp::IGNORECASE
+          )
+          /^(# ?)(\b#{keywords_regex}\b)(\s*:)?(\s+)?(\S+)?/i
+        end
+      end
+
+      def keyword_appearance?
+        keyword && (colon || space)
+      end
+
+      def just_keyword_of_sentence?
+        keyword == keyword.capitalize && !colon && space && note
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Handles the `MinSize` configuration option for array-based cops
+    # `Style/SymbolArray` and `Style/WordArray`, which check for use of the
+    # relevant percent literal syntax such as `%i[...]` and `%w[...]`
+    module ArrayMinSize
+      private
+
+      def below_array_length?(node)
+        node.values.length < min_size_config
+      end
+
+      def min_size_config
+        cop_config['MinSize']
+      end
+
+      def array_style_detected(style, ary_size) # rubocop:todo Metrics/AbcSize
+        cfg = config_to_allow_offenses
+        return if cfg['Enabled'] == false
+
+        largest_brackets = largest_brackets_size(style, ary_size)
+        smallest_percent = smallest_percent_size(style, ary_size)
+
+        if cfg['EnforcedStyle'] == style.to_s
+          # do nothing
+        elsif cfg['EnforcedStyle'].nil?
+          cfg['EnforcedStyle'] = style.to_s
+        elsif smallest_percent <= largest_brackets
+          self.config_to_allow_offenses = { 'Enabled' => false }
+        else
+          cfg['EnforcedStyle'] = 'percent'
+          cfg['MinSize'] = largest_brackets + 1
+        end
+      end
+
+      def largest_brackets_size(style, ary_size)
+        self.class.largest_brackets ||= -Float::INFINITY
+
+        if style == :brackets && ary_size > self.class.largest_brackets
+          self.class.largest_brackets = ary_size
+        end
+
+        self.class.largest_brackets
+      end
+
+      def smallest_percent_size(style, ary_size)
+        @smallest_percent ||= Float::INFINITY
+
+        @smallest_percent = ary_size if style == :percent && ary_size < @smallest_percent
+
+        @smallest_percent
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common code for ordinary arrays with [] that can be written with %
+    # syntax.
+    module ArraySyntax
+      private
+
+      def bracketed_array_of?(element_type, node)
+        return false unless node.square_brackets? && !node.values.empty?
+
+        node.values.all? { |value| value.type == element_type }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # extend this module to signal autocorrection support
+    module AutoCorrector
+      def support_autocorrect?
+        true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking assignment nodes.
+    module CheckAssignment
+      def on_lvasgn(node)
+        check_assignment(node, extract_rhs(node))
+      end
+      alias on_ivasgn   on_lvasgn
+      alias on_cvasgn   on_lvasgn
+      alias on_gvasgn   on_lvasgn
+      alias on_casgn    on_lvasgn
+      alias on_masgn    on_lvasgn
+      alias on_op_asgn  on_lvasgn
+      alias on_or_asgn  on_lvasgn
+      alias on_and_asgn on_lvasgn
+
+      def on_send(node)
+        return unless (rhs = extract_rhs(node))
+
+        check_assignment(node, rhs)
+      end
+
+      module_function
+
+      def extract_rhs(node)
+        if node.call_type?
+          node.last_argument
+        elsif node.assignment?
+          node.expression
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This mixin detects collections that are safe to "break"
+    # by inserting new lines. This is useful for breaking
+    # up long lines.
+    #
+    # Let's look at hashes as an example:
+    #
+    # We know hash keys are safe to break across lines. We can add
+    # linebreaks into hashes on lines longer than the specified maximum.
+    # Then in further passes cops can clean up the multi-line hash.
+    # For example, say the maximum line length is as indicated below:
+    #
+    #                                         |
+    #                                         v
+    # {foo: "0000000000", bar: "0000000000", baz: "0000000000"}
+    #
+    # In a LineLength autocorrection pass, a line is added before
+    # the first key that exceeds the column limit:
+    #
+    # {foo: "0000000000", bar: "0000000000",
+    # baz: "0000000000"}
+    #
+    # In a MultilineHashKeyLineBreaks pass, lines are inserted
+    # before all keys:
+    #
+    # {foo: "0000000000",
+    # bar: "0000000000",
+    # baz: "0000000000"}
+    #
+    # Then in future passes FirstHashElementLineBreak,
+    # MultilineHashBraceLayout, and TrailingCommaInHashLiteral will
+    # manipulate as well until we get:
+    #
+    # {
+    #   foo: "0000000000",
+    #   bar: "0000000000",
+    #   baz: "0000000000",
+    # }
+    #
+    # (Note: Passes may not happen exactly in this sequence.)
+    module CheckLineBreakable
+      def extract_breakable_node(node, max)
+        if node.call_type?
+          return if chained_to_heredoc?(node)
+
+          args = process_args(node.arguments)
+          return extract_breakable_node_from_elements(node, args, max)
+        elsif node.any_def_type?
+          return extract_breakable_node_from_elements(node, node.arguments, max)
+        elsif node.type?(:array, :hash)
+          return extract_breakable_node_from_elements(node, node.children, max)
+        end
+        nil
+      end
+
+      private
+
+      # @api private
+      def extract_breakable_node_from_elements(node, elements, max)
+        return unless breakable_collection?(node, elements)
+        return if safe_to_ignore?(node)
+
+        line = processed_source.lines[node.first_line - 1]
+        return if processed_source.line_with_comment?(node.loc.line)
+        return if line.length <= max
+
+        extract_first_element_over_column_limit(node, elements, max)
+      end
+
+      # @api private
+      def extract_first_element_over_column_limit(node, elements, max)
+        line = node.first_line
+
+        # If a `send` or `csend` node is not parenthesized, don't move the first element, because it
+        # can result in changed behavior or a syntax error.
+        if node.call_type? && !node.parenthesized? && !first_argument_is_heredoc?(node)
+          elements = elements.drop(1)
+        end
+
+        i = 0
+        i += 1 while within_column_limit?(elements[i], max, line)
+        i = shift_elements_for_heredoc_arg(node, elements, i)
+
+        return if i.nil?
+        return elements.first if i.zero?
+
+        elements[i - 1]
+      end
+
+      # @api private
+      def first_argument_is_heredoc?(node)
+        first_argument = node.first_argument
+
+        first_argument.respond_to?(:heredoc?) && first_argument.heredoc?
+      end
+
+      # @api private
+      # If a `send` or `csend` node contains a heredoc argument, splitting cannot happen
+      # after the heredoc or else it will cause a syntax error.
+      def shift_elements_for_heredoc_arg(node, elements, index)
+        return index unless node.type?(:call, :array)
+
+        heredoc_index = elements.index { |arg| arg.respond_to?(:heredoc?) && arg.heredoc? }
+        return index unless heredoc_index
+        return nil if heredoc_index.zero?
+
+        heredoc_index >= index ? index : heredoc_index + 1
+      end
+
+      # @api private
+      def within_column_limit?(element, max, line)
+        element && element.loc.column <= max && element.loc.line == line
+      end
+
+      # @api private
+      def safe_to_ignore?(node)
+        return true unless max
+        return true if already_on_multiple_lines?(node)
+
+        # If there's a containing breakable collection on the same
+        # line, we let that one get broken first. In a separate pass,
+        # this one might get broken as well, but to avoid conflicting
+        # or redundant edits, we only mark one offense at a time.
+        return true if contained_by_breakable_collection_on_same_line?(node)
+
+        return true if contained_by_multiline_collection_that_could_be_broken_up?(node)
+
+        false
+      end
+
+      # @api private
+      def breakable_collection?(node, elements)
+        # For simplicity we only want to insert breaks in normal
+        # hashes wrapped in a set of curly braces like {foo: 1}.
+        # That is, not a kwargs hash. For method calls, this ensures
+        # the method call is made with parens.
+        starts_with_bracket = !node.hash_type? || node.loc.begin
+
+        # If the call has a second argument, we can insert a line
+        # break before the second argument and the rest of the
+        # argument will get auto-formatted onto separate lines
+        # by other cops.
+        has_second_element = elements.length >= 2
+
+        starts_with_bracket && has_second_element
+      end
+
+      # @api private
+      def contained_by_breakable_collection_on_same_line?(node)
+        node.each_ancestor.find do |ancestor|
+          # Ignore ancestors on different lines.
+          break if ancestor.first_line != node.first_line
+
+          if ancestor.type?(:hash, :array)
+            elements = ancestor.children
+          elsif ancestor.call_type?
+            elements = process_args(ancestor.arguments)
+          else
+            next
+          end
+
+          return true if breakable_collection?(ancestor, elements)
+        end
+
+        false
+      end
+
+      # @api private
+      def contained_by_multiline_collection_that_could_be_broken_up?(node)
+        node.each_ancestor.find do |ancestor|
+          if ancestor.type?(:hash, :array) &&
+             breakable_collection?(ancestor, ancestor.children)
+            return children_could_be_broken_up?(ancestor.children)
+          end
+
+          next unless ancestor.call_type?
+
+          args = process_args(ancestor.arguments)
+          return children_could_be_broken_up?(args) if breakable_collection?(ancestor, args)
+        end
+
+        false
+      end
+
+      # @api private
+      def children_could_be_broken_up?(children)
+        return false if all_on_same_line?(children)
+
+        last_seen_line = -1
+        children.each do |child|
+          return true if last_seen_line >= child.first_line
+
+          last_seen_line = child.last_line
+        end
+        false
+      end
+
+      # @api private
+      def all_on_same_line?(nodes)
+        return true if nodes.empty?
+
+        nodes.first.first_line == nodes.last.last_line
+      end
+
+      # @api private
+      def process_args(args)
+        # 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 = args[0...-1] + last_arg.children if last_arg&.hash_type? && !last_arg&.braces?
+        args
+      end
+
+      # @api private
+      def already_on_multiple_lines?(node)
+        return node.first_line != node.last_argument.last_line if node.any_def_type?
+
+        !node.single_line?
+      end
+
+      def chained_to_heredoc?(node)
+        while (node = node.receiver)
+          return true if node.type?(:str, :dstr, :xstr) && node.heredoc?
+        end
+
+        false
+      end
+    end
+  end
+end