Fix typos

Author: Kijewski

askama_derive/src/generator.rs

@@ -205,7 +205,7 @@ fn find_used_templates(
                     let dependency_path = (path.clone(), extends.clone());
                     if dependency_graph.contains(&dependency_path) {
                         return Err(format!(
-                            "cyclic dependecy in graph {:#?}",
+                            "cyclic dependency in graph {:#?}",
                             dependency_graph
                                 .iter()
                                 .map(|e| format!("{:#?} --> {:#?}", e.0, e.1))
@@ -1211,7 +1211,7 @@ impl<'a> Generator<'a> {
                     };
 
                     let id = match expr_cache.entry(expression.clone()) {
-                        Entry::Occupied(e) if s.is_cachable() => *e.get(),
+                        Entry::Occupied(e) if s.is_cacheable() => *e.get(),
                         e => {
                             let id = self.named;
                             self.named += 1;

askama_derive/src/parser/expr.rs

@@ -84,7 +84,7 @@ impl Expr<'_> {
     /// Returns `true` if the outcome of this expression may be used multiple times in the same
     /// `write!()` call, without evaluating the expression again, i.e. the expression should be
     /// side-effect free.
-    pub(crate) fn is_cachable(&self) -> bool {
+    pub(crate) fn is_cacheable(&self) -> bool {
         match self {
             // Literals are the definition of pure:
             Expr::BoolLit(_) => true,
@@ -95,18 +95,18 @@ impl Expr<'_> {
             Expr::Var(_) => true,
             Expr::Path(_) => true,
             // Check recursively:
-            Expr::Array(args) => args.iter().all(|arg| arg.is_cachable()),
-            Expr::Attr(lhs, _) => lhs.is_cachable(),
-            Expr::Index(lhs, rhs) => lhs.is_cachable() && rhs.is_cachable(),
-            Expr::Filter(_, args) => args.iter().all(|arg| arg.is_cachable()),
-            Expr::Unary(_, arg) => arg.is_cachable(),
-            Expr::BinOp(_, lhs, rhs) => lhs.is_cachable() && rhs.is_cachable(),
+            Expr::Array(args) => args.iter().all(|arg| arg.is_cacheable()),
+            Expr::Attr(lhs, _) => lhs.is_cacheable(),
+            Expr::Index(lhs, rhs) => lhs.is_cacheable() && rhs.is_cacheable(),
+            Expr::Filter(_, args) => args.iter().all(|arg| arg.is_cacheable()),
+            Expr::Unary(_, arg) => arg.is_cacheable(),
+            Expr::BinOp(_, lhs, rhs) => lhs.is_cacheable() && rhs.is_cacheable(),
             Expr::Range(_, lhs, rhs) => {
-                lhs.as_ref().map_or(true, |v| v.is_cachable())
-                    && rhs.as_ref().map_or(true, |v| v.is_cachable())
+                lhs.as_ref().map_or(true, |v| v.is_cacheable())
+                    && rhs.as_ref().map_or(true, |v| v.is_cacheable())
             }
-            Expr::Group(arg) => arg.is_cachable(),
-            Expr::Tuple(args) => args.iter().all(|arg| arg.is_cachable()),
+            Expr::Group(arg) => arg.is_cacheable(),
+            Expr::Tuple(args) => args.iter().all(|arg| arg.is_cacheable()),
             // We have too little information to tell if the expression is pure:
             Expr::Call(_, _) => false,
             Expr::RustMacro(_, _) => false,