klenod-lsp 0.0.15

data/lib/klenod/lsp/renames.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require "language_server-protocol"
+
+require "klenod/build/module_id"
+
+require_relative "diagnostics"
+require_relative "languages"
+
+module Klenod
+  module LSP
+    # Workspace edits that keep imports valid when the editor renames or
+    # moves files or folders under the source directory.
+    #
+    # Importers get their literals rewritten to the new location, and a
+    # moved module gets its own relative imports rewritten from its new
+    # directory. Each literal keeps its style: root-relative stays
+    # root-relative, `./` stays `./`, bare stays bare, and an extension is
+    # kept only when the literal had one. Edits are keyed by the files' old
+    # URIs because the client applies them before renaming.
+    module Renames
+      Interface = LanguageServer::Protocol::Interface
+
+      Move = Data.define(:old_path, :new_path) do
+        def apply(path)
+          return new_path if path == old_path
+          return path unless path.start_with?("#{old_path}/")
+
+          new_path + path.delete_prefix(old_path)
+        end
+      end
+
+      module_function
+
+      def call(files, index, workspace)
+        moves = files.filter_map do |old_uri, new_uri|
+          old_path = workspace.path_for_uri(old_uri)
+          new_path = workspace.path_for_uri(new_uri)
+          Move.new(old_path, new_path) if old_path && new_path
+        end
+        return nil if moves.empty?
+
+        changes = Hash.new { |hash, uri| hash[uri] = [] }
+        moves.each do |move|
+          moved_module_ids(move, index, workspace).each do |module_id|
+            index.ensure_collected(module_id)
+            importer_edits(module_id, moves, index, workspace, changes)
+            own_edits(module_id, moves, index, workspace, changes)
+          end
+        end
+        return nil if changes.empty?
+
+        sorted = changes.transform_values { |edits| edits.sort_by { |edit| [edit.range.start.line, edit.range.start.character] } }
+        Interface::WorkspaceEdit.new(changes: sorted)
+      end
+
+      def moved_module_ids(move, index, workspace)
+        if File.directory?(move.old_path)
+          index.records.keys.select do |module_id|
+            path = workspace.path_for_module_id(module_id)
+            path&.start_with?("#{move.old_path}/")
+          end
+        else
+          module_id = workspace.module_id_for_path(move.old_path)
+          module_id ? [module_id] : []
+        end
+      end
+
+      def importer_edits(module_id, moves, index, workspace, changes)
+        new_target_path = apply_moves(workspace.path_for_module_id(module_id), moves)
+
+        index.dependents(module_id).each do |importer_id|
+          record = index.record(importer_id)
+          importer_path = record && workspace.path_for_module_id(importer_id)
+          next unless importer_path
+
+          lines = record.source.lines(chomp: true)
+          importer_new_path = apply_moves(importer_path, moves)
+          record.resolved_dependencies.each do |resolved|
+            next unless resolved.module_id == module_id
+
+            add_edit(changes, workspace.uri_for_path(importer_path), lines, resolved.dependency.specifier.to_s, importer_new_path, new_target_path, workspace)
+          end
+        end
+      end
+
+      def own_edits(module_id, moves, index, workspace, changes)
+        record = index.record(module_id)
+        path = record && workspace.path_for_module_id(module_id)
+        return unless path
+
+        lines = record.source.lines(chomp: true)
+        new_path = apply_moves(path, moves)
+        record.resolved_dependencies.each do |resolved|
+          specifier = resolved.dependency.specifier.to_s
+          next if specifier.start_with?("/") || specifier.match?(Klenod::Build::ModuleId::SCHEME_PATTERN)
+
+          target_path = workspace.path_for_module_id(resolved.module_id)
+          next unless target_path
+
+          add_edit(changes, workspace.uri_for_path(path), lines, specifier, new_path, apply_moves(target_path, moves), workspace)
+        end
+      end
+
+      def add_edit(changes, uri, lines, specifier, importer_path, target_path, workspace)
+        replacement = rewrite_specifier(specifier, importer_path, target_path, workspace.source_dir)
+        return if replacement == specifier
+
+        syntax = Languages.syntax_for(File.extname(workspace.path_for_uri(uri).to_s))
+        Diagnostics.literal_spans(specifier, lines, syntax: syntax).each do |span|
+          next if changes[uri].any? { |edit| edit.range.start.line == span.line && edit.range.start.character == span.start_character }
+
+          changes[uri] << Interface::TextEdit.new(range: span.to_range, new_text: replacement)
+        end
+      end
+
+      def rewrite_specifier(specifier, importer_path, target_path, source_dir)
+        path_part, query = specifier.split("?", 2)
+        target = File.extname(path_part).empty? ? target_path.delete_suffix(File.extname(target_path)) : target_path
+
+        rewritten =
+          if path_part.start_with?("/")
+            "/#{Pathname.new(target).relative_path_from(Pathname.new(source_dir))}"
+          else
+            relative = Pathname.new(target).relative_path_from(Pathname.new(File.dirname(importer_path))).to_s
+            if path_part.start_with?("./")
+              relative.start_with?("../") ? relative : "./#{relative}"
+            else
+              relative
+            end
+          end
+
+        query ? "#{rewritten}?#{query}" : rewritten
+      end
+
+      def apply_moves(path, moves)
+        moves.reduce(path) { |current, move| move.apply(current) }
+      end
+    end
+  end
+end

