Make capture lazy

masklinn · masklinn · commit d91b9571231e · 2025-05-05T17:24:10.000+02:00
Fixes #1
diff --git a/ua-parser/src/lib.rs b/ua-parser/src/lib.rs
@@ -2,8 +2,6 @@
 #![warn(missing_docs)]
 #![allow(clippy::empty_docs)]
 #![doc = include_str!("../README.md")]
-
-use regex::Captures;
 use serde::Deserialize;
 
 pub use regex_filtered::{BuildError, ParseError};
@@ -123,6 +121,7 @@ impl<'a> Extractor<'a> {
 pub mod user_agent {
     use serde::Deserialize;
     use std::borrow::Cow;
+    use std::cell::LazyCell;
 
     use crate::resolvers::{FallbackResolver, FamilyResolver};
     use regex_filtered::BuildError;
@@ -234,16 +233,16 @@ pub mod user_agent {
         ///   but there is no group in the regex
         pub fn extract(&'a self, ua: &'a str) -> Option<ValueRef<'a>> {
             let (idx, re) = self.matcher.matching(ua).next()?;
-            let c = re.captures(ua)?;
+            let c = LazyCell::new(move || re.captures(ua));
 
             let (f, v1, v2, v3, v4) = &self.repl[idx];
 
             Some(ValueRef {
-                family: f.resolve(&c),
-                major: v1.resolve(&c),
-                minor: v2.resolve(&c),
-                patch: v3.resolve(&c),
-                patch_minor: v4.resolve(&c),
+                family: f.resolve(&c)?,
+                major: v1.resolve(&c)?,
+                minor: v2.resolve(&c)?,
+                patch: v3.resolve(&c)?,
+                patch_minor: v4.resolve(&c)?,
             })
         }
     }
@@ -300,6 +299,7 @@ pub mod user_agent {
 pub mod os {
     use serde::Deserialize;
     use std::borrow::Cow;
+    use std::cell::LazyCell;
 
     use regex_filtered::{BuildError, ParseError};
 
@@ -396,16 +396,16 @@ pub mod os {
         /// returns `None` if the UA string could not be matched.
         pub fn extract(&'a self, ua: &'a str) -> Option<ValueRef<'a>> {
             let (idx, re) = self.matcher.matching(ua).next()?;
-            let c = re.captures(ua)?;
+            let c = LazyCell::new(move || re.captures(ua));
 
             let (o, v1, v2, v3, v4) = &self.repl[idx];
 
             Some(ValueRef {
-                os: o.resolve(&c),
-                major: v1.resolve(&c),
-                minor: v2.resolve(&c),
-                patch: v3.resolve(&c),
-                patch_minor: v4.resolve(&c),
+                os: o.resolve(&c)?,
+                major: v1.resolve(&c)?,
+                minor: v2.resolve(&c)?,
+                patch: v3.resolve(&c)?,
+                patch_minor: v4.resolve(&c)?,
             })
         }
     }
@@ -460,6 +460,7 @@ pub mod os {
 pub mod device {
     use serde::Deserialize;
     use std::borrow::Cow;
+    use std::cell::LazyCell;
 
     use regex_filtered::{BuildError, ParseError};
 
@@ -558,14 +559,14 @@ pub mod device {
         /// the input.
         pub fn extract(&'a self, ua: &'a str) -> Option<ValueRef<'a>> {
             let (idx, re) = self.matcher.matching(ua).next()?;
-            let c = re.captures(ua)?;
+            let c = LazyCell::new(move || re.captures(ua));
 
             let (d, v1, v2) = &self.repl[idx];
 
             Some(ValueRef {
-                device: d.resolve(&c),
-                brand: v1.resolve(&c),
-                model: v2.resolve(&c),
+                device: d.resolve(&c)?,
+                brand: v1.resolve(&c)?,
+                model: v2.resolve(&c)?,
             })
         }
     }
diff --git a/ua-parser/src/resolvers.rs b/ua-parser/src/resolvers.rs
@@ -7,9 +7,17 @@
 use crate::Error;
 use regex::Captures;
 use std::borrow::Cow;
+use std::cell::LazyCell;
 
-fn get<'s>(c: &Captures<'s>, group: usize) -> Option<&'s str> {
-    c.get(group).map(|g| g.as_str()).filter(|s| !s.is_empty())
+type C<'s, F> = LazyCell<Option<Captures<'s>>, F>;
+
+fn get<'s, F>(c: &C<'s, F>, group: usize) -> Option<Option<&'s str>>
+where
+    F: FnOnce() -> Option<Captures<'s>>,
+{
+    LazyCell::force(c)
+        .as_ref()
+        .map(|c| c.get(group).map(|g| g.as_str()).filter(|s| !s.is_empty()))
 }
 
 // TODO:
@@ -50,21 +58,24 @@ impl<'a> Resolver<'a> {
         }
     }
 
