rubocop-grantbirki 1.75.2

data/lib/rubocop/cop/commissioner.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Commissioner class is responsible for processing the AST and delegating
+    # work to the specified cops.
+    class Commissioner
+      include RuboCop::AST::Traversal
+
+      RESTRICTED_CALLBACKS = %i[on_send on_csend after_send after_csend].freeze
+      private_constant :RESTRICTED_CALLBACKS
+
+      # How a Commissioner returns the results of the investigation
+      # as a list of Cop::InvestigationReport and any errors caught
+      # during the investigation.
+      # Immutable
+      # Consider creation API private
+      InvestigationReport = Struct.new(:processed_source, :cop_reports, :errors) do
+        def cops
+          @cops ||= cop_reports.map(&:cop)
+        end
+
+        def offenses_per_cop
+          @offenses_per_cop ||= cop_reports.map(&:offenses)
+        end
+
+        def correctors
+          @correctors ||= cop_reports.map(&:corrector)
+        end
+
+        def offenses
+          @offenses ||= offenses_per_cop.flatten(1)
+        end
+
+        def merge(investigation)
+          InvestigationReport.new(processed_source,
+                                  cop_reports + investigation.cop_reports,
+                                  errors + investigation.errors)
+        end
+      end
+
+      attr_reader :errors
+
+      def initialize(cops, forces = [], options = {})
+        @cops = cops
+        @forces = forces
+        @options = options
+        initialize_callbacks
+
+        reset
+      end
+
+      # Create methods like :on_send, :on_super, etc. They will be called
+      # during AST traversal and try to call corresponding methods on cops.
+      # A call to `super` is used
+      # to continue iterating over the children of a node.
+      # However, if we know that a certain node type (like `int`) never has
+      # child nodes, there is no reason to pay the cost of calling `super`.
+      Parser::Meta::NODE_TYPES.each do |node_type|
+        method_name = :"on_#{node_type}"
+        next unless method_defined?(method_name)
+
+        # Hacky: Comment-out code as needed
+        r = '#' unless RESTRICTED_CALLBACKS.include?(method_name) # has Restricted?
+        c = '#' if NO_CHILD_NODES.include?(node_type) # has Children?
+
+        class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+                  def on_#{node_type}(node)                               # def on_send(node)
+                    trigger_responding_cops(:on_#{node_type}, node)       #   trigger_responding_cops(:on_send, node)
+              #{r}  trigger_restricted_cops(:on_#{node_type}, node)       #   trigger_restricted_cops(:on_send, node)
+          #{c}      super(node)                                           #   super(node)
+          #{c}      trigger_responding_cops(:after_#{node_type}, node)    #   trigger_responding_cops(:after_send, node)
+          #{c}#{r}  trigger_restricted_cops(:after_#{node_type}, node)    #   trigger_restricted_cops(:after_send, node)
+                  end                                                     # end
+        RUBY
+      end
+
+      # @return [InvestigationReport]
+      def investigate(processed_source, offset: 0, original: processed_source)
+        reset
+
+        begin_investigation(processed_source, offset: offset, original: original)
+        if processed_source.valid_syntax?
+          invoke(:on_new_investigation, @cops)
+          invoke_with_argument(:investigate, @forces, processed_source)
+
+          walk(processed_source.ast) unless @cops.empty?
+          invoke(:on_investigation_end, @cops)
+        else
+          invoke(:on_other_file, @cops)
+        end
+        reports = @cops.map { |cop| cop.send(:complete_investigation) }
+        InvestigationReport.new(processed_source, reports, @errors)
+      end
+
+      private
+
+      def begin_investigation(processed_source, offset:, original:)
+        @cops.each do |cop|
+          cop.begin_investigation(processed_source, offset: offset, original: original)
+        end
+      end
+
+      def trigger_responding_cops(callback, node)
+        @callbacks[callback]&.each do |cop|
+          with_cop_error_handling(cop, node) do
+            cop.public_send(callback, node)
+          end
+        end
+      end
+
+      def reset
+        @errors = []
+      end
+
+      def initialize_callbacks
+        @callbacks = build_callbacks(@cops)
+        @restricted_map = restrict_callbacks(@callbacks)
+      end
+
+      def build_callbacks(cops)
+        callbacks = {}
+        cops.each do |cop|
+          cop.callbacks_needed.each do |callback|
+            (callbacks[callback] ||= []) << cop
+          end
+        end
+        callbacks
+      end
+
+      def restrict_callbacks(callbacks)
+        restricted = {}
+        RESTRICTED_CALLBACKS.each do |callback|
+          restricted[callback] = restricted_map(callbacks[callback])
+        end
+        restricted
+      end
+
+      def trigger_restricted_cops(event, node)
+        name = node.method_name
+        @restricted_map[event][name]&.each do |cop|
+          with_cop_error_handling(cop, node) do
+            cop.public_send(event, node)
+          end
+        end
+      end
+
+      # NOTE: mutates `callbacks` in place
+      def restricted_map(callbacks)
+        map = {}
+        callbacks&.select! do |cop|
+          restrictions = cop.class.send :restrict_on_send
+          restrictions.each { |name| (map[name] ||= []) << cop }
+          restrictions.empty?
+        end
+        map
+      end
+
+      def invoke(callback, cops)
+        cops.each { |cop| with_cop_error_handling(cop) { cop.send(callback) } }
+      end
+
+      def invoke_with_argument(callback, cops, arg)
+        cops.each { |cop| with_cop_error_handling(cop) { cop.send(callback, arg) } }
+      end
+
+      # Allow blind rescues here, since we're absorbing and packaging or
+      # re-raising exceptions that can be raised from within the individual
+      # cops' `#investigate` methods.
+      def with_cop_error_handling(cop, node = nil)
+        yield
+      rescue StandardError => e
+        raise e if @options[:raise_error] # For internal testing
+
+        err = ErrorWithAnalyzedFileLocation.new(cause: e, node: node, cop: cop)
+        raise err if @options[:raise_cop_error] # From user-input option
+
+        @errors << err
+      end
+    end
+  end
+end

data/lib/rubocop/cop/cop.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require 'uri'
+require_relative 'legacy/corrections_proxy'
+
+module RuboCop
+  module Cop
+    # @deprecated Use Cop::Base instead
+    # Legacy scaffold for Cops.
+    # See https://docs.rubocop.org/rubocop/v1_upgrade_notes.html
+    class Cop < Base
+      attr_reader :offenses
+
+      exclude_from_registry
+
+      # @deprecated
+      Correction = Struct.new(:lambda, :node, :cop) do
+        def call(corrector)
+          lambda.call(corrector)
+        rescue StandardError => e
+          raise ErrorWithAnalyzedFileLocation.new(cause: e, node: node, cop: cop)
+        end
+      end
+
+      def self.inherited(_subclass)
+        super
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          Inheriting from `RuboCop::Cop::Cop` is deprecated. Use `RuboCop::Cop::Base` instead.
+          For more information, see https://docs.rubocop.org/rubocop/v1_upgrade_notes.html.
+        WARNING
+      end
+
+      def self.support_autocorrect?
+        method_defined?(:autocorrect)
+      end
+
+      def self.joining_forces
+        return unless method_defined?(:join_force?)
+
+        cop = new
+        Force.all.select { |force_class| cop.join_force?(force_class) }
+      end
+
+      ### Deprecated registry access
+
+      # @deprecated Use Registry.global
+      def self.registry
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `Cop.registry` is deprecated. Use `Registry.global` instead.
+        WARNING
+
+        Registry.global
+      end
+
+      # @deprecated Use Registry.all
+      def self.all
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `Cop.all` is deprecated. Use `Registry.all` instead.
+        WARNING
+
+        Registry.all
+      end
+
+      # @deprecated Use Registry.qualified_cop_name
+      def self.qualified_cop_name(name, origin)
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `Cop.qualified_cop_name` is deprecated. Use `Registry.qualified_cop_name` instead.
+        WARNING
+
+        Registry.qualified_cop_name(name, origin)
+      end
+
+      def add_offense(node_or_range, location: :expression, message: nil, severity: nil, &block)
+        @v0_argument = node_or_range
+        range = find_location(node_or_range, location)
+
+        # Since this range may be generated from Ruby code embedded in some
+        # template file, we convert it to location info in the original file.
+        range = range_for_original(range)
+
+        if block.nil? && !self.class.support_autocorrect?
+          super(range, message: message, severity: severity)
+        else
+          super(range, message: message, severity: severity) do |corrector|
+            emulate_v0_callsequence(corrector, &block)
+          end
+        end
+      end
+
+      def find_location(node, loc)
+        # Location can be provided as a symbol, e.g.: `:keyword`
+        loc.is_a?(Symbol) ? node.loc.public_send(loc) : loc
+      end
+
+      # @deprecated Use class method
+      def support_autocorrect?
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `support_autocorrect?` is deprecated. Use `cop.class.support_autocorrect?`.
+        WARNING
+
+        self.class.support_autocorrect?
+      end
+
+      # @deprecated
+      def corrections
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `Cop#corrections` is deprecated.
+        WARNING
+
+        return [] unless @last_corrector
+
+        Legacy::CorrectionsProxy.new(@last_corrector)
+      end
+
+      # Called before all on_... have been called
+      def on_new_investigation
+        investigate(processed_source) if respond_to?(:investigate)
+        super
+      end
+
+      # Called after all on_... have been called
+      def on_investigation_end
+        investigate_post_walk(processed_source) if respond_to?(:investigate_post_walk)
+        super
+      end
+
+      # Called before any investigation
+      # @api private
+      def begin_investigation(processed_source, offset: 0, original: processed_source)
+        super
+        @offenses = current_offenses
+        @last_corrector = @current_corrector
+
+        # We need to keep track of the original source and offset,
+        # because `processed_source` here may be an embedded code in it.
+        @current_offset = offset
+        @current_original = original
+      end
+
+      private
+
+      # Override Base
+      def callback_argument(_range)
+        @v0_argument
+      end
+
+      def apply_correction(corrector)
+        suppress_clobbering { super }
+      end
+
+      # Just for legacy
+      def emulate_v0_callsequence(corrector)
+        lambda = correction_lambda
+        yield corrector if block_given?
+        unless corrector.empty?
+          raise 'Your cop must inherit from Cop::Base and extend AutoCorrector'
+        end
+
+        return unless lambda
+
+        suppress_clobbering { lambda.call(corrector) }
+      end
+
+      def correction_lambda
+        return unless self.class.support_autocorrect?
+
+        dedupe_on_node(@v0_argument) { autocorrect(@v0_argument) }
+      end
+
+      def dedupe_on_node(node)
+        @corrected_nodes ||= {}.compare_by_identity
+        yield unless @corrected_nodes.key?(node)
+      ensure
+        @corrected_nodes[node] = true
+      end
+
+      def suppress_clobbering
+        yield
+      rescue ::Parser::ClobberingError
+        # ignore Clobbering errors
+      end
+
+      def range_for_original(range)
+        ::Parser::Source::Range.new(
+          @current_original.buffer,
+          range.begin_pos + @current_offset,
+          range.end_pos + @current_offset
+        )
+      end
+    end
+  end
+end

data/lib/rubocop/cop/corrector.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This class takes a source buffer and rewrite its source
+    # based on the different correction rules supplied.
+    #
+    # Important!
+    # The nodes modified by the corrections should be part of the
+    # AST of the source_buffer.
+    class Corrector < ::Parser::Source::TreeRewriter
+      NOOP_CONSUMER = ->(diagnostic) {} # noop
+
+      # Duck typing for get to a ::Parser::Source::Buffer
+      def self.source_buffer(source)
+        source = source.processed_source if source.respond_to?(:processed_source)
+        source = source.buffer if source.respond_to?(:buffer)
+        source = source.source_buffer if source.respond_to?(:source_buffer)
+
+        unless source.is_a? ::Parser::Source::Buffer
+          raise TypeError, 'Expected argument to lead to a Parser::Source::Buffer ' \
+                           "but got #{source.inspect}"
+        end
+
+        source
+      end
+
+      # @param source [Parser::Source::Buffer, or anything
+      #                leading to one via `(processed_source.)buffer`]
+      #
+      #   corrector = Corrector.new(cop)
+      def initialize(source)
+        source = self.class.source_buffer(source)
+        super(
+          source,
+          different_replacements: :raise,
+          swallowed_insertions: :raise,
+          crossing_deletions: :accept
+        )
+
+        # Don't print warnings to stderr if corrections conflict with each other
+        diagnostics.consumer = NOOP_CONSUMER
+      end
+
+      alias rewrite process # Legacy
+
+      # Removes `size` characters prior to the source range.
+      #
+      # @param [Parser::Source::Range, RuboCop::AST::Node] range or node
+      # @param [Integer] size
+      def remove_preceding(node_or_range, size)
+        range = to_range(node_or_range)
+        to_remove = range.with(begin_pos: range.begin_pos - size, end_pos: range.begin_pos)
+        remove(to_remove)
+      end
+
+      # Removes `size` characters from the beginning of the given range.
+      # If `size` is greater than the size of `range`, the removed region can
+      # overrun the end of `range`.
+      #
+      # @param [Parser::Source::Range, RuboCop::AST::Node] range or node
+      # @param [Integer] size
+      def remove_leading(node_or_range, size)
+        range = to_range(node_or_range)
+        to_remove = range.with(end_pos: range.begin_pos + size)
+        remove(to_remove)
+      end
+
+      # Removes `size` characters from the end of the given range.
+      # If `size` is greater than the size of `range`, the removed region can
+      # overrun the beginning of `range`.
+      #
+      # @param [Parser::Source::Range, RuboCop::AST::Node] range or node
+      # @param [Integer] size
+      def remove_trailing(node_or_range, size)
+        range = to_range(node_or_range)
+        to_remove = range.with(begin_pos: range.end_pos - size)
+        remove(to_remove)
+      end
+
+      # Swaps sources at the given ranges.
+      #
+      # @param [Parser::Source::Range, RuboCop::AST::Node] node_or_range1
+      # @param [Parser::Source::Range, RuboCop::AST::Node] node_or_range2
+      def swap(node_or_range1, node_or_range2)
+        range1 = to_range(node_or_range1)
+        range2 = to_range(node_or_range2)
+
+        if range1.end_pos == range2.begin_pos
+          insert_before(range1, range2.source)
+          remove(range2)
+        elsif range2.end_pos == range1.begin_pos
+          insert_before(range2, range1.source)
+          remove(range1)
+        else
+          replace(range1, range2.source)
+          replace(range2, range1.source)
+        end
+      end
+
+      private
+
+      # :nodoc:
+      def to_range(node_or_range)
+        range = case node_or_range
+                when ::RuboCop::AST::Node, ::Parser::Source::Comment
+                  node_or_range.source_range
+                when ::Parser::Source::Range
+                  node_or_range
+                else
+                  raise TypeError,
+                        'Expected a Parser::Source::Range, Comment or ' \
+                        "RuboCop::AST::Node, got #{node_or_range.class}"
+                end
+        validate_buffer(range.source_buffer)
+        range
+      end
+
+      def check_range_validity(node_or_range)
+        super(to_range(node_or_range))
+      end
+
+      def validate_buffer(buffer)
+        return if buffer == source_buffer
+
+        unless buffer.is_a?(::Parser::Source::Buffer)
+          # actually this should be enforced by parser gem
+          raise 'Corrector expected range source buffer to be a ' \
+                "Parser::Source::Buffer, but got #{buffer.class}"
+        end
+        raise "Correction target buffer #{buffer.object_id} " \
+              "name:#{buffer.name.inspect} " \
+              "is not current #{@source_buffer.object_id} " \
+              "name:#{@source_buffer.name.inspect} under investigation"
+      end
+    end
+  end
+end

data/lib/rubocop/cop/correctors/alignment_corrector.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This class does autocorrection of nodes that should just be moved to
+    # the left or to the right, amount being determined by the instance
+    # variable column_delta.
+    class AlignmentCorrector
+      extend RangeHelp
+      extend Alignment
+
+      class << self
+        attr_reader :processed_source
+
+        def correct(corrector, processed_source, node, column_delta)
+          return unless node
+
+          @processed_source = processed_source
+          expr = node.respond_to?(:loc) ? node.source_range : node
+          return if block_comment_within?(expr)
+
+          taboo_ranges = inside_string_ranges(node)
+
+          each_line(expr) do |line_begin_pos|
+            autocorrect_line(corrector, line_begin_pos, expr, column_delta, taboo_ranges)
+          end
+        end
+
+        def align_end(corrector, processed_source, node, align_to)
+          @processed_source = processed_source
+          whitespace = whitespace_range(node)
+          return false unless whitespace.source.strip.empty?
+
+          column = alignment_column(align_to)
+          corrector.replace(whitespace, ' ' * column)
+        end
+
+        private
+
+        def autocorrect_line(corrector, line_begin_pos, expr, column_delta,
+                             taboo_ranges)
+          range = calculate_range(expr, line_begin_pos, column_delta)
+          # We must not change indentation of heredoc strings or inside other
+          # string literals
+          return if taboo_ranges.any? { |t| within?(range, t) }
+
+          if column_delta.positive? && range.resize(1).source != "\n"
+            corrector.insert_before(range, ' ' * column_delta)
+          elsif /\A[ \t]+\z/.match?(range.source)
+            corrector.remove(range)
+          end
+        end
+
+        def inside_string_ranges(node)
+          return [] unless node.is_a?(Parser::AST::Node)
+
+          node.each_node(:str, :dstr, :xstr).filter_map { |n| inside_string_range(n) }
+        end
+
+        def inside_string_range(node)
+          loc = node.location
+
+          if node.heredoc?
+            loc.heredoc_body.join(loc.heredoc_end)
+          elsif delimited_string_literal?(node)
+            loc.begin.end.join(loc.end.begin)
+          end
+        end
+
+        # Some special kinds of string literals are not composed of literal
+        # characters between two delimiters:
+        # - The source map of `?a` responds to :begin and :end but its end is
+        #   nil.
+        # - The source map of `__FILE__` responds to neither :begin nor :end.
+        def delimited_string_literal?(node)
+          loc = node.location
+
+          loc.respond_to?(:begin) && loc.begin && loc.respond_to?(:end) && loc.end
+        end
+
+        def block_comment_within?(expr)
+          processed_source.comments.select(&:document?).any? do |c|
+            within?(c.source_range, expr)
+          end
+        end
+
+        def calculate_range(expr, line_begin_pos, column_delta)
+          return range_between(line_begin_pos, line_begin_pos) if column_delta.positive?
+
+          starts_with_space = expr.source_buffer.source[line_begin_pos].start_with?(' ')
+
+          if starts_with_space
+            range_between(line_begin_pos, line_begin_pos + column_delta.abs)
+          else
+            range_between(line_begin_pos - column_delta.abs, line_begin_pos)
+          end
+        end
+
+        def each_line(expr)
+          line_begin_pos = expr.begin_pos
+          expr.source.each_line do |line|
+            yield line_begin_pos
+            line_begin_pos += line.length
+          end
+        end
+
+        def whitespace_range(node)
+          begin_pos = node.loc.end.begin_pos
+
+          range_between(begin_pos - node.loc.end.column, begin_pos)
+        end
+
+        def alignment_column(align_to)
+          if !align_to
+            0
+          elsif align_to.respond_to?(:loc)
+            align_to.source_range.column
+          else
+            align_to.column
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/correctors/condition_corrector.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This class does condition autocorrection
+    class ConditionCorrector
+      class << self
+        def correct_negative_condition(corrector, node)
+          condition = negated_condition(node)
+
+          corrector.replace(node.loc.keyword, node.inverse_keyword)
+          corrector.replace(condition, condition.children.first.source)
+        end
+
+        private
+
+        def negated_condition(node)
+          condition = node.condition
+          condition = condition.children.first while condition.begin_type?
+          condition
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/correctors/each_to_for_corrector.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This class autocorrects `#each` enumeration to `for` iteration.
+    class EachToForCorrector
+      extend NodePattern::Macros
+
+      CORRECTION_WITH_ARGUMENTS = 'for %<variables>s in %<collection>s do'
+      CORRECTION_WITHOUT_ARGUMENTS = 'for _ in %<enumerable>s do'
+
+      def initialize(block_node)
+        @block_node = block_node
+        @collection_node = block_node.receiver
+        @argument_node = block_node.arguments
+      end
+
+      def call(corrector)
+        corrector.replace(offending_range, correction)
+      end
+
+      private
+
+      attr_reader :block_node, :collection_node, :argument_node
+
+      def correction
+        if block_node.arguments?
+          format(CORRECTION_WITH_ARGUMENTS,
+                 collection: collection_node.source,
+                 variables: argument_node.children.first.source)
+        else
+          format(CORRECTION_WITHOUT_ARGUMENTS, enumerable: collection_node.source)
+        end
+      end
+
+      def offending_range
+        begin_range = block_node.source_range.begin
+
+        if block_node.arguments?
+          begin_range.join(argument_node.source_range.end)
+        else
+          begin_range.join(block_node.loc.begin.end)
+        end
+      end
+    end
+  end
+end