klenod-lsp 0.0.15

data/lib/klenod/lsp/symbols.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require "language_server-protocol"
+
+require "klenod/build/plugins/haml_plugin"
+
+require_relative "languages/imports"
+require_relative "text"
+
+module Klenod
+  module LSP
+    # Outlines for documents and name search across the indexed graph.
+    module Symbols
+      Interface = LanguageServer::Protocol::Interface
+      Constant = LanguageServer::Protocol::Constant
+
+      COMPONENT_TAG = /%(?<name>[A-Z][A-Za-z0-9_:]*)/
+      ELEMENT_TAG = /%(?<name>[a-z][A-Za-z0-9_-]*)/
+      METHOD = /\A\s*def\s+(?<name>(?:self\.)?[A-Za-z_][A-Za-z0-9_]*[?!=]?)/
+      WORKSPACE_LIMIT = 200
+
+      module_function
+
+      # The outline of a Haml component: constants and methods from the
+      # leading `:ruby` filter, then the tag tree. Script lines such as
+      # `- if` are transparent, so their children appear at the same level.
+      def haml_document_symbols(source)
+        lines = source.lines(chomp: true)
+        root = Klenod::Build::Plugins::HamlPlugin.parse_haml(source)
+        symbols_for_nodes(root.children, lines)
+      rescue Klenod::Build::Error
+        []
+      end
+
+      # Constants bound to imports, for Ruby modules.
+      def binding_symbols(source)
+        lines = source.lines(chomp: true)
+        symbols = []
+        lines.each_with_index do |line_text, index|
+          Text.each_match(line_text, index, Languages::Imports::BINDING, group: :name) do |match, span|
+            symbols << symbol(match[:name], Constant::SymbolKind::CONSTANT, Text.line_span(lines, index), span, detail: match[:specifier])
+          end
+        end
+        symbols
+      end
+
+      # Modules under the source directory whose name or path matches the
+      # query, as SymbolInformation so every client can show them.
+      def workspace_symbols(query, index, workspace)
+        needle = query.to_s.downcase
+        matches = []
+
+        index.records.each_key do |module_id|
+          next unless module_id.scheme == :app && GraphIndex::ROOT_EXTENSIONS.include?(module_id.extname)
+
+          relative = module_id.relative_path
+          stylesheet = module_id.extname == ".css"
+          name = stylesheet ? File.basename(relative) : File.basename(relative, module_id.extname)
+          next unless needle.empty? || fuzzy_match?(name.downcase, needle) || relative.downcase.include?(needle)
+
+          uri = workspace.uri_for_module_id(module_id)
+          next unless uri
+
+          matches << Interface::SymbolInformation.new(
+            name: name,
+            kind: symbol_kind(module_id),
+            location: Interface::Location.new(uri: uri, range: Text.zero_range),
+            container_name: File.dirname(relative)
+          )
+        end
+
+        matches.sort_by { |symbol| [symbol.name.downcase, symbol.container_name] }.first(WORKSPACE_LIMIT)
+      end
+
+      def symbol_kind(module_id)
+        case module_id.extname
+        when ".haml" then Constant::SymbolKind::CLASS
+        when ".css" then Constant::SymbolKind::FILE
+        else Constant::SymbolKind::MODULE
+        end
+      end
+
+      def symbols_for_nodes(nodes, lines)
+        nodes.flat_map do |node|
+          case node.type
+          when :tag
+            [tag_symbol(node, lines)]
+          when :filter
+            (node.value[:name] == "ruby") ? ruby_filter_symbols(node, lines) : []
+          when :script, :silent_script
+            symbols_for_nodes(node.children, lines)
+          else
+            []
+          end
+        end
+      end
+
+      def tag_symbol(node, lines)
+        name = node.value.fetch(:name)
+        line_index = node.line - 1
+        component = name.match?(/\A[A-Z]/)
+        span = tag_span(lines[line_index].to_s, line_index, component ? COMPONENT_TAG : ELEMENT_TAG, name)
+
+        symbol(
+          "%#{name}",
+          component ? Constant::SymbolKind::CLASS : Constant::SymbolKind::FIELD,
+          Text::Span.new(line_index, 0, 0).with(line: line_index),
+          span,
+          range_end: last_line(node),
+          children: symbols_for_nodes(node.children, lines),
+          lines: lines
+        )
+      end
+
+      def ruby_filter_symbols(node, lines)
+        symbols = []
+        node.value.fetch(:text).to_s.each_line.with_index(node.line) do |text, line_index|
+          if (match = Languages::Imports::BINDING.match(text))
+            Text.each_match(lines[line_index].to_s, line_index, Languages::Imports::BINDING, group: :name) do |_match, span|
+              symbols << symbol(match[:name], Constant::SymbolKind::CONSTANT, Text.line_span(lines, line_index), span, detail: match[:specifier])
+            end
+          elsif (match = METHOD.match(text))
+            Text.each_match(lines[line_index].to_s, line_index, METHOD, group: :name) do |_match, span|
+              symbols << symbol(match[:name], Constant::SymbolKind::METHOD, Text.line_span(lines, line_index), span)
+            end
+          end
+        end
+        symbols
+      end
+
+      def tag_span(line_text, line_index, pattern, name)
+        Text.each_match(line_text, line_index, pattern, group: :name) do |match, span|
+          return span if match[:name] == name
+        end
+
+        Text.line_span([line_text], 0).with(line: line_index)
+      end
+
+      def last_line(node)
+        [node.line, *node.children.map { |child| last_line(child) }].max
+      end
+
+      def symbol(name, kind, full_span, selection_span, detail: nil, range_end: nil, children: nil, lines: nil)
+        range =
+          if range_end
+            end_index = range_end - 1
+            Interface::Range.new(
+              start: Interface::Position.new(line: full_span.line, character: 0),
+              end: Interface::Position.new(line: end_index, character: lines[end_index].to_s.length)
+            )
+          else
+            full_span.to_range
+          end
+
+        Interface::DocumentSymbol.new(
+          name: name,
+          detail: detail,
+          kind: kind,
+          range: range,
+          selection_range: selection_span.to_range,
+          children: (children.nil? || children.empty?) ? nil : children
+        )
+      end
+
+      def fuzzy_match?(name, needle)
+        position = 0
+        needle.each_char do |char|
+          position = name.index(char, position)
+          return false unless position
+
+          position += 1
+        end
+        true
+      end
+    end
+  end
+end

