.vscode/launch.json

@@ -1,45 +0,0 @@
-{
-    // Use IntelliSense to learn about possible attributes.
-    // Hover to view descriptions of existing attributes.
-    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
-    "version": "0.2.0",
-    "configurations": [
-        {
-            "type": "lldb",
-            "request": "launch",
-            "name": "Debug executable 'bible'",
-            "cargo": {
-                "args": [
-                    "build",
-                    "--bin=bible",
-                    "--package=bible"
-                ],
-                "filter": {
-                    "name": "bible",
-                    "kind": "bin"
-                }
-            },
-            "args": [],
-            "cwd": "${workspaceFolder}"
-        },
-        {
-            "type": "lldb",
-            "request": "launch",
-            "name": "Debug unit tests in executable 'bible'",
-            "cargo": {
-                "args": [
-                    "test",
-                    "--no-run",
-                    "--bin=bible",
-                    "--package=bible"
-                ],
-                "filter": {
-                    "name": "bible",
-                    "kind": "bin"
-                }
-            },
-            "args": [],
-            "cwd": "${workspaceFolder}"
-        }
-    ]
-}

Cargo.toml

@@ -4,7 +4,6 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-iced = "0.13.1"
 inline_colorization = "0.1.6"
 quick-xml = { version="0.37.2", features=["serialize"] }
 serde = { version = "1.0.219", features = ["derive"] }

README.md

