chore: remove lazy_static

skim/Cargo.toml

@@ -23,7 +23,6 @@ path = "src/bin/main.rs"
 [dependencies]
 nix = { version = "0.29.0", features = ["fs"] }
 regex = "1.6.0"
-lazy_static = "1.4.0"
 shlex = { version = "1.1.0", optional = true }
 unicode-width = "0.2.0"
 log = "0.4.25"

skim/src/engine/factory.rs

@@ -6,12 +6,10 @@ use crate::engine::regexp::RegexEngine;
 use crate::item::RankBuilder;
 use crate::{CaseMatching, MatchEngine, MatchEngineFactory};
 use regex::Regex;
-use std::sync::Arc;
+use std::sync::{Arc, LazyLock};
 
-lazy_static! {
-    static ref RE_AND: Regex = Regex::new(r"([^ |]+( +\| +[^ |]*)+)|( +)").unwrap();
-    static ref RE_OR: Regex = Regex::new(r" +\| +").unwrap();
-}
+static RE_AND: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"([^ |]+( +\| +[^ |]*)+)|( +)").unwrap());
+static RE_OR: LazyLock<Regex> = LazyLock::new(|| Regex::new(r" +\| +").unwrap());
 //------------------------------------------------------------------------------
 // Exact engine factory
 pub struct ExactOrFuzzyEngineFactory {

skim/src/field.rs

@@ -1,9 +1,11 @@
 use regex::Regex;
-use std::cmp::{max, min};
+use std::{
+    cmp::{max, min},
+    sync::LazyLock,
+};
 
-lazy_static! {
-    static ref FIELD_RANGE: Regex = Regex::new(r"^(?P<left>-?\d+)?(?P<sep>\.\.)?(?P<right>-?\d+)?$").unwrap();
-}
+static FIELD_RANGE: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(r"^(?P<left>-?\d+)?(?P<sep>\.\.)?(?P<right>-?\d+)?$").unwrap());
 
 #[derive(PartialEq, Eq, Clone, Debug)]
 pub enum FieldRange {

skim/src/global.rs

@@ -1,21 +1,19 @@
 use std::collections::HashMap;
 use std::sync::atomic::{AtomicU32, Ordering};
-use std::sync::Mutex;
+use std::sync::{LazyLock, Mutex};
 
 // Consider that you invoke a command with different arguments several times
 // If you select some items each time, how will skim remember it?
 // => Well, we'll give each invocation a number, i.e. RUN_NUM
 // What if you invoke the same command and same arguments twice?
 // => We use NUM_MAP to specify the same run number.
-lazy_static! {
-    static ref RUN_NUM: AtomicU32 = AtomicU32::new(0);
-    static ref SEQ: AtomicU32 = AtomicU32::new(1);
-    static ref NUM_MAP: Mutex<HashMap<String, u32>> = {
-        let mut m = HashMap::new();
-        m.insert("".to_string(), 0);
-        Mutex::new(m)
-    };
-}
+static RUN_NUM: LazyLock<AtomicU32> = LazyLock::new(|| AtomicU32::new(0));
+static SEQ: LazyLock<AtomicU32> = LazyLock::new(|| AtomicU32::new(1));
+static NUM_MAP: LazyLock<Mutex<HashMap<String, u32>>> = LazyLock::new(|| {
+    let mut m = HashMap::new();
+    m.insert("".to_string(), 0);
+    Mutex::new(m)
+});
 
 pub fn current_run_num() -> u32 {
     RUN_NUM.load(Ordering::SeqCst)

skim/src/input.rs

@@ -3,6 +3,7 @@
 use crate::event::{parse_event, Event};
 use regex::Regex;
 use std::collections::HashMap;
+use std::sync::LazyLock;
 use tuikit::event::Event as TermEvent;
 use tuikit::key::{from_keyname, Key};
 
@@ -87,14 +88,17 @@ type KeyActions<'a> = (&'a str, Vec<(&'a str, Option<String>)>);
 /// parse key action string to `(key, action, argument)` tuple
 /// key_action is comma separated: 'ctrl-j:accept,ctrl-k:kill-line'
 pub fn parse_key_action(key_action: &str) -> Vec<KeyActions> {
-    lazy_static! {
-        // match `key:action` or `key:action:arg` or `key:action(arg)` etc.
-        static ref RE: Regex =
-            Regex::new(r#"(?si)([^:]+?):((?:\+?[a-z-]+?(?:"[^"]*?"|'[^']*?'|\([^\)]*?\)|\[[^\]]*?\]|:[^:]*?)?\s*)+)(?:,|$)"#)
-                .unwrap();
-        // grab key, action and arg out.
-        static ref RE_BIND: Regex = Regex::new(r#"(?si)([a-z-]+)("[^"]+?"|'[^']+?'|\([^\)]+?\)|\[[^\]]+?\]|:[^:]+?)?(?:\+|$)"#).unwrap();
-    }
+    // match `key:action` or `key:action:arg` or `key:action(arg)` etc.
+    static RE: LazyLock<Regex> = LazyLock::new(|| {
+        Regex::new(
+            r#"(?si)([^:]+?):((?:\+?[a-z-]+?(?:"[^"]*?"|'[^']*?'|\([^\)]*?\)|\[[^\]]*?\]|:[^:]*?)?\s*)+)(?:,|$)"#,
+        )
+        .unwrap()
+    });
+    // grab key, action and arg out.
+    static RE_BIND: LazyLock<Regex> = LazyLock::new(|| {
+        Regex::new(r#"(?si)([a-z-]+)("[^"]+?"|'[^']+?'|\([^\)]+?\)|\[[^\]]+?\]|:[^:]+?)?(?:\+|$)"#).unwrap()
+    });
 
     RE.captures_iter(key_action)
         .map(|caps| {

skim/src/lib.rs

@@ -1,6 +1,4 @@
 #[macro_use]
-extern crate lazy_static;
-#[macro_use]
 extern crate log;
 
 use std::any::Any;

skim/src/model/mod.rs

@@ -8,7 +8,7 @@ use std::env;
 
 use std::process::Command;
 use std::rc::Rc;
-use std::sync::Arc;
+use std::sync::{Arc, LazyLock};
 use std::time::Instant;
 
 use chrono::Duration as TimerDuration;
@@ -39,10 +39,8 @@ use std::cmp::max;
 
 const REFRESH_DURATION: i64 = 100;
 
-lazy_static! {
-    static ref RE_FIELDS: Regex = Regex::new(r"\\?(\{-?[0-9.,q]*?})").unwrap();
-    static ref RE_PREVIEW_OFFSET: Regex = Regex::new(r"^\+([0-9]+|\{-?[0-9]+\})(-[0-9]+|-/[1-9][0-9]*)?$").unwrap();
-}
+static RE_PREVIEW_OFFSET: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(r"^\+([0-9]+|\{-?[0-9]+\})(-[0-9]+|-/[1-9][0-9]*)?$").unwrap());
 
 struct ModelEnv {
     pub cmd: String,

skim/src/model/status.rs

@@ -1,7 +1,6 @@
 use std::sync::Arc;
 use std::time::Duration;
 
-use regex::Regex;
 use tuikit::attr::{Attr, Effect};
 use tuikit::canvas::Canvas;
 use tuikit::draw::{Draw, DrawResult};
@@ -18,11 +17,6 @@ const SPINNER_DURATION: u32 = 200;
 const SPINNERS_INLINE: [char; 2] = ['-', '<'];
 const SPINNERS_UNICODE: [char; 10] = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
 
-lazy_static! {
-    static ref RE_FIELDS: Regex = Regex::new(r"\\?(\{-?[0-9.,q]*?})").unwrap();
-    static ref RE_PREVIEW_OFFSET: Regex = Regex::new(r"^\+([0-9]+|\{-?[0-9]+\})(-[0-9]+|-/[1-9][0-9]*)?$").unwrap();
-}
-
 #[derive(Clone)]
 pub(crate) struct Status {
     pub(crate) total: usize,

skim/src/theme.rs

@@ -1,11 +1,10 @@
 //! Handle the color theme
+use std::sync::LazyLock;
+
 use crate::options::SkimOptions;
 use tuikit::prelude::*;
 
-#[rustfmt::skip]
-lazy_static! {
-    pub static ref DEFAULT_THEME:  ColorTheme = ColorTheme::dark256();
-}
+pub static DEFAULT_THEME: LazyLock<ColorTheme> = LazyLock::new(|| ColorTheme::dark256());
 
 /// The color scheme of skim's UI
 ///

skim/src/util.rs

@@ -4,6 +4,7 @@ use std::fs::File;
 use std::io::{BufRead, BufReader};
 use std::prelude::v1::*;
 use std::str::FromStr;
+use std::sync::LazyLock;
 
 use regex::{Captures, Regex};
 use tuikit::prelude::*;
@@ -12,10 +13,8 @@ use unicode_width::UnicodeWidthChar;
 use crate::field::get_string_by_range;
 use crate::AnsiString;
 
-lazy_static! {
-    static ref RE_ESCAPE: Regex = Regex::new(r"['\U{00}]").unwrap();
-    static ref RE_NUMBER: Regex = Regex::new(r"[+|-]?\d+").unwrap();
-}
+static RE_ESCAPE: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"['\U{00}]").unwrap());
+static RE_NUMBER: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"[+|-]?\d+").unwrap());
 
 pub fn clear_canvas(canvas: &mut dyn Canvas) -> DrawResult<()> {
     let (screen_width, screen_height) = canvas.size()?;
@@ -322,10 +321,8 @@ pub struct InjectContext<'a> {
     pub cmd_query: &'a str,
 }
 
-lazy_static! {
-    static ref RE_ITEMS: Regex = Regex::new(r"\\?(\{ *-?[0-9.+]*? *})").unwrap();
-    static ref RE_FIELDS: Regex = Regex::new(r"\\?(\{ *-?[0-9.,cq+n]*? *})").unwrap();
-}
+static RE_ITEMS: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"\\?(\{ *-?[0-9.+]*? *})").unwrap());
+static RE_FIELDS: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"\\?(\{ *-?[0-9.,cq+n]*? *})").unwrap());
 
 /// Check if a command depends on item
 /// e.g. contains `{}`, `{1..}`, `{+}`