itsscb/askama
1
0
Fork 0
mirror of https://github.com/askama-rs/askama.git synced 2025-10-02 07:20:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

Use if-let-chains

Browse Source 
I ran `cargo +nightly clippy --all-targets --fix  -- -D warnings` and
made only tiny manual improvements.
This commit is contained in:
René Kijewski 2025-07-13 22:27:59 +02:00
parent 79d8f8886b
commit f201285ede
10 changed files with 90 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
askama/src/filters/json.rs
View File

@ -195,11 +195,11 @@ where
fn get_escaped(byte: u8) -> Option<[AsciiChar; 2]> { fn get_escaped(byte: u8) -> Option<[AsciiChar; 2]> {
const _: () = assert!(CHAR_RANGE < 32); const _: () = assert!(CHAR_RANGE < 32);
if let MIN_CHAR..=MAX_CHAR = byte { if let MIN_CHAR..=MAX_CHAR = byte
if (1u32 << (byte - MIN_CHAR)) & BITS != 0 { && (1u32 << (byte - MIN_CHAR)) & BITS != 0
{
return Some(TABLE.0[(byte - MIN_CHAR) as usize]); return Some(TABLE.0[(byte - MIN_CHAR) as usize]);
} }
}
None None
} }

6
askama/src/helpers.rs
View File

@ -90,12 +90,12 @@ where
{ {
#[inline] #[inline]
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
if let Some(func) = self.func.take() { if let Some(func) = self.func.take()
if let Err(err) = func(f) { && let Err(err) = func(f)
{
self.err.set(Some(err)); self.err.set(Some(err));
return Err(fmt::Error); return Err(fmt::Error);
} }
}
Ok(()) Ok(())
} }
} }

6
askama_derive/src/generator/expr.rs
View File