@@ -8,6 +8,3 @@
 
 [HewbrewLexicon](https://github.com/openscriptures/HebrewLexicon/tree/master)
 
-[27, 91, 49, 109, 91, 69, 110, 103, 108, 105, 115, 104, 32, 78, 65, 83, 66, 93, 32, 27, 91, 52, 109, 71, 101, 110, 101, 115, 105, 115, 32, 49, 58, 49, 27, 91, 48, 109, 58, 32, 73, 110, 32, 116, 104, 101, 32, 98, 101, 103, 105, 110, 110, 105, 110, 103, 32, 71, 111, 100, 32, 99, 114, 101, 97, 116, 101, 100, 32, 116, 104, 101, 32, 104, 101, 97, 118, 101, 110, 115, 32, 97, 110, 100, 32, 116, 104, 101, 32, 101, 97, 114, 116, 104, 46, 10]
-
-[??, [, 1, m, [, E, n,,,]

src/bible.rs

@@ -1,10 +1,10 @@
 use inline_colorization::*;
-use std::{fmt::Display, fs, path::PathBuf};
+use std::{fmt::Display, fs};
 
 use quick_xml::de::from_str;
 use serde::Deserialize;
 
-pub const BOOKS_IN_ORDER: [&str; 66] = [
+const BOOKS_IN_ORDER: [&str; 66] = [
     "Genesis",
     "Exodus",
     "Leviticus",
@@ -73,14 +73,20 @@ pub const BOOKS_IN_ORDER: [&str; 66] = [
     "Revelation",
 ];
 
-pub fn get(book: &str, chap_and_ver: &str, from_files: Vec<PathBuf>) -> Option<String> {
+// This would eventaully be a list built by the user
+const BIBLES: [&str; 2] = [
+    "/usr/local/bible/EnglishNASBBible.xml",
+    "/usr/local/bible/EnglishNIVBible.xml",
+];
+
+pub fn get(query: &str, loc: &str) {
     // expecting query to be in format:
     // Gen 1:2
     // Gen 1:2-5
     // Gen 1
     // The book name needs to be just long enough to be unique
 
-    let mut splits = chap_and_ver.split(':');
+    let mut splits = loc.split(':');
     let chapter = splits.next();
     let verse = splits.next();
 
@@ -89,26 +95,26 @@ pub fn get(book: &str, chap_and_ver: &str, from_files: Vec<PathBuf>) -> Option<S
     let res = BOOKS_IN_ORDER
         .iter()
         .enumerate()
-        .filter(|(_, lbook)| lbook.to_lowercase().contains(&book.trim().to_lowercase()))
+        .filter(|(_, book)| book.to_lowercase().contains(&query.to_lowercase()))
         .collect::<Vec<(usize, &&str)>>();
 
     let (book_idx, book_name) = match res.len() {
         1 => res[0],
         2.. => {
-            eprintln!("Err: Ambigious input '{book}', could be any of:");
+            eprintln!("Err: Ambigious input '{query}', could be any of:");
             for (_, i) in &res {
                 eprintln!("\t{i}");
             }
-            return None;
+            return;
         }
         _ => {
-            eprintln!("'{book}' is not a book");
+            eprintln!("'{query}' is not a book");
-            return None;
+            return;
         }
     };
 
     // Load Bibles into memory
-    let bibles = from_files 
+    let bibles = BIBLES
         .iter()
         .filter_map(|path| fs::read_to_string(path).ok())
         .filter_map(|contents| from_str::<Bible>(&contents).ok())
@@ -132,10 +138,10 @@ pub fn get(book: &str, chap_and_ver: &str, from_files: Vec<PathBuf>) -> Option<S
                 .map(|(bible,book,chapter)| (*bible,*book,chapter.unwrap()))
                 .collect::<Vec<(&Bible, &Book, &Chapter)>>()
         } else {
-            return None;
+            return;
         }
     } else {
-        return None;
+        return;
     };
 
     // Get the verse in each Bible
@@ -149,54 +155,46 @@ pub fn get(book: &str, chap_and_ver: &str, from_files: Vec<PathBuf>) -> Option<S
                 // range of verses
                 (Some(sn), Some(en)) => {
                     if let (Ok(start), Ok(end)) = (sn.parse::<usize>(), en.parse::<usize>()) {
-                        let mut buf = String::new();
                         for num in start..=end {
                             for (bible, _book, chapter) in &chapters {
                                 if let Some(verse) = chapter.get_verse_by_index(num) {
-                                    buf += &format!(
+                                    println!(
-                                        "{style_bold}[{}] {style_underline}{book_name} {}:{}{style_reset}: {verse}\n",
+                                        "{style_bold}[{}] {style_underline}{book_name} {}:{}{style_reset}: {verse}",
                                         bible.translation_name, chapter.number, verse.number
                                     );
                                 }
                             }
                         }
-                        return Some(buf);
                     }
-                    return None;
                 }
                 // only one verse
                 (Some(ver_num), None) => {
                     if let Ok(num) = ver_num.parse::<usize>() {
-                        let mut buf = String::new();
                         for (bible, _book, chapter) in chapters {
                             if let Some(verse) = chapter.get_verse_by_index(num) {
-                                buf += &format!(
+                                println!(
-                                    "{style_bold}[{}] {style_underline}{book_name} {}:{}{style_reset}: {verse}\n",
+                                    "{style_bold}[{}] {style_underline}{book_name} {}:{}{style_reset}: {verse}",
                                     bible.translation_name, chapter.number, verse.number
                                 );
                             }
                         }
-                        return Some(buf);
                     }
-                    return None;
                 }
                 _ => {
                     // couldn't parse verse
-                    return None;
+                    return;
                 }
             }
         }
         None => {
             // only chapter
-            let mut buf = String::new();
+            for (bible, _book, chapter) in chapters {
-            for (bible, _, chapter) in chapters {
+                println!(
-                buf += &format!(
+                    "{style_bold}[{}] {style_underline}{book_name} {}{style_reset}:",
-                    "{style_bold}[{}] {style_underline}{book_name} {}{style_reset}:\n",
                     bible.translation_name, chapter.number
                 );
-                buf += &format!("{}", chapter);
+                print!("{}", chapter);
             }
-            return Some(buf);
         }
     }
 }

src/main.rs

@@ -1,210 +1,19 @@
-#![feature(iter_map_windows)]
+use std::env;
-use iced::{
-    Element,
-    widget::{self, column, combo_box},
-};
-use std::{env, fs, path::PathBuf};
-use texts::*;
 
-mod texts;
+mod strong;
+mod bible;
 
-pub const BIBLE_DIRECTORY: &str = "./Holy-Bible-XML-Format";
+fn main() {
-
-fn main() -> iced::Result {
     let arg = env::args().collect::<Vec<String>>();
     if let Some(query) = arg.get(1) {
         if query.starts_with("H") | query.starts_with("h") {
             if let Some(found) = strong::get(query) {
                 print!("{found}");
-                return Ok(());
+                return;
             }
-        }
+        } 
-        if let Some(second_query) = arg.get(2) {
+        if let Some(second_query) = arg.get(2)  {
-            if let Some(f) = bible::get(
+            bible::get(query,second_query);
-                query,
-                second_query,
-                vec![format!("{BIBLE_DIRECTORY}/EnglishNASBBible.xml").into()],
-            ) {
-                println!("{}", f);
-            }
-            return Ok(())
-        }
-    }
-
-    iced::run("Bible Search", State::update, State::view)
-}
-
-#[derive(Debug, Clone)]
-enum Message {
-    InputChange(String),
-    BibleSelected(String),
-    SubmitQuery,
-}
-
-struct State {
-    files: combo_box::State<String>,
-    file_selected: Option<String>,
-
-    query: String,
-    body: Option<String>,
-}
-impl Default for State {
-    fn default() -> Self {
-        let files = if let Ok(contents) = fs::read_dir(BIBLE_DIRECTORY) {
-            let paths = contents
-                .into_iter()
-                .filter_map(|f| f.ok())
-                .map(|f| (f.path(), f.file_type()))
-                .filter(|(_, f)| f.is_ok())
-                .map(|(a, b)| (a, b.unwrap()))
-                .filter(|(_, f)| f.is_file())
-                .map(|(f, _)| f)
-                .filter(|f| f.extension().is_some())
-                .filter(|f| f.extension().unwrap() == "xml")
-                .collect::<Vec<PathBuf>>();
-            paths
-        } else {
-            todo!()
-        };
-        let files = files
-            .iter()
-            .filter_map(|f| f.to_str())
-            .map(|f| f.to_owned())
-            .collect::<Vec<String>>();
-
-        Self {
-            files: combo_box::State::new(files),
-            file_selected: None,
-
-            query: String::new(),
-            body: None,
         }
     }
 }
-
-impl State {
-    fn update(&mut self, msg: Message) {
-        match msg {
-            Message::BibleSelected(file) => {
-                self.file_selected = Some(file);
-            }
-            Message::InputChange(query) => {
-                // update self's state
-                self.query = query;
-            }
-            Message::SubmitQuery => {
-                let mut splits = self.query.split_whitespace();
-                let book = splits.next();
-                let location = splits.next();
-
-                if let (Some(book), Some(chap_and_ver), Some(file)) =
-                    (book, location, &self.file_selected)
-                {
-                    self.body = bible::get(book, chap_and_ver, vec![file.into()]);
-                }
-            }
-        }
-    }
-
-    fn view(&self) -> Element<Message> {
-        let msg = if let Some(body) = self.body.clone() {
-            parse(&body)
-        } else {
-            "None".to_string()
-        };
-
-        column![
-            widget::combo_box(
-                &self.files,
-                "Select Bible",
-                self.file_selected.as_ref(),
-                Message::BibleSelected
-            ),
-            widget::text_input("Search query, ie: Gen 1:1", &self.query)
-                .on_input(Message::InputChange)
-                .on_submit(Message::SubmitQuery),
-            widget::text(msg),
-        ]
-        .into()
-    }
-}
-
-// parse out terminal style codes
-fn parse(input: &str) -> String {
-    let magic_start_indices = input
-        .bytes()
-        .into_iter()
-        .enumerate()
-        .map_windows(|[(ai, a), (bi, b)]| {
-            // 27 91 is the start sequence for a color/style
-            if *a == 27 && *b == 91 {
-                Some(*ai)
-            } else {
-                None
-            }
-        })
-        .filter_map(|f| f)
-        .collect::<Vec<usize>>();
-
-    let mut to_remove = Vec::new();
-    for start in magic_start_indices {
-        let range = &input[start..];
-        // "m" is the end of sequence
-        if let Some(end) = range.find("m") {
-            let end = start + end;
-            let code = &input[start..=end];
-
-            match code {
-                "\x1B[1m" => {}   //style_bold
-                "\x1B[4m" => {}   //style_underline
-                "\x1B[0m" => {}   //style_reset
-                "\x1B[30m" => {}  //color_black
-                "\x1B[31m" => {}  //color_red
-                "\x1B[32m" => {}  //color_green
-                "\x1B[33m" => {}  //color_yellow
-                "\x1B[34m" => {}  //color_blue
-                "\x1B[35m" => {}  //color_magenta
-                "\x1B[36m" => {}  //color_cyan
-                "\x1B[37m" => {}  //color_white
-                "\x1B[90m" => {}  //color_bright_black
-                "\x1B[91m" => {}  //color_bright_red
-                "\x1B[92m" => {}  //color_bright_green
-                "\x1B[93m" => {}  //color_bright_yellow
-                "\x1B[94m" => {}  //color_bright_blue
-                "\x1B[95m" => {}  //color_bright_magenta
-                "\x1B[96m" => {}  //color_bright_cyan
-                "\x1B[97m" => {}  //color_bright_white
-                "\x1B[39m" => {}  //color_reset
-                "\x1B[40m" => {}  //bg_black
-                "\x1B[41m" => {}  //bg_red
-                "\x1B[42m" => {}  //bg_green
-                "\x1B[43m" => {}  //bg_yellow
-                "\x1B[44m" => {}  //bg_blue
-                "\x1B[45m" => {}  //bg_magenta
-                "\x1B[46m" => {}  //bg_cyan
-                "\x1B[47m" => {}  //bg_white
-                "\x1B[100m" => {} //bg_bright_black
-                "\x1B[101m" => {} //bg_bright_red
-                "\x1B[102m" => {} //bg_bright_green
-                "\x1B[103m" => {} //bg_bright_yellow
-                "\x1B[104m" => {} //bg_bright_blue
-                "\x1B[105m" => {} //bg_bright_magenta
-                "\x1B[106m" => {} //bg_bright_cyan
-                "\x1B[107m" => {} //bg_bright_white
-                "\x1B[49m" => {}  //bg_reset
-                _ => {}
-            }
-            to_remove.push((start, end));
-        }
-    }
-    to_remove.reverse();
-    let mut modified = input.to_owned();
-
-    for (s,e) in to_remove {
-        let front = modified[..s].to_string();
-        let back = modified[e+1..].to_string();
-        modified = front + &back;
-    }
-    
-    modified
-}

src/texts/mod.rs

@@ -1,2 +0,0 @@
-pub mod bible;
-pub mod strong;