data/lib/klenod/lsp/text.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "language_server-protocol"
+
+module Klenod
+  module LSP
+    # Line and character arithmetic shared by every language handler.
+    #
+    # Klenod's parsers report lines but not columns, so character ranges are
+    # recovered by scanning the original line text. Characters are counted as
+    # Ruby characters, which matches LSP's UTF-16 encoding for every character
+    # in the Basic Multilingual Plane.
+    module Text
+      Interface = LanguageServer::Protocol::Interface
+
+      Position = Data.define(:line, :character)
+
+      Span = Data.define(:line, :start_character, :end_character) do
+        # Cursor positions directly after the last character count as inside,
+        # which is where an editor places the caret at the end of a word.
+        def include?(position)
+          position.line == line && position.character.between?(start_character, end_character)
+        end
+
+        def to_range
+          Interface::Range.new(
+            start: Interface::Position.new(line: line, character: start_character),
+            end: Interface::Position.new(line: line, character: end_character)
+          )
+        end
+      end
+
+      module_function
+
+      def each_match(line_text, line_index, regex, group:)
+        offset = 0
+        while (match = regex.match(line_text, offset))
+          start_character = match.begin(group)
+          end_character = match.end(group)
+          yield match, Span.new(line_index, start_character, end_character)
+          offset = [match.end(0), offset + 1].max
+        end
+      end
+
+      def line_span(lines, line_index)
+        line_index = line_index.clamp(0, [lines.length - 1, 0].max)
+        Span.new(line_index, 0, lines[line_index]&.length || 0)
+      end
+
+      def zero_range
+        Span.new(0, 0, 0).to_range
+      end
+
+      def protocol_character(line_text, character, encoding)
+        prefix = line_text.each_char.first(character).join
+        case encoding
+        when "utf-8" then prefix.bytesize
+        when "utf-16" then prefix.encode(Encoding::UTF_16LE).bytesize / 2
+        else character
+        end
+      end
+
+      def ruby_character(line_text, character, encoding)
+        return character if encoding == "utf-32"
+
+        units = 0
+        line_text.each_char.with_index do |char, index|
+          width = (encoding == "utf-8") ? char.bytesize : char.encode(Encoding::UTF_16LE).bytesize / 2
+          return index if units + width > character
+
+          units += width
+          return index + 1 if units == character
+        end
+        line_text.length
+      end
+    end
+  end
+end

