lightning_ui_kit 0.3.5 → 0.4.1

data/vendor/bundle/ruby/3.4.0/gems/rubocop-1.82.1/lib/rubocop/lsp/diagnostic.rb

@@ -1,185 +0,0 @@
-# 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
-    # Diagnostic for Language Server Protocol of RuboCop.
-    # @api private
-    class Diagnostic
-      def initialize(document_encoding, offense, uri, cop_class)
-        @document_encoding = document_encoding
-        @offense = offense
-        @uri = uri
-        @cop_class = cop_class
-      end
-
-      def to_lsp_code_actions
-        code_actions = []
-
-        code_actions << autocorrect_action if correctable?
-        code_actions << disable_line_action
-
-        code_actions
-      end
-
-      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-      def to_lsp_diagnostic(config)
-        highlighted = @offense.highlighted_area
-
-        LanguageServer::Protocol::Interface::Diagnostic.new(
-          message: message,
-          source: 'RuboCop',
-          code: @offense.cop_name,
-          code_description: code_description(config),
-          severity: severity,
-          range: LanguageServer::Protocol::Interface::Range.new(
-            start: LanguageServer::Protocol::Interface::Position.new(
-              line: @offense.line - 1,
-              character: to_position_character(highlighted.begin_pos)
-            ),
-            end: LanguageServer::Protocol::Interface::Position.new(
-              line: @offense.line - 1,
-              character: to_position_character(highlighted.end_pos)
-            )
-          ),
-          data: {
-            correctable: correctable?,
-            code_actions: to_lsp_code_actions
-          }
-        )
-      end
-      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
-
-      private
-
-      def message
-        message = @offense.message
-        message += "\n\nThis offense is not autocorrectable.\n" unless correctable?
-        message
-      end
-
-      def severity
-        Severity.find_by(@offense.severity.name)
-      end
-
-      def code_description(config)
-        return unless @cop_class
-        return unless (doc_url = @cop_class.documentation_url(config))
-
-        LanguageServer::Protocol::Interface::CodeDescription.new(href: doc_url)
-      end
-
-      # rubocop:disable Metrics/MethodLength
-      def autocorrect_action
-        LanguageServer::Protocol::Interface::CodeAction.new(
-          title: "Autocorrect #{@offense.cop_name}",
-          kind: LanguageServer::Protocol::Constant::CodeActionKind::QUICK_FIX,
-          edit: LanguageServer::Protocol::Interface::WorkspaceEdit.new(
-            document_changes: [
-              LanguageServer::Protocol::Interface::TextDocumentEdit.new(
-                text_document: LanguageServer::Protocol::Interface::OptionalVersionedTextDocumentIdentifier.new(
-                  uri: ensure_uri_scheme(@uri.to_s).to_s,
-                  version: nil
-                ),
-                edits: correctable? ? offense_replacements : []
-              )
-            ]
-          ),
-          is_preferred: true
-        )
-      end
-      # rubocop:enable Metrics/MethodLength
-
-      # rubocop:disable Metrics/MethodLength
-      def offense_replacements
-        @offense.corrector.as_replacements.map do |range, replacement|
-          LanguageServer::Protocol::Interface::TextEdit.new(
-            range: LanguageServer::Protocol::Interface::Range.new(
-              start: LanguageServer::Protocol::Interface::Position.new(
-                line: range.line - 1,
-                character: to_position_character(range.column)
-              ),
-              end: LanguageServer::Protocol::Interface::Position.new(
-                line: range.last_line - 1,
-                character: to_position_character(range.last_column)
-              )
-            ),
-            new_text: replacement
-          )
-        end
-      end
-      # rubocop:enable Metrics/MethodLength
-
-      # rubocop:disable Metrics/MethodLength
-      def disable_line_action
-        LanguageServer::Protocol::Interface::CodeAction.new(
-          title: "Disable #{@offense.cop_name} for this line",
-          kind: LanguageServer::Protocol::Constant::CodeActionKind::QUICK_FIX,
-          edit: LanguageServer::Protocol::Interface::WorkspaceEdit.new(
-            document_changes: [
-              LanguageServer::Protocol::Interface::TextDocumentEdit.new(
-                text_document: LanguageServer::Protocol::Interface::OptionalVersionedTextDocumentIdentifier.new(
-                  uri: ensure_uri_scheme(@uri.to_s).to_s,
-                  version: nil
-                ),
-                edits: line_disable_comment
-              )
-            ]
-          )
-        )
-      end
-      # rubocop:enable Metrics/MethodLength
-
-      def line_disable_comment
-        new_text = if @offense.source_line.include?(' # rubocop:disable ')
-                     ",#{@offense.cop_name}"
-                   else
-                     " # rubocop:disable #{@offense.cop_name}"
-                   end
-
-        eol = LanguageServer::Protocol::Interface::Position.new(
-          line: @offense.line - 1,
-          character: to_position_character(@offense.source_line.length)
-        )
-
-        # TODO: fails for multiline strings - may be preferable to use block
-        # comments to disable some offenses
-        inline_comment = LanguageServer::Protocol::Interface::TextEdit.new(
-          range: LanguageServer::Protocol::Interface::Range.new(start: eol, end: eol),
-          new_text: new_text
-        )
-
-        [inline_comment]
-      end
-
-      def to_position_character(utf8_index)
-        str = @offense.source_line[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 correctable?
-        !@offense.corrector.nil?
-      end
-
-      def ensure_uri_scheme(uri)
-        uri = URI.parse(uri)
-        uri.scheme = 'file' if uri.scheme.nil?
-        uri
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.4.0/gems/rubocop-1.82.1/lib/rubocop/lsp/routes.rb

@@ -1,256 +0,0 @@
-# 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
-        yjit = Object.const_defined?('RubyVM::YJIT') && RubyVM::YJIT.enabled? ? ' +YJIT' : ''
-
-        Logger.log("RuboCop #{version} language server#{yjit} 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/vendor/bundle/ruby/3.4.0/gems/rubocop-1.82.1/lib/rubocop/lsp/runtime.rb

@@ -1,69 +0,0 @@
-# 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)
-        @cop_registry = RuboCop::Cop::Registry.global.to_h
-
-        @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)
-        @runner.offenses.map do |offense|
-          Diagnostic.new(
-            document_encoding, offense, path, @cop_registry[offense.cop_name]&.first
-          ).to_lsp_diagnostic(@runner.config_for_working_directory)
-        end
-      end
-
-      private
-
-      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/vendor/bundle/ruby/3.4.0/gems/rubocop-1.82.1/lib/rubocop/lsp/stdin_runner.rb

@@ -1,69 +0,0 @@
-# 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
-
-      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
-
-        @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
-    end
-  end
-end

data/vendor/bundle/ruby/3.4.0/gems/rubocop-1.82.1/lib/rubocop/remote_config.rb

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-require 'net/http'
-require 'time'
-
-module RuboCop
-  # Common methods and behaviors for dealing with remote config files.
-  # @api private
-  class RemoteConfig
-    attr_reader :uri
-
-    CACHE_LIFETIME = 24 * 60 * 60
-
-    def initialize(url, cache_root)
-      begin
-        @uri = URI.parse(url)
-      rescue URI::InvalidURIError
-        raise ConfigNotFoundError, "Failed to resolve configuration: '#{url}' is not a valid URI"
-      end
-      @cache_root = cache_root
-    end
-
-    def file
-      return cache_path unless cache_path_expired?
-
-      request do |response|
-        next if response.is_a?(Net::HTTPNotModified)
-        next if response.is_a?(SocketError)
-
-        FileUtils.mkdir_p(File.dirname(cache_path))
-        File.write(cache_path, response.body)
-      end
-
-      cache_path
-    end
-
-    def inherit_from_remote(file)
-      new_uri = @uri.dup
-      new_uri.path.gsub!(%r{/[^/]*$}, "/#{file.delete_prefix('./')}")
-      RemoteConfig.new(new_uri.to_s, @cache_root)
-    end
-
-    private
-
-    def request(uri = @uri, limit = 10, &block)
-      raise ArgumentError, 'HTTP redirect too deep' if limit.zero?
-
-      http = Net::HTTP.new(uri.hostname, uri.port)
-      http.use_ssl = uri.instance_of?(URI::HTTPS)
-
-      generate_request(uri) do |request|
-        handle_response(http.request(request), limit, &block)
-      rescue SocketError => e
-        handle_response(e, limit, &block)
-      end
-    end
-
-    def generate_request(uri)
-      request = Net::HTTP::Get.new(uri.request_uri)
-
-      request.basic_auth(uri.user, uri.password) if uri.user
-      request['If-Modified-Since'] = File.stat(cache_path).mtime.rfc2822 if cache_path_exists?
-
-      yield request
-    end
-
-    def handle_response(response, limit, &block)
-      case response
-      when Net::HTTPSuccess, Net::HTTPNotModified, SocketError
-        yield response
-      when Net::HTTPRedirection
-        request(URI.parse(response['location']), limit - 1, &block)
-      else
-        begin
-          response.error!
-        rescue StandardError => e
-          message = "#{e.message} while downloading remote config file #{cloned_url}"
-          raise e, message
-        end
-      end
-    end
-
-    def cache_path
-      @cache_path ||= File.expand_path(".rubocop-remote-#{cache_name_from_uri}", @cache_root)
-    end
-
-    def cache_path_exists?
-      @cache_path_exists ||= File.exist?(cache_path)
-    end
-
-    def cache_path_expired?
-      return true unless cache_path_exists?
-
-      @cache_path_expired ||= begin
-        file_age = (Time.now - File.stat(cache_path).mtime).to_f
-        (file_age / CACHE_LIFETIME) > 1
-      end
-    end
-
-    def cache_name_from_uri
-      "#{Digest::MD5.hexdigest(@uri.to_s)}.yml"
-    end
-
-    def cloned_url
-      uri = @uri.clone
-      uri.user = nil if uri.user
-      uri.password = nil if uri.password
-      uri
-    end
-  end
-end