rubocop-grantbirki 1.75.2

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

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for Style/HashTransformKeys and
+    # Style/HashTransformValues
+    module HashTransformMethod
+      extend NodePattern::Macros
+
+      RESTRICT_ON_SEND = %i[[] to_h].freeze
+
+      # Internal helper class to hold match data
+      Captures = Struct.new(:transformed_argname, :transforming_body_expr, :unchanged_body_expr) do
+        def noop_transformation?
+          transforming_body_expr.lvar_type? &&
+            transforming_body_expr.children == [transformed_argname]
+        end
+
+        def transformation_uses_both_args?
+          transforming_body_expr.descendants.include?(unchanged_body_expr)
+        end
+
+        def use_transformed_argname?
+          transforming_body_expr.each_descendant(:lvar).any? do |node|
+            node.source == transformed_argname.to_s
+          end
+        end
+      end
+
+      # Internal helper class to hold autocorrect data
+      Autocorrection = Struct.new(:match, :block_node, :leading, :trailing) do
+        def self.from_each_with_object(node, match)
+          new(match, node, 0, 0)
+        end
+
+        def self.from_hash_brackets_map(node, match)
+          new(match, node.children.last, 'Hash['.length, ']'.length)
+        end
+
+        def self.from_map_to_h(node, match)
+          if node.parent&.block_type? && node.parent.send_node == node
+            strip_trailing_chars = 0
+          else
+            map_range = node.children.first.source_range
+            node_range = node.source_range
+            strip_trailing_chars = node_range.end_pos - map_range.end_pos
+          end
+
+          new(match, node.children.first, 0, strip_trailing_chars)
+        end
+
+        def self.from_to_h(node, match)
+          new(match, node, 0, 0)
+        end
+
+        def strip_prefix_and_suffix(node, corrector)
+          expression = node.source_range
+          corrector.remove_leading(expression, leading)
+          corrector.remove_trailing(expression, trailing)
+        end
+
+        def set_new_method_name(new_method_name, corrector)
+          range = block_node.send_node.loc.selector
+          if (send_end = block_node.send_node.loc.end)
+            # If there are arguments (only true in the `each_with_object`
+            # case)
+            range = range.begin.join(send_end)
+          end
+          corrector.replace(range, new_method_name)
+        end
+
+        def set_new_arg_name(transformed_argname, corrector)
+          corrector.replace(block_node.arguments, "|#{transformed_argname}|")
+        end
+
+        def set_new_body_expression(transforming_body_expr, corrector)
+          body_source = transforming_body_expr.source
+          if transforming_body_expr.hash_type? && !transforming_body_expr.braces?
+            body_source = "{ #{body_source} }"
+          end
+
+          corrector.replace(block_node.body, body_source)
+        end
+      end
+
+      # @!method array_receiver?(node)
+      def_node_matcher :array_receiver?, <<~PATTERN
+        {(array ...) (send _ :each_with_index) (send _ :with_index _ ?) (send _ :zip ...)}
+      PATTERN
+
+      def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+        on_bad_each_with_object(node) do |*match|
+          handle_possible_offense(node, match, 'each_with_object')
+        end
+
+        return if target_ruby_version < 2.6
+
+        on_bad_to_h(node) { |*match| handle_possible_offense(node, match, 'to_h {...}') }
+      end
+
+      def on_send(node)
+        on_bad_hash_brackets_map(node) do |*match|
+          handle_possible_offense(node, match, 'Hash[_.map {...}]')
+        end
+        on_bad_map_to_h(node) { |*match| handle_possible_offense(node, match, 'map {...}.to_h') }
+      end
+
+      def on_csend(node)
+        on_bad_map_to_h(node) { |*match| handle_possible_offense(node, match, 'map {...}.to_h') }
+      end
+
+      private
+
+      # @abstract Implemented with `def_node_matcher`
+      def on_bad_each_with_object(_node)
+        raise NotImplementedError
+      end
+
+      # @abstract Implemented with `def_node_matcher`
+      def on_bad_hash_brackets_map(_node)
+        raise NotImplementedError
+      end
+
+      # @abstract Implemented with `def_node_matcher`
+      def on_bad_map_to_h(_node)
+        raise NotImplementedError
+      end
+
+      # @abstract Implemented with `def_node_matcher`
+      def on_bad_to_h(_node)
+        raise NotImplementedError
+      end
+
+      def handle_possible_offense(node, match, match_desc)
+        captures = extract_captures(match)
+
+        # If key didn't actually change either, this is most likely a false
+        # positive (receiver isn't a hash).
+        return if captures.noop_transformation?
+
+        # Can't `transform_keys` if key transformation uses value, or
+        # `transform_values` if value transformation uses key.
+        return if captures.transformation_uses_both_args?
+
+        return unless captures.use_transformed_argname?
+
+        message = "Prefer `#{new_method_name}` over `#{match_desc}`."
+        add_offense(node, message: message) do |corrector|
+          correction = prepare_correction(node)
+          execute_correction(corrector, node, correction)
+        end
+      end
+
+      # @abstract
+      #
+      # @return [Captures]
+      def extract_captures(_match)
+        raise NotImplementedError
+      end
+
+      # @abstract
+      #
+      # @return [String]
+      def new_method_name
+        raise NotImplementedError
+      end
+
+      def prepare_correction(node)
+        if (match = on_bad_each_with_object(node))
+          Autocorrection.from_each_with_object(node, match)
+        elsif (match = on_bad_hash_brackets_map(node))
+          Autocorrection.from_hash_brackets_map(node, match)
+        elsif (match = on_bad_map_to_h(node))
+          Autocorrection.from_map_to_h(node, match)
+        elsif (match = on_bad_to_h(node))
+          Autocorrection.from_to_h(node, match)
+        else
+          raise 'unreachable'
+        end
+      end
+
+      def execute_correction(corrector, node, correction)
+        correction.strip_prefix_and_suffix(node, corrector)
+        correction.set_new_method_name(new_method_name, corrector)
+
+        captures = extract_captures(correction.match)
+        correction.set_new_arg_name(captures.transformed_argname, corrector)
+        correction.set_new_body_expression(captures.transforming_body_expr, corrector)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for working with heredoc strings.
+    module Heredoc
+      OPENING_DELIMITER = /(<<[~-]?)['"`]?([^'"`]+)['"`]?/.freeze
+
+      def on_str(node)
+        return unless node.heredoc?
+
+        on_heredoc(node)
+      end
+      alias on_dstr on_str
+      alias on_xstr on_str
+
+      def on_heredoc(_node)
+        raise NotImplementedError
+      end
+
+      private
+
+      def indent_level(str)
+        indentations = str.lines.map { |line| line[/^\s*/] }.reject { |line| line.end_with?("\n") }
+        indentations.empty? ? 0 : indentations.min_by(&:size).size
+      end
+
+      def delimiter_string(node)
+        return '' unless (match = node.source.match(OPENING_DELIMITER))
+
+        match.captures[1]
+      end
+
+      def heredoc_type(node)
+        return '' unless (match = node.source.match(OPENING_DELIMITER))
+
+        match.captures[0]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking integer nodes.
+    module IntegerNode
+      private
+
+      def integer_part(node)
+        node.source.sub(/^[+-]/, '').split(/[eE.]/, 2).first
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for working with string interpolations.
+    #
+    # @abstract Subclasses are expected to implement {#on_interpolation}.
+    module Interpolation
+      def on_dstr(node)
+        on_node_with_interpolations(node)
+      end
+
+      alias on_xstr on_dstr
+      alias on_dsym on_dstr
+      alias on_regexp on_dstr
+
+      def on_node_with_interpolations(node)
+        node.each_child_node(:begin) { |begin_node| on_interpolation(begin_node) }
+      end
+
+      # @!method on_interpolation(begin_node)
+      #   Inspect the `:begin` node of an interpolation
+    end
+  end
+end

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

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Help methods for determining if a line is too long.
+    module LineLengthHelp
+      include Alignment
+
+      private
+
+      def ignore_cop_directives?
+        config.for_cop('Layout/LineLength')['IgnoreCopDirectives']
+      end
+
+      def directive_on_source_line?(line_index)
+        source_line_number = line_index + processed_source.buffer.first_line
+        comment = processed_source.comment_at_line(source_line_number)
+
+        return false unless comment
+
+        !!DirectiveComment.new(comment).match_captures
+      end
+
+      def allow_uri?
+        config.for_cop('Layout/LineLength')['AllowURI']
+      end
+
+      def allowed_uri_position?(line, uri_range)
+        uri_range.begin < max_line_length && uri_range.end == line_length(line)
+      end
+
+      def line_length(line)
+        line.length + indentation_difference(line)
+      end
+
+      def find_excessive_uri_range(line)
+        last_uri_match = match_uris(line).last
+        return nil unless last_uri_match
+
+        begin_position, end_position = last_uri_match.offset(0)
+        end_position = extend_uri_end_position(line, end_position)
+
+        line_indentation_difference = indentation_difference(line)
+        begin_position += line_indentation_difference
+        end_position += line_indentation_difference
+
+        return nil if begin_position < max_line_length && end_position < max_line_length
+
+        begin_position...end_position
+      end
+
+      def match_uris(string)
+        matches = []
+        string.scan(uri_regexp) do
+          matches << $LAST_MATCH_INFO if valid_uri?($LAST_MATCH_INFO[0])
+        end
+        matches
+      end
+
+      def indentation_difference(line)
+        return 0 unless tab_indentation_width
+
+        index =
+          if line.match?(/^[^\t]/)
+            0
+          else
+            line.index(/[^\t]/) || 0
+          end
+
+        index * (tab_indentation_width - 1)
+      end
+
+      def extend_uri_end_position(line, end_position)
+        # Extend the end position YARD comments with linked URLs of the form {<uri> <title>}
+        if line&.match(/{(\s|\S)*}$/)
+          match = line[end_position..line_length(line)]&.match(/(\s|\S)*}/)
+          end_position += match.offset(0).last
+        end
+
+        # Extend the end position until the start of the next word, if any.
+        # This allows for URIs that are wrapped in quotes or parens to be handled properly
+        # while not allowing additional words to be added after the URL.
+        if (match = line[end_position..line_length(line)]&.match(/^\S+(?=\s|$)/))
+          end_position += match.offset(0).last
+        end
+        end_position
+      end
+
+      def tab_indentation_width
+        config.for_cop('Layout/IndentationStyle')['IndentationWidth'] ||
+          configured_indentation_width
+      end
+
+      def uri_regexp
+        @uri_regexp ||= begin
+          # Ruby 3.4 changes the default parser to RFC3986 which warns on make_regexp.
+          # Additionally, the RFC2396_PARSER alias is only available on 3.4 for now.
+          # Extra info at https://github.com/ruby/uri/issues/118
+          parser = defined?(URI::RFC2396_PARSER) ? URI::RFC2396_PARSER : URI::DEFAULT_PARSER
+          parser.make_regexp(config.for_cop('Layout/LineLength')['URISchemes'])
+        end
+      end
+
+      def valid_uri?(uri_ish_string)
+        URI.parse(uri_ish_string)
+        true
+      rescue URI::InvalidURIError, NoMethodError
+        false
+      end
+
+      def line_length_without_directive(line)
+        DirectiveComment.before_comment(line).rstrip.length
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for obtaining source ranges from regexp matches
+    module MatchRange
+      include RangeHelp
+
+      private
+
+      # Return a new `Range` covering the first matching group number for each
+      # match of `regex` inside `range`
+      def each_match_range(range, regex)
+        range.source.scan(regex) { yield match_range(range, Regexp.last_match) }
+      end
+
+      # For a `match` inside `range`, return a new `Range` covering the match
+      def match_range(range, match)
+        range_between(range.begin_pos + match.begin(1), range.begin_pos + match.end(1))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # @api private
+    #
+    # This module handles measurement and reporting of complexity in methods.
+    module MethodComplexity
+      include AllowedMethods
+      include AllowedPattern
+      include Metrics::Utils::RepeatedCsendDiscount
+      extend NodePattern::Macros
+      extend ExcludeLimit
+
+      exclude_limit 'Max'
+
+      def on_def(node)
+        return if allowed_method?(node.method_name) || matches_allowed_pattern?(node.method_name)
+
+        check_complexity(node, node.method_name)
+      end
+      alias on_defs on_def
+
+      def on_block(node)
+        define_method?(node) do |name|
+          return if allowed_method?(name) || matches_allowed_pattern?(name)
+
+          check_complexity(node, name)
+        end
+      end
+
+      alias on_numblock on_block
+      alias on_itblock on_block
+
+      private
+
+      # @!method define_method?(node)
+      def_node_matcher :define_method?, <<~PATTERN
+        (any_block
+         (send nil? :define_method ({sym str} $_)) _ _)
+      PATTERN
+
+      def check_complexity(node, method_name)
+        # Accepts empty methods always.
+        return unless node.body
+
+        max = cop_config['Max']
+        reset_repeated_csend
+        complexity, abc_vector = complexity(node.body)
+
+        return unless complexity > max
+
+        msg = format(
+          self.class::MSG,
+          method: method_name, complexity: complexity, abc_vector: abc_vector, max: max
+        )
+        location = location(node)
+
+        add_offense(location, message: msg) { self.max = complexity.ceil }
+      end
+
+      def complexity(body)
+        score = 1
+        body.each_node(:lvasgn, *self.class::COUNTED_NODES) do |node|
+          if node.lvasgn_type?
+            reset_on_lvasgn(node)
+          else
+            score += complexity_score_for(node)
+          end
+        end
+        score
+      end
+
+      def location(node)
+        if LSP.enabled?
+          end_range = node.loc.respond_to?(:name) ? node.loc.name : node.loc.begin
+          node.source_range.begin.join(end_range)
+        else
+          node.source_range
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common code for cops that deal with preferred methods.
+    module MethodPreference
+      private
+
+      def preferred_method(method)
+        preferred_methods[method.to_sym]
+      end
+
+      def preferred_methods
+        @preferred_methods ||=
+          begin
+            # Make sure default configuration 'foo' => 'bar' is removed from
+            # the total configuration if there is a 'bar' => 'foo' override.
+            default = default_cop_config['PreferredMethods']
+            merged = cop_config['PreferredMethods']
+            overrides = merged.values - default.values
+            merged.reject { |key, _| overrides.include?(key) }.transform_keys(&:to_sym)
+          end
+      end
+
+      def default_cop_config
+        ConfigLoader.default_configuration[cop_name]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking minimum body length.
+    module MinBodyLength
+      private
+
+      def min_body_length?(node)
+        (node.loc.end.line - node.loc.keyword.line) > min_body_length
+      end
+
+      def min_body_length
+        length = cop_config['MinBodyLength'] || 1
+        return length if length.is_a?(Integer) && length.positive?
+
+        raise 'MinBodyLength needs to be a positive integer!'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking minimum branches count.
+    module MinBranchesCount
+      private
+
+      def min_branches_count?(node)
+        branches =
+          if node.case_type?
+            node.when_branches
+          elsif node.if_type?
+            if_conditional_branches(node)
+          else
+            raise ArgumentError, "Unsupported #{node.type.inspect} node type"
+          end
+
+        branches.size >= min_branches_count
+      end
+
+      def min_branches_count
+        length = cop_config['MinBranchesCount'] || 3
+        return length if length.is_a?(Integer) && length.positive?
+
+        raise 'MinBranchesCount needs to be a positive integer!'
+      end
+
+      def if_conditional_branches(node, branches = [])
+        return [] if node.nil? || !node.if_type?
+
+        branches << node.if_branch
+
+        else_branch = node.else_branch
+        if_conditional_branches(else_branch, branches) if else_branch&.if_type?
+        branches
+      end
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common code for indenting the first elements in multiline
+    # array literals, hash literals, and method definitions.
+    module MultilineElementIndentation
+      private
+
+      def each_argument_node(node, type)
+        left_parenthesis = node.loc.begin
+
+        return unless left_parenthesis
+
+        node.arguments.each do |arg|
+          on_node(type, arg, :send) do |type_node|
+            left_brace = type_node.loc.begin
+            if left_brace && same_line?(left_brace, left_parenthesis)
+              yield type_node, left_parenthesis
+              ignore_node(type_node)
+            end
+          end
+        end
+      end
+
+      def check_first(first, left_brace, left_parenthesis, offset)
+        actual_column = first.source_range.column
+
+        indent_base_column, indent_base_type = indent_base(left_brace, first, left_parenthesis)
+        expected_column = indent_base_column + configured_indentation_width + offset
+
+        @column_delta = expected_column - actual_column
+        styles = detected_styles(actual_column, offset, left_parenthesis, left_brace)
+
+        if @column_delta.zero?
+          check_expected_style(styles)
+        else
+          incorrect_style_detected(styles, first, indent_base_type)
+        end
+      end
+
+      def check_expected_style(styles)
+        if styles.size > 1
+          ambiguous_style_detected(*styles)
+        else
+          correct_style_detected
+        end
+      end
+
+      def indent_base(left_brace, first, left_parenthesis)
+        return [left_brace.column, :left_brace_or_bracket] if style == brace_alignment_style
+
+        pair = hash_pair_where_value_beginning_with(left_brace, first)
+        if pair && key_and_value_begin_on_same_line?(pair) &&
+           right_sibling_begins_on_subsequent_line?(pair)
+          return [pair.loc.column, :parent_hash_key]
+        end
+
+        if left_parenthesis && style == :special_inside_parentheses
+          return [left_parenthesis.column + 1, :first_column_after_left_parenthesis]
+        end
+
+        [left_brace.source_line =~ /\S/, :start_of_line]
+      end
+
+      def hash_pair_where_value_beginning_with(left_brace, first)
+        return unless first && first.parent.loc.begin == left_brace
+
+        first.parent&.parent&.pair_type? ? first.parent.parent : nil
+      end
+
+      def key_and_value_begin_on_same_line?(pair)
+        same_line?(pair.key, pair.value)
+      end
+
+      def right_sibling_begins_on_subsequent_line?(pair)
+        pair.right_sibling && (pair.last_line < pair.right_sibling.first_line)
+      end
+
+      def detected_styles(actual_column, offset, left_parenthesis, left_brace)
+        base_column = actual_column - configured_indentation_width - offset
+        detected_styles_for_column(base_column, left_parenthesis, left_brace)
+      end
+
+      def detected_styles_for_column(column, left_parenthesis, left_brace)
+        styles = []
+        if column == (left_brace.source_line =~ /\S/)
+          styles << :consistent
+          styles << :special_inside_parentheses unless left_parenthesis
+        end
+        if left_parenthesis && column == left_parenthesis.column + 1
+          styles << :special_inside_parentheses
+        end
+        styles << brace_alignment_style if column == left_brace.column
+        styles
+      end
+
+      def incorrect_style_detected(styles, first, base_column_type)
+        msg = message(base_description(base_column_type))
+
+        add_offense(first, message: msg) do |corrector|
+          autocorrect(corrector, first)
+
+          ambiguous_style_detected(*styles)
+        end
+      end
+    end
+  end
+end