super-pro-sys 0.0.1

data/rubocop-1.88.1/lib/rubocop/lsp/disable_comment_edits.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module LSP
+    # Builds LSP text edits for rubocop:disable comments.
+    # @api private
+    class DisableCommentEdits
+      def initialize(offense:, document_encoding:, processed_source:)
+        @offense = offense
+        @document_encoding = document_encoding
+        @processed_source = processed_source
+      end
+
+      def edits
+        literal_range = multiline_literal_range
+        return block_disable_comments(literal_range) if literal_range
+
+        inline_disable_comment
+      end
+
+      private
+
+      def inline_disable_comment
+        eol = position(@offense.line - 1, @offense.source_line.length, @offense.source_line)
+        [text_edit(eol, inline_comment_text)]
+      end
+
+      def inline_comment_text
+        if @offense.source_line.include?(' # rubocop:disable ')
+          ",#{@offense.cop_name}"
+        else
+          " # rubocop:disable #{@offense.cop_name}"
+        end
+      end
+
+      def block_disable_comments(range)
+        full_line_range = range_by_lines(range)
+        leading_whitespace = full_line_range.source_line[/^\s*/].to_s
+        [
+          disable_edit(full_line_range.first_line, leading_whitespace),
+          enable_edit(full_line_range, leading_whitespace)
+        ]
+      end
+
+      def disable_edit(first_line, leading_whitespace)
+        position = position(first_line - 1, 0, '')
+        text_edit(position, "#{leading_whitespace}# rubocop:disable #{@offense.cop_name}\n")
+      end
+
+      def enable_edit(full_line_range, leading_whitespace)
+        last_line = full_line_range.last_line
+        last_line_text = full_line_range.source_buffer.source_line(last_line)
+        position = position(last_line - 1, last_line_text.length, last_line_text)
+        text_edit(position, "\n#{leading_whitespace}# rubocop:enable #{@offense.cop_name}")
+      end
+
+      def text_edit(position, new_text)
+        range = LanguageServer::Protocol::Interface::Range.new(start: position, end: position)
+        LanguageServer::Protocol::Interface::TextEdit.new(range: range, new_text: new_text)
+      end
+
+      def position(line, utf8_index, line_text)
+        LanguageServer::Protocol::Interface::Position.new(
+          line: line,
+          character: position_character(utf8_index, line_text)
+        )
+      end
+
+      def position_character(utf8_index, line_text)
+        str = line_text[0, utf8_index]
+        if @document_encoding == Encoding::UTF_16LE || @document_encoding.nil?
+          str.length + str.b.count("\xf0-\xff".b)
+        else
+          str.length
+        end
+      end
+
+      def multiline_literal_range
+        return unless @processed_source&.ast
+
+        offense_range = @offense.location
+        multiline_ranges&.find do |range|
+          eol_comment_would_be_inside_literal?(offense_range, range)
+        end
+      end
+
+      def multiline_ranges
+        @processed_source.ast.each_node.filter_map do |node|
+          if surrounding_heredoc?(node)
+            heredoc_range(node)
+          elsif string_continuation?(node)
+            range_by_lines(node.source_range)
+          elsif surrounding_percent_array?(node) || multiline_string?(node)
+            node.source_range
+          end
+        end
+      end
+
+      def eol_comment_would_be_inside_literal?(offense_range, literal_range)
+        offense_line = offense_range.line
+        offense_line >= literal_range.first_line && offense_line < literal_range.last_line
+      end
+
+      def surrounding_heredoc?(node)
+        node.any_str_type? && node.heredoc?
+      end
+
+      def heredoc_range(node)
+        node.source_range.join(node.loc.heredoc_end)
+      end
+
+      def surrounding_percent_array?(node)
+        node.array_type? && node.percent_literal?
+      end
+
+      def string_continuation?(node)
+        node.any_str_type? && node.source.match?(/\\\s*$/)
+      end
+
+      def multiline_string?(node)
+        node.dstr_type? && node.multiline?
+      end
+
+      def range_by_lines(range)
+        begin_of_first_line = range.begin_pos - range.column
+
+        last_line = range.source_buffer.source_line(range.last_line)
+        last_line_offset = last_line.length - range.last_column
+        end_of_last_line = range.end_pos + last_line_offset
+
+        Parser::Source::Range.new(range.source_buffer, begin_of_first_line, end_of_last_line)
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/lsp/logger.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+#
+# This code is based on https://github.com/standardrb/standard.
+#
+# Copyright (c) 2023 Test Double, Inc.
+#
+# The MIT License (MIT)
+#
+# https://github.com/standardrb/standard/blob/main/LICENSE.txt
+#
+module RuboCop
+  module LSP
+    # Log for Language Server Protocol of RuboCop.
+    # @api private
+    class Logger
+      def self.log(message, prefix: '[server]')
+        warn("#{prefix} #{message}")
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/lsp/routes.rb

