vendor nucleo fork into atuin workspace

Rename crates (nucleo → atuin-nucleo, nucleo-matcher → atuin-nucleo-matcher),
add to workspace members and dependencies, update all import paths, remove
vendored CI workflow, and suppress upstream clippy warnings.

format

codespell fixes

clippy clappy

6 files changed, 20 insertions, 18 deletions

diff --git a/crates/atuin-nucleo/matcher/src/chars/normalize.rs b/crates/atuin-nucleo/matcher/src/chars/normalize.rs
index 3de501aa..7e3b3b17 100644
--- a/crates/atuin-nucleo/matcher/src/chars/normalize.rs
+++ b/crates/atuin-nucleo/matcher/src/chars/normalize.rs
@@ -19,7 +19,7 @@
 ///
 /// # Example
 /// ```
-/// # use nucleo_matcher::chars::normalize;
+/// # use atuin_nucleo_matcher::chars::normalize;
 /// assert_eq!(normalize('ä'), 'a');
 /// assert_eq!(normalize('Æ'), 'Æ');
 /// assert_eq!(normalize('ữ'), 'u');
diff --git a/crates/atuin-nucleo/matcher/src/fuzzy_greedy.rs b/crates/atuin-nucleo/matcher/src/fuzzy_greedy.rs
index 8215bf31..386d289c 100644
--- a/crates/atuin-nucleo/matcher/src/fuzzy_greedy.rs
+++ b/crates/atuin-nucleo/matcher/src/fuzzy_greedy.rs
@@ -2,7 +2,7 @@ use crate::chars::Char;
 use crate::Matcher;
 
 impl Matcher {
-    /// greedy fallback algorithm, much faster (linear time) but reported scores/indicies
+    /// greedy fallback algorithm, much faster (linear time) but reported scores/indices
     /// might not be the best match
     pub(crate) fn fuzzy_match_greedy_<const INDICES: bool, H: Char + PartialEq<N>, N: Char>(
         &mut self,
diff --git a/crates/atuin-nucleo/matcher/src/fuzzy_optimal.rs b/crates/atuin-nucleo/matcher/src/fuzzy_optimal.rs
index 5d53ecfb..1bcebe2c 100644
--- a/crates/atuin-nucleo/matcher/src/fuzzy_optimal.rs
+++ b/crates/atuin-nucleo/matcher/src/fuzzy_optimal.rs
@@ -49,7 +49,7 @@ impl Matcher {
             .iter()
             .enumerate()
             .max_by_key(|(_, cell)| cell.score)
-            .expect("there must be atleast one match");
+            .expect("there must be at least one match");
         if INDICES {
             matrix.reconstruct_optimal_path(match_end as u16, indices, matrix_len, start as u32);
         }
@@ -60,7 +60,7 @@ impl Matcher {
 const UNMATCHED: ScoreCell = ScoreCell {
     score: 0,
     // if matched is true then the consecutive bonus
-    // is always atleast BONUS_CONSECUTIVE so
+    // is always at least BONUS_CONSECUTIVE so
     // this constant can never occur naturally
     consecutive_bonus: 0,
     matched: true,
@@ -145,7 +145,7 @@ impl<H: Char> MatcherDataView<'_, H> {
                     (needle_char, row_start) = next;
                 } else if !matched {
                     *row_start = i;
-                    // we have atleast one match
+                    // we have at least one match
                     matched = true;
                 }
             }
diff --git a/crates/atuin-nucleo/matcher/src/lib.rs b/crates/atuin-nucleo/matcher/src/lib.rs
index 3e8874c5..9ae4b665 100644
--- a/crates/atuin-nucleo/matcher/src/lib.rs
+++ b/crates/atuin-nucleo/matcher/src/lib.rs
@@ -1,5 +1,7 @@
+#![allow(clippy::needless_return, mismatched_lifetime_syntaxes)]
+
 /*!
-`nucleo_matcher` is a low level crate that contains the matcher implementation
+`atuin_nucleo_matcher` is a low level crate that contains the matcher implementation
 used by the high level `nucleo` crate.
 
 **NOTE**: If you are building an fzf-like interactive fuzzy finder that is
@@ -20,8 +22,8 @@ can contain special characters to control what kind of match is performed (see
 [`AtomKind`](crate::pattern::AtomKind)).
 
 ```
-# use nucleo_matcher::{Matcher, Config};
-# use nucleo_matcher::pattern::{Pattern, Normalization, CaseMatching};
+# use atuin_nucleo_matcher::{Matcher, Config};
+# use atuin_nucleo_matcher::pattern::{Pattern, Normalization, CaseMatching};
 let paths = ["foo/bar", "bar/foo", "foobar"];
 let mut matcher = Matcher::new(Config::DEFAULT.match_paths());
 let matches = Pattern::parse("foo bar", CaseMatching::Ignore, Normalization::Smart).match_list(paths, &mut matcher);
@@ -34,8 +36,8 @@ If the pattern should be matched literally (without this special parsing)
 [`Pattern::new`](pattern::Pattern::new) can be used instead.
 
 ```
-# use nucleo_matcher::{Matcher, Config};
-# use nucleo_matcher::pattern::{Pattern, CaseMatching, AtomKind, Normalization};
+# use atuin_nucleo_matcher::{Matcher, Config};
+# use atuin_nucleo_matcher::pattern::{Pattern, CaseMatching, AtomKind, Normalization};
 let paths = ["foo/bar", "bar/foo", "foobar"];
 let mut matcher = Matcher::new(Config::DEFAULT.match_paths());
 let matches = Pattern::new("foo bar", CaseMatching::Ignore, Normalization::Smart, AtomKind::Fuzzy).match_list(paths, &mut matcher);
@@ -49,7 +51,7 @@ Word segmentation is performed automatically on any unescaped character for whic
 This is relevant, for instance, with non-english keyboard input.
 
 ```
-# use nucleo_matcher::pattern::{Atom, Pattern, Normalization, CaseMatching};
+# use atuin_nucleo_matcher::pattern::{Atom, Pattern, Normalization, CaseMatching};
 assert_eq!(
     // double-width 'Ideographic Space', i.e. `'\u{3000}'`
     Pattern::parse("ほげ　ふが", CaseMatching::Smart, Normalization::Smart).atoms,
@@ -63,8 +65,8 @@ assert_eq!(
 If word segmentation is also not desired, a single `Atom` can be constructed directly.
 
 ```
-# use nucleo_matcher::{Matcher, Config};
-# use nucleo_matcher::pattern::{Pattern, Atom, CaseMatching, Normalization, AtomKind};
+# use atuin_nucleo_matcher::{Matcher, Config};
+# use atuin_nucleo_matcher::pattern::{Pattern, Atom, CaseMatching, Normalization, AtomKind};
 let paths = ["foobar", "foo bar"];
 let mut matcher = Matcher::new(Config::DEFAULT);
 let matches = Atom::new("foo bar", CaseMatching::Ignore, Normalization::Smart, AtomKind::Fuzzy, false).match_list(paths, &mut matcher);
diff --git a/crates/atuin-nucleo/matcher/src/tests.rs b/crates/atuin-nucleo/matcher/src/tests.rs
index 32a02403..a883c6ba 100644
--- a/crates/atuin-nucleo/matcher/src/tests.rs
+++ b/crates/atuin-nucleo/matcher/src/tests.rs
@@ -631,7 +631,7 @@ fn test_optimal() {
                     + BONUS_NON_WORD,
             ),
             // this case is a cool example of why our algorithm is more than fzf
-            // we handle this corretly detect that it's better to match
+            // we handle this correctly detect that it's better to match
             // the second f instead of the third yielding a higher score
             // (despite using the same scoring function!)
             (
diff --git a/crates/atuin-nucleo/matcher/src/utf32_str.rs b/crates/atuin-nucleo/matcher/src/utf32_str.rs
index 664dae7a..77bd9d51 100644
--- a/crates/atuin-nucleo/matcher/src/utf32_str.rs
+++ b/crates/atuin-nucleo/matcher/src/utf32_str.rs
@@ -45,14 +45,14 @@ fn has_ascii_graphemes(string: &str) -> bool {
 /// In the presence of a multi-codepoint grapheme (e.g. `"u\u{0308}"` which is `u +
 /// COMBINING_DIAERESIS`), the trailing codepoints are truncated.
 /// ```
-/// # use nucleo_matcher::Utf32String;
+/// # use atuin_nucleo_matcher::Utf32String;
 /// assert_eq!(Utf32String::from("u\u{0308}").to_string(), "u");
 /// ```
 ///
 /// ### Indexing is done by grapheme
 /// Indexing into a string is done by grapheme rather than by codepoint.
 /// ```
-/// # use nucleo_matcher::Utf32String;
+/// # use atuin_nucleo_matcher::Utf32String;
 /// assert!(Utf32String::from("au\u{0308}").len() == 2);
 /// ```
 ///
@@ -60,7 +60,7 @@ fn has_ascii_graphemes(string: &str) -> bool {
 /// Since the windows-style newline `\r\n` is ASCII only but considered to be a single grapheme,
 /// strings containing `\r\n` will still result in a `Unicode` variant.
 /// ```
-/// # use nucleo_matcher::Utf32String;
+/// # use atuin_nucleo_matcher::Utf32String;
 /// let s = Utf32String::from("\r\n");
 /// assert!(!s.slice(..).is_ascii());
 /// assert!(s.len() == 1);
@@ -73,7 +73,7 @@ fn has_ascii_graphemes(string: &str) -> bool {
 /// much hassle to deal with), we want to quickly iterate over codepoints (up to 5
 /// times) during matching.
 ///
-/// Doing codepoint segmentation on the fly not only blows trough the cache
+/// Doing codepoint segmentation on the fly not only blows through the cache
 /// (lookup tables and I-cache) but also has nontrivial runtime compared to the
 /// matching itself. Furthermore there are many extra optimizations available
 /// for ASCII only text, but checking each match has too much overhead.