Sorted results by closeness

Might be worth sorting by relevance

scryfall_deser/src/db.rs

@@ -38,49 +38,19 @@ pub fn get_all_lowercase_card_names() -> Vec<String> {
     card_names
 }
 
-pub fn update_db_with_file(file: PathBuf) -> bool {
+pub fn get_all_mtg_words() -> Vec<String> {
-    let ac = fs::read_to_string(file).unwrap();
-    let ac: Vec<ScryfallCard> = serde_json::from_str(&ac).unwrap();
     let sqlite_file = get_local_data_sqlite_file();
-    let mut conn = rusqlite::Connection::open(sqlite_file).unwrap();
+    let conn = rusqlite::Connection::open(sqlite_file).unwrap();
-    let tx = conn.transaction().unwrap();
+    let mut stmt = conn.prepare("SELECT word FROM mtg_words;").unwrap();
-    for card in ac {
+    let mut rows = stmt.query([]).unwrap();
-        for word in card.name.split_whitespace() {
+    let mut card_names = Vec::new();
-            let word = deunicode(word);
+    while let Some(row) = rows.next().unwrap() {
-            let res = tx.execute(
+        card_names.push(row.get(0).unwrap());
-                "INSERT INTO magic_words (word) VALUES (?1)
-                     ON CONFLICT (word) DO NOTHING;",
-                [word.replace(",", "")],
-            );
-        }
-        let lowercase_name = deunicode(&card.name.to_lowercase());
-        let power_toughness = match card.power {
-            Some(p) => Some(format!("{}/{}", p, card.toughness.unwrap())),
-            None => None,
-        };
-        let oracle_text = match card.oracle_text {
-            Some(ot) => ot,
-            None => "<No Oracle Text>".to_string(),
-        };
-        let loyalty = match card.loyalty {
-            Some(loy) => Some(loy),
-            None => None,
-        };
-        let mana_cost = match card.mana_cost {
-            Some(mc) => Some(mc),
-            None => None,
-        };
-        let res = tx.execute(
-            "INSERT INTO cards (name, lowercase_name, type_line, oracle_text, power_toughness, loyalty, mana_cost, scryfall_uri) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8)",
-            rusqlite::params![card.name, lowercase_name, card.type_line, oracle_text, power_toughness, loyalty, mana_cost, card.scryfall_uri],
-        );
     }
-    tx.commit();
+    card_names
-    true
 }
 
 // unsure if this should be in this file...
-
 impl fmt::Display for DbCard {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match &self.mana_cost {
@@ -172,7 +142,6 @@ pub fn find_matching_cards_scryfall_style(search_strings: &Vec<String>) -> Vec<D
     sql.pop();
     sql.pop();
     sql.pop();
-    dbg!(&sql);
     let mut stmt = conn.prepare(&sql).unwrap();
     stmt.query_map(rusqlite::params_from_iter(percentaged_string), |row| {
         Ok(DbCard {
@@ -234,7 +203,7 @@ CREATE TABLE cards (
 )";
 
 const CREATE_MAGIC_WORDS_TABLE_SQL: &str = "
-CREATE TABLE magic_words (
+CREATE TABLE mtg_words (
     word TEXT NOT NULL UNIQUE
 )";
 
@@ -254,3 +223,44 @@ pub fn init_db() -> bool {
         .unwrap();
     true
 }
+
+pub fn update_db_with_file(file: PathBuf) -> bool {
+    let ac = fs::read_to_string(file).unwrap();
+    let ac: Vec<ScryfallCard> = serde_json::from_str(&ac).unwrap();
+    let sqlite_file = get_local_data_sqlite_file();
+    let mut conn = rusqlite::Connection::open(sqlite_file).unwrap();
+    let tx = conn.transaction().unwrap();
+    for card in ac {
+        for word in card.name.split_whitespace() {
+            let word = deunicode(&word.to_lowercase());
+            let res = tx.execute(
+                "INSERT INTO mtg_words (word) VALUES (?1)
+                     ON CONFLICT (word) DO NOTHING;",
+                [word.replace(",", "")],
+            );
+        }
+        let lowercase_name = deunicode(&card.name.to_lowercase());
+        let power_toughness = match card.power {
+            Some(p) => Some(format!("{}/{}", p, card.toughness.unwrap())),
+            None => None,
+        };
+        let oracle_text = match card.oracle_text {
+            Some(ot) => ot,
+            None => "<No Oracle Text>".to_string(),
+        };
+        let loyalty = match card.loyalty {
+            Some(loy) => Some(loy),
+            None => None,
+        };
+        let mana_cost = match card.mana_cost {
+            Some(mc) => Some(mc),
+            None => None,
+        };
+        let res = tx.execute(
+            "INSERT INTO cards (name, lowercase_name, type_line, oracle_text, power_toughness, loyalty, mana_cost, scryfall_uri) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8)",
+            rusqlite::params![card.name, lowercase_name, card.type_line, oracle_text, power_toughness, loyalty, mana_cost, card.scryfall_uri],
+        );
+    }
+    tx.commit();
+    true
+}

scryfall_deser/src/lib.rs

@@ -7,7 +7,8 @@ pub use crate::deser::ScryfallCard;
 mod db;
 pub use db::{
     find_matching_cards, find_matching_cards_scryfall_style, get_all_card_names,
-    get_all_lowercase_card_names, get_card_by_name, init_db, update_db_with_file, GetNameType,
+    get_all_lowercase_card_names, get_all_mtg_words, get_card_by_name, init_db,
+    update_db_with_file, GetNameType,
 };
 
 mod utils;

scryfall_deser/src/main.rs

@@ -1,5 +1,6 @@
 use clap::Parser;
 use scryfall_deser::find_matching_cards_scryfall_style;
+use scryfall_deser::get_all_mtg_words;
 use scryfall_deser::get_card_by_name;
 use scryfall_deser::get_local_cache_folder;
 use scryfall_deser::init_db;
@@ -15,15 +16,16 @@ impl Termination for MtgCardExit {
             MtgCardExit::Success => ExitCode::SUCCESS,
             MtgCardExit::EmptySearchString => ExitCode::from(101),
             MtgCardExit::NoExactMatchCard => ExitCode::from(102),
+            MtgCardExit::DidYouMean => ExitCode::from(105),
         }
     }
 }
 
 enum MtgCardExit {
-    // No error... unsure it should be in this enum
     Success,
     EmptySearchString,
     NoExactMatchCard,
+    DidYouMean,
 }
 
 #[derive(Parser, Debug)]
@@ -88,14 +90,27 @@ fn main() -> MtgCardExit {
     let matching_cards = find_matching_cards_scryfall_style(&args.search_text);
 
     if matching_cards.is_empty() {
-        // Do some distance checking stuff
+        let mtg_words = get_all_mtg_words();
+        let mut close_names = Vec::new();
+        for search_string in args.search_text {
+            for mtg_card_name in &mtg_words {
+                let dist = damerau_levenshtein(&search_string, &mtg_card_name);
+                if dist <= 2 {
+                    close_names.push((dist, mtg_card_name));
+                }
+            }
+        }
+        close_names.sort_by_key(|k| k.0);
+        for (_, card) in close_names {
+            println!("{}", card);
+        }
+        return MtgCardExit::DidYouMean;
     } else if matching_cards.len() == 1 {
         let card = get_card_by_name(&matching_cards[0].name, GetNameType::LowercaseName).unwrap();
         println!("{}", card);
         return MtgCardExit::Success;
     } else {
         for card in matching_cards {
-            dbg!(&card);
             println!(
                 "{}",
                 get_card_by_name(&card.lowercase_name, GetNameType::LowercaseName)
@@ -105,5 +120,4 @@ fn main() -> MtgCardExit {
         }
         return MtgCardExit::Success;
     }
-    unreachable!("Don't know how you got here - there's a real bug with this");
 }