@ -673,15 +673,15 @@ impl<'a> Generator<'a, '_> {
for (i, part) in path.iter().copied().enumerate() { for (i, part) in path.iter().copied().enumerate() {
if i > 0 { if i > 0 {
buf.write("::"); buf.write("::");
} else if let Some(enum_ast) = self.input.enum_ast { } else if let Some(enum_ast) = self.input.enum_ast
if part == "Self" { && part == "Self"
{
let this = &enum_ast.ident; let this = &enum_ast.ident;
let (_, generics, _) = enum_ast.generics.split_for_impl(); let (_, generics, _) = enum_ast.generics.split_for_impl();
let generics = generics.as_turbofish(); let generics = generics.as_turbofish();
buf.write(quote!(#this #generics)); buf.write(quote!(#this #generics));
continue; continue;
} }
}
buf.write(part); buf.write(part);
} }
DisplayWrap::Unwrapped DisplayWrap::Unwrapped

6
askama_derive/src/generator/filter.rs
View File

@ -562,8 +562,9 @@ impl<'a> Generator<'a, '_> {
) -> Result<DisplayWrap, CompileError> { ) -> Result<DisplayWrap, CompileError> {
ensure_filter_has_feature_alloc(ctx, "format", node)?; ensure_filter_has_feature_alloc(ctx, "format", node)?;
ensure_no_named_arguments(ctx, "format", args, node)?; ensure_no_named_arguments(ctx, "format", args, node)?;
if !args.is_empty() { if !args.is_empty()
if let Expr::StrLit(ref fmt) = *args[0] { && let Expr::StrLit(ref fmt) = *args[0]
{
buf.write("askama::helpers::alloc::format!("); buf.write("askama::helpers::alloc::format!(");
self.visit_str_lit(buf, fmt); self.visit_str_lit(buf, fmt);
if args.len() > 1 { if args.len() > 1 {
@ -573,7 +574,6 @@ impl<'a> Generator<'a, '_> {
buf.write(')'); buf.write(')');
return Ok(DisplayWrap::Unwrapped); return Ok(DisplayWrap::Unwrapped);
} }
}
Err(ctx.generate_error( Err(ctx.generate_error(
r#"use `format` filter like `"a={} b={}"|format(a, b)`"#, r#"use `format` filter like `"a={} b={}"|format(a, b)`"#,
node, node,

6
askama_derive/src/generator/node.rs
View File

@ -1585,8 +1585,9 @@ fn macro_call_ensure_arg_count(
} }
_ => Some(pos), _ => Some(pos),
}; };
if let Some(pos) = pos { if let Some(pos) = pos
if mem::take(&mut args[pos]).is_none() { && mem::take(&mut args[pos]).is_none()
{
// This argument was already passed, so error. // This argument was already passed, so error.
return Err(ctx.generate_error( return Err(ctx.generate_error(
format_args!( format_args!(
@ -1597,7 +1598,6 @@ fn macro_call_ensure_arg_count(
)); ));
} }
} }
}
// Now we can check off arguments with a default value, too. // Now we can check off arguments with a default value, too.
for (pos, (_, dflt)) in def.args.iter().enumerate() { for (pos, (_, dflt)) in def.args.iter().enumerate() {

6
askama_derive/src/integration.rs
View File

@ -386,11 +386,11 @@ where
A: FnMut(&mut S) -> &mut Option<T>, A: FnMut(&mut S) -> &mut Option<T>,
{ {
let dest = access(dest); let dest = access(dest);
if dest.is_none() { if dest.is_none()
if let Some(parent) = access(parent) { && let Some(parent) = access(parent)
{
*dest = Some(parent.clone()); *dest = Some(parent.clone());
} }
}
} }
/// Generates a `struct` to contain the data of an enum variant /// Generates a `struct` to contain the data of an enum variant

6
askama_derive/src/lib.rs
View File

@ -331,11 +331,11 @@ pub(crate) fn build_template(
build_template_enum(buf, ast, enum_args, vars_args, has_default_impl) build_template_enum(buf, ast, enum_args, vars_args, has_default_impl)
} }
}; };
if let Err(err) = &mut result { if let Err(err) = &mut result
if err.span.is_none() { && err.span.is_none()
{
err.span = err_span; err.span = err_span;
} }
}
result result
} }

27
askama_parser/src/expr.rs
View File

@ -71,11 +71,11 @@ fn check_expr<'a>(expr: &WithSpan<'a, Expr<'a>>, allowed: Allowed) -> ParseResul
} }
} }
Expr::Path(path) => { Expr::Path(path) => {
if let &[name] = path.as_slice() { if let &[name] = path.as_slice()
if !crate::can_be_variable_name(name) { && !crate::can_be_variable_name(name)
{
return err_reserved_identifier(name); return err_reserved_identifier(name);
} }
}
Ok(()) Ok(())
} }
Expr::Array(elems) | Expr::Tuple(elems) | Expr::Concat(elems) => { Expr::Array(elems) | Expr::Tuple(elems) | Expr::Concat(elems) => {
@ -996,26 +996,25 @@ impl<'a> Suffix<'a> {
const THREE_CHARS: &[&str] = &["<<=", ">>=", "...", "..="]; const THREE_CHARS: &[&str] = &["<<=", ">>=", "...", "..="];
// need to check long to short // need to check long to short
if let Some((head, tail)) = i.split_at_checked(3) { if let Some((head, tail)) = i.split_at_checked(3)
if THREE_CHARS.contains(&head) { && THREE_CHARS.contains(&head)
{
*i = tail; *i = tail;
return Ok(()); return Ok(());
} }
} if let Some((head, tail)) = i.split_at_checked(2)
if let Some((head, tail)) = i.split_at_checked(2) { && TWO_CHARS.contains(&head)
if TWO_CHARS.contains(&head) { {
*i = tail; *i = tail;
return Ok(()); return Ok(());
} }
} if let Some((head, tail)) = i.split_at_checked(1)
if let Some((head, tail)) = i.split_at_checked(1) { && let [head] = head.as_bytes()
if let [head] = head.as_bytes() { && ONE_CHAR.contains(head)
if ONE_CHAR.contains(head) { {
*i = tail; *i = tail;
return Ok(()); return Ok(());
} }
}
}
fail(i) fail(i)
} }

18
askama_parser/src/node.rs
View File

@ -42,14 +42,14 @@ impl<'a> Node<'a> {
let result = match (|i: &mut _| Self::many(i, s)).parse_next(i) { let result = match (|i: &mut _| Self::many(i, s)).parse_next(i) {
Ok(result) => result, Ok(result) => result,
Err(err) => { Err(err) => {
if let ErrMode::Backtrack(err) | ErrMode::Cut(err) = &err { if let ErrMode::Backtrack(err) | ErrMode::Cut(err) = &err
if err.message.is_none() { && err.message.is_none()
{
*i = start; *i = start;
if let Some(mut span) = err.span.as_suffix_of(i) { if let Some(mut span) = err.span.as_suffix_of(i) {
opt(|i: &mut _| unexpected_tag(i, s)).parse_next(&mut span)?; opt(|i: &mut _| unexpected_tag(i, s)).parse_next(&mut span)?;
} }
} }
}
return Err(err); return Err(err);
} }
}; };
@ -216,14 +216,14 @@ fn cut_node<'a, O>(
move |i: &mut &'a str| { move |i: &mut &'a str| {
let start = *i; let start = *i;
let result = inner.parse_next(i); let result = inner.parse_next(i);
if let Err(ErrMode::Cut(err) | ErrMode::Backtrack(err)) = &result { if let Err(ErrMode::Cut(err) | ErrMode::Backtrack(err)) = &result
if err.message.is_none() { && err.message.is_none()
{
*i = start; *i = start;
if let Some(mut span) = err.span.as_suffix_of(i) { if let Some(mut span) = err.span.as_suffix_of(i) {
opt(|i: &mut _| unexpected_raw_tag(kind, i)).parse_next(&mut span)?; opt(|i: &mut _| unexpected_raw_tag(kind, i)).parse_next(&mut span)?;
} }
} }
}
result result
} }
} }
@ -414,15 +414,15 @@ impl<'a> CondTest<'a> {
ws(|i: &mut _| { ws(|i: &mut _| {
let start = *i; let start = *i;
let mut expr = Expr::parse(i, s.level, false)?; let mut expr = Expr::parse(i, s.level, false)?;
if let Expr::BinOp(v) = &mut expr.inner { if let Expr::BinOp(v) = &mut expr.inner
if matches!(v.rhs.inner, Expr::Var("set" | "let")) { && matches!(v.rhs.inner, Expr::Var("set" | "let"))
{
let _level_guard = s.level.nest(i)?; let _level_guard = s.level.nest(i)?;
*i = v.rhs.span.as_suffix_of(start).unwrap(); *i = v.rhs.span.as_suffix_of(start).unwrap();
let start_span = Span::from(*i); let start_span = Span::from(*i);
let new_right = Self::parse_cond(i, s)?; let new_right = Self::parse_cond(i, s)?;
v.rhs.inner = Expr::LetCond(Box::new(WithSpan::new(new_right, start_span))); v.rhs.inner = Expr::LetCond(Box::new(WithSpan::new(new_right, start_span)));
} }
}
Ok(expr) Ok(expr)
}), }),
) )

6
askama_parser/src/target.rs
View File

@ -165,11 +165,11 @@ impl<'a> Target<'a> {
*i, *i,
); );
} }
if let Target::Rest(ref s) = rest.0 { if let Target::Rest(ref s) = rest.0
if s.inner.is_some() { && s.inner.is_some()
{
return cut_error!("`@ ..` cannot be used in struct", s.span); return cut_error!("`@ ..` cannot be used in struct", s.span);
} }
}
return Ok((rest.1, rest.0)); return Ok((rest.1, rest.0));
} }