oak_markdown/lsp/
mod.rs

1#![doc = include_str!("readme.md")]
2#[cfg(feature = "oak-highlight")]
3pub mod highlighter;
4
5use crate::{language::MarkdownLanguage, parser::element_type::MarkdownElementType};
6use core::range::Range;
7use oak_core::{ElementRole, ElementType, Source, TokenType, tree::RedNode};
8#[cfg(feature = "lsp")]
9use {
10    futures::{Future, FutureExt},
11    oak_hover::{Hover as HoverInfo, HoverProvider},
12    oak_lsp::{service::LanguageService, types::Hover as LspHover},
13    oak_vfs::Vfs,
14};
15/// Hover provider for Markdown.
16#[cfg(feature = "lsp")]
17pub struct MarkdownHoverProvider;
18#[cfg(feature = "lsp")]
19impl HoverProvider<MarkdownLanguage> for MarkdownHoverProvider {
20    fn hover(&self, node: &RedNode<'_, MarkdownLanguage>, _range: Range<usize>) -> Option<HoverInfo> {
21        let kind = node.green.kind;
22        let contents = match kind {
23            MarkdownElementType::Heading1 => "### Heading 1\nTop-level heading.",
24            MarkdownElementType::Heading2 => "### Heading 2\nSecond-level heading.",
25            MarkdownElementType::Link => "### Markdown Link\nLink to an external resource or internal anchor.",
26            MarkdownElementType::CodeBlock => "### Code Block\nA block of source code.",
27            MarkdownElementType::Strong => "### Strong Emphasis\nBold text.",
28            MarkdownElementType::Emphasis => "### Emphasis\nItalic text.",
29            _ => return None,
30        };
31        Some(HoverInfo { contents: contents.to_string(), range: Some(node.span()) })
32    }
33}
34/// Language service for Markdown providing LSP features.
35#[cfg(feature = "lsp")]
36pub struct MarkdownLanguageService<V: Vfs> {
37    vfs: V,
38    workspace: oak_lsp::workspace::WorkspaceManager,
39    hover_provider: MarkdownHoverProvider,
40}
41impl<V: Vfs> MarkdownLanguageService<V> {
42    /// Creates a new MarkdownLanguageService with the given VFS.
43    pub fn new(vfs: V) -> Self {
44        Self { vfs, workspace: oak_lsp::workspace::WorkspaceManager::new(), hover_provider: MarkdownHoverProvider }
45    }
46    fn collect_definitions(&self, node: &RedNode<MarkdownLanguage>, name: &str, source: &str, uri: &str, definitions: &mut Vec<oak_lsp::LocationRange>) {
47        use oak_core::{language::UniversalElementRole, tree::RedTree};
48        let role = ElementType::role(&node.green.kind);
49        if ElementRole::universal(&role) == UniversalElementRole::Definition {
50            for child in node.children() {
51                if let RedTree::Leaf(leaf) = child {
52                    if TokenType::is_universal(&leaf.kind, oak_core::language::UniversalTokenRole::Name) {
53                        if &source[leaf.span.clone()] == name {
54                            definitions.push(oak_lsp::LocationRange { uri: uri.into(), range: leaf.span });
55                            return;
56                        }
57                    }
58                }
59            }
60        }
61        for child in node.children() {
62            if let RedTree::Node(child_node) = child {
63                self.collect_definitions(&child_node, name, source, uri, definitions);
64            }
65        }
66    }
67}
68impl<V: Vfs + Send + Sync + 'static + oak_vfs::WritableVfs> LanguageService for MarkdownLanguageService<V> {
69    type Lang = MarkdownLanguage;
70    type Vfs = V;
71    fn vfs(&self) -> &Self::Vfs {
72        &self.vfs
73    }
74    fn workspace(&self) -> &oak_lsp::workspace::WorkspaceManager {
75        &self.workspace
76    }
77    fn get_root(&self, _uri: &str) -> impl Future<Output = Option<RedNode<'_, MarkdownLanguage>>> + Send + '_ {
78        async move { None }
79    }
80    fn definition<'a>(&'a self, uri: &'a str, range: Range<usize>) -> impl Future<Output = Vec<oak_lsp::LocationRange>> + Send + 'a {
81        let uri = uri.to_string();
82        async move {
83            let root = self.get_root(&uri).await?;
84            let source = self.vfs().get_source(&uri)?;
85            let leaf = root.leaf_at_offset(range.start)?;
86            if !TokenType::is_universal(&leaf.kind, oak_core::language::UniversalTokenRole::Name) {
87                return None;
88            }
89            let name = source.get_text_in(leaf.span.clone());
90            let mut definitions = Vec::new();
91            let full_text = source.get_text_in(Range { start: 0, end: source.length() });
92            self.collect_definitions(&root, &name, &full_text, &uri, &mut definitions);
93            Some(definitions)
94        }
95        .map(|opt| opt.unwrap_or_default())
96    }
97    fn references<'a>(&'a self, uri: &'a str, range: Range<usize>) -> impl Future<Output = Vec<oak_lsp::LocationRange>> + Send + 'a {
98        let uri = uri.to_string();
99        async move {
100            let root = self.get_root(&uri).await?;
101            let source = self.vfs().get_source(&uri)?;
102            let leaf = root.leaf_at_offset(range.start)?;
103            if !TokenType::is_universal(&leaf.kind, oak_core::language::UniversalTokenRole::Name) {
104                return None;
105            }
106            let name = source.get_text_in(leaf.span.clone());
107            let name = name.to_string();
108            let mut all_refs = Vec::new();
109            let files = self.list_all_files(&uri).await;
110            for file_uri in files {
111                if let Some(file_root) = self.get_root(&file_uri).await {
112                    if let Some(file_source) = self.vfs().get_source(&file_uri) {
113                        let full_text = file_source.get_text_in(Range { start: 0, end: file_source.length() });
114                        let refs = oak_navigation::SimpleReferenceFinder::find(&file_root, &name, &full_text, file_uri.clone());
115                        all_refs.extend(refs.into_iter().map(|l| oak_lsp::LocationRange { uri: l.uri, range: l.range }));
116                    }
117                }
118            }
119            Some(all_refs)
120        }
121        .map(|opt| opt.unwrap_or_default())
122    }
123    fn rename<'a>(&'a self, uri: &'a str, range: Range<usize>, new_name: String) -> impl Future<Output = Option<oak_lsp::WorkspaceEdit>> + Send + 'a {
124        let uri = uri.to_string();
125        async move {
126            let refs = self.references(&uri, range).await;
127            if refs.is_empty() {
128                return None;
129            }
130            let mut changes = std::collections::HashMap::new();
131            for r in refs {
132                changes.entry(r.uri.to_string()).or_insert_with(Vec::new).push(oak_lsp::TextEdit { range: r.range, new_text: new_name.clone() });
133            }
134            Some(oak_lsp::WorkspaceEdit { changes })
135        }
136    }
137    fn hover(&self, uri: &str, range: Range<usize>) -> impl Future<Output = Option<LspHover>> + Send + '_ {
138        let uri = uri.to_string();
139        async move { self.with_root(&uri, |root| self.hover_provider.hover(&root, range).map(|h| LspHover { contents: h.contents, range: h.range })).await.flatten() }
140    }
141}
oak_markdown/lsp/mod.rs

oak_markdown/lsp/
mod.rs
