gui is working

.vscode/launch.json

@@ -0,0 +1,45 @@
+{
+    // 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,6 +4,7 @@ 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,3 +8,6 @@
 
 [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/main.rs

@@ -1,9 +1,9 @@
+#![feature(iter_map_windows)]
 use iced::{
-    Alignment::Center,
     Element,
-    widget::{self, Column, column, combo_box, text},
+    widget::{self, column, combo_box},
 };
-use std::{env, fmt::Display, fs, path::PathBuf};
+use std::{env, fs, path::PathBuf};
 use texts::*;
 
 mod texts;
@@ -20,28 +20,33 @@ fn main() -> iced::Result {
             }
         }
         if let Some(second_query) = arg.get(2) {
-            bible::get(
+            if let Some(f) = bible::get(
                 query,
                 second_query,
                 vec![format!("{BIBLE_DIRECTORY}/EnglishNASBBible.xml").into()],
-            );
+            ) {
+                println!("{}", f);
+            }
+            return Ok(())
         }
     }
 
-    iced::run("A cool counter", State::update, State::view)
+    iced::run("Bible Search", State::update, State::view)
 }
 
 #[derive(Debug, Clone)]
 enum Message {
-    BookSelected(&'static str),
+    InputChange(String),
     BibleSelected(String),
+    SubmitQuery,
 }
 
 struct State {
-    book: combo_box::State<&'static str>,
-    selected: Option<&'static str>,
     files: combo_box::State<String>,
     file_selected: Option<String>,
+
+    query: String,
+    body: Option<String>,
 }
 impl Default for State {
     fn default() -> Self {
@@ -69,9 +74,10 @@ impl Default for State {
 
         Self {
             files: combo_box::State::new(files),
-            book: combo_box::State::new(texts::bible::BOOKS_IN_ORDER.to_vec()),
-            selected: None,
             file_selected: None,
+
+            query: String::new(),
+            body: None,
         }
     }
 }
@@ -79,27 +85,126 @@ impl Default for State {
 impl State {
     fn update(&mut self, msg: Message) {
         match msg {
-            Message::BibleSelected(file) => self.file_selected = Some(file),
+            Message::BibleSelected(file) => {
-            Message::BookSelected(version) => self.selected = Some(version),
+                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 (type)",
+                "Select Bible",
                 self.file_selected.as_ref(),
                 Message::BibleSelected
             ),
-            widget::combo_box(
+            widget::text_input("Search query, ie: Gen 1:1", &self.query)
-                &self.book,
+                .on_input(Message::InputChange)
-                "Select Book",
+                .on_submit(Message::SubmitQuery),
-                self.selected.as_ref(),
+            widget::text(msg),
-                Message::BookSelected,
-            ),
-
         ]
         .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/bible.rs

@@ -73,14 +73,14 @@ pub const BOOKS_IN_ORDER: [&str; 66] = [
     "Revelation",
 ];
 
-pub fn get(query: &str, location: &str, files: Vec<PathBuf>) {
+pub fn get(book: &str, chap_and_ver: &str, from_files: Vec<PathBuf>) -> Option<String> {
     // 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 = location.split(':');
+    let mut splits = chap_and_ver.split(':');
     let chapter = splits.next();
     let verse = splits.next();
 
@@ -89,26 +89,26 @@ pub fn get(query: &str, location: &str, files: Vec<PathBuf>) {
     let res = BOOKS_IN_ORDER
         .iter()
         .enumerate()
-        .filter(|(_, book)| book.to_lowercase().contains(&query.to_lowercase()))
+        .filter(|(_, lbook)| lbook.to_lowercase().contains(&book.trim().to_lowercase()))
         .collect::<Vec<(usize, &&str)>>();
 
     let (book_idx, book_name) = match res.len() {
         1 => res[0],
         2.. => {
-            eprintln!("Err: Ambigious input '{query}', could be any of:");
+            eprintln!("Err: Ambigious input '{book}', could be any of:");
             for (_, i) in &res {
                 eprintln!("\t{i}");
             }
-            return;
+            return None;
         }
         _ => {
-            eprintln!("'{query}' is not a book");
+            eprintln!("'{book}' is not a book");
-            return;
+            return None;
         }
     };
 
     // Load Bibles into memory
-    let bibles = files 
+    let bibles = from_files 
         .iter()
         .filter_map(|path| fs::read_to_string(path).ok())
         .filter_map(|contents| from_str::<Bible>(&contents).ok())
@@ -132,10 +132,10 @@ pub fn get(query: &str, location: &str, files: Vec<PathBuf>) {
                 .map(|(bible,book,chapter)| (*bible,*book,chapter.unwrap()))
                 .collect::<Vec<(&Bible, &Book, &Chapter)>>()
         } else {
-            return;
+            return None;
         }
     } else {
-        return;
+        return None;
     };
 
     // Get the verse in each Bible
@@ -149,46 +149,54 @@ pub fn get(query: &str, location: &str, files: Vec<PathBuf>) {
                 // 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) {
-                                    println!(
+                                    buf += &format!(
-                                        "{style_bold}[{}] {style_underline}{book_name} {}:{}{style_reset}: {verse}",
+                                        "{style_bold}[{}] {style_underline}{book_name} {}:{}{style_reset}: {verse}\n",
                                         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) {
-                                println!(
+                                buf += &format!(
-                                    "{style_bold}[{}] {style_underline}{book_name} {}:{}{style_reset}: {verse}",
+                                    "{style_bold}[{}] {style_underline}{book_name} {}:{}{style_reset}: {verse}\n",
                                     bible.translation_name, chapter.number, verse.number
                                 );
                             }
                         }
+                        return Some(buf);
                     }
+                    return None;
                 }
                 _ => {
                     // couldn't parse verse
-                    return;
+                    return None;
                 }
             }
         }
         None => {
             // only chapter
-            for (bible, _book, chapter) in chapters {
+            let mut buf = String::new();
-                println!(
+            for (bible, _, chapter) in chapters {
-                    "{style_bold}[{}] {style_underline}{book_name} {}{style_reset}:",
+                buf += &format!(
+                    "{style_bold}[{}] {style_underline}{book_name} {}{style_reset}:\n",
                     bible.translation_name, chapter.number
                 );
-                print!("{}", chapter);
+                buf += &format!("{}", chapter);
             }
+            return Some(buf);
         }
     }
 }