@@ -0,0 +1,263 @@
+# frozen_string_literal: true
+
+require_relative 'severity'
+
+#
+# This code is based on https://github.com/standardrb/standard.
+#
+# Copyright (c) 2023 Test Double, Inc.
+#
+# The MIT License (MIT)
+#
+# https://github.com/standardrb/standard/blob/main/LICENSE.txt
+#
+module RuboCop
+  module LSP
+    # Routes for Language Server Protocol of RuboCop.
+    # @api private
+    class Routes
+      CONFIGURATION_FILE_PATTERNS = [
+        RuboCop::ConfigFinder::DOTFILE,
+        RuboCop::CLI::Command::AutoGenerateConfig::AUTO_GENERATED_FILE
+      ].freeze
+
+      def self.handle(name, &block)
+        define_method(:"handle_#{name}", &block)
+      end
+
+      private_class_method :handle
+
+      def initialize(server)
+        @server = server
+
+        @text_cache = {}
+      end
+
+      def for(name)
+        name = "handle_#{name}"
+        return unless respond_to?(name)
+
+        method(name)
+      end
+
+      handle 'initialize' do |request|
+        initialization_options = extract_initialization_options_from(request)
+
+        @server.configure(initialization_options)
+
+        @server.write(
+          id: request[:id],
+          result: LanguageServer::Protocol::Interface::InitializeResult.new(
+            capabilities: LanguageServer::Protocol::Interface::ServerCapabilities.new(
+              document_formatting_provider: true,
+              text_document_sync: LanguageServer::Protocol::Interface::TextDocumentSyncOptions.new(
+                change: LanguageServer::Protocol::Constant::TextDocumentSyncKind::INCREMENTAL,
+                open_close: true
+              )
+            )
+          )
+        )
+      end
+
+      handle 'initialized' do |_request|
+        version = RuboCop::Version::STRING
+        # Only one JIT can be enabled at the same time, since YJIT and ZJIT are mutually exclusive.
+        jit = if Object.const_defined?('RubyVM::YJIT') && RubyVM::YJIT.enabled?
+                '+YJIT'
+              elsif Object.const_defined?('RubyVM::ZJIT') && RubyVM::ZJIT.enabled?
+                '+ZJIT'
+              else
+                ''
+              end
+
+        Logger.log("RuboCop #{version} language server#{jit} initialized, PID #{Process.pid}")
+      end
+
+      handle 'shutdown' do |request|
+        Logger.log('Client asked to shutdown RuboCop language server.')
+        @server.stop do
+          @server.write(id: request[:id], result: nil)
+          Logger.log('Exiting...')
+        end
+      end
+
+      handle 'textDocument/didChange' do |request|
+        params = request[:params]
+        file_uri = params[:textDocument][:uri]
+        text = @text_cache[file_uri]
+        params[:contentChanges].each do |content|
+          text = change_text(text, content[:text], content[:range])
+        end
+        result = diagnostic(file_uri, text)
+        @server.write(result)
+      end
+
+      handle 'textDocument/didOpen' do |request|
+        doc = request[:params][:textDocument]
+        result = diagnostic(doc[:uri], doc[:text])
+        @server.write(result)
+      end
+
+      handle 'textDocument/didClose' do |request|
+        @text_cache.delete(request.dig(:params, :textDocument, :uri))
+      end
+
+      handle 'textDocument/formatting' do |request|
+        uri = request[:params][:textDocument][:uri]
+        @server.write(id: request[:id], result: format_file(uri))
+      end
+
+      handle 'workspace/didChangeConfiguration' do |_request|
+        Logger.log('Ignoring workspace/didChangeConfiguration')
+      end
+
+      handle 'workspace/didChangeWatchedFiles' do |request|
+        changed = request[:params][:changes].any? do |change|
+          CONFIGURATION_FILE_PATTERNS.any? { |path| change[:uri].end_with?(path) }
+        end
+
+        if changed
+          Logger.log('Configuration file changed; restart required')
+          @server.stop
+        end
+      end
+
+      handle 'workspace/executeCommand' do |request|
+        case (command = request[:params][:command])
+        when 'rubocop.formatAutocorrects'
+          label = 'Format with RuboCop autocorrects'
+        when 'rubocop.formatAutocorrectsAll'
+          label = 'Format all with RuboCop autocorrects'
+        else
+          handle_unsupported_method(request, command)
+          return
+        end
+
+        uri = request[:params][:arguments][0][:uri]
+        formatted = nil
+
+        # The `workspace/executeCommand` is an LSP method triggered by intentional user actions,
+        # so the user's intention for autocorrection is respected.
+        LSP.disable { formatted = format_file(uri, command: command) }
+
+        @server.write(
+          id: request[:id],
+          method: 'workspace/applyEdit',
+          params: {
+            label: label,
+            edit: {
+              changes: {
+                uri => formatted
+              }
+            }
+          }
+        )
+      end
+
+      handle 'textDocument/willSave' do |_request|
+        # Nothing to do
+      end
+
+      handle 'textDocument/didSave' do |_request|
+        # Nothing to do
+      end
+
+      handle '$/cancelRequest' do |_request|
+        # Can't cancel anything because single-threaded
+      end
+
+      handle '$/setTrace' do |_request|
+        # No-op, we log everything
+      end
+
+      def handle_unsupported_method(request, method = request[:method])
+        @server.write(
+          id: request[:id],
+          error: LanguageServer::Protocol::Interface::ResponseError.new(
+            code: LanguageServer::Protocol::Constant::ErrorCodes::METHOD_NOT_FOUND,
+            message: "Unsupported Method: #{method}"
+          )
+        )
+        Logger.log("Unsupported Method: #{method}")
+      end
+
+      def handle_method_missing(request)
+        return unless request.key?(:id)
+
+        @server.write(id: request[:id], result: nil)
+      end
+
+      private
+
+      def extract_initialization_options_from(request)
+        safe_autocorrect = request.dig(:params, :initializationOptions, :safeAutocorrect)
+
+        {
+          safe_autocorrect: safe_autocorrect.nil? || safe_autocorrect == true,
+          lint_mode: request.dig(:params, :initializationOptions, :lintMode) == true,
+          layout_mode: request.dig(:params, :initializationOptions, :layoutMode) == true
+        }
+      end
+
+      def format_file(file_uri, command: nil)
+        unless (text = @text_cache[file_uri])
+          Logger.log("Format request arrived before text synchronized; skipping: `#{file_uri}'")
+
+          return []
+        end
+
+        new_text = @server.format(convert_file_uri_to_path(file_uri), text, command: command)
+
+        return [] if new_text == text
+
+        [{
+          newText: new_text,
+          range: {
+            start: { line: 0, character: 0 },
+            end: { line: text.count("\n") + 1, character: 0 }
+          }
+        }]
+      end
+
+      def diagnostic(file_uri, text)
+        @text_cache[file_uri] = text
+
+        {
+          method: 'textDocument/publishDiagnostics',
+          params: {
+            uri: file_uri,
+            diagnostics: @server.offenses(convert_file_uri_to_path(file_uri), text)
+          }
+        }
+      end
+
+      def change_text(orig_text, text, range)
+        return text unless range
+
+        start_pos = text_pos(orig_text, range[:start])
+        end_pos = text_pos(orig_text, range[:end])
+        text_bin = orig_text.b
+        text_bin[start_pos...end_pos] = text.b
+        text_bin.force_encoding(orig_text.encoding)
+      end
+
+      def text_pos(text, range)
+        line = range[:line]
+        char = range[:character]
+        pos = 0
+        text.each_line.with_index do |l, i|
+          if i == line
+            pos += l.encode('utf-16be').b[0, char * 2].encode('utf-8', 'utf-16be').bytesize
+            return pos
+          end
+          pos += l.bytesize
+        end
+        pos
+      end
+
+      def convert_file_uri_to_path(uri)
+        URI.decode_www_form_component(uri.delete_prefix('file://'))
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/lsp/runtime.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative 'diagnostic'
+require_relative 'stdin_runner'
+
+#
+# This code is based on https://github.com/standardrb/standard.
+#
+# Copyright (c) 2023 Test Double, Inc.
+#
+# The MIT License (MIT)
+#
+# https://github.com/standardrb/standard/blob/main/LICENSE.txt
+#
+module RuboCop
+  module LSP
+    # Runtime for Language Server Protocol of RuboCop.
+    # @api private
+    class Runtime
+      attr_writer :safe_autocorrect, :lint_mode, :layout_mode
+
+      def initialize(config_store)
+        RuboCop::LSP.enable
+
+        @runner = RuboCop::Lsp::StdinRunner.new(config_store)
+
+        @safe_autocorrect = true
+        @lint_mode = false
+        @layout_mode = false
+      end
+
+      def format(path, text, command:, prism_result: nil)
+        safe_autocorrect = if command
+                             command == 'rubocop.formatAutocorrects'
+                           else
+                             @safe_autocorrect
+                           end
+
+        formatting_options = { autocorrect: true, safe_autocorrect: safe_autocorrect }
+        formatting_options[:only] = config_only_options if @lint_mode || @layout_mode
+
+        @runner.run(path, text, formatting_options, prism_result: prism_result)
+        @runner.formatted_source
+      end
+
+      def offenses(path, text, document_encoding = nil, prism_result: nil)
+        diagnostic_options = {}
+        diagnostic_options[:only] = config_only_options if @lint_mode || @layout_mode
+
+        @runner.run(path, text, diagnostic_options, prism_result: prism_result)
+        processed_source = @runner.processed_source
+        config = @runner.config_for_working_directory
+        @runner.offenses.map do |offense|
+          build_diagnostic(offense, path, document_encoding, processed_source, config)
+        end
+      end
+
+      private
+
+      def build_diagnostic(offense, path, document_encoding, processed_source, config)
+        Diagnostic.new(
+          document_encoding,
+          offense,
+          path,
+          RuboCop::Cop::Registry.global.find_by_cop_name(offense.cop_name),
+          processed_source
+        ).to_lsp_diagnostic(config)
+      end
+
+      def config_only_options
+        only_options = []
+        only_options << 'Lint' if @lint_mode
+        only_options << 'Layout' if @layout_mode
+        only_options
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/lsp/server.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'language_server-protocol'
+require_relative 'logger'
+require_relative 'routes'
+require_relative 'runtime'
+
+#
+# This code is based on https://github.com/standardrb/standard.
+#
+# Copyright (c) 2023 Test Double, Inc.
+#
+# The MIT License (MIT)
+#
+# https://github.com/standardrb/standard/blob/main/LICENSE.txt
+#
+module RuboCop
+  module LSP
+    # Language Server Protocol of RuboCop.
+    # @api private
+    class Server
+      def initialize(config_store)
+        $PROGRAM_NAME = "rubocop --lsp #{ConfigFinder.project_root}"
+
+        @reader = LanguageServer::Protocol::Transport::Io::Reader.new($stdin)
+        @writer = LanguageServer::Protocol::Transport::Io::Writer.new($stdout)
+        @runtime = RuboCop::LSP::Runtime.new(config_store)
+        @routes = Routes.new(self)
+      end
+
+      def start
+        @reader.read do |request|
+          if !request.key?(:method)
+            @routes.handle_method_missing(request)
+          elsif (route = @routes.for(request[:method]))
+            route.call(request)
+          else
+            @routes.handle_unsupported_method(request)
+          end
+        rescue StandardError => e
+          Logger.log("Error #{e.class} #{e.message[0..100]}")
+          Logger.log(e.backtrace.inspect)
+        end
+      end
+
+      def write(response)
+        @writer.write(response)
+      end
+
+      def format(path, text, command:)
+        @runtime.format(path, text, command: command)
+      end
+
+      def offenses(path, text)
+        @runtime.offenses(path, text)
+      end
+
+      def configure(options)
+        @runtime.safe_autocorrect = options[:safe_autocorrect]
+        @runtime.lint_mode = options[:lint_mode]
+        @runtime.layout_mode = options[:layout_mode]
+      end
+
+      def stop(&block)
+        at_exit(&block) if block
+        exit
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/lsp/severity.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module LSP
+    # Severity for Language Server Protocol of RuboCop.
+    # @api private
+    class Severity
+      SEVERITIES = {
+        fatal: LanguageServer::Protocol::Constant::DiagnosticSeverity::ERROR,
+        error: LanguageServer::Protocol::Constant::DiagnosticSeverity::ERROR,
+        warning: LanguageServer::Protocol::Constant::DiagnosticSeverity::WARNING,
+        convention: LanguageServer::Protocol::Constant::DiagnosticSeverity::INFORMATION,
+        refactor: LanguageServer::Protocol::Constant::DiagnosticSeverity::HINT,
+        info: LanguageServer::Protocol::Constant::DiagnosticSeverity::HINT
+      }.freeze
+
+      def self.find_by(rubocop_severity)
+        if (severity = SEVERITIES[rubocop_severity.to_sym])
+          return severity
+        end
+
+        Logger.log("Unknown severity: #{rubocop_severity}")
+        LanguageServer::Protocol::Constant::DiagnosticSeverity::HINT
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/lsp/stdin_runner.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+#
+# This code is based on https://github.com/standardrb/standard.
+#
+# Copyright (c) 2023 Test Double, Inc.
+#
+# The MIT License (MIT)
+#
+# https://github.com/standardrb/standard/blob/main/LICENSE.txt
+#
+module RuboCop
+  module Lsp
+    # Originally lifted from:
+    # https://github.com/Shopify/ruby-lsp/blob/8d4c17efce4e8ecc8e7c557ab2981db6b22c0b6d/lib/ruby_lsp/requests/support/rubocop_runner.rb#L20
+    # @api private
+    class StdinRunner < RuboCop::Runner
+      class ConfigurationError < StandardError; end
+
+      attr_reader :offenses, :config_for_working_directory, :processed_source
+
+      DEFAULT_RUBOCOP_OPTIONS = {
+        stderr: true,
+        force_exclusion: true,
+        formatters: ['RuboCop::Formatter::BaseFormatter'],
+        raise_cop_error: true,
+        todo_file: nil,
+        todo_ignore_files: []
+      }.freeze
+
+      def initialize(config_store)
+        @options = {}
+
+        @offenses = []
+        @warnings = []
+        @errors = []
+
+        @config_for_working_directory = config_store.for_pwd
+
+        super(@options, config_store)
+      end
+
+      def run(path, contents, options, prism_result: nil)
+        @options = options.merge(DEFAULT_RUBOCOP_OPTIONS)
+        @options[:stdin] = contents
+
+        @prism_result = prism_result
+        @processed_source = nil
+
+        @offenses = []
+        @warnings = []
+        @errors = []
+
+        super([path])
+
+        raise Interrupt if aborting?
+      end
+
+      def formatted_source
+        @options[:stdin]
+      end
+
+      private
+
+      def file_finished(_file, offenses)
+        @offenses = offenses
+      end
+
+      def do_inspection_loop(file)
+        source, offenses = super
+        @processed_source = source
+        [source, offenses]
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/lsp.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # The RuboCop's built-in LSP module.
+  module LSP
+    module_function
+
+    # Returns true when LSP is enabled, false when disabled.
+    #
+    # @return [Boolean]
+    def enabled?
+      @enabled ||= false
+    end
+
+    # Enable LSP.
+    #
+    # @return [void]
+    def enable
+      @enabled = true
+    end
+
+    # Disable LSP.
+    #
+    # @return [void]
+    def disable(&block)
+      if block
+        original = @enabled
+        @enabled = false
+        yield
+        @enabled = original
+      else
+        @enabled = false
+      end
+    end
+  end
+end