data/lib/klenod/lsp/routes.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "klenod/build/plugins/router_plugin"
+
+module Klenod
+  module LSP
+    # What the router plugin knows about a module: the route a page or
+    # handler serves, the routes a layout wraps, or the special view it is.
+    # The manifest is discovered from the pages directory and kept until
+    # files change.
+    class Routes
+      def initialize(workspace)
+        @workspace = workspace
+        @manifest = nil
+        @discovered = false
+      end
+
+      def invalidate
+        @manifest = nil
+        @discovered = false
+      end
+
+      def descriptions(module_id)
+        manifest = self.manifest
+        return [] unless manifest
+
+        id = module_id.to_s
+        descriptions = []
+        manifest.routes.each do |route|
+          descriptions << "Route #{route.path}" if [route.page_module_id, route.handler_module_id].compact.any? { |candidate| candidate.to_s == id }
+        end
+        wrapped = manifest.routes.count { |route| [*route.layout_module_ids, route.slot_layout_module_id].compact.any? { |candidate| candidate.to_s == id } }
+        descriptions << "Layout for #{wrapped} #{(wrapped == 1) ? "route" : "routes"}" if wrapped.positive?
+        manifest.special_views.each do |view|
+          descriptions << "#{view.kind.to_s.tr("_", " ").capitalize} view for #{view.path}" if view.view_module_id.to_s == id
+        end
+        descriptions
+      end
+
+      # Markdown for a hover on a route module: the route and its params,
+      # the page and handler files, and the layouts wrapping it; for a layout,
+      # the routes it wraps; for a special view, its kind and scope.
+      def hover_markdown(module_id)
+        manifest = self.manifest
+        return nil unless manifest
+
+        id = module_id.to_s
+        sections = []
+        manifest.routes.each do |route|
+          next unless [route.page_module_id, route.handler_module_id].compact.any? { |candidate| candidate.to_s == id }
+
+          lines = ["**Route** `#{route.path}` · `#{directory_form(route)}`"]
+          params = route.params
+          lines << "Params: #{params.map { |param| "`#{param.name}` (#{param.kind})" }.join(", ")}" unless params.empty?
+          lines << "Page: `#{route.page_module_id.path}`" if route.page_module_id
+          lines << "Handler: `#{route.handler_module_id.path}`" if route.handler_module_id
+          lines << layouts_line(route.layout_module_ids)
+          sections << lines.compact.join("\n\n")
+        end
+
+        wrapped = manifest.routes.select { |route| [*route.layout_module_ids, route.slot_layout_module_id].compact.any? { |candidate| candidate.to_s == id } }
+        unless wrapped.empty?
+          listed = wrapped.first(10).map { |route| "`#{route.path}`" }
+          listed << "…" if wrapped.length > 10
+          sections << "**Layout** for #{wrapped.length} #{(wrapped.length == 1) ? "route" : "routes"}: #{listed.join(", ")}"
+        end
+
+        manifest.special_views.each do |view|
+          next unless view.view_module_id.to_s == id
+
+          lines = ["**#{view.kind.to_s.tr("_", " ").capitalize} view** for `#{view.path}`"]
+          lines << "Status: #{view.status}" if view.status
+          lines << layouts_line(view.layout_module_ids)
+          sections << lines.compact.join("\n\n")
+        end
+
+        sections.empty? ? nil : sections.join("\n\n---\n\n")
+      end
+
+      private
+
+      # The directory spelling of a route, e.g. `pages/docs/[slug]`, next to
+      # the URL pattern the router matches, e.g. `/docs/:slug`.
+      def directory_form(route)
+        File.dirname(route.module_id.path)
+      end
+
+      def layouts_line(layout_module_ids)
+        return nil if layout_module_ids.nil? || layout_module_ids.empty?
+
+        "Layouts: #{layout_module_ids.map { |layout_id| "`#{layout_id.path}`" }.join(" → ")}"
+      end
+
+      def manifest
+        return @manifest if @discovered
+
+        @discovered = true
+        plugin = @workspace.context.graph.plugins.find { |candidate| candidate.is_a?(Klenod::Build::Plugins::RouterPlugin::Plugin) }
+        @manifest = plugin&.discover(source_dir: @workspace.source_dir)
+      rescue Klenod::Build::Error
+        @manifest = nil
+      end
+    end
+  end
+end