Merge pull request #8 from uros-5/channels

Server state moved to channels

jinja-lsp-queries/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "jinja-lsp-queries"
-version = "0.1.5"
+version = "0.1.6"
 edition = "2021"
 description = "TreeSitter queries for jinja-lsp"
 license = "MIT"
@@ -9,7 +9,6 @@ license = "MIT"
 tree-sitter = "0.20.10"
 tree-sitter-jinja2 = "0.0.5"
 tree-sitter-rust = "0.20.4"
-dashmap = "5.1.0"
 tower-lsp = { version = "0.20.0", features = ["proposed"] }
 ropey = "1.5.0"
 

jinja-lsp-queries/src/capturer/included.rs

@@ -1,16 +1,29 @@
+use tower_lsp::lsp_types::Url;
 use tree_sitter::Point;
 
 use super::Capturer;
 
 #[derive(Default, Debug)]
 pub struct IncludeCapturer {
-    pub template: String,
-    point: (Point, Point),
+    pub included: Vec<IncludedTemplate>,
 }
 
 impl IncludeCapturer {
-    pub fn in_template(&self, trigger_point: Point) -> bool {
-        trigger_point >= self.point.0 && trigger_point <= self.point.1
+    pub fn in_template(&self, trigger_point: Point) -> Option<&IncludedTemplate> {
+        if let Some(last) = self.included.last() {
+            if trigger_point >= last.range.0 && trigger_point <= last.range.1 {
+                return Some(last);
+            }
+        }
+        None
+    }
+
+    pub fn add_template(&mut self, name: String, range: (Point, Point)) {
+        self.included.push(IncludedTemplate { name, range });
+    }
+
+    pub fn last(&self) -> Option<&String> {
+        Some(&self.included.last()?.name)
     }
 }
 
@@ -26,10 +39,32 @@ impl Capturer for IncludeCapturer {
             if let Ok(value) = capture.node.utf8_text(source.as_bytes()) {
                 let start = capture.node.start_position();
                 let end = capture.node.end_position();
-                self.template = value.replace(['\'', '\"'], "");
-                self.point.0 = start;
-                self.point.1 = end;
+                let name = value.replace(['\'', '\"'], "");
+                self.add_template(name, (start, end));
             }
         }
     }
 }
+
+#[derive(Default, Debug)]
+pub struct IncludedTemplate {
+    pub name: String,
+    pub range: (Point, Point),
+}
+
+impl IncludedTemplate {
+    pub fn new(name: &str) -> Self {
+        Self {
+            name: name.to_owned(),
+            range: (Point::default(), Point::default()),
+        }
+    }
+
+    pub fn is_template(&self, root: &str) -> Option<Url> {
+        let template = format!("{}/{}", root, &self.name);
+        let template = std::fs::canonicalize(template).ok()?;
+        let url = format!("file://{}", template.to_str()?);
+        let uri = Url::parse(&url).ok()?;
+        Some(uri)
+    }
+}

jinja-lsp-queries/src/capturer/object.rs

@@ -65,28 +65,24 @@ impl JinjaObjectCapturer {
         let end = capture.node.end_position();
         if let Ok(value) = value {
             if start.row == self.dot.1.row && start.column == self.dot.1.column {
-                match self
-                    .objects
-                    .last_mut()
-                    .map(|last| {
-                        last.fields.push((String::from(value), (start, end)));
-                        self.ident = (start, end);
-                    })
-                    .is_none()
-                {
-                    true => {
-                        self.ident = (start, end);
-                        let is_filter = self.is_hover(start);
-                        self.objects.push(JinjaObject::new(
-                            String::from(value),
-                            start,
-                            end,
-                            is_filter,
-                        ));
+                if let Some(last) = self.objects.last_mut() {
+                    last.fields.push((String::from(value), (start, end)));
+                    self.ident = (start, end);
+                } else {
+                    // TODO: in future add those to main library
+                    if VALID_IDENTIFIERS.contains(&value) {
+                        return;
                     }
-                    false => (),
+                    self.ident = (start, end);
+                    let is_filter = self.is_hover(start);
+                    self.objects
+                        .push(JinjaObject::new(String::from(value), start, end, is_filter));
                 }
             } else {
+                // TODO: in future add those to main library
+                if VALID_IDENTIFIERS.contains(&value) {
+                    return;
+                }
                 self.ident = (start, end);
                 let is_filter = self.is_hover(start);
                 self.objects
@@ -143,3 +139,5 @@ pub enum CompletionType {
     Filter,
     Identifier,
 }
+
+static VALID_IDENTIFIERS: [&str; 4] = ["loop", "true", "false", "not"];

jinja-lsp-queries/src/lsp_helper.rs

@@ -1,6 +1,5 @@
 use std::collections::HashMap;
 
-use dashmap::DashMap;
 use tree_sitter::{Node, Point};
 
 use crate::{
@@ -13,42 +12,38 @@ pub fn search_errors(
     root: Node<'_>,
     source: &str,
     query: &Queries,
-    variables: &DashMap<String, Vec<JinjaVariable>>,
+    variables: &HashMap<String, Vec<JinjaVariable>>,
     file_name: &String,
-    diags: &mut HashMap<String, Vec<(JinjaVariable, JinjaDiagnostic)>>,
-) -> Option<()> {
+) -> Option<Vec<(JinjaVariable, JinjaDiagnostic)>> {
     let trigger_point = Point::new(0, 0);
     let query = &query.jinja_idents;
     let capturer = JinjaObjectCapturer::default();
     let props = query_props(root, source, trigger_point, query, true, capturer);
     let props = props.show();
+    let mut diags = vec![];
     for object in props {
         if object.is_filter {
             continue;
         }
-        let file = variables.get(file_name)?;
+        let jinja_variables = variables.get(file_name)?;
         let mut exist = false;
         let mut err_type = JinjaDiagnostic::Undefined;
         let mut to_warn = false;
-        let temp = file
-            .value()
+        // variable definition is in this file
+        let located = jinja_variables
             .iter()
             .filter(|variable| variable.name == object.name)
             .filter(|variable| {
                 exist = true;
                 object.location.0 >= variable.location.0
             });
-        let empty = temp.count() == 0;
+        let empty = located.count() == 0;
         if empty && exist {
             to_warn = true;
         } else if empty {
             to_warn = true;
-            drop(file);
             for i in variables {
-                let temp = i
-                    .value()
-                    .iter()
-                    .filter(|variable| variable.name == object.name);
+                let temp = i.1.iter().filter(|variable| variable.name == object.name);
 
                 if temp.count() != 0 {
                     err_type = JinjaDiagnostic::DefinedSomewhere;
@@ -59,12 +54,12 @@ pub fn search_errors(
         }
         if to_warn {
             let variable = JinjaVariable::new(&object.name, object.location, DataType::Variable);
-            if diags.get(file_name).is_none() {
-                diags.insert(file_name.to_string(), vec![(variable, err_type)]);
-            } else {
-                diags.get_mut(file_name).unwrap().push((variable, err_type));
-            }
+            diags.push((variable, err_type));
         }
     }
-    None
+    if diags.is_empty() {
+        None
+    } else {
+        Some(diags)
+    }
 }