wip

Author: joshuadavidthomas

crates/djls-ide/src/navigation.rs

@@ -1,9 +1,7 @@
 use djls_semantic::resolve_template;
 use djls_semantic::ResolveResult;
 use djls_source::File;
-use djls_source::LineCol;
 use djls_source::Offset;
-use djls_source::PositionEncoding;
 use djls_templates::parse_template;
 use djls_templates::Node;
 use tower_lsp_server::lsp_types;
@@ -12,17 +10,10 @@ use tower_lsp_server::UriExt;
 pub fn goto_template_definition(
     db: &dyn djls_semantic::Db,
     file: File,
-    position: lsp_types::Position,
-    encoding: PositionEncoding,
+    offset: Offset,
 ) -> Option<lsp_types::GotoDefinitionResponse> {
     let nodelist = parse_template(db, file)?;
 
-    let line_index = file.line_index(db);
-    let source = file.source(db);
-    let line_col = LineCol::new(position.line, position.character);
-
-    let offset = encoding.line_col_to_offset(line_index, line_col, source.as_str())?;
-
     let template_name = find_template_name_at_offset(nodelist.nodelist(db), offset)?;
     tracing::debug!("Found template reference: '{}'", template_name);
 
@@ -49,14 +40,9 @@ pub fn goto_template_definition(
 pub fn find_template_references(
     db: &dyn djls_semantic::Db,
     file: File,
-    position: lsp_types::Position,
-    encoding: PositionEncoding,
+    offset: Offset,
 ) -> Option<Vec<lsp_types::Location>> {
     let nodelist = parse_template(db, file)?;
-    let line_index = file.line_index(db);
-    let source = file.source(db);
-    let line_col = LineCol::new(position.line, position.character);
-    let offset = encoding.line_col_to_offset(line_index, line_col, source.as_str())?;
 
     let template_name = find_template_name_at_offset(nodelist.nodelist(db), offset)?;
     tracing::debug!(

crates/djls-ide/src/references.rs

@@ -0,0 +1,94 @@
+use djls_semantic::Db as SemanticDb;
+use djls_source::File;
+use djls_source::LineCol;
+use djls_source::Offset;
+use djls_source::PositionEncoding;
+use djls_templates::parse_template;
+use djls_templates::Node;
+use tower_lsp_server::lsp_types;
+use tower_lsp_server::UriExt;
+
+pub fn references(
+    db: &dyn SemanticDb,
+    file: File,
+    offset: Offset,
+) -> Option<Vec<lsp_types::Location>> {
+    let nodelist = parse_template(db, file)?;
+    let line_index = file.line_index(db);
+    let source = file.source(db);
+    let line_col = LineCol::new(position.line, position.character);
+    let offset = encoding.line_col_to_offset(line_index, line_col, source.as_str())?;
+
+    let template_name = find_template_name_at_offset(nodelist.nodelist(db), offset)?;
+    tracing::debug!(
+        "Cursor is inside extends/include tag referencing: '{}'",
+        template_name
+    );
+
+    let references = djls_semantic::find_references_to_template(db, &template_name);
+
+    let locations: Vec<lsp_types::Location> = references
+        .iter()
+        .filter_map(|reference| {
+            let source_template = reference.source(db);
+            let source_path = source_template.path_buf(db);
+            let uri = lsp_types::Uri::from_file_path(source_path.as_std_path())?;
+
+            let ref_file = djls_source::File::new(db, source_path.clone(), 0);
+            let line_index = ref_file.line_index(db);
+
+            let tag = reference.tag(db);
+            let tag_span = tag.span(db);
+            let start_offset = tag_span.start_offset();
+            let end_offset = tag_span.end_offset();
+
+            let start_lc = line_index.to_line_col(start_offset);
+            let end_lc = line_index.to_line_col(end_offset);
+
+            let start_pos = lsp_types::Position {
+                line: start_lc.line(),
+                character: start_lc.column(),
+            };
+            let end_pos = lsp_types::Position {
+                line: end_lc.line(),
+                character: end_lc.column(),
+            };
+
+            Some(lsp_types::Location {
+                uri,
+                range: lsp_types::Range {
+                    start: start_pos,
+                    end: end_pos,
+                },
+            })
+        })
+        .collect();
+
+    if locations.is_empty() {
+        None
+    } else {
+        Some(locations)
+    }
+}
+
+fn find_template_name_at_offset(nodes: &[Node], offset: Offset) -> Option<String> {
+    for node in nodes {
+        if let Node::Tag {
+            name, bits, span, ..
+        } = node
+        {
+            if (name == "extends" || name == "include") && span.contains(offset) {
+                let template_str = bits.first()?;
+                let template_name = template_str
+                    .trim()
+                    .trim_start_matches('"')
+                    .trim_end_matches('"')
+                    .trim_start_matches('\'')
+                    .trim_end_matches('\'')
+                    .to_string();
+                return Some(template_name);
+            }
+        }
+    }
+    None
+}

crates/djls-server/src/ext.rs

@@ -0,0 +1,91 @@
+use std::str::FromStr;
+
+use camino::Utf8PathBuf;
+use djls_source::File;
+use djls_source::LineCol;
+use djls_source::LineIndex;
+use djls_source::Offset;
+use djls_source::PositionEncoding;
+use djls_workspace::paths;
+use djls_workspace::Db as WorkspaceDb;
+use djls_workspace::TextDocument;
+use tower_lsp_server::lsp_types;
+use url::Url;
+
+pub(crate) trait PositionExt {
+    fn to_offset(&self, text: &str, index: &LineIndex, encoding: PositionEncoding) -> Offset;
+}
+
+impl PositionExt for lsp_types::Position {
+    fn to_offset(&self, text: &str, index: &LineIndex, encoding: PositionEncoding) -> Offset {
+        let line_col = LineCol::new(self.line, self.character);
+        index.offset(line_col, text, encoding)
+    }
+}
+
+pub(crate) trait TextDocumentIdentifierExt {
+    fn to_file(&self, db: &mut dyn WorkspaceDb) -> Option<File>;
+}
+
+impl TextDocumentIdentifierExt for lsp_types::TextDocumentIdentifier {
+    fn to_file(&self, db: &mut dyn WorkspaceDb) -> Option<File> {
+        let path = self.uri.to_utf8_path_buf()?;
+        Some(db.ensure_file_tracked(&path))
+    }
+}
+
+pub(crate) trait TextDocumentItemExt {
+    /// Convert LSP `TextDocumentItem` to internal `TextDocument`
+    fn to_text_document(self) -> TextDocument;
+}
+
+impl TextDocumentItemExt for lsp_types::TextDocumentItem {
+    fn to_text_document(self) -> TextDocument {
+        TextDocument::new(
+            self.text,
+            self.version,
+            djls_workspace::LanguageId::from(self.language_id.as_str()),
+        )
+    }
+}
+
+pub(crate) trait UriExt {
+    /// Convert `uri::Url` to LSP Uri
+    fn from_url(url: &Url) -> Option<Self>
+    where
+        Self: Sized;
+
+    /// Convert LSP URI to `url::Url,` logging errors
+    fn to_url(&self) -> Option<Url>;
+
+    /// Convert LSP URI directly to `Utf8PathBuf` (convenience)
+    fn to_utf8_path_buf(&self) -> Option<Utf8PathBuf>;
+}
+
+impl UriExt for lsp_types::Uri {
+    fn from_url(url: &Url) -> Option<Self> {
+        let uri_string = url.to_string();
+        lsp_types::Uri::from_str(&uri_string)
+            .inspect_err(|e| {
+                tracing::error!("Failed to convert URL to LSP Uri: {} - Error: {}", url, e);
+            })
+            .ok()
+    }
+
+    fn to_url(&self) -> Option<Url> {
+        Url::parse(self.as_str())
+            .inspect_err(|e| {
+                tracing::error!(
+                    "Invalid URI from LSP client: {} - Error: {}",
+                    self.as_str(),
+                    e
+                );
+            })
+            .ok()
+    }
+
+    fn to_utf8_path_buf(&self) -> Option<Utf8PathBuf> {
+        let url = self.to_url()?;
+        paths::url_to_path(&url)
+    }
+}

crates/djls-server/src/lib.rs

@@ -1,5 +1,6 @@
 pub mod db;
 mod encoding;
+mod ext;
 mod logging;
 mod queue;
 pub mod server;