wip

Author: joshuadavidthomas

crates/djls-template-ast/src/ast.rs

@@ -2,13 +2,13 @@ use crate::tokens::Token;
 use serde::Serialize;
 use thiserror::Error;
 
-#[derive(Clone, Debug, Default, Serialize)]
-pub struct Ast {
+#[derive(Clone, Default, Debug, Serialize)]
+pub struct NodeList {
     nodes: Vec<Node>,
     line_offsets: LineOffsets,
 }
 
-impl Ast {
+impl NodeList {
     pub fn nodes(&self) -> &Vec<Node> {
         &self.nodes
     }
@@ -25,7 +25,7 @@ impl Ast {
         self.line_offsets = line_offsets
     }
 
-    pub fn finalize(&mut self) -> Ast {
+    pub fn finalize(&mut self) -> NodeList {
         self.clone()
     }
 }
@@ -67,6 +67,28 @@ impl LineOffsets {
     }
 }
 
+#[derive(Clone, Debug, Serialize)]
+pub enum Node {
+    Tag {
+        name: String,
+        bits: Vec<String>,
+        span: Span,
+    },
+    Comment {
+        content: String,
+        span: Span,
+    },
+    Text {
+        content: String,
+        span: Span,
+    },
+    Variable {
+        var: String,
+        filters: Vec<String>,
+        span: Span,
+    },
+}
+
 #[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize)]
 pub struct Span {
     start: u32,
@@ -95,127 +117,6 @@ impl From<Token> for Span {
     }
 }
 
-#[derive(Clone, Debug, Serialize)]
-pub enum Node {
-    Block(Block),
-    Comment {
-        content: String,
-        span: Span,
-    },
-    Text {
-        content: String,
-        span: Span,
-    },
-    Variable {
-        bits: Vec<String>,
-        filters: Vec<DjangoFilter>,
-        span: Span,
-    },
-}
-
-impl Node {
-    pub fn span(&self) -> Option<&Span> {
-        match self {
-            Node::Block(block) => Some(&block.tag().span),
-            Node::Comment { span, .. } => Some(span),
-            Node::Text { span, .. } => Some(span),
-            Node::Variable { span, .. } => Some(span),
-        }
-    }
-
-    pub fn children(&self) -> Option<&Vec<Node>> {
-        match self {
-            Node::Block(block) => block.nodes(),
-            _ => None,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Serialize)]
-pub enum Block {
-    Branch {
-        tag: Tag,
-        nodes: Vec<Node>,
-    },
-    Closing {
-        tag: Tag,
-    },
-    Container {
-        tag: Tag,
-        nodes: Vec<Node>,
-        closing: Option<Box<Block>>,
-    },
-    Inclusion {
-        tag: Tag,
-        template_name: String,
-    },
-    Single {
-        tag: Tag,
-    },
-}
-
-impl Block {
-    pub fn tag(&self) -> &Tag {
-        match self {
-            Self::Branch { tag, .. }
-            | Self::Container { tag, .. }
-            | Self::Closing { tag }
-            | Self::Inclusion { tag, .. }
-            | Self::Single { tag } => tag,
-        }
-    }
-
-    pub fn nodes(&self) -> Option<&Vec<Node>> {
-        match self {
-            Block::Branch { nodes, .. } => Some(nodes),
-            Block::Container { nodes, .. } => Some(nodes),
-            _ => None,
-        }
-    }
-
-    pub fn closing(&self) -> Option<&Block> {
-        match self {
-            Block::Container { closing, .. } => closing.as_deref(),
-            _ => None,
-        }
-    }
-
-    pub fn template_name(&self) -> Option<&String> {
-        match self {
-            Block::Inclusion { template_name, .. } => Some(template_name),
-            _ => None,
-        }
-    }
-}
-
-#[derive(Clone, Debug, Serialize)]
-pub struct Tag {
-    pub name: String,
-    pub bits: Vec<String>,
-    pub span: Span,
-    pub tag_span: Span,
-    pub assignment: Option<String>,
-}
-
-#[derive(Clone, Debug, Serialize)]
-pub struct Assignment {
-    pub target: String,
-    pub value: String,
-}
-
-#[derive(Clone, Debug, Serialize)]
-pub struct DjangoFilter {
-    pub name: String,
-    pub args: Vec<String>,
-    pub span: Span,
-}
-
-impl DjangoFilter {
-    pub fn new(name: String, args: Vec<String>, span: Span) -> Self {
-        Self { name, args, span }
-    }
-}
-
 #[derive(Clone, Debug, Error, Serialize)]
 pub enum AstError {
     #[error("Empty AST")]
@@ -272,28 +173,25 @@ mod tests {
 
     mod spans_and_positions {
         use super::*;
-        use crate::tagspecs::TagSpecs;
 
         #[test]
         fn test_variable_spans() {
             let template = "Hello\n{{ user.name }}\nWorld";
             let tokens = Lexer::new(template).tokenize().unwrap();
-            println!("Tokens: {:#?}", tokens); // Add debug print
-            let tags = TagSpecs::load_builtin_specs().unwrap();
-            let mut parser = Parser::new(tokens, tags);
-            let (ast, errors) = parser.parse().unwrap();
+            let mut parser = Parser::new(tokens);
+            let (nodelist, errors) = parser.parse().unwrap();
             assert!(errors.is_empty());
 
             // Find the variable node
-            let nodes = ast.nodes();
+            let nodes = nodelist.nodes();
             let var_node = nodes
                 .iter()
                 .find(|n| matches!(n, Node::Variable { .. }))
                 .unwrap();
 
             if let Node::Variable { span, .. } = var_node {
                 // Variable starts after newline + "{{"
-                let (line, col) = ast
+                let (line, col) = nodelist
                     .line_offsets()
                     .position_to_line_col(*span.start() as usize);
                 assert_eq!(
@@ -302,84 +200,8 @@ mod tests {
                     "Variable should start at line 2, col 3"
                 );
 
-                // Span should be exactly "user.name"
                 assert_eq!(*span.length(), 9, "Variable span should cover 'user.name'");
             }
         }
-
-        #[test]
-        fn test_block_spans() {
-            let nodes = vec![Node::Block(Block::Container {
-                tag: Tag {
-                    name: "if".to_string(),
-                    bits: vec!["user.is_authenticated".to_string()],
-                    span: Span::new(0, 35),
-                    tag_span: Span::new(0, 35),
-                    assignment: None,
-                },
-                nodes: vec![],
-                closing: None,
-            })];
-
-            let ast = Ast {
-                nodes,
-                line_offsets: LineOffsets::new(),
-            };
-
-            let node = &ast.nodes()[0];
-            if let Node::Block(block) = node {
-                assert_eq!(block.tag().span.start(), &0);
-                assert_eq!(block.tag().span.length(), &35);
-            } else {
-                panic!("Expected Block node");
-            }
-        }
-
-        #[test]
-        fn test_multiline_template() {
-            let template = "{% if user.active %}\n  Welcome!\n{% endif %}";
-            let tokens = Lexer::new(template).tokenize().unwrap();
-            let tags = TagSpecs::load_builtin_specs().unwrap();
-            let mut parser = Parser::new(tokens, tags);
-            let (ast, errors) = parser.parse().unwrap();
-            assert!(errors.is_empty());
-
-            let nodes = ast.nodes();
-            if let Node::Block(Block::Container {
-                tag,
-                nodes,
-                closing,
-                ..
-            }) = &nodes[0]
-            {
-                // Check block tag
-                assert_eq!(tag.name, "if");
-                assert_eq!(tag.bits, vec!["if", "user.active"]);
-
-                // Check nodes
-                eprintln!("Nodes: {:?}", nodes);
-                assert_eq!(nodes.len(), 1);
-                if let Node::Text { content, span } = &nodes[0] {
-                    assert_eq!(content, "Welcome!");
-                    eprintln!("Line offsets: {:?}", ast.line_offsets());
-                    eprintln!("Span: {:?}", span);
-                    let (line, col) = ast.line_offsets().position_to_line_col(span.start as usize);
-                    assert_eq!((line, col), (2, 2), "Content should be on line 2, col 2");
-
-                    // Check closing tag
-                    if let Block::Closing { tag } =
-                        closing.as_ref().expect("Expected closing tag").as_ref()
-                    {
-                        assert_eq!(tag.name, "endif");
-                    } else {
-                        panic!("Expected closing block");
-                    }
-                } else {
-                    panic!("Expected text node");
-                }
-            } else {
-                panic!("Expected block node");
-            }
-        }
     }
 }

crates/djls-template-ast/src/lib.rs

@@ -6,13 +6,11 @@ mod tagspecs;
 mod tokens;
 mod validator;
 
+use ast::NodeList;
 pub use error::{to_lsp_diagnostic, QuickFix, TemplateError};
 
-pub use ast::Ast;
 use lexer::Lexer;
 pub use parser::{Parser, ParserError};
-use tagspecs::TagSpecs;
-use validator::Validator;
 
 /// Parses a Django template and returns the AST and any parsing errors.
 ///
@@ -21,35 +19,27 @@ use validator::Validator;
 ///
 /// Returns a `Result` containing a tuple of `(Ast, Vec<ParserError>)` on success,
 /// or a `ParserError` on failure.
-pub fn parse_template(
-    source: &str,
-    tag_specs: Option<&TagSpecs>,
-) -> Result<(Ast, Vec<TemplateError>), TemplateError> {
+pub fn parse_template(source: &str) -> Result<(NodeList, Vec<TemplateError>), TemplateError> {
     let tokens = Lexer::new(source)
         .tokenize()
         .map_err(|e| TemplateError::Lexer(e.to_string()))?;
 
-    let tag_specs = match tag_specs {
-        Some(specs) => specs.clone(),
-        None => TagSpecs::load_builtin_specs()
-            .map_err(|e| TemplateError::Config(format!("Failed to load builtin specs: {}", e)))?,
-    };
+    // let tag_specs = match tag_specs {
+    //     Some(specs) => specs.clone(),
+    //     None => TagSpecs::load_builtin_specs()
+    //         .map_err(|e| TemplateError::Config(format!("Failed to load builtin specs: {}", e)))?,
+    // };
 
-    let mut parser = Parser::new(tokens, tag_specs.clone());
-    let (ast, parser_errors) = parser
+    let mut parser = Parser::new(tokens);
+    let (nodelist, parser_errors) = parser
         .parse()
         .map_err(|e| TemplateError::Parser(e.to_string()))?;
 
     // Convert parser errors to TemplateError
-    let mut all_errors = parser_errors
+    let all_errors = parser_errors
         .into_iter()
         .map(|e| TemplateError::Parser(e.to_string()))
         .collect::<Vec<_>>();
 
-    // Run validation
-    let mut validator = Validator::new(&ast, &tag_specs);
-    let validation_errors = validator.validate();
-    all_errors.extend(validation_errors.into_iter().map(TemplateError::Validation));
-
-    Ok((ast, all_errors))
+    Ok((nodelist, all_errors))
 }