-    pub(crate) fn resolve(&'a self, c: &Captures<'a>) -> Cow<'a, str> {
-        match self {
+    pub(crate) fn resolve<F>(&'a self, c: &C<'a, F>) -> Option<Cow<'a, str>>
+    where
+        F: FnOnce() -> Option<Captures<'a>>,
+    {
+        Some(match self {
             Self::Replacement(s) => (**s).into(),
-            Self::Capture(i) => get(c, *i).unwrap_or("").into(),
+            Self::Capture(i) => get(c, *i)?.unwrap_or("").into(),
             Self::Template(t) => {
                 let mut r = String::new();
-                c.expand(t, &mut r);
+                LazyCell::force(c).as_ref()?.expand(t, &mut r);
                 let trimmed = r.trim();
                 if r.len() == trimmed.len() {
                     r.into()
                 } else {
                     trimmed.to_string().into()
                 }
             }
-        }
+        })
     }
 }
 
@@ -90,14 +101,17 @@ impl<'a> OptResolver<'a> {
         }
     }
 
-    pub(crate) fn resolve(&'a self, c: &Captures<'a>) -> Option<Cow<'a, str>> {
-        match self {
+    pub(crate) fn resolve<F>(&'a self, c: &C<'a, F>) -> Option<Option<Cow<'a, str>>>
+    where
+        F: FnOnce() -> Option<Captures<'a>>,
+    {
+        Some(match self {
             Self::None => None,
             Self::Replacement(s) => Some((**s).into()),
-            Self::Capture(i) => get(c, *i).map(From::from),
+            Self::Capture(i) => get(c, *i)?.map(From::from),
             Self::Template(t) => {
                 let mut r = String::new();
-                c.expand(t, &mut r);
+                LazyCell::force(c).as_ref()?.expand(t, &mut r);
                 let trimmed = r.trim();
                 if trimmed.is_empty() {
                     None
@@ -107,7 +121,7 @@ impl<'a> OptResolver<'a> {
                     Some(trimmed.to_string().into())
                 }
             }
-        }
+        })
     }
 }
 
@@ -135,12 +149,15 @@ impl<'a> FamilyResolver<'a> {
         }
     }
 
-    pub(crate) fn resolve(&'a self, c: &super::Captures<'a>) -> Cow<'a, str> {
-        match self {
-            FamilyResolver::Capture => get(c, 1).unwrap_or("").into(),
+    pub(crate) fn resolve<F>(&'a self, c: &C<'a, F>) -> Option<Cow<'a, str>>
+    where
+        F: FnOnce() -> Option<Captures<'a>>,
+    {
+        Some(match self {
+            FamilyResolver::Capture => get(c, 1)?.unwrap_or("").into(),
             FamilyResolver::Replacement(s) => (**s).into(),
-            FamilyResolver::Template(t) => t.replace("$1", get(c, 1).unwrap_or("")).into(),
-        }
+            FamilyResolver::Template(t) => t.replace("$1", get(c, 1)?.unwrap_or("")).into(),
+        })
     }
 }
 
@@ -161,11 +178,14 @@ impl<'a> FallbackResolver<'a> {
             Self::None
         }
     }
-    pub(crate) fn resolve(&'a self, c: &super::Captures<'a>) -> Option<&'a str> {
-        match self {
+    pub(crate) fn resolve<F>(&'a self, c: &C<'a, F>) -> Option<Option<&'a str>>
+    where
+        F: FnOnce() -> Option<Captures<'a>>,
+    {
+        Some(match self {
             FallbackResolver::None => None,
-            FallbackResolver::Capture(n) => get(c, *n),
+            FallbackResolver::Capture(n) => get(c, *n)?,
             FallbackResolver::Replacement(r) => Some(r),
-        }
+        })
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -7,9 +7,17 @@`
`7`	`7`	`use crate::Error;`
`8`	`8`	`use regex::Captures;`
`9`	`9`	`use std::borrow::Cow;`
	`10`	`+use std::cell::LazyCell;`
`10`	`11`
`11`		`-fn get<'s>(c: &Captures<'s>, group: usize) -> Option<&'s str> {`
`12`		`- c.get(group).map(\|g\| g.as_str()).filter(\|s\| !s.is_empty())`
	`12`	`+type C<'s, F> = LazyCell<Option<Captures<'s>>, F>;`
	`13`	`+`
	`14`	`+fn get<'s, F>(c: &C<'s, F>, group: usize) -> Option<Option<&'s str>>`
	`15`	`+where`
	`16`	`+ F: FnOnce() -> Option<Captures<'s>>,`
	`17`	`+{`
	`18`	`+ LazyCell::force(c)`
	`19`	`+ .as_ref()`
	`20`	`+ .map(\|c\| c.get(group).map(\|g\| g.as_str()).filter(\|s\| !s.is_empty()))`
`13`	`21`	`}`
`14`	`22`
`15`	`23`	`// TODO:`
`@@ -50,21 +58,24 @@ impl<'a> Resolver<'a> {`
`50`	`58`	`}`
`51`	`59`	`}`
`52`	`60`
`53`		`- pub(crate) fn resolve(&'a self, c: &Captures<'a>) -> Cow<'a, str> {`
`54`		`- match self {`
	`61`	`+ pub(crate) fn resolve<F>(&'a self, c: &C<'a, F>) -> Option<Cow<'a, str>>`
	`62`	`+ where`
	`63`	`+ F: FnOnce() -> Option<Captures<'a>>,`
	`64`	`+ {`
	`65`	`+ Some(match self {`
