Rename State/state to Context/ctx in code generator

1 files changed, 70 insertions, 70 deletions

diff --git a/askama_derive/src/generator.rs b/askama_derive/src/generator.rs
index e2235f3..a56bd2d 100644
--- a/askama_derive/src/generator.rs
+++ b/askama_derive/src/generator.rs
@@ -70,7 +70,7 @@ pub fn generate(input: &TemplateInput, nodes: &[Node]) -> String {
         }
     }
 
-    Generator::default().build(&State {
+    Generator::default().build(&Context {
         input,
         nodes,
         blocks: &blocks,
@@ -85,7 +85,7 @@ pub fn generate(input: &TemplateInput, nodes: &[Node]) -> String {
     })
 }
 
-struct State<'a> {
+struct Context<'a> {
     input: &'a TemplateInput<'a>,
     nodes: &'a [Node<'a>],
     blocks: &'a [&'a Node<'a>],
@@ -141,45 +141,45 @@ impl<'a> Generator<'a> {
         Self::new(locals, self.indent)
     }
 
-    // Takes a State and generates the relevant implementations.
-    fn build(mut self, state: &'a State) -> String {
-        if !state.blocks.is_empty() {
-            if !state.derived {
-                self.define_trait(state);
+    // Takes a Context and generates the relevant implementations.
+    fn build(mut self, ctx: &'a Context) -> String {
+        if !ctx.blocks.is_empty() {
+            if !ctx.derived {
+                self.define_trait(ctx);
             } else {
-                let parent_type = get_parent_type(state.input.ast)
+                let parent_type = get_parent_type(ctx.input.ast)
                     .expect("expected field '_parent' in extending template struct");
-                self.deref_to_parent(state, parent_type);
+                self.deref_to_parent(ctx, parent_type);
             }
 
-            let trait_nodes = if !state.derived {
-                Some(&state.nodes[..])
+            let trait_nodes = if !ctx.derived {
+                Some(&ctx.nodes[..])
             } else {
                 None
             };
-            self.impl_trait(state, trait_nodes);
-            self.impl_template_for_trait(state);
+            self.impl_trait(ctx, trait_nodes);
+            self.impl_template_for_trait(ctx);
         } else {
-            self.impl_template(state);
+            self.impl_template(ctx);
         }
-        self.impl_display(state);
+        self.impl_display(ctx);
         if cfg!(feature = "iron") {
-            self.impl_modifier_response(state);
+            self.impl_modifier_response(ctx);
         }
         if cfg!(feature = "rocket") {
-            self.impl_responder(state);
+            self.impl_responder(ctx);
         }
         self.buf
     }
 
     // Implement `Template` for the given context struct.
-    fn impl_template(&mut self, state: &'a State) {
-        self.write_header(state, "::askama::Template", None);
+    fn impl_template(&mut self, ctx: &'a Context) {
+        self.write_header(ctx, "::askama::Template", None);
         self.writeln(
             "fn render_into(&self, writer: &mut ::std::fmt::Write) -> \
              ::askama::Result<()> {",
         );
-        self.handle(state, state.nodes, AstLevel::Top);
+        self.handle(ctx, ctx.nodes, AstLevel::Top);
         self.flush_ws(&WS(false, false));
         self.writeln("Ok(())");
         self.writeln("}");
@@ -187,8 +187,8 @@ impl<'a> Generator<'a> {
     }
 
     // Implement `Display` for the given context struct.
-    fn impl_display(&mut self, state: &'a State) {
-        self.write_header(state, "::std::fmt::Display", None);
+    fn impl_display(&mut self, ctx: &'a Context) {
+        self.write_header(ctx, "::std::fmt::Display", None);
         self.writeln("fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {");
         self.writeln("self.render_into(f).map_err(|_| ::std::fmt::Error {})");
         self.writeln("}");
@@ -196,8 +196,8 @@ impl<'a> Generator<'a> {
     }
 
     // Implement `Deref<Parent>` for an inheriting context struct.
-    fn deref_to_parent(&mut self, state: &'a State, parent_type: &syn::Type) {
-        self.write_header(state, "::std::ops::Deref", None);
+    fn deref_to_parent(&mut self, ctx: &'a Context, parent_type: &syn::Type) {
+        self.write_header(ctx, "::std::ops::Deref", None);
         self.writeln(&format!(
             "type Target = {};",
             parent_type.into_token_stream()
@@ -209,20 +209,20 @@ impl<'a> Generator<'a> {
     }
 
     // Implement `TraitFromPathName` for the given context struct.
-    fn impl_trait(&mut self, state: &'a State, nodes: Option<&'a [Node]>) {
-        self.write_header(state, &state.trait_name, None);
-        self.write_block_defs(state);
+    fn impl_trait(&mut self, ctx: &'a Context, nodes: Option<&'a [Node]>) {
+        self.write_header(ctx, &ctx.trait_name, None);
+        self.write_block_defs(ctx);
 
         self.writeln("#[allow(unused_variables)]");
         self.writeln(&format!(
             "fn render_trait_into(&self, timpl: &{}, writer: &mut ::std::fmt::Write) \
              -> ::askama::Result<()> {{",
-            state.trait_name
+            ctx.trait_name
         ));
 
         if let Some(nodes) = nodes {
             self.impl_blocks = true;
-            self.handle(state, nodes, AstLevel::Top);
+            self.handle(ctx, nodes, AstLevel::Top);
             self.flush_ws(&WS(false, false));
             self.impl_blocks = false;
             self.writeln("Ok(())");
@@ -236,13 +236,13 @@ impl<'a> Generator<'a> {
     }
 
     // Implement `Template` for templates that implement a template trait.
-    fn impl_template_for_trait(&mut self, state: &'a State) {
-        self.write_header(state, "::askama::Template", None);
+    fn impl_template_for_trait(&mut self, ctx: &'a Context) {
+        self.write_header(ctx, "::askama::Template", None);
         self.writeln(
             "fn render_into(&self, writer: &mut ::std::fmt::Write) \
              -> ::askama::Result<()> {",
         );
-        if state.derived {
+        if ctx.derived {
             self.writeln("self._parent.render_trait_into(self, writer)");
         } else {
             self.writeln("self.render_trait_into(self, writer)");
@@ -252,28 +252,28 @@ impl<'a> Generator<'a> {
     }
 
     // Defines the `TraitFromPathName` trait.
-    fn define_trait(&mut self, state: &'a State) {
-        self.writeln(&format!("pub trait {} {{", state.trait_name));
-        self.write_block_defs(state);
+    fn define_trait(&mut self, ctx: &'a Context) {
+        self.writeln(&format!("pub trait {} {{", ctx.trait_name));
+        self.write_block_defs(ctx);
         self.writeln(&format!(
             "fn render_trait_into(&self, timpl: &{}, writer: &mut ::std::fmt::Write) \
              -> ::askama::Result<()>;",
-            state.trait_name
+            ctx.trait_name
         ));
         self.writeln("}");
     }
 
     // Implement iron's Modifier<Response> if enabled
-    fn impl_modifier_response(&mut self, state: &'a State) {
+    fn impl_modifier_response(&mut self, ctx: &'a Context) {
         self.write_header(
-            state,
+            ctx,
             "::askama::iron::Modifier<::askama::iron::Response>",
             None,
         );
         self.writeln("fn modify(self, res: &mut ::askama::iron::Response) {");
         self.writeln("res.body = Some(Box::new(self.render().unwrap().into_bytes()));");
 
-        let ext = state
+        let ext = ctx
             .input
             .path
             .extension()
@@ -290,11 +290,11 @@ impl<'a> Generator<'a> {
     }
 
     // Implement Rocket's `Responder`.
-    fn impl_responder(&mut self, state: &'a State) {
+    fn impl_responder(&mut self, ctx: &'a Context) {
         let lifetime = syn::Lifetime::new("'askama", Span::call_site());
         let param = syn::GenericParam::Lifetime(syn::LifetimeDef::new(lifetime));
         self.write_header(
-            state,
+            ctx,
             "::askama::rocket::Responder<'askama>",
             Some(vec![param]),
         );
@@ -303,7 +303,7 @@ impl<'a> Generator<'a> {
              -> ::askama::rocket::Result<'askama> {",
         );
 
-        let ext = match state.input.path.extension() {
+        let ext = match ctx.input.path.extension() {
             Some(s) => s.to_str().unwrap(),
             None => "txt",
         };
@@ -317,24 +317,24 @@ impl<'a> Generator<'a> {
     // for the given context struct.
     fn write_header(
         &mut self,
-        state: &'a State,
+        ctx: &'a Context,
         target: &str,
         params: Option<Vec<syn::GenericParam>>,
     ) {
-        let mut generics = state.input.ast.generics.clone();
+        let mut generics = ctx.input.ast.generics.clone();
         if let Some(params) = params {
             for param in params {
                 generics.params.push(param);
             }
         }
-        let (_, orig_ty_generics, _) = state.input.ast.generics.split_for_impl();
+        let (_, orig_ty_generics, _) = ctx.input.ast.generics.split_for_impl();
         let (impl_generics, _, where_clause) = generics.split_for_impl();
         self.writeln(
             format!(
                 "{} {} for {}{} {{",
                 quote!(impl#impl_generics),
                 target,
-                state.input.ast.ident,
+                ctx.input.ast.ident,
                 quote!(#orig_ty_generics #where_clause),
             ).as_ref(),
         );
@@ -342,7 +342,7 @@ impl<'a> Generator<'a> {
 
     /* Helper methods for handling node types */
 
-    fn handle(&mut self, state: &'a State, nodes: &'a [Node], level: AstLevel) {
+    fn handle(&mut self, ctx: &'a Context, nodes: &'a [Node], level: AstLevel) {
         for n in nodes {
             match *n {
                 Node::Lit(lws, val, rws) => {
@@ -352,7 +352,7 @@ impl<'a> Generator<'a> {
                     self.write_comment(ws);
                 }
                 Node::Expr(ref ws, ref val) => {
-                    self.write_expr(state, ws, val);
+                    self.write_expr(ctx, ws, val);
                 }
                 Node::LetDecl(ref ws, ref var) => {
                     self.write_let_decl(ws, var);
@@ -361,13 +361,13 @@ impl<'a> Generator<'a> {
                     self.write_let(ws, var, val);
                 }
                 Node::Cond(ref conds, ref ws) => {
-                    self.write_cond(state, conds, ws);
+                    self.write_cond(ctx, conds, ws);
                 }
                 Node::Match(ref ws1, ref expr, inter, ref arms, ref ws2) => {
-                    self.write_match(state, ws1, expr, inter, arms, ws2);
+                    self.write_match(ctx, ws1, expr, inter, arms, ws2);
                 }
                 Node::Loop(ref ws1, ref var, ref iter, ref body, ref ws2) => {
-                    self.write_loop(state, ws1, var, iter, body, ws2);
+                    self.write_loop(ctx, ws1, var, iter, body, ws2);
                 }
                 Node::BlockDef(ref ws1, name, _, ref ws2) => {
                     if let AstLevel::Nested = level {
@@ -380,10 +380,10 @@ impl<'a> Generator<'a> {
                     self.write_block(ws1, name, ws2);
                 }
                 Node::Include(ref ws, path) => {
-                    self.handle_include(state, ws, path);
+                    self.handle_include(ctx, ws, path);
                 }
                 Node::Call(ref ws, scope, name, ref args) => {
-                    self.write_call(state, ws, scope, name, args);
+                    self.write_call(ctx, ws, scope, name, args);
                 }
                 Node::Macro(_, ref m) => {
                     if level != AstLevel::Top {
@@ -409,8 +409,8 @@ impl<'a> Generator<'a> {
         }
     }
 
-    fn write_block_defs(&mut self, state: &'a State) {
-        for b in state.blocks.iter() {
+    fn write_block_defs(&mut self, ctx: &'a Context) {
+        for b in ctx.blocks.iter() {
             if let Node::BlockDef(ref ws1, name, ref nodes, ref ws2) = **b {
                 self.writeln("#[allow(unused_variables)]");
                 self.writeln(&format!(
@@ -421,7 +421,7 @@ impl<'a> Generator<'a> {
                 self.prepare_ws(ws1);
 
                 self.locals.push();
-                self.handle(state, nodes, AstLevel::Block);
+                self.handle(ctx, nodes, AstLevel::Block);
                 self.locals.pop();
 
                 self.flush_ws(ws2);
@@ -433,7 +433,7 @@ impl<'a> Generator<'a> {
         }
     }
 
-    fn write_cond(&mut self, state: &'a State, conds: &'a [Cond], ws: &WS) {
+    fn write_cond(&mut self, ctx: &'a Context, conds: &'a [Cond], ws: &WS) {
         for (i, &(ref cws, ref cond, ref nodes)) in conds.iter().enumerate() {
             self.handle_ws(cws);
             match *cond {
@@ -454,7 +454,7 @@ impl<'a> Generator<'a> {
             }
             self.writeln(" {");
             self.locals.push();
-            self.handle(state, nodes, AstLevel::Nested);
+            self.handle(ctx, nodes, AstLevel::Nested);
             self.locals.pop();
         }
         self.handle_ws(ws);
@@ -463,7 +463,7 @@ impl<'a> Generator<'a> {
 
     fn write_match(
         &mut self,
-        state: &'a State,
+        ctx: &'a Context,
         ws1: &WS,
         expr: &Expr,
         inter: Option<&'a str>,
@@ -503,7 +503,7 @@ impl<'a> Generator<'a> {
             }
             self.writeln(" => {");
             self.handle_ws(ws);
-            self.handle(state, body, AstLevel::Nested);
+            self.handle(ctx, body, AstLevel::Nested);
             self.writeln("}");
             self.locals.pop();
         }
@@ -514,7 +514,7 @@ impl<'a> Generator<'a> {
 
     fn write_loop(
         &mut self,
-        state: &'a State,
+        ctx: &'a Context,
         ws1: &WS,
         var: &'a Target,
         iter: &Expr,
@@ -533,7 +533,7 @@ impl<'a> Generator<'a> {
         }
         self.writeln(&format!(") in (&{}).into_iter().enumerate() {{", expr_code));
 
-        self.handle(state, body, AstLevel::Nested);
+        self.handle(ctx, body, AstLevel::Nested);
         self.handle_ws(ws2);
         self.writeln("}");
         self.locals.pop();
@@ -541,13 +541,13 @@ impl<'a> Generator<'a> {
 
     fn write_call(
         &mut self,
-        state: &'a State,
+        ctx: &'a Context,
         ws: &WS,
         scope: Option<&str>,
         name: &str,
         args: &[Expr],
     ) {
-        let def = state.macros.get(&(scope, name)).unwrap_or_else(|| {
+        let def = ctx.macros.get(&(scope, name)).unwrap_or_else(|| {
             if let Some(s) = scope {
                 panic!(format!("macro '{}::{}' not found", s, name));
             } else {
@@ -568,7 +568,7 @@ impl<'a> Generator<'a> {
             self.write(&format!("let {} = &{};", arg, expr_code));
             self.locals.insert(arg);
         }
-        self.handle(state, &def.nodes, AstLevel::Nested);
+        self.handle(ctx, &def.nodes, AstLevel::Nested);
 
         self.flush_ws(&def.ws2);
         self.writeln("}");
@@ -576,14 +576,14 @@ impl<'a> Generator<'a> {
         self.prepare_ws(ws);
     }
 
-    fn handle_include(&mut self, state: &'a State, ws: &WS, path: &str) {
+    fn handle_include(&mut self, ctx: &'a Context, ws: &WS, path: &str) {
         self.flush_ws(ws);
-        let path = path::find_template_from_path(path, Some(&state.input.path));
+        let path = path::find_template_from_path(path, Some(&ctx.input.path));
         let src = path::get_template_source(&path);
         let nodes = parser::parse(&src);
         let nested = {
             let mut gen = self.child();
-            gen.handle(state, &nodes, AstLevel::Nested);
+            gen.handle(ctx, &nodes, AstLevel::Nested);
             gen.buf
         };
         self.buf.push_str(&nested);
@@ -626,7 +626,7 @@ impl<'a> Generator<'a> {
         self.prepare_ws(ws2);
     }
 
-    fn write_expr(&mut self, state: &'a State, ws: &WS, s: &Expr) {
+    fn write_expr(&mut self, ctx: &'a Context, ws: &WS, s: &Expr) {
         self.handle_ws(ws);
         let mut code = String::new();
         let wrapped = self.visit_expr(s, &mut code);
@@ -635,7 +635,7 @@ impl<'a> Generator<'a> {
         use self::DisplayWrap::*;
         use super::input::EscapeMode::*;
         self.write("writer.write_fmt(format_args!(\"{}\", ");
-        self.write(match (wrapped, &state.input.escaping) {
+        self.write(match (wrapped, &ctx.input.escaping) {
             (Wrapped, &Html) | (Wrapped, &None) | (Unwrapped, &None) => "askama_expr",
             (Unwrapped, &Html) => "&::askama::MarkupDisplay::from(askama_expr)",
         });