Update nom to 8.0.0.

Author: kaj

.github/workflows/ci.yml

@@ -14,7 +14,7 @@ jobs:
           - stable
           - 1.75.0
           - 1.67.1
-          - 1.63.0
+          - 1.65.0
           - beta
           - nightly
     steps:

CHANGELOG.md

@@ -8,6 +8,12 @@ project adheres to
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 
+## Unreleased
+
+* Updated `nom` to 8.0.0, and added `nom-language`.
+* MSRV is now 1.65.0, as required by `nom` 8.0.
+
+
 ## Release 0.18.0 -- 2025-02-03
 
 * Fixed clippy lints in generated code (PR #143).  Thanks @vbrandl!

Cargo.toml

@@ -10,7 +10,7 @@ keywords = ["web", "templating", "template", "html"]
 categories = ["template-engine", "web-programming"]
 license = "MIT OR Apache-2.0"
 edition = "2021"
-rust-version = "1.63.0"
+rust-version = "1.65.0"
 
 [features]
 sass = ["dep:rsass"]
@@ -27,7 +27,8 @@ base64 = "0.22.1"
 bytecount = "0.6.0"
 itertools = "0.14.0"
 md5 = "0.7"
-nom = "7.1.0"
+nom = "8.0.0"
+nom-language = "0.1.0"
 
 rsass = { version = "0.29.0", optional = true }
 mime = { version = "0.3", optional = true }

src/expression.rs

@@ -3,16 +3,17 @@ use nom::branch::alt;
 use nom::bytes::complete::{escaped, is_a, is_not, tag};
 use nom::character::complete::{alpha1, char, digit1, none_of, one_of};
 use nom::combinator::{map, map_res, not, opt, recognize, value};
-use nom::error::context; //, VerboseError};
+use nom::error::context;
 use nom::multi::{fold_many0, many0, separated_list0};
-use nom::sequence::{delimited, pair, preceded, terminated, tuple};
+use nom::sequence::{delimited, pair, preceded, terminated};
+use nom::Parser as _;
 use std::str::{from_utf8, Utf8Error};
 
 pub fn expression(input: &[u8]) -> PResult<&str> {
     map_res(
         recognize(context(
             "Expected rust expression",
-            tuple((
+            (
                 map_res(alt((tag("&"), tag("*"), tag(""))), input_to_str),
                 alt((
                     rust_name,
@@ -34,10 +35,11 @@ pub fn expression(input: &[u8]) -> PResult<&str> {
                     || (),
                     |_, _| (),
                 ),
-            )),
+            ),
         )),
         input_to_str,
-    )(input)
+    )
+    .parse(input)
 }
 
 pub fn input_to_str(s: &[u8]) -> Result<&str, Utf8Error> {
@@ -48,7 +50,8 @@ pub fn comma_expressions(input: &[u8]) -> PResult<String> {
     map(
         separated_list0(preceded(tag(","), many0(tag(" "))), expression),
         |list: Vec<_>| list.join(", "),
-    )(input)
+    )
+    .parse(input)
 }
 
 pub fn rust_name(input: &[u8]) -> PResult<&str> {
@@ -58,14 +61,15 @@ pub fn rust_name(input: &[u8]) -> PResult<&str> {
             opt(is_a("_0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")),
         )),
         input_to_str,
-    )(input)
+    ).parse(input)
 }
 
 fn expr_in_parens(input: &[u8]) -> PResult<&str> {
     map_res(
         recognize(delimited(tag("("), expr_inside_parens, tag(")"))),
         input_to_str,
-    )(input)
+    )
+    .parse(input)
 }
 
 fn expr_in_brackets(input: &[u8]) -> PResult<&str> {
@@ -84,7 +88,8 @@ fn expr_in_brackets(input: &[u8]) -> PResult<&str> {
             tag("]"),
         )),
         input_to_str,
-    )(input)
+    )
+    .parse(input)
 }
 
 pub fn expr_in_braces(input: &[u8]) -> PResult<&str> {
@@ -103,7 +108,8 @@ pub fn expr_in_braces(input: &[u8]) -> PResult<&str> {
             tag("}"),
         )),
         input_to_str,
-    )(input)
+    )
+    .parse(input)
 }
 
 pub fn expr_inside_parens(input: &[u8]) -> PResult<&str> {
@@ -118,7 +124,8 @@ pub fn expr_inside_parens(input: &[u8]) -> PResult<&str> {
             value((), terminated(tag("/"), none_of("*"))),
         )))),
         input_to_str,
-    )(input)
+    )
+    .parse(input)
 }
 
 pub fn quoted_string(input: &[u8]) -> PResult<&str> {
@@ -129,7 +136,8 @@ pub fn quoted_string(input: &[u8]) -> PResult<&str> {
             char('"'),
         )),
         input_to_str,
-    )(input)
+    )
+    .parse(input)
 }
 
 pub fn rust_comment(input: &[u8]) -> PResult<&[u8]> {
@@ -140,7 +148,8 @@ pub fn rust_comment(input: &[u8]) -> PResult<&[u8]> {
             terminated(tag("*"), not(tag("/"))),
         )))),
         tag("*/"),
