bindings: Refactor kinds into a lazy static for reuse

We want to use kind patterns elsewhere so refactoring them into
a lazy static seemed sensible.

Signed-off-by: Daniel Silverstone <dsilvers@digital-scurf.org>

1 files changed, 23 insertions, 14 deletions

diff --git a/src/bindings.rs b/src/bindings.rs
index 9b9a119..3d321ec 100644
--- a/src/bindings.rs
+++ b/src/bindings.rs
@@ -12,6 +12,7 @@ use std::fs::File;
 use std::io::Read;
 use std::path::Path;
 
+use lazy_static::lazy_static;
 use regex::{escape, Regex, RegexBuilder};
 
 /// A binding of a scenario step to its implementation.
@@ -679,20 +680,28 @@ mod test_bindings {
     }
 }
 
-fn regex_from_simple_pattern(pattern: &str, explicit_plain: bool) -> Result<String> {
-    let kinds = vec![
-        ("word", r"\S+"),
-        ("text", r".*"),
-        ("int", r"-?\d+"),
-        ("uint", r"\d+"),
-        ("number", r"-?\d+(\.\d+)?"),
-    ];
-    let mut regexes: HashMap<String, Regex> = HashMap::new();
-    for (k, v) in kinds.iter() {
-        let r = Regex::new(&v).unwrap();
-        regexes.insert((*k).to_string(), r);
-    }
+lazy_static! {
+    static ref KIND_PATTERNS: HashMap<&'static str, (&'static str, Regex)> = {
+        let mut map = HashMap::new();
+        for (tyname, pattern) in (&[
+            ("file", r"\S+"),
+            ("word", r"\S+"),
+            ("text", r".*"),
+            ("int", r"-?\d+"),
+            ("uint", r"\d+"),
+            ("number", r"-?\d+(\.\d+)?"),
+        ]).iter().copied() {
+            // This Unwrap is okay because we shouldn't have any bugs in the
+            // regular expressions here, and if we did, it'd be bad for everyone
+            // and caught in the test suite anyway.
+            let rx = Regex::new(&format!("^{}$", pattern)).unwrap();
+            map.insert(tyname, (pattern, rx));
+        }
+        map
+    };
+}
 
+fn regex_from_simple_pattern(pattern: &str, explicit_plain: bool) -> Result<String> {
     let pat = Regex::new(r"\{[^\s\{\}]+\}").unwrap();
     let mut r = String::new();
     let mut end = 0;
@@ -717,7 +726,7 @@ fn regex_from_simple_pattern(pattern: &str, explicit_plain: bool) -> Result<Stri
             (name, "word")
         };
 
-        if let Some(regex) = regexes.get(kind) {
+        if let Some((regex, _)) = KIND_PATTERNS.get(kind) {
             r.push_str(&format!(r"(?P<{}>{})", name, regex));
         } else {
             return Err(SubplotError::UnknownSimplePatternKind(kind.to_string()));