Replace all once_cell uses with LazyLock.

See also scpwiki/wikijump#2473

Author: emmiegit

Cargo.toml

@@ -30,7 +30,6 @@ entities = "1"
 latex2mathml = { version = "0.2", optional = true }
 log = "0.4"
 maplit = "1"
-once_cell = "1.17.1"
 parcel_css = { version = "1.0.0-alpha.32", optional = true }
 parcel_selectors = "=0.24.7"  # this is *not* a required dependency,
                               # but we are pinning it since 0.24.8 does

src/includes/mod.rs

@@ -39,19 +39,19 @@ use self::parse::parse_include_block;
 use crate::data::PageRef;
 use crate::settings::WikitextSettings;
 use crate::tree::VariableMap;
-use once_cell::sync::Lazy;
 use regex::{Regex, RegexBuilder};
+use std::sync::LazyLock;
 
-static INCLUDE_REGEX: Lazy<Regex> = Lazy::new(|| {
+static INCLUDE_REGEX: LazyLock<Regex> = LazyLock::new(|| {
     RegexBuilder::new(r"^\[\[\s*include\s+")
         .case_insensitive(true)
         .multi_line(true)
         .dot_matches_new_line(true)
         .build()
         .unwrap()
 });
-static VARIABLE_REGEX: Lazy<Regex> =
-    Lazy::new(|| Regex::new(r"\{\$(?P<name>[a-zA-Z0-9_\-]+)\}").unwrap());
+static VARIABLE_REGEX: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(r"\{\$(?P<name>[a-zA-Z0-9_\-]+)\}").unwrap());
 
 /// Replaces the include blocks in a string with the content of the pages referenced by those
 /// blocks.

src/info.rs

@@ -31,9 +31,9 @@ pub use self::build::{
     RUSTC_VERSION, TARGET,
 };
 
-use once_cell::sync::Lazy;
+use std::sync::LazyLock;
 
-static VERSION_INFO: Lazy<String> = Lazy::new(|| {
+static VERSION_INFO: LazyLock<String> = LazyLock::new(|| {
     let mut version = format!("v{PKG_VERSION}");
 
     if let Some(commit_hash) = *GIT_COMMIT_HASH_SHORT {
@@ -42,10 +42,13 @@ static VERSION_INFO: Lazy<String> = Lazy::new(|| {
 
     version
 });
+
 /// The package name and version info.
-pub static VERSION: Lazy<String> = Lazy::new(|| format!("{PKG_NAME} {}", *VERSION_INFO));
+pub static VERSION: LazyLock<String> =
+    LazyLock::new(|| format!("{PKG_NAME} {}", *VERSION_INFO));
+
 /// The full version info, including build information.
-pub static FULL_VERSION: Lazy<String> = Lazy::new(|| {
+pub static FULL_VERSION: LazyLock<String> = LazyLock::new(|| {
     let mut version = format!("{}\n\nCompiled:\n", *VERSION_INFO);
 
     str_writeln!(&mut version, "* across {NUM_JOBS} threads");
@@ -56,11 +59,12 @@ pub static FULL_VERSION: Lazy<String> = Lazy::new(|| {
     version
 });
 /// The package name and full version info, including build information.
-pub static FULL_VERSION_WITH_NAME: Lazy<String> =
-    Lazy::new(|| format!("{PKG_NAME} {}", *FULL_VERSION));
+pub static FULL_VERSION_WITH_NAME: LazyLock<String> =
+    LazyLock::new(|| format!("{PKG_NAME} {}", *FULL_VERSION));
+
 // The last 8 characters of the commit hash for this version.
-pub static GIT_COMMIT_HASH_SHORT: Lazy<Option<&'static str>> =
-    Lazy::new(|| GIT_COMMIT_HASH.map(|s| &s[..8]));
+pub static GIT_COMMIT_HASH_SHORT: LazyLock<Option<&'static str>> =
+    LazyLock::new(|| GIT_COMMIT_HASH.map(|s| &s[..8]));
 
 #[test]
 fn info() {

src/parsing/rule/impls/block/blocks/char.rs

@@ -20,23 +20,24 @@
 
 use super::prelude::*;
 use entities::ENTITIES;
-use once_cell::sync::Lazy;
 use std::borrow::Cow;
 use std::char;
 use std::collections::HashMap;
+use std::sync::LazyLock;
 
-static ENTITY_MAPPING: Lazy<HashMap<&'static str, &'static str>> = Lazy::new(|| {
-    let mut mapping = HashMap::new();
+static ENTITY_MAPPING: LazyLock<HashMap<&'static str, &'static str>> =
+    LazyLock::new(|| {
+        let mut mapping = HashMap::new();
 
-    for entity in &ENTITIES {
-        let key = strip_entity(entity.entity);
-        let value = entity.characters;
+        for entity in &ENTITIES {
+            let key = strip_entity(entity.entity);
+            let value = entity.characters;
 
-        mapping.insert(key, value);
-    }
+            mapping.insert(key, value);
+        }
 
-    mapping
-});
+        mapping
+    });
 
 pub const BLOCK_CHAR: BlockRule = BlockRule {
     name: "block-char",

src/parsing/rule/impls/block/blocks/date.rs

@@ -20,8 +20,8 @@
 
 use super::prelude::*;
 use crate::tree::DateItem;
-use once_cell::sync::Lazy;
 use regex::Regex;
+use std::sync::LazyLock;
 use time::format_description::well_known::{Iso8601, Rfc2822, Rfc3339};
 use time::{Date, OffsetDateTime, PrimitiveDateTime, UtcOffset};
 
@@ -147,8 +147,8 @@ fn parse_date(value: &str) -> Result<DateItem, DateParseError> {
 
 /// Parse the timezone based on the specifier string.
 fn parse_timezone(value: &str) -> Result<UtcOffset, DateParseError> {
-    static TIMEZONE_REGEX: Lazy<Regex> =
-        Lazy::new(|| Regex::new(r"^(\+|-)?([0-9]{1,2}):?([0-9]{2})?$").unwrap());
+    static TIMEZONE_REGEX: LazyLock<Regex> =
+        LazyLock::new(|| Regex::new(r"^(\+|-)?([0-9]{1,2}):?([0-9]{2})?$").unwrap());
 
     debug!("Parsing possible timezone value '{value}'");
 

src/parsing/rule/impls/block/blocks/module/mapping.rs

@@ -19,8 +19,8 @@
  */
 
 use super::{modules::*, ModuleRule};
-use once_cell::sync::Lazy;
 use std::collections::HashMap;
+use std::sync::LazyLock;
 use unicase::UniCase;
 
 pub const MODULE_RULES: [ModuleRule; 6] = [
@@ -34,8 +34,8 @@ pub const MODULE_RULES: [ModuleRule; 6] = [
 
 pub type ModuleRuleMap = HashMap<UniCase<&'static str>, &'static ModuleRule>;
 
-pub static MODULE_RULE_MAP: Lazy<ModuleRuleMap> =
-    Lazy::new(|| build_module_rule_map(&MODULE_RULES));
+pub static MODULE_RULE_MAP: LazyLock<ModuleRuleMap> =
+    LazyLock::new(|| build_module_rule_map(&MODULE_RULES));
 
 #[inline]
 pub fn get_module_rule_with_name(name: &str) -> Option<&'static ModuleRule> {

src/parsing/rule/impls/block/mapping.rs

@@ -19,8 +19,8 @@
  */
 
 use super::{blocks::*, BlockRule};
-use once_cell::sync::Lazy;
 use std::collections::HashMap;
+use std::sync::LazyLock;
 use unicase::UniCase;
 
 pub const BLOCK_RULES: [BlockRule; 60] = [
@@ -88,8 +88,8 @@ pub const BLOCK_RULES: [BlockRule; 60] = [
 
 pub type BlockRuleMap = HashMap<UniCase<&'static str>, &'static BlockRule>;
 
-pub static BLOCK_RULE_MAP: Lazy<BlockRuleMap> =
-    Lazy::new(|| build_block_rule_map(&BLOCK_RULES));
+pub static BLOCK_RULE_MAP: LazyLock<BlockRuleMap> =
+    LazyLock::new(|| build_block_rule_map(&BLOCK_RULES));
 
 #[inline]
 pub fn get_block_rule_with_name(name: &str) -> Option<&'static BlockRule> {

src/parsing/rule/impls/block/parser.rs

@@ -28,10 +28,11 @@ use crate::parsing::{
     ParseResult, Parser, Token,
 };
 use crate::tree::Element;
-use once_cell::sync::Lazy;
 use regex::Regex;
+use std::sync::LazyLock;
 
-static ARGUMENT_KEY: Lazy<Regex> = Lazy::new(|| Regex::new(r"[A-Za-z0-9_\-]+").unwrap());
+static ARGUMENT_KEY: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(r"[A-Za-z0-9_\-]+").unwrap());
 
 impl<'r, 't> Parser<'r, 't>
 where

src/parsing/rule/impls/color.rs

@@ -19,12 +19,12 @@
  */
 
 use super::prelude::*;
-use once_cell::sync::Lazy;
 use regex::Regex;
 use std::borrow::Cow;
+use std::sync::LazyLock;
 
-static HEX_COLOR: Lazy<Regex> =
-    Lazy::new(|| Regex::new(r"^([a-fA-F0-9]{3}|[a-fA-F0-9]{6})$").unwrap());
+static HEX_COLOR: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(r"^([a-fA-F0-9]{3}|[a-fA-F0-9]{6})$").unwrap());
 
 pub const RULE_COLOR: Rule = Rule {
     name: "color",

src/parsing/rule/impls/variable.rs

@@ -19,10 +19,11 @@
  */
 
 use super::prelude::*;
-use once_cell::sync::Lazy;
 use regex::Regex;
+use std::sync::LazyLock;
 
-static VARIABLE_REGEX: Lazy<Regex> = Lazy::new(|| Regex::new(r"\{\$(.+)\}").unwrap());
+static VARIABLE_REGEX: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(r"\{\$(.+)\}").unwrap());
 
 pub const RULE_VARIABLE: Rule = Rule {
     name: "variable",