rubocop 1.71.1 → 1.88.2

data/lib/rubocop/cop/utils/regexp_ranges.rb

@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Utils
-      # Helper to abstract complexity of building range pairs
-      # with octal escape reconstruction (needed for regexp_parser < 2.7).
-      class RegexpRanges
-        attr_reader :root
-
-        def initialize(root)
-          @root = root
-          @compound_token = []
-          @pairs = []
-          @populated = false
-        end
-
-        def compound_token
-          populate_all unless @populated
-
-          @compound_token
-        end
-
-        def pairs
-          populate_all unless @populated
-
-          @pairs
-        end
-
-        private
-
-        def populate_all
-          populate(@root)
-
-          # If either bound is a compound the first one is an escape
-          # and that's all we need to work with.
-          # If there are any cops that wanted to operate on the compound
-          # expression we could wrap it with a facade class.
-          @pairs.map! { |pair| pair.map(&:first) }
-
-          @populated = true
-        end
-
-        def populate(expr)
-          expressions = expr.expressions.to_a
-
-          until expressions.empty?
-            current = expressions.shift
-
-            if escaped_octal?(current)
-              @compound_token << current
-              @compound_token.concat(pop_octal_digits(expressions))
-              # If we have all the digits we can discard.
-            end
-
-            next unless current.type == :set
-
-            process_set(expressions, current)
-            @compound_token.clear
-          end
-        end
-
-        def process_set(expressions, current)
-          case current.token
-          when :range
-            @pairs << compose_range(expressions, current)
-          when :character
-            # Child expressions may include the range we are looking for.
-            populate(current)
-          when :intersection
-            # Each child expression could have child expressions that lead to ranges.
-            current.expressions.each do |intersected|
-              populate(intersected)
-            end
-          end
-        end
-
-        def compose_range(expressions, current)
-          range_start, range_end = current.expressions
-          range_start = if @compound_token.size.between?(1, 2) && octal_digit?(range_start.text)
-                          @compound_token.dup << range_start
-                        else
-                          [range_start]
-                        end
-          range_end = [range_end]
-          range_end.concat(pop_octal_digits(expressions)) if escaped_octal?(range_end.first)
-          [range_start, range_end]
-        end
-
-        def escaped_octal?(expr)
-          expr.text.valid_encoding? && expr.text =~ /^\\[0-7]$/
-        end
-
-        def octal_digit?(char)
-          ('0'..'7').cover?(char)
-        end
-
-        def pop_octal_digits(expressions)
-          digits = []
-
-          2.times do
-            next unless (next_child = expressions.first)
-            next unless next_child.type == :literal && next_child.text =~ /^[0-7]$/
-
-            digits << expressions.shift
-          end
-
-          digits
-        end
-      end
-    end
-  end
-end

data/lib/ruby_lsp/rubocop/wraps_built_in_lsp_runtime.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../rubocop/lsp/runtime'
-
-module RubyLsp
-  module RuboCop
-    # Wrap RuboCop's built-in runtime for Ruby LSP's add-on.
-    class WrapsBuiltinLspRuntime
-      include RubyLsp::Requests::Support::Formatter
-
-      def initialize
-        init!
-      end
-
-      def init!
-        config = ::RuboCop::ConfigStore.new
-
-        @runtime = ::RuboCop::LSP::Runtime.new(config)
-      end
-
-      def run_diagnostic(uri, document)
-        @runtime.offenses(uri_to_path(uri), document.source, document.encoding)
-      end
-
-      def run_formatting(uri, document)
-        @runtime.format(uri_to_path(uri), document.source, command: 'rubocop.formatAutocorrects')
-      end
-
-      def run_range_formatting(_uri, _partial_source, _base_indentation)
-        # Not yet supported. Should return the formatted version of `partial_source` which is
-        # a partial selection of the entire document. For example, it should not try to add
-        # a frozen_string_literal magic comment and all style corrections should start from
-        # the `base_indentation`.
-        nil
-      end
-
-      private
-
-      # duplicated from: lib/standard/lsp/routes.rb
-      # modified to incorporate Ruby LSP's to_standardized_path method
-      def uri_to_path(uri)
-        if uri.respond_to?(:to_standardized_path) && (standardized_path = uri.to_standardized_path)
-          standardized_path
-        else
-          uri.to_s.delete_prefix('file://')
-        end
-      end
-    end
-  end
-end