-    )(input)
+    )
+    .parse(input)
 }
 
 #[cfg(test)]

src/parseresult.rs

@@ -1,5 +1,5 @@
-use nom::error::{VerboseError, VerboseErrorKind};
 use nom::{Err, IResult};
+use nom_language::error::{VerboseError, VerboseErrorKind};
 use std::io::Write;
 use std::str::from_utf8;
 

src/spacelike.rs

@@ -5,13 +5,14 @@ use nom::character::complete::{multispace1, none_of};
 use nom::combinator::{map, value};
 use nom::multi::many0;
 use nom::sequence::preceded;
+use nom::Parser as _;
 
 pub fn spacelike(input: &[u8]) -> PResult<()> {
-    map(many0(alt((comment, map(multispace1, |_| ())))), |_| ())(input)
+    map(many0(alt((comment, map(multispace1, |_| ())))), |_| ()).parse(input)
 }
 
 pub fn comment(input: &[u8]) -> PResult<()> {
-    preceded(tag("@*"), comment_tail)(input)
+    preceded(tag("@*"), comment_tail).parse(input)
 }
 
 pub fn comment_tail(input: &[u8]) -> PResult<()> {
@@ -21,14 +22,15 @@ pub fn comment_tail(input: &[u8]) -> PResult<()> {
             value((), preceded(tag("*"), none_of("@"))),
         ))),
         value((), tag("*@")),
-    )(input)
+    )
+    .parse(input)
 }
 
 #[cfg(test)]
 mod test {
     use super::{comment, spacelike};
-    use nom::error::{ErrorKind, VerboseError, VerboseErrorKind};
-    use nom::Err;
+    use nom::{error::ErrorKind, Err};
+    use nom_language::error::{VerboseError, VerboseErrorKind};
 
     #[test]
     fn comment1() {

src/template.rs

@@ -10,7 +10,8 @@ use nom::character::complete::{char, multispace0};
 use nom::combinator::{map, map_res, opt, recognize};
 use nom::error::context;
 use nom::multi::{many0, many_till, separated_list0, separated_list1};
-use nom::sequence::{delimited, preceded, terminated, tuple};
+use nom::sequence::{delimited, preceded, terminated};
+use nom::Parser as _;
 use std::io::{self, Write};
 
 #[derive(Debug, PartialEq, Eq)]
@@ -62,7 +63,7 @@ impl Template {
 
 pub fn template(input: &[u8]) -> PResult<Template> {
     map(
-        tuple((
+        (
             spacelike,
             many0(map(
                 delimited(
@@ -114,21 +115,22 @@ pub fn template(input: &[u8]) -> PResult<Template> {
                 ),
                 end_of_file,
             ),
-        )),
+        ),
         |((), preamble, _, type_args, args, body)| Template {
             preamble,
             type_args: type_args.map(String::from).unwrap_or_default(),
             args,
             body: body.0,
         },
-    )(input)
+    )
+    .parse(input)
 }
 
 fn end_of_file(input: &[u8]) -> PResult<()> {
     if input.is_empty() {
         Ok((input, ()))
     } else {
-        use nom::error::{VerboseError, VerboseErrorKind};
+        use nom_language::error::{VerboseError, VerboseErrorKind};
         Err(nom::Err::Error(VerboseError {
             errors: vec![(input, VerboseErrorKind::Context("end of file"))],
         }))
@@ -137,20 +139,21 @@ fn end_of_file(input: &[u8]) -> PResult<()> {
 
 fn formal_argument(input: &[u8]) -> PResult<&str> {
     map_res(
-        recognize(tuple((
+        recognize((
             rust_name,
             spacelike,
             char(':'),
             spacelike,
             type_expression,
-        ))),
+        )),
         input_to_str,
-    )(input)
+    )
+    .parse(input)
 }
 
 fn type_expression(input: &[u8]) -> PResult<()> {
     map(
-        tuple((
+        (
             alt((tag("&"), tag(""))),
             opt(lifetime),
             delimited(
@@ -173,9 +176,10 @@ fn type_expression(input: &[u8]) -> PResult<()> {
                 )),
             ),
             opt(delimited(tag("<"), comma_type_expressions, tag(">"))),
-        )),
+        ),
         |_| (),
-    )(input)
+    )
+    .parse(input)
 }
 
 pub fn comma_type_expressions(input: &[u8]) -> PResult<()> {
@@ -188,11 +192,12 @@ pub fn comma_type_expressions(input: &[u8]) -> PResult<()> {
             opt(preceded(tag(","), multispace0)),
         ),
         |_| (),
-    )(input)
+    )
+    .parse(input)
 }
 
 fn lifetime(input: &[u8]) -> PResult<()> {
-    map(delimited(spacelike, tag("'"), rust_name), |_| ())(input)
+    map(delimited(spacelike, tag("'"), rust_name), |_| ()).parse(input)
 }
 
 #[cfg(test)]