From f759c364f9966412c69a0613567e9cac7bf5b85c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ren=C3=A9=20Kijewski?= Date: Fri, 7 Feb 2025 23:20:12 +0100 Subject: [PATCH 1/4] derive: no `rinja` on enum variants --- rinja_derive/src/input.rs | 19 ++++++++++++++----- testing/tests/ui/enum.rs | 33 +++++++++++++++++++++++++++++++++ testing/tests/ui/enum.stderr | 23 +++++++++++++++++++++++ 3 files changed, 70 insertions(+), 5 deletions(-) create mode 100644 testing/tests/ui/enum.rs create mode 100644 testing/tests/ui/enum.stderr diff --git a/rinja_derive/src/input.rs b/rinja_derive/src/input.rs index 5e20edb2..ad614b88 100644 --- a/rinja_derive/src/input.rs +++ b/rinja_derive/src/input.rs @@ -289,11 +289,11 @@ impl AnyTemplateArgs { return Ok(Self::Struct(TemplateArgs::new(ast)?)); }; - let enum_args = PartialTemplateArgs::new(ast, &ast.attrs)?; + let enum_args = PartialTemplateArgs::new(ast, &ast.attrs, false)?; let vars_args = enum_data .variants .iter() - .map(|variant| PartialTemplateArgs::new(ast, &variant.attrs)) + .map(|variant| PartialTemplateArgs::new(ast, &variant.attrs, true)) .collect::, _>>()?; if vars_args.is_empty() { return Ok(Self::Struct(TemplateArgs::from_partial(ast, enum_args)?)); @@ -361,7 +361,7 @@ pub(crate) struct TemplateArgs { impl TemplateArgs { pub(crate) fn new(ast: &syn::DeriveInput) -> Result { - Self::from_partial(ast, PartialTemplateArgs::new(ast, &ast.attrs)?) + Self::from_partial(ast, PartialTemplateArgs::new(ast, &ast.attrs, false)?) } pub(crate) fn from_partial( @@ -719,8 +719,9 @@ const _: () = { pub(crate) fn new( ast: &syn::DeriveInput, attrs: &[Attribute], + is_enum_variant: bool, ) -> Result, CompileError> { - new(ast, attrs) + new(ast, attrs, is_enum_variant) } } @@ -728,6 +729,7 @@ const _: () = { fn new( ast: &syn::DeriveInput, attrs: &[Attribute], + is_enum_variant: bool, ) -> Result, CompileError> { // FIXME: implement once is stable if let syn::Data::Union(data) = &ast.data { @@ -794,6 +796,13 @@ const _: () = { }; if ident == "rinja" { + if is_enum_variant { + return Err(CompileError::no_file_info( + "template attribute `rinja` can only be used on the `enum`, \ + not its variants", + Some(ident.span()), + )); + } ensure_only_once(ident, &mut this.crate_name)?; this.crate_name = Some(get_exprpath(ident, pair.value)?); continue; @@ -845,7 +854,7 @@ const _: () = { set_parseable_string(ident, value, &mut this.whitespace)?; } else { return Err(CompileError::no_file_info( - format!("unsupported template attribute `{ident}` found"), + format_args!("unsupported template attribute `{ident}` found"), Some(ident.span()), )); } diff --git a/testing/tests/ui/enum.rs b/testing/tests/ui/enum.rs new file mode 100644 index 00000000..bd0ef8fb --- /dev/null +++ b/testing/tests/ui/enum.rs @@ -0,0 +1,33 @@ +use rinja::Template; + +#[derive(Template)] +enum CratePathOnVariant { + #[template(ext = "txt", source = "🫨", rinja = rinja)] + Variant, +} + +#[derive(Template)] +enum CratePathOnVariants { + #[template(ext = "txt", source = "🫏", rinja = rinja)] + Variant1, + #[template(ext = "txt", source = "🪿", rinja = rinja)] + Variant2, +} + +#[derive(Template)] +#[template(ext = "txt", source = "🪼", rinja = rinja)] +enum CratePathOnBoth { + #[template(ext = "txt", source = "🪻", rinja = rinja)] + Variant, +} + +#[derive(Template)] +#[template(ext = "txt", source = "🫛", rinja = rinja)] +enum CratePathOnAll { + #[template(ext = "txt", source = "🫠", rinja = rinja)] + Variant1, + #[template(ext = "txt", source = "🧌", rinja = rinja)] + Variant2, +} + +fn main() {} diff --git a/testing/tests/ui/enum.stderr b/testing/tests/ui/enum.stderr new file mode 100644 index 00000000..3dee0168 --- /dev/null +++ b/testing/tests/ui/enum.stderr @@ -0,0 +1,23 @@ +error: template attribute `rinja` can only be used on the `enum`, not its variants + --> tests/ui/enum.rs:5:43 + | +5 | #[template(ext = "txt", source = "🫨", rinja = rinja)] + | ^^^^^ + +error: template attribute `rinja` can only be used on the `enum`, not its variants + --> tests/ui/enum.rs:11:43 + | +11 | #[template(ext = "txt", source = "🫏", rinja = rinja)] + | ^^^^^ + +error: template attribute `rinja` can only be used on the `enum`, not its variants + --> tests/ui/enum.rs:20:43 + | +20 | #[template(ext = "txt", source = "🪻", rinja = rinja)] + | ^^^^^ + +error: template attribute `rinja` can only be used on the `enum`, not its variants + --> tests/ui/enum.rs:27:43 + | +27 | #[template(ext = "txt", source = "🫠", rinja = rinja)] + | ^^^^^ From f0ded0ba32853c77071ab78d5339bee98a6483ef Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ren=C3=A9=20Kijewski?= Date: Fri, 7 Feb 2025 23:29:04 +0100 Subject: [PATCH 2/4] derive: add span to missing block message --- rinja_derive/src/generator/node.rs | 3 ++- rinja_derive/src/input.rs | 8 ++++---- rinja_derive/src/lib.rs | 6 +++--- testing/tests/ui/enum.rs | 21 +++++++++++++++++++++ testing/tests/ui/enum.stderr | 6 ++++++ 5 files changed, 36 insertions(+), 8 deletions(-) diff --git a/rinja_derive/src/generator/node.rs b/rinja_derive/src/generator/node.rs index 04756166..19acbd2b 100644 --- a/rinja_derive/src/generator/node.rs +++ b/rinja_derive/src/generator/node.rs @@ -1013,7 +1013,8 @@ impl<'a> Generator<'a, '_> { self.write_buf_writable(ctx, buf)?; - let block_fragment_write = self.input.block == name && self.buf_writable.discard; + let block_fragment_write = + self.input.block.map(|(block, _)| block) == name && self.buf_writable.discard; // Allow writing to the buffer if we're in the block fragment if block_fragment_write { self.buf_writable.discard = false; diff --git a/rinja_derive/src/input.rs b/rinja_derive/src/input.rs index ad614b88..b657e51b 100644 --- a/rinja_derive/src/input.rs +++ b/rinja_derive/src/input.rs @@ -24,7 +24,7 @@ pub(crate) struct TemplateInput<'a> { pub(crate) syntax: &'a SyntaxAndCache<'a>, pub(crate) source: &'a Source, pub(crate) source_span: Option, - pub(crate) block: Option<&'a str>, + pub(crate) block: Option<(&'a str, Span)>, pub(crate) print: Print, pub(crate) escaper: &'a str, pub(crate) path: Arc, @@ -133,7 +133,7 @@ impl TemplateInput<'_> { syntax, source, source_span: *source_span, - block: block.as_deref(), + block: block.as_ref().map(|(block, span)| (block.as_str(), *span)), print: *print, escaper, path, @@ -346,7 +346,7 @@ impl AnyTemplateArgs { pub(crate) struct TemplateArgs { pub(crate) source: (Source, Option), - block: Option, + block: Option<(String, Span)>, print: Print, escaping: Option, ext: Option, @@ -395,7 +395,7 @@ impl TemplateArgs { )); } }, - block: args.block.map(|value| value.value()), + block: args.block.map(|value| (value.value(), value.span())), print: args.print.unwrap_or_default(), escaping: args.escape.map(|value| value.value()), ext: args.ext.as_ref().map(|value| value.value()), diff --git a/rinja_derive/src/lib.rs b/rinja_derive/src/lib.rs index 27e6ac50..6af7b3ff 100644 --- a/rinja_derive/src/lib.rs +++ b/rinja_derive/src/lib.rs @@ -286,11 +286,11 @@ fn build_template_item( let heritage = if !ctx.blocks.is_empty() || ctx.extends.is_some() { let heritage = Heritage::new(ctx, &contexts); - if let Some(block_name) = input.block { + if let Some((block_name, block_span)) = input.block { if !heritage.blocks.contains_key(&block_name) { return Err(CompileError::no_file_info( - format!("cannot find block {block_name}"), - None, + format_args!("cannot find block `{block_name}`"), + Some(block_span), )); } } diff --git a/testing/tests/ui/enum.rs b/testing/tests/ui/enum.rs index bd0ef8fb..de952ae4 100644 --- a/testing/tests/ui/enum.rs +++ b/testing/tests/ui/enum.rs @@ -30,4 +30,25 @@ enum CratePathOnAll { Variant2, } +#[derive(Template)] +#[template( + ext = "txt", + source = " + {%- block a -%} a {%- endblock -%} + {%- block b -%} b {%- endblock -%} + {#- no block c -#} + {%- block d -%} d {%- endblock -%} + ", +)] +enum MissingBlockName { + #[template(block = "a")] + A, + #[template(block = "b")] + B, + #[template(block = "c")] + C, + #[template(block = "d")] + D, +} + fn main() {} diff --git a/testing/tests/ui/enum.stderr b/testing/tests/ui/enum.stderr index 3dee0168..59b5adfa 100644 --- a/testing/tests/ui/enum.stderr +++ b/testing/tests/ui/enum.stderr @@ -21,3 +21,9 @@ error: template attribute `rinja` can only be used on the `enum`, not its varian | 27 | #[template(ext = "txt", source = "🫠", rinja = rinja)] | ^^^^^ + +error: cannot find block `c` + --> tests/ui/enum.rs:48:24 + | +48 | #[template(block = "c")] + | ^^^ From 24c37c49f09ff08f191970a8b63109a335d1b194 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ren=C3=A9=20Kijewski?= Date: Fri, 7 Feb 2025 23:47:20 +0100 Subject: [PATCH 3/4] derive: replace some more `format!` with `format_args!` --- rinja_derive/src/input.rs | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/rinja_derive/src/input.rs b/rinja_derive/src/input.rs index b657e51b..256a1e04 100644 --- a/rinja_derive/src/input.rs +++ b/rinja_derive/src/input.rs @@ -76,7 +76,7 @@ impl TemplateInput<'_> { || Ok(config.syntaxes.get(config.default_syntax).unwrap()), |s| { config.syntaxes.get(s).ok_or_else(|| { - CompileError::no_file_info(format!("syntax `{s}` is undefined"), None) + CompileError::no_file_info(format_args!("syntax `{s}` is undefined"), None) }) }, )?; @@ -98,7 +98,7 @@ impl TemplateInput<'_> { }) .ok_or_else(|| { CompileError::no_file_info( - format!( + format_args!( "no escaper defined for extension '{escaping}'. You can define an escaper \ in the config file (named `rinja.toml` by default). {}", MsgValidEscapers(&config.escapers), @@ -509,7 +509,7 @@ fn no_rinja_code_block(span: Span, ast: &syn::DeriveInput) -> CompileError { syn::Data::Union(_) => "union", }; CompileError::no_file_info( - format!( + format_args!( "when using `in_doc` with the value `true`, the {kind}'s documentation needs a \ `rinja` code block" ), @@ -641,7 +641,7 @@ impl FromStr for Print { fn cyclic_graph_error(dependency_graph: &[(Arc, Arc)]) -> Result<(), CompileError> { Err(CompileError::no_file_info( - format!( + format_args!( "cyclic dependency in graph {:#?}", dependency_graph .iter() @@ -776,7 +776,7 @@ const _: () = { .parse_args_with(>::parse_terminated) .map_err(|e| { CompileError::no_file_info( - format!("unable to parse template arguments: {e}"), + format_args!("unable to parse template arguments: {e}"), Some(attr.path().span()), ) })?; @@ -907,7 +907,7 @@ const _: () = { Ok(()) } else { Err(CompileError::no_file_info( - format!("template attribute `{name}` already set"), + format_args!("template attribute `{name}` already set"), Some(name.span()), )) } @@ -920,7 +920,7 @@ const _: () = { Expr::Group(group) => expr = *group.expr, v => { return Err(CompileError::no_file_info( - format!("template attribute `{name}` expects a literal"), + format_args!("template attribute `{name}` expects a literal"), Some(v.span()), )); } @@ -933,7 +933,7 @@ const _: () = { Ok(s) } else { Err(CompileError::no_file_info( - format!("template attribute `{name}` expects a string literal"), + format_args!("template attribute `{name}` expects a string literal"), Some(value.lit.span()), )) } @@ -944,7 +944,7 @@ const _: () = { Ok(s) } else { Err(CompileError::no_file_info( - format!("template attribute `{name}` expects a boolean value"), + format_args!("template attribute `{name}` expects a boolean value"), Some(value.lit.span()), )) } @@ -957,7 +957,7 @@ const _: () = { Expr::Group(group) => expr = *group.expr, v => { return Err(CompileError::no_file_info( - format!("template attribute `{name}` expects a path or identifier"), + format_args!("template attribute `{name}` expects a path or identifier"), Some(v.span()), )); } From 137aaa060417d3d100bfbf93273b49f34b5e9ef9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ren=C3=A9=20Kijewski?= Date: Sat, 8 Feb 2025 01:38:56 +0100 Subject: [PATCH 4/4] derive: implement template attribute `blocks` --- rinja/Cargo.toml | 3 +- rinja_derive/Cargo.toml | 1 + rinja_derive/src/generator.rs | 159 ++++++++++++++++++++++++++++- rinja_derive/src/input.rs | 67 +++++++++++- rinja_derive/src/lib.rs | 2 +- rinja_derive_standalone/Cargo.toml | 1 + testing/Cargo.toml | 5 +- testing/tests/blocks.rs | 40 ++++++++ 8 files changed, 269 insertions(+), 9 deletions(-) create mode 100644 testing/tests/blocks.rs diff --git a/rinja/Cargo.toml b/rinja/Cargo.toml index efc71169..69272201 100644 --- a/rinja/Cargo.toml +++ b/rinja/Cargo.toml @@ -44,7 +44,7 @@ maintenance = { status = "actively-developed" } [features] default = ["config", "std", "urlencode"] -full = ["default", "code-in-doc", "serde_json"] +full = ["default", "blocks", "code-in-doc", "serde_json"] alloc = [ "rinja_derive/alloc", @@ -52,6 +52,7 @@ alloc = [ "serde_json?/alloc", "percent-encoding?/alloc" ] +blocks = ["rinja_derive/blocks"] code-in-doc = ["rinja_derive/code-in-doc"] config = ["rinja_derive/config"] serde_json = ["rinja_derive/serde_json", "dep:serde", "dep:serde_json"] diff --git a/rinja_derive/Cargo.toml b/rinja_derive/Cargo.toml index 4306ab63..e9a2b548 100644 --- a/rinja_derive/Cargo.toml +++ b/rinja_derive/Cargo.toml @@ -39,6 +39,7 @@ syn = { version = "2.0.3", features = ["full"] } [features] alloc = [] +blocks = ["syn/full"] code-in-doc = ["dep:pulldown-cmark"] config = ["dep:serde", "dep:basic-toml", "parser/config"] urlencode = [] diff --git a/rinja_derive/src/generator.rs b/rinja_derive/src/generator.rs index 4cd60df5..749b5c68 100644 --- a/rinja_derive/src/generator.rs +++ b/rinja_derive/src/generator.rs @@ -25,7 +25,7 @@ pub(crate) fn template_to_string( input: &TemplateInput<'_>, contexts: &HashMap<&Arc, Context<'_>, FxBuildHasher>, heritage: Option<&Heritage<'_, '_>>, - tmpl_kind: TmplKind, + tmpl_kind: TmplKind<'_>, ) -> Result { let generator = Generator::new( input, @@ -50,11 +50,14 @@ pub(crate) fn template_to_string( } #[derive(Debug, Clone, Copy, PartialEq, Eq)] -pub(crate) enum TmplKind { +pub(crate) enum TmplKind<'a> { /// [`rinja::Template`] Struct, /// [`rinja::helpers::EnumVariantTemplate`] Variant, + /// Used in `blocks` implementation + #[allow(unused)] + Block(&'a str), } struct Generator<'a, 'h> { @@ -113,13 +116,14 @@ impl<'a, 'h> Generator<'a, 'h> { fn impl_template( mut self, buf: &mut Buffer, - tmpl_kind: TmplKind, + tmpl_kind: TmplKind<'a>, ) -> Result { let ctx = &self.contexts[&self.input.path]; let target = match tmpl_kind { TmplKind::Struct => "rinja::Template", TmplKind::Variant => "rinja::helpers::EnumVariantTemplate", + TmplKind::Block(trait_name) => trait_name, }; write_header(self.input.ast, buf, target); buf.write( @@ -170,9 +174,158 @@ impl<'a, 'h> Generator<'a, 'h> { } buf.write('}'); + + #[cfg(feature = "blocks")] + for (block, span) in self.input.blocks { + self.impl_block(buf, block, span)?; + } + Ok(size_hint) } + #[cfg(feature = "blocks")] + fn impl_block( + &self, + buf: &mut Buffer, + block: &str, + span: &proc_macro2::Span, + ) -> Result<(), CompileError> { + // RATIONALE: `*self` must be the input type, implementation details should not leak: + // - impl Self { fn as_block(self) } -> + // - struct __Rinja__Self__as__block__Wrapper { this: self } -> + // - impl Template for __Rinja__Self__as__block__Wrapper { fn render_into_with_values() } -> + // - impl __Rinja__Self__as__block for Self { render_into_with_values() } + + use quote::quote_spanned; + use syn::{GenericParam, Ident, Lifetime, LifetimeParam, Token}; + + let span = *span; + buf.write( + "\ + #[allow(missing_docs, non_camel_case_types, non_snake_case, unreachable_pub)]\ + const _: () = {", + ); + + let ident = &self.input.ast.ident; + + let doc = format!("A sub-template that renders only the block `{block}` of [`{ident}`]."); + let method_name = format!("as_{block}"); + let trait_name = format!("__Rinja__{ident}__as__{block}"); + let wrapper_name = format!("__Rinja__{ident}__as__{block}__Wrapper"); + let self_lt_name = format!("'__Rinja__{ident}__as__{block}__self"); + + let method_id = Ident::new(&method_name, span); + let trait_id = Ident::new(&trait_name, span); + let wrapper_id = Ident::new(&wrapper_name, span); + let self_lt = Lifetime::new(&self_lt_name, span); + + // generics of the input with an additional lifetime to capture `self` + let mut wrapper_generics = self.input.ast.generics.clone(); + if wrapper_generics.lt_token.is_none() { + wrapper_generics.lt_token = Some(Token![<](span)); + wrapper_generics.gt_token = Some(Token![>](span)); + } + wrapper_generics.params.insert( + 0, + GenericParam::Lifetime(LifetimeParam::new(self_lt.clone())), + ); + + let (impl_generics, ty_generics, where_clause) = self.input.ast.generics.split_for_impl(); + let (wrapper_impl_generics, wrapper_ty_generics, wrapper_where_clause) = + wrapper_generics.split_for_impl(); + + let input = TemplateInput { + block: Some((block, span)), + #[cfg(feature = "blocks")] + blocks: &[], + ..self.input.clone() + }; + let size_hint = template_to_string( + buf, + &input, + self.contexts, + self.heritage, + TmplKind::Block(&trait_name), + )?; + + buf.write(quote_spanned! { + span => + pub trait #trait_id { + fn render_into_with_values( + &self, + writer: &mut RinjaW, + values: &dyn rinja::Values, + ) -> rinja::Result<()> + where + RinjaW: + rinja::helpers::core::fmt::Write + ?rinja::helpers::core::marker::Sized; + } + + impl #impl_generics #ident #ty_generics #where_clause { + #[inline] + #[doc = #doc] + pub fn #method_id(&self) -> impl rinja::Template + '_ { + #wrapper_id { + this: self, + } + } + } + + #[rinja::helpers::core::prelude::rust_2021::derive( + rinja::helpers::core::prelude::rust_2021::Clone, + rinja::helpers::core::prelude::rust_2021::Copy + )] + pub struct #wrapper_id #wrapper_generics #wrapper_where_clause { + this: &#self_lt #ident #ty_generics, + } + + impl #wrapper_impl_generics rinja::Template + for #wrapper_id #wrapper_ty_generics #wrapper_where_clause { + #[inline] + fn render_into_with_values( + &self, + writer: &mut RinjaW, + values: &dyn rinja::Values + ) -> rinja::Result<()> + where + RinjaW: rinja::helpers::core::fmt::Write + ?rinja::helpers::core::marker::Sized + { + <_ as #trait_id>::render_into_with_values(self.this, writer, values) + } + + const SIZE_HINT: rinja::helpers::core::primitive::usize = #size_hint; + } + + // cannot use `crate::integrations::impl_fast_writable()` w/o cloning the struct + impl #wrapper_impl_generics rinja::filters::FastWritable + for #wrapper_id #wrapper_ty_generics #wrapper_where_clause { + #[inline] + fn write_into(&self, dest: &mut RinjaW) -> rinja::Result<()> + where + RinjaW: rinja::helpers::core::fmt::Write + ?rinja::helpers::core::marker::Sized + { + <_ as rinja::Template>::render_into(self, dest) + } + } + + // cannot use `crate::integrations::impl_display()` w/o cloning the struct + impl #wrapper_impl_generics rinja::helpers::core::fmt::Display + for #wrapper_id #wrapper_ty_generics #wrapper_where_clause { + #[inline] + fn fmt( + &self, + f: &mut rinja::helpers::core::fmt::Formatter<'_> + ) -> rinja::helpers::core::fmt::Result { + <_ as rinja::Template>::render_into(self, f) + .map_err(|_| rinja::helpers::core::fmt::Error) + } + } + }); + + buf.write("};"); + Ok(()) + } + fn is_var_defined(&self, var_name: &str) -> bool { self.locals.get(var_name).is_some() || self.input.fields.iter().any(|f| f == var_name) } diff --git a/rinja_derive/src/input.rs b/rinja_derive/src/input.rs index 256a1e04..cb3d3ebb 100644 --- a/rinja_derive/src/input.rs +++ b/rinja_derive/src/input.rs @@ -17,6 +17,7 @@ use syn::{Attribute, Expr, ExprLit, ExprPath, Ident, Lit, LitBool, LitStr, Meta, use crate::config::{Config, SyntaxAndCache}; use crate::{CompileError, FileInfo, MsgValidEscapers, OnceMap}; +#[derive(Clone)] pub(crate) struct TemplateInput<'a> { pub(crate) ast: &'a syn::DeriveInput, pub(crate) enum_ast: Option<&'a syn::DeriveInput>, @@ -25,10 +26,12 @@ pub(crate) struct TemplateInput<'a> { pub(crate) source: &'a Source, pub(crate) source_span: Option, pub(crate) block: Option<(&'a str, Span)>, + #[cfg(feature = "blocks")] + pub(crate) blocks: &'a [(String, Span)], pub(crate) print: Print, pub(crate) escaper: &'a str, pub(crate) path: Arc, - pub(crate) fields: Vec, + pub(crate) fields: Arc<[String]>, } impl TemplateInput<'_> { @@ -44,6 +47,8 @@ impl TemplateInput<'_> { let TemplateArgs { source: (source, source_span), block, + #[cfg(feature = "blocks")] + blocks, print, escaping, ext, @@ -134,10 +139,12 @@ impl TemplateInput<'_> { source, source_span: *source_span, block: block.as_ref().map(|(block, span)| (block.as_str(), *span)), + #[cfg(feature = "blocks")] + blocks: blocks.as_slice(), print: *print, escaper, path, - fields, + fields: fields.into(), }) } @@ -347,6 +354,8 @@ impl AnyTemplateArgs { pub(crate) struct TemplateArgs { pub(crate) source: (Source, Option), block: Option<(String, Span)>, + #[cfg(feature = "blocks")] + blocks: Vec<(String, Span)>, print: Print, escaping: Option, ext: Option, @@ -396,6 +405,13 @@ impl TemplateArgs { } }, block: args.block.map(|value| (value.value(), value.span())), + #[cfg(feature = "blocks")] + blocks: args + .blocks + .unwrap_or_default() + .into_iter() + .map(|value| (value.value(), value.span())) + .collect(), print: args.print.unwrap_or_default(), escaping: args.escape.map(|value| value.value()), ext: args.ext.as_ref().map(|value| value.value()), @@ -413,6 +429,8 @@ impl TemplateArgs { Self { source: (Source::Source("".into()), None), block: None, + #[cfg(feature = "blocks")] + blocks: vec![], print: Print::default(), escaping: None, ext: Some("txt".to_string()), @@ -692,6 +710,8 @@ pub(crate) struct PartialTemplateArgs { pub(crate) config: Option, pub(crate) whitespace: Option, pub(crate) crate_name: Option, + #[cfg(feature = "blocks")] + pub(crate) blocks: Option>, } #[derive(Clone)] @@ -754,6 +774,8 @@ const _: () = { config: None, whitespace: None, crate_name: None, + #[cfg(feature = "blocks")] + blocks: None, }; let mut has_data = false; @@ -806,6 +828,31 @@ const _: () = { ensure_only_once(ident, &mut this.crate_name)?; this.crate_name = Some(get_exprpath(ident, pair.value)?); continue; + } else if ident == "blocks" { + if !cfg!(feature = "blocks") { + return Err(CompileError::no_file_info( + "enable feature `blocks` to use `blocks` argument", + Some(ident.span()), + )); + } else if is_enum_variant { + return Err(CompileError::no_file_info( + "template attribute `blocks` can only be used on the `enum`, \ + not its variants", + Some(ident.span()), + )); + } + #[cfg(feature = "blocks")] + { + ensure_only_once(ident, &mut this.blocks)?; + this.blocks = Some( + get_exprarray(ident, pair.value)? + .elems + .into_iter() + .map(|value| get_strlit(ident, get_lit(ident, value)?)) + .collect::>()?, + ); + continue; + } } let value = get_lit(ident, pair.value)?; @@ -965,6 +1012,22 @@ const _: () = { } } + #[cfg(feature = "blocks")] + fn get_exprarray(name: &Ident, mut expr: Expr) -> Result { + loop { + match expr { + Expr::Array(array) => return Ok(array), + Expr::Group(group) => expr = *group.expr, + v => { + return Err(CompileError::no_file_info( + format_args!("template attribute `{name}` expects an array"), + Some(v.span()), + )); + } + } + } + } + fn ensure_source_only_once( name: &Ident, source: &Option, diff --git a/rinja_derive/src/lib.rs b/rinja_derive/src/lib.rs index 6af7b3ff..0d6a68f5 100644 --- a/rinja_derive/src/lib.rs +++ b/rinja_derive/src/lib.rs @@ -262,7 +262,7 @@ fn build_template_item( ast: &syn::DeriveInput, enum_ast: Option<&syn::DeriveInput>, template_args: &TemplateArgs, - tmpl_kind: TmplKind, + tmpl_kind: TmplKind<'_>, ) -> Result { let config_path = template_args.config_path(); let s = read_config_file(config_path, template_args.config_span)?; diff --git a/rinja_derive_standalone/Cargo.toml b/rinja_derive_standalone/Cargo.toml index 63686383..50a9f252 100644 --- a/rinja_derive_standalone/Cargo.toml +++ b/rinja_derive_standalone/Cargo.toml @@ -46,6 +46,7 @@ syn = { version = "2.0.3", features = ["full"] } default = ["__standalone"] __standalone = [] +blocks = ["syn/full"] code-in-doc = ["dep:pulldown-cmark"] config = ["dep:serde", "dep:basic-toml", "parser/config"] urlencode = [] diff --git a/testing/Cargo.toml b/testing/Cargo.toml index 6a4817bd..accde7de 100644 --- a/testing/Cargo.toml +++ b/testing/Cargo.toml @@ -23,7 +23,7 @@ serde_json = { version = "1.0", optional = true } core = { package = "intentionally-empty", version = "1.0.0" } [dev-dependencies] -rinja = { path = "../rinja", version = "0.3.5", features = ["code-in-doc", "serde_json"] } +rinja = { path = "../rinja", version = "0.3.5", features = ["blocks", "code-in-doc", "serde_json"] } assert_matches = "1.5.0" criterion = "0.5" @@ -31,7 +31,8 @@ phf = { version = "0.11", features = ["macros" ] } trybuild = "1.0.100" [features] -default = ["code-in-doc", "serde_json"] +default = ["blocks", "code-in-doc", "serde_json"] +blocks = ["rinja/blocks"] code-in-doc = ["rinja/code-in-doc"] serde_json = ["dep:serde_json", "rinja/serde_json"] diff --git a/testing/tests/blocks.rs b/testing/tests/blocks.rs new file mode 100644 index 00000000..511f2b4c --- /dev/null +++ b/testing/tests/blocks.rs @@ -0,0 +1,40 @@ +#![cfg(feature = "blocks")] + +use std::fmt::Display; + +use rinja::Template; + +#[test] +fn test_blocks() { + #[derive(Template)] + #[template( + ext = "txt", + source = " + {%- block first -%} first=<{{first}}> {%- endblock -%} + {%- block second -%} second=<{{second}}> {%- endblock -%} + {%- block third -%} third=<{{third}}> {%- endblock -%} + {%- block fail -%} better luck next time {%- endblock -%} + ", + block = "fail", + blocks = ["first", "second", "third"] + )] + struct WithBlocks<'a, S: Display, T> + where + T: Display, + { + first: &'a str, + second: S, + third: &'a T, + } + + let tmpl = WithBlocks { + first: "number one", + second: 2, + third: &"bronze", + }; + + assert_eq!(tmpl.as_first().render().unwrap(), "first="); + assert_eq!(tmpl.as_second().render().unwrap(), "second=<2>"); + assert_eq!(tmpl.as_third().render().unwrap(), "third="); + assert_eq!(tmpl.render().unwrap(), "better luck next time"); +}