clippy and fmt

Author: joshuadavidthomas

crates/djls-server/src/completions.rs

@@ -186,29 +186,29 @@ fn generate_template_completions(
             let (insert_text, insert_format) = if supports_snippets {
                 if let Some(specs) = tag_specs {
                     if let Some(spec) = specs.get(tag.name()) {
-                        if !spec.args.is_empty() {
+                        if spec.args.is_empty() {
+                            // No args, use plain text
+                            build_plain_insert(tag.name(), context)
+                        } else {
                             // Generate snippet from tag spec
                             let mut text = String::new();
-                            
+
                             // Add leading space if needed
                             if context.needs_leading_space {
                                 text.push(' ');
                             }
-                            
+
                             // Add tag name and snippet arguments
                             text.push_str(&generate_snippet_for_tag(tag.name(), spec));
-                            
+
                             // Add closing based on what's already present
                             match context.closing_brace {
                                 ClosingBrace::None => text.push_str(" %}"),
                                 ClosingBrace::PartialClose => text.push('%'),
                                 ClosingBrace::FullClose => {} // No closing needed
                             }
-                            
+
                             (text, InsertTextFormat::SNIPPET)
-                        } else {
-                            // No args, use plain text
-                            build_plain_insert(tag.name(), context)
                         }
                     } else {
                         // No spec found, use plain text
@@ -338,4 +338,4 @@ mod tests {
 
         assert!(completions.is_empty());
     }
-}
+}

crates/djls-server/src/server.rs

@@ -2,7 +2,6 @@ use std::future::Future;
 use std::sync::Arc;
 
 use djls_templates::analyze_template;
-use djls_templates::db::Db as TemplateDb;
 use djls_templates::TemplateDiagnostic;
 use djls_workspace::paths;
 use djls_workspace::FileKind;
@@ -371,7 +370,7 @@ impl LanguageServer for DjangoLanguageServer {
                     let encoding = session.position_encoding();
                     let file_kind = FileKind::from_path(&path);
                     let template_tags = session.project().and_then(|p| p.template_tags());
-                    let tag_specs = session.with_db(|db| db.tag_specs());
+                    let tag_specs = session.with_db(djls_templates::Db::tag_specs);
                     let supports_snippets = true; // TODO: Get from client capabilities
 
                     let completions = crate::completions::handle_completion(

crates/djls-templates/src/templatetags/snippets.rs

@@ -4,17 +4,18 @@ use super::specs::SimpleArgType;
 use super::specs::TagSpec;
 
 /// Generate an LSP snippet pattern from an array of arguments
+#[must_use]
 pub fn generate_snippet_from_args(args: &[Arg]) -> String {
     let mut parts = Vec::new();
     let mut placeholder_index = 1;
-    
+
     for arg in args {
         // Skip optional args if we haven't seen any required args after them
         // This prevents generating snippets like: "{% for %}" when everything is optional
         if !arg.required && parts.is_empty() {
             continue;
         }
-        
+
         let snippet_part = match &arg.arg_type {
             ArgType::Simple(simple_type) => match simple_type {
                 SimpleArgType::Literal => {
@@ -60,23 +61,24 @@ pub fn generate_snippet_from_args(args: &[Arg]) -> String {
                 result
             }
         };
-        
+
         parts.push(snippet_part);
     }
-    
+
     parts.join(" ")
 }
 
 /// Generate a complete LSP snippet for a tag including the tag name
+#[must_use]
 pub fn generate_snippet_for_tag(tag_name: &str, spec: &TagSpec) -> String {
     let args_snippet = generate_snippet_from_args(&spec.args);
-    
+
     if args_snippet.is_empty() {
         // Tag with no arguments
         tag_name.to_string()
     } else {
         // Tag with arguments
-        format!("{} {}", tag_name, args_snippet)
+        format!("{tag_name} {args_snippet}")
     }
 }
 
@@ -110,61 +112,57 @@ mod tests {
                 arg_type: ArgType::Simple(SimpleArgType::Literal),
             },
         ];
-        
+
         let snippet = generate_snippet_from_args(&args);
         assert_eq!(snippet, "${1:item} in ${2:items} ${3:reversed}");
     }
-    
+
     #[test]
     fn test_snippet_for_if_tag() {
-        let args = vec![
-            Arg {
-                name: "condition".to_string(),
-                required: true,
-                arg_type: ArgType::Simple(SimpleArgType::Expression),
-            },
-        ];
-        
+        let args = vec![Arg {
+            name: "condition".to_string(),
+            required: true,
+            arg_type: ArgType::Simple(SimpleArgType::Expression),
+        }];
+
         let snippet = generate_snippet_from_args(&args);
         assert_eq!(snippet, "${1:condition}");
     }
-    
+
     #[test]
     fn test_snippet_for_autoescape_tag() {
-        let args = vec![
-            Arg {
-                name: "mode".to_string(),
-                required: true,
-                arg_type: ArgType::Choice { choice: vec!["on".to_string(), "off".to_string()] },
+        let args = vec![Arg {
+            name: "mode".to_string(),
+            required: true,
+            arg_type: ArgType::Choice {
+                choice: vec!["on".to_string(), "off".to_string()],
             },
-        ];
-        
+        }];
+
         let snippet = generate_snippet_from_args(&args);
         assert_eq!(snippet, "${1|on,off|}");
     }
-    
+
     #[test]
     fn test_snippet_for_extends_tag() {
-        let args = vec![
-            Arg {
-                name: "template".to_string(),
-                required: true,
-                arg_type: ArgType::Simple(SimpleArgType::String),
-            },
-        ];
-        
+        let args = vec![Arg {
+            name: "template".to_string(),
+            required: true,
+            arg_type: ArgType::Simple(SimpleArgType::String),
+        }];
+
         let snippet = generate_snippet_from_args(&args);
         assert_eq!(snippet, "\"${1:template}\"");
     }
-    
+
     #[test]
     fn test_snippet_for_csrf_token_tag() {
         let args = vec![];
-        
+
         let snippet = generate_snippet_from_args(&args);
         assert_eq!(snippet, "");
     }
-    
+
     #[test]
     fn test_snippet_for_url_tag() {
         let args = vec![
@@ -189,8 +187,8 @@ mod tests {
                 arg_type: ArgType::Simple(SimpleArgType::Variable),
             },
         ];
-        
+
         let snippet = generate_snippet_from_args(&args);
         assert_eq!(snippet, "\"${1:view_name}\" ${2:args} ${3:as} ${4:varname}");
     }
-}
+}

crates/djls-templates/src/templatetags/specs.rs

@@ -430,21 +430,12 @@ mod tests {
         }
 
         // Check that newly added tags are present
-        let additional_tags = [
-            "debug",
-            "firstof",
-            "lorem",
-            "regroup",
-            "widthratio",
-        ];
+        let additional_tags = ["debug", "firstof", "lorem", "regroup", "widthratio"];
 
         for tag in additional_tags {
-            assert!(
-                specs.get(tag).is_some(),
-                "{tag} tag should be present"
-            );
+            assert!(specs.get(tag).is_some(), "{tag} tag should be present");
         }
-        
+
         // Check that some tags are still missing
         let missing_tags = [
             "querystring", // Django 5.1+

crates/djls-templates/src/validation.rs

@@ -114,18 +114,20 @@ impl<'db> TagValidator<'db> {
 
         // Count required arguments
         let required_count = args.iter().filter(|arg| arg.required).count();
-        
+
         if bits.len() < required_count {
             self.errors.push(AstError::MissingRequiredArguments {
                 tag: name.to_string(),
                 min: required_count,
                 span,
             });
         }
-        
+
         // If there are more bits than defined args, that might be okay for varargs
-        let has_varargs = args.iter().any(|arg| matches!(arg.arg_type, ArgType::Simple(SimpleArgType::VarArgs)));
-        
+        let has_varargs = args
+            .iter()
+            .any(|arg| matches!(arg.arg_type, ArgType::Simple(SimpleArgType::VarArgs)));
+
         if !has_varargs && bits.len() > args.len() {
             self.errors.push(AstError::TooManyArguments {
                 tag: name.to_string(),