`55`	`66`	`Self::Replacement(s) => (**s).into(),`
`56`		`- Self::Capture(i) => get(c, *i).unwrap_or("").into(),`
	`67`	`+ Self::Capture(i) => get(c, *i)?.unwrap_or("").into(),`
`57`	`68`	`Self::Template(t) => {`
`58`	`69`	`let mut r = String::new();`
`59`		`- c.expand(t, &mut r);`
	`70`	`+ LazyCell::force(c).as_ref()?.expand(t, &mut r);`
`60`	`71`	`let trimmed = r.trim();`
`61`	`72`	`if r.len() == trimmed.len() {`
`62`	`73`	`r.into()`
`63`	`74`	`} else {`
`64`	`75`	`trimmed.to_string().into()`
`65`	`76`	`}`
`66`	`77`	`}`
`67`		`- }`
	`78`	`+ })`
`68`	`79`	`}`
`69`	`80`	`}`
`70`	`81`
`@@ -90,14 +101,17 @@ impl<'a> OptResolver<'a> {`
`90`	`101`	`}`
`91`	`102`	`}`
`92`	`103`
`93`		`- pub(crate) fn resolve(&'a self, c: &Captures<'a>) -> Option<Cow<'a, str>> {`
`94`		`- match self {`
	`104`	`+ pub(crate) fn resolve<F>(&'a self, c: &C<'a, F>) -> Option<Option<Cow<'a, str>>>`
	`105`	`+ where`
	`106`	`+ F: FnOnce() -> Option<Captures<'a>>,`
	`107`	`+ {`
	`108`	`+ Some(match self {`
`95`	`109`	`Self::None => None,`
`96`	`110`	`Self::Replacement(s) => Some((**s).into()),`
`97`		`- Self::Capture(i) => get(c, *i).map(From::from),`
	`111`	`+ Self::Capture(i) => get(c, *i)?.map(From::from),`
`98`	`112`	`Self::Template(t) => {`
`99`	`113`	`let mut r = String::new();`
`100`		`- c.expand(t, &mut r);`
	`114`	`+ LazyCell::force(c).as_ref()?.expand(t, &mut r);`
`101`	`115`	`let trimmed = r.trim();`
`102`	`116`	`if trimmed.is_empty() {`
`103`	`117`	`None`
`@@ -107,7 +121,7 @@ impl<'a> OptResolver<'a> {`
`107`	`121`	`Some(trimmed.to_string().into())`
`108`	`122`	`}`
`109`	`123`	`}`
`110`		`- }`
	`124`	`+ })`
`111`	`125`	`}`
`112`	`126`	`}`
`113`	`127`
`@@ -135,12 +149,15 @@ impl<'a> FamilyResolver<'a> {`
`135`	`149`	`}`
`136`	`150`	`}`
`137`	`151`
`138`		`- pub(crate) fn resolve(&'a self, c: &super::Captures<'a>) -> Cow<'a, str> {`
`139`		`- match self {`
`140`		`- FamilyResolver::Capture => get(c, 1).unwrap_or("").into(),`
	`152`	`+ pub(crate) fn resolve<F>(&'a self, c: &C<'a, F>) -> Option<Cow<'a, str>>`
	`153`	`+ where`
	`154`	`+ F: FnOnce() -> Option<Captures<'a>>,`
	`155`	`+ {`
	`156`	`+ Some(match self {`
	`157`	`+ FamilyResolver::Capture => get(c, 1)?.unwrap_or("").into(),`
`141`	`158`	`FamilyResolver::Replacement(s) => (**s).into(),`
`142`		`- FamilyResolver::Template(t) => t.replace("$1", get(c, 1).unwrap_or("")).into(),`
`143`		`- }`
	`159`	`+ FamilyResolver::Template(t) => t.replace("$1", get(c, 1)?.unwrap_or("")).into(),`
	`160`	`+ })`
`144`	`161`	`}`
`145`	`162`	`}`
`146`	`163`
`@@ -161,11 +178,14 @@ impl<'a> FallbackResolver<'a> {`
`161`	`178`	`Self::None`
`162`	`179`	`}`
`163`	`180`	`}`
`164`		`- pub(crate) fn resolve(&'a self, c: &super::Captures<'a>) -> Option<&'a str> {`
`165`		`- match self {`
	`181`	`+ pub(crate) fn resolve<F>(&'a self, c: &C<'a, F>) -> Option<Option<&'a str>>`
	`182`	`+ where`
	`183`	`+ F: FnOnce() -> Option<Captures<'a>>,`
	`184`	`+ {`
	`185`	`+ Some(match self {`
`166`	`186`	`FallbackResolver::None => None,`
`167`		`- FallbackResolver::Capture(n) => get(c, *n),`
	`187`	`+ FallbackResolver::Capture(n) => get(c, *n)?,`
`168`	`188`	`FallbackResolver::Replacement(r) => Some(r),`
`169`		`- }`
	`189`	`+ })`
`170`	`190`	`}`
`171`	`191`	`}`