Fix parsing of non-numeric page numbers and serial numbers

Resolves #170
Resolves #440 (which is a part of #312)

Author: YDX-2147483647

docs/file-format.md

@@ -537,9 +537,14 @@ ampersands, and hyphens. Numeric variables can express a single number or a
 range and contain only integers, but may contain negative numbers. Numeric variables can have a non-numeric prefix and suffix.
 
 ```yaml
-page-range: S10-15
+page-range: S10-15  # Page S10 to 15
 ```
 
+Note that the prefix and suffix for a numeric variable should be non-numeric. If
+you specify a number with leading zeros or numeric suffix, then the whole variable
+will be interpreted as a [string](#string) instead. This improves the style for
+atypical page numbers like `011` and `11E201`.
+
 #### Unicode Language Identifier
 
 A [Unicode Language Identifier](https://unicode.org/reports/tr35/tr35.html#unicode_language_id) identifies a language or its variants. At the simplest, you can specify an all-lowercase [two-letter ISO 639-1 code](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) like `en` or `es` as a language. It is possible to specify regions, scripts, or variants to more precisely identify a variety of a language, especially in cases where the ISO 639-1 code is considered a "macrolanguage" (`zh` includes both Cantonese and Mandarin). In such cases, specify values like `en-US` for American English or `zh-Hans-CN` for Mandarin written in simplified script in mainland China. The region tags have to be written in all-caps and are mostly corresponding to [ISO 3166-1 alpha_2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2#Officially_assigned_code_elements) codes.

src/types/mod.rs

@@ -606,6 +606,33 @@ mod tests {
         assert!(Numeric::from_str("2nd edition").is_err());
     }
 
+    #[test]
+    fn test_preserve_space_separator() {
+        // https://github.com/typst/hayagriva/issues/312
+        // https://github.com/typst/hayagriva/issues/440
+        let serial_numbers = &["ISO/IEC 23009-1:2022(E)", "GB/T 7714—2025", "GB/T 7714"];
+        for s in serial_numbers {
+            let val: MaybeTyped<Numeric> = MaybeTyped::infallible_from_str(s);
+            // It can be either typed or string, as long as whitespaces between
+            // prefixes and numbers are preserved.
+            assert_eq!(val.to_string(), *s);
+        }
+
+        // For GB standards, em dash is the recommended separator, but
+        // hyphen-minus and en dash should also be supported.
+        let dashes = ["-", "–", "—"];
+        for dash in dashes {
+            let s = format!("GB/T 7714{dash}2015");
+            let val: MaybeTyped<Numeric> = MaybeTyped::infallible_from_str(&s);
+            assert_eq!(
+                val.to_string()
+                    .replace(dashes[0], dashes[2])
+                    .replace(dashes[1], dashes[2]),
+                format!("GB/T 7714{}2015", dashes[2])
+            );
+        }
+    }
+
     #[test]
     #[cfg(feature = "biblatex")]
     fn test_issue_227() {

src/types/numeric.rs

@@ -246,8 +246,8 @@ impl FromStr for Numeric {
 
     fn from_str(value: &str) -> Result<Self, Self::Err> {
         let mut s = Scanner::new(value);
-        let prefix =
-            s.eat_while(|c: char| !c.is_numeric() && !c.is_whitespace() && c != '-');
+        s.eat_whitespace();
+        let prefix = s.eat_while(|c: char| !c.is_numeric() && c != '-');
 
         let value = number(&mut s).ok_or(NumericError::NoNumber)?;
         s.eat_whitespace();
@@ -258,6 +258,7 @@ impl FromStr for Numeric {
                 s.eat_until(|c: char| !is_delimiter(c));
                 let mut items = vec![(value, Some(NumericDelimiter::try_from(c)?))];
                 loop {
+                    s.eat_whitespace();
                     let num = number(&mut s).ok_or(NumericError::NoNumber)?;
                     s.eat_whitespace();
                     match NumericDelimiter::from_str(s.eat_while(is_delimiter)) {
@@ -276,7 +277,7 @@ impl FromStr for Numeric {
             _ => NumericValue::Number(value),
         };
         s.eat_whitespace();
-        let post = s.eat_while(|c: char| !c.is_whitespace());
+        let post = s.eat_while(|c: char| !c.is_numeric() && !c.is_whitespace());
 
         if !s.after().is_empty() {
             return Err(NumericError::UnexpectedCharactersAfterPostfix);
@@ -324,15 +325,23 @@ pub enum NumericError {
     MissingDelimiter,
 }
 
+/// Eat a number from the scanner.
+/// The number can be positive, negative, or zero, but can't have leading zeros.
 fn number(s: &mut Scanner) -> Option<i32> {
-    s.eat_whitespace();
+    let start = s.cursor();
+
     let negative = s.eat_if('-');
+    let leading_zero = s.eat_if('0');
     let num = s.eat_while(|c: char| c.is_numeric());
-    if num.is_empty() {
-        return None;
-    }
 
-    num.parse::<i32>().ok().map(|n| if negative { -n } else { n })
+    match (leading_zero, num.is_empty()) {
+        (true, true) => Some(0),
+        (false, false) => num.parse::<i32>().ok().map(|n| if negative { -n } else { n }),
+        _ => {
+            s.jump(start);
+            None
+        }
+    }
 }
 
 impl Display for Numeric {

src/types/page.rs

@@ -392,6 +392,8 @@ where
 
 #[cfg(test)]
 mod test {
+    use super::*;
+
     #[test]
     fn group_by() {
         fn group(s: &str) -> Vec<&'_ str> {
@@ -410,4 +412,23 @@ mod test {
         assert_eq!(["–a", ","], group("–a,").as_slice());
         assert_eq!(["a–", ",", "–b"], group("a–,–b").as_slice());
     }
+
+    #[test]
+    fn nonnumeric_page() {
+        // https://github.com/typst/hayagriva/issues/170
+        for s in &["11E201", "072711"] {
+            let n: MaybeTyped<PageRanges> = MaybeTyped::infallible_from_str(s);
+            assert_eq!(n, MaybeTyped::String(s.to_string()));
+        }
+
+        // Page ranges should still be parsed as numeric values.
+        let n: MaybeTyped<PageRanges> = MaybeTyped::infallible_from_str("S10-15");
+        assert_eq!(
+            n,
+            MaybeTyped::Typed(PageRanges::new(vec![PageRangesPart::Range(
+                Numeric::from_str("S10").unwrap(),
+                Numeric::from_str("15").unwrap(),
+            )]))
+        );
+    }
 }