data/lib/klenod/lsp/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Klenod
+  module LSP
+    VERSION = "0.0.15"
+  end
+end

data/lib/klenod/lsp/workspace.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require "klenod/build/context"
+
+require_relative "analysis"
+require_relative "routes"
+
+module Klenod
+  module LSP
+    # Adapts a Klenod::Build::Context to editor documents.
+    #
+    # The workspace only transforms and resolves; it never collects records
+    # or evaluates application code. That keeps unsaved editor text out of
+    # the graph and keeps the server responsive without a file watcher.
+    class Workspace
+      IMPORT_KIND = :haml_import
+
+      attr_reader :context, :source_dir
+
+      def initialize(context:)
+        @context = context
+        @graph = context.graph
+        @source_dir = File.expand_path(@graph.source_dir.to_s)
+        @routes = Routes.new(self)
+      end
+
+      attr_reader :routes
+
+      def path_for_uri(uri)
+        return nil unless uri.start_with?("file://")
+
+        path = uri.delete_prefix("file://").split("?", 2).first.to_s
+        path = path.sub(/\A[^\/]+/, "") unless path.start_with?("/")
+        percent_decode(path)
+      end
+
+      def uri_for_path(path)
+        "file://#{path.split("/", -1).map { |segment| percent_encode(segment) }.join("/")}"
+      end
+
+      def module_id_for_uri(uri)
+        path = path_for_uri(uri)
+        path && module_id_for_path(path)
+      end
+
+      def module_id_for_path(path)
+        return nil unless path.start_with?("#{source_dir}/")
+
+        Klenod::Build::ModuleId.new("app:/#{path.delete_prefix("#{source_dir}/")}")
+      end
+
+      # App modules map through the resolver; gem modules through the gem
+      # import plugin, which reports the file in its resolution metadata.
+      def path_for_module_id(module_id)
+        case module_id.scheme
+        when :app
+          @graph.absolute_path(module_id).to_s
+        when :gem
+          dependency = Klenod::Build::Dependency.create(specifier: module_id.to_s, importer_id: nil, kind: IMPORT_KIND)
+          @graph.resolve_dependency(dependency).metadata[:path]&.to_s
+        end
+      rescue Klenod::Build::ResolveError
+        nil
+      end
+
+      def uri_for_module_id(module_id)
+        path = path_for_module_id(module_id)
+        path && uri_for_path(path)
+      end
+
+      # The Haml plugin's `variables` mapping, e.g. `{global: "@__props"}`.
+      # Empty when no Haml plugin is configured or it maps nothing.
+      def haml_variables
+        plugin = @graph.plugins.find { |candidate| candidate.is_a?(Klenod::Build::Plugins::HamlPlugin::Plugin) }
+        plugin&.variables || {}
+      end
+
+      def analyze(module_id, source)
+        transform = @graph.transform_source(module_id, source)
+        resolved_dependencies, resolve_errors = resolve_dependencies(module_id, transform)
+
+        Analysis.new(
+          module_id: module_id,
+          source: source,
+          transform: transform,
+          resolved_dependencies: resolved_dependencies,
+          build_error: nil,
+          ruby_errors: ruby_errors_for(transform),
+          resolve_errors: resolve_errors
+        )
+      rescue Klenod::Build::Error => error
+        failed_analysis(module_id, source, error)
+      rescue => error
+        # Plugins can raise their parser's own errors on half-typed source,
+        # e.g. SyntaxTree on an unterminated import string. Report them
+        # rather than dropping the document's diagnostics.
+        failed_analysis(module_id, source, error)
+      end
+
+      def resolve(specifier, importer_id:, kind: IMPORT_KIND)
+        dependency = Klenod::Build::Dependency.create(specifier: specifier, importer_id: importer_id, kind: kind)
+        @graph.resolve_dependency(dependency).module_id
+      rescue Klenod::Build::ResolveError
+        nil
+      end
+
+      private
+
+      def failed_analysis(module_id, source, error)
+        Analysis.new(
+          module_id: module_id,
+          source: source,
+          transform: nil,
+          resolved_dependencies: [],
+          build_error: error,
+          ruby_errors: [],
+          resolve_errors: []
+        )
+      end
+
+      def resolve_dependencies(module_id, transform)
+        resolved = []
+        errors = []
+
+        transform.dependencies.each do |dependency|
+          resolved << @graph.resolve_dependency(dependency)
+        rescue Klenod::Build::ResolveError => error
+          errors << error.with_resolution_context(dependency: dependency, importer_id: module_id)
+        end
+
+        [resolved, errors]
+      end
+
+      # Ruby modules are checked against their original source by RubyPlugin,
+      # which reports better locations than the generated code would.
+      def ruby_errors_for(transform)
+        return [] if transform.code.nil?
+
+        Prism.parse(transform.code).errors.map do |error|
+          RubyError.new(message: error.message, generated_line: error.location.start_line)
+        end
+      end
+
+      def percent_decode(value)
+        value.gsub(/%[0-9A-Fa-f]{2}/) { |escaped| escaped[1..].hex.chr }.force_encoding(Encoding::UTF_8)
+      end
+
+      def percent_encode(segment)
+        segment.b.gsub(/[^A-Za-z0-9\-._~!$&'()*+,;=:@]/) { |byte| format("%%%02X", byte.ord) }
+      end
+    end
+  end
+end

data/lib/klenod/lsp.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "lsp/version"
+require_relative "lsp/server"
+
+module Klenod
+  module LSP
+  end
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: klenod-lsp
+version: !ruby/object:Gem::Version
+  version: 0.0.15
+platform: ruby
+authors:
+- Andrés Alin
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: klenod-build
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.15
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.15
+- !ruby/object:Gem::Dependency
+  name: language_server-protocol
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.17'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.17'
+description: Editor diagnostics and navigation for Klenod Haml modules over the Language
+  Server Protocol.
+email:
+- andreas.alin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/klenod/lsp.rb
+- lib/klenod/lsp/analysis.rb
+- lib/klenod/lsp/cli.rb
+- lib/klenod/lsp/diagnostics.rb
+- lib/klenod/lsp/documents.rb
+- lib/klenod/lsp/graph_index.rb
+- lib/klenod/lsp/languages.rb
+- lib/klenod/lsp/languages/css.rb
+- lib/klenod/lsp/languages/haml.rb
+- lib/klenod/lsp/languages/haml/classes.rb
+- lib/klenod/lsp/languages/haml/completion.rb
+- lib/klenod/lsp/languages/haml/props.rb
+- lib/klenod/lsp/languages/haml/rename.rb
+- lib/klenod/lsp/languages/haml/ruby_regions.rb
+- lib/klenod/lsp/languages/imports.rb
+- lib/klenod/lsp/languages/ruby.rb
+- lib/klenod/lsp/languages/syntax.rb
+- lib/klenod/lsp/renames.rb
+- lib/klenod/lsp/routes.rb
+- lib/klenod/lsp/server.rb
+- lib/klenod/lsp/symbols.rb
+- lib/klenod/lsp/text.rb
+- lib/klenod/lsp/version.rb
+- lib/klenod/lsp/workspace.rb
+homepage: https://github.com/aalin/klenod
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/aalin/klenod
+  source_code_uri: https://github.com/aalin/klenod/tree/main/gems/klenod-lsp
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '4.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: Language server for Klenod applications.
+test_files: []