closes #11

Reviewed-on: #1

.gitmodules

@@ -3,4 +3,4 @@
 	url = https://github.com/openscriptures/HebrewLexicon.git
 [submodule "Holy-Bible-XML-Format"]
 	path = Holy-Bible-XML-Format
-	url = https://github.com/Beblia/Holy-Bible-XML-Format.git
+	url = https://github.com/Rushmore75/Holy-Bible-XML-Format.git

Cargo.lock

@@ -48,6 +48,15 @@ dependencies = [
  "zerocopy 0.7.35",
 ]
 
+[[package]]
+name = "aho-corasick"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "allocator-api2"
 version = "0.2.21"
@@ -288,6 +297,7 @@ dependencies = [
  "iced",
  "inline_colorization",
  "quick-xml",
+ "regex",
  "serde",
 ]
 
@@ -2546,6 +2556,35 @@ dependencies = [
  "thiserror",
 ]
 
+[[package]]
+name = "regex"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
+
 [[package]]
 name = "renderdoc-sys"
 version = "1.1.0"

Cargo.toml

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

README.md

@@ -1,13 +1,13 @@
-# cli bible
+# Bible
 
 ## Important Links
 
-[Tanach.us](https://tanach.us)
+[XML Bibles in 190+ languages](https://github.com/Beblia/Holy-Bible-XML-Format)
-
-[XML bible in 190+ languages](https://github.com/Beblia/Holy-Bible-XML-Format)
 
 [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]
+## Could be useful later links
 
-[??, [, 1, m, [, E, n,,,]
+[Tanach.us](https://tanach.us)
+
+[AndBible's formats](https://github.com/AndBible/and-bible/wiki/Supported-3rd-party-module-formats)

src/main.rs

@@ -1,8 +1,19 @@
 #![feature(iter_map_windows)]
+use iced::keyboard::key::Named;
+use iced::keyboard::{Key, Modifiers};
+use iced::{event, Event, Subscription};
+use iced::widget::{scrollable, text_editor};
 use iced::{
-    Element,
+    Element, Length, Task, Theme, clipboard, color,
-    widget::{self, column, combo_box},
+    widget::{
+        button, column, combo_box, row,
+        scrollable::{Direction, Scrollbar},
+        text, text_input,
+    },
 };
+
+use std::fs::OpenOptions;
+use std::io::{BufWriter, Write};
 use std::{env, fs, path::PathBuf};
 use texts::*;
 
@@ -11,6 +22,7 @@ mod texts;
 pub const BIBLE_DIRECTORY: &str = "./Holy-Bible-XML-Format";
 
 fn main() -> iced::Result {
+    // CLI
     let arg = env::args().collect::<Vec<String>>();
     if let Some(query) = arg.get(1) {
         if query.starts_with("H") | query.starts_with("h") {
@@ -20,34 +32,115 @@ fn main() -> iced::Result {
             }
         }
         if let Some(second_query) = arg.get(2) {
-            if let Some(f) = bible::get(
+            if let Ok(contents) = fs::read_to_string(&format!("{BIBLE_DIRECTORY}/EnglishNASBBible.xml")) {
-                query,
+                if let Ok(bible) = quick_xml::de::from_str::<bible::Bible>(&contents) {
-                second_query,
+                    if let Ok(f) = bible::get(
-                vec![format!("{BIBLE_DIRECTORY}/EnglishNASBBible.xml").into()],
+                        query,
-            ) {
+                        second_query,
-                println!("{}", f);
+                        &bible,
+                    ) {
+                        println!("{}", f);
+                    }
+                }
             }
-            return Ok(())
+
+            return Ok(());
         }
     }
 
-    iced::run("Bible Search", State::update, State::view)
+    // GUI
+    iced::application("Bible Study", State::update, State::view)
+        .subscription(State::subscription)
+        .theme(State::theme)
+        .run()
 }
 
 #[derive(Debug, Clone)]
 enum Message {
-    InputChange(String),
+    CycleTheme,
-    BibleSelected(String),
+    BibleSearchInput(usize, String),
-    SubmitQuery,
+    BibleSelected(usize, String),
+    BibleSearchSubmit(usize),
+    CopyText(usize),
+    Clear(usize),
+    WordSearchInput(usize, String),
+    SubmitWordSearch(usize),
+    QuickSearch(usize, String, usize),
+    AddColRight,
+    DeleteColumn(usize),
+    SetErrorMessage(usize, String),
+    RecievedEvent(Event),
+    NoteInput(usize, text_editor::Action),
+    Save,
+}
+
+impl Message {
+    fn get_col_idx(&self) -> Option<usize> {
+        match self {
+            Message::SetErrorMessage(i, _) |
+            Message::BibleSearchInput(i, _) |
+            Message::BibleSelected(i, _) |
+            Message::BibleSearchSubmit(i) |
+            Message::CopyText(i) |
+            Message::Clear(i) |
+            Message::WordSearchInput(i, _) |
+            Message::SubmitWordSearch(i) |
+            Message::QuickSearch(i, _, _) |
+            Message::DeleteColumn(i) |
+            Message::NoteInput(i, _)
+            => {
+                Some(*i)
+            },
+            _ => None
+        }
+    }
+}
+
+struct ColState {
+    file: Option<String>,
+    bible_selected: Option<bible::Bible>,
+
+    bible_search: String,
+    scripture_body: Option<String>,
+
+    word_search: String,
+    word_search_results: Option<Vec<(String, bool)>>,
+
+    notes: text_editor::Content,
+
+    error: Option<String>,
+}
+
+impl Default for ColState {
+    fn default() -> Self {
+        Self {
+            file: None,
+            bible_selected: None,
+
+            bible_search: String::new(),
+            scripture_body: None,
+
+            word_search: String::new(),
+            word_search_results: None,
+
+            notes: text_editor::Content::new(),
+
+            error: None,
+        }
+    }
 }
 
 struct State {
     files: combo_box::State<String>,
-    file_selected: Option<String>,
+    states: Vec<ColState>,
+    // cols: usize,
+    tab_index: Option<i32>,
+
+    theme_idx: usize,
+    themes: [Theme; 3],
 
-    query: String,
-    body: Option<String>,
 }
+
 impl Default for State {
     fn default() -> Self {
         let files = if let Ok(contents) = fs::read_dir(BIBLE_DIRECTORY) {
@@ -74,56 +167,353 @@ impl Default for State {
 
         Self {
             files: combo_box::State::new(files),
-            file_selected: None,
+            states: vec![ColState::default()],
-
+            // cols: 1,
-            query: String::new(),
+            tab_index: None,
-            body: None,
+            // THEMES
+            //    Dark - KanagawaDragon
+            //    Default - Nord
+            //    Light - TokyoNightLight
+            theme_idx: 0,
+            themes: [
+                Theme::KanagawaDragon,
+                Theme::Nord,
+                Theme::TokyoNightLight
+            ]
         }
     }
 }
 
 impl State {
-    fn update(&mut self, msg: Message) {
+    fn theme(&self) -> Theme {
+        self.themes[self.theme_idx].clone()
+    }
+
+    fn subscription(&self) -> Subscription<Message> {
+        event::listen().map(Message::RecievedEvent)
+    }
+
+    fn update(&mut self, msg: Message) -> Task<Message> {
+        // clear error messages
+        if let Some(idx) = msg.get_col_idx() {
+            self.states[idx].error = None
+        }
+        // match normal messages
         match msg {
-            Message::BibleSelected(file) => {
+            Message::Save => {
-                self.file_selected = Some(file);
+                let opt = OpenOptions::new()
+                    // create if doesn't already exist
+                    .create(true)
+                    .append(false)
+                    // clear existing file
+                    .truncate(true)
+                    .write(true)
+                    .open("save.md")
+                    ;
+                match opt {
+                    Ok(file) => {
+                        let mut buffer = BufWriter::new(file);
+
+                        // the toml heading at the top of md files
+                        let _ = buffer.write_all("---\n---\n".as_bytes());
+
+                        for col in &self.states {
+                            // separate each col with hr
+                            let _ = buffer.write_all("\n---\n".as_bytes());
+                            if let Some(scripture) = &col.scripture_body {
+                                // code block for scripture
+                                let _ = buffer.write_all("```\n".as_bytes());
+                                let _ = buffer.write_all(parse(scripture).as_bytes());
+                                let _ = buffer.write_all("```\n".as_bytes());
+                            }
+                            let _ = buffer.write_all(&col.notes.text().as_bytes());
+                        }
+                        let _ = buffer.flush();
+                    },
+                    Err(err) => {
+                        eprintln!("{err}");
+                    }
+                }
+            },
+            Message::NoteInput(i, action) => {
+                let notes = &mut self.states[i].notes;
+                notes.perform(action);
+            },
+            Message::CycleTheme => {
+                let len = self.themes.len();
+                let i = &mut self.theme_idx;
+                if *i == len-1 {
+                    *i = 0;
+                } else {
+                    *i += 1;
+                }
+            },
+            Message::RecievedEvent(event) => {
+                if let Event::Keyboard(kbd) = event {
+                    if let iced::keyboard::Event::KeyReleased {key, modifiers, ..} = kbd {
+                        if let Key::Named(n) = key {
+                            if let Named::Tab = n {
+                                if let Some(idx) = self.tab_index {
+                                    let new_idx = if modifiers == Modifiers::SHIFT { idx-1 } else { idx+1 };
+
+                                    // 2 because two buttons on each col
+                                    let new_idx = new_idx.clamp(0, (self.states.len()*2) as i32 -1);
+                                    self.tab_index = Some(new_idx);
+
+                                    let id = format!("tabId-{}", new_idx);
+                                    return text_input::focus(id);
+                                } else {
+                                    if self.states.len() > 0 {
+                                        self.tab_index = Some(0);
+                                        return text_input::focus("tabId-0");
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
             }
-            Message::InputChange(query) => {
+            Message::SetErrorMessage(i, m) => {
-                // update self's state
+                self.states[i].error = Some(m);
-                self.query = query;
             }
-            Message::SubmitQuery => {
+            Message::DeleteColumn(idx) => {
-                let mut splits = self.query.split_whitespace();
+                // self.cols -= 1;
+                self.states.remove(idx);
+            }
+            Message::AddColRight => {
+                self.states.push(ColState::default());
+
+                // Add the rightmost opened Bible to the new column
+                if let Some(last) = self.states.get(self.states.len()-2) {
+                    let file = &last.file;
+                    if let Some(file) = file {
+                        return self.update(Message::BibleSelected(self.states.len()-1, file.to_string())); 
+                    }
+                }; 
+                
+            }
+            Message::BibleSelected(i, file) => {
+                match fs::read_to_string(&file) {
+                    Ok(contents) => {
+                        match quick_xml::de::from_str::<bible::Bible>(&contents) {
+                            Ok(bible)  => {
+                                // State is held technically in this variable, although
+                                // the Bible is held in memory in it's own variable.
+                                self.states[i].bible_selected = Some(bible);
+                                self.states[i].file = Some(file);
+
+                            }
+                            Err(err) => {
+                                eprintln!("{}", err);
+                                return self.update(Message::SetErrorMessage(i, err.to_string()));
+                            },
+                        }
+                    },
+                    Err(err) => {
+                        eprintln!("{}", err);
+                        return self.update(Message::SetErrorMessage(i, err.to_string()));
+                    }
+                }
+            }
+            Message::QuickSearch(i, s, result_index) => {
+                self.states[i].bible_search = s;
+                if let Some(wsr) = &mut self.states[i].word_search_results {
+                    // set "visited" for this link
+                    wsr[result_index].1 = true;
+                }
+                return self.update(Message::BibleSearchSubmit(i));
+            }
+            Message::BibleSearchInput(i, query) => self.states[i].bible_search = query,
+            Message::WordSearchInput(i, query) => self.states[i].word_search = query,
+            Message::BibleSearchSubmit(i) => {
+                let mut splits = self.states[i].bible_search.split_whitespace();
                 let book = splits.next();
                 let location = splits.next();
 
-                if let (Some(book), Some(chap_and_ver), Some(file)) =
+                if let (Some(book), Some(chap_and_ver), Some(bible)) =
-                    (book, location, &self.file_selected)
+                    (book, location, &self.states[i].bible_selected)
                 {
-                    self.body = bible::get(book, chap_and_ver, vec![file.into()]);
+                    self.states[i].scripture_body = match bible::get(book, chap_and_ver, bible) {
+                        Ok(s) => {
+                            Some(s)
+                        },
+                        Err(s) => {
+                            return self.update(Message::SetErrorMessage(i, s)); 
+                        },
+                    };
+                } else {
+                    if let None = book {
+                        return self.update(Message::SetErrorMessage(i, format!("Error selecting book {:?}", book)));
+                    }
+                    if let None = location {
+                        return self.update(Message::SetErrorMessage(i, format!("Error getting chapter and/or verse {:?}", location)));
+                    }
+                    if let None = &self.states[i].bible_selected {
+                        return self.update(Message::SetErrorMessage(i, format!("Error getting selected bible"))); 
+                    }
                 }
             }
-        }
+            Message::SubmitWordSearch(i) => {
+                if let Some(bible) = &self.states[i].bible_selected {
+                    let res = bible::search_for_word(&self.states[i].word_search, bible);
+                    self.states[i].word_search_results = Some(
+                        res
+                            .into_iter()
+                            .map(|f| (f, false))
+                            .collect()
+                        );
+                }
+            }
+            Message::CopyText(i) => {
+                if let Some(text) = &self.states[i].scripture_body {
+                    return clipboard::write::<Message>(parse(text));
+                }
+            }
+            Message::Clear(i) => {
+                self.states[i].scripture_body = None;
+                self.states[i].word_search_results = None;
+                self.states[i].bible_search = String::new();
+                self.states[i].word_search = String::new();
+            }
+        };
+        Task::none()
     }
 
     fn view(&self) -> Element<Message> {
-        let msg = if let Some(body) = self.body.clone() {
-            parse(&body)
-        } else {
-            "None".to_string()
-        };
 
+        // TODO make this dynamic
+        // max height that the scripture body can be
+        // max height that the search resutls can be
+        let max_height = 600;
+
+        // Header bar, static, doesn't scroll
         column![
-            widget::combo_box(
+            row![
-                &self.files,
+                button("Cycle Themes")
-                "Select Bible",
+                    .on_press(Message::CycleTheme)
-                self.file_selected.as_ref(),
+                    .style(button::secondary)
-                Message::BibleSelected
+                    ,
-            ),
+                button("Save")
-            widget::text_input("Search query, ie: Gen 1:1", &self.query)
+                    .on_press(Message::Save)
-                .on_input(Message::InputChange)
+                    .style(button::secondary)
-                .on_submit(Message::SubmitQuery),
+                    ,
-            widget::text(msg),
+            ],
+       scrollable(
+            row![
+                row((0..self.states.len()).map(|col_index| {
+                    column![
+                        // Top of Column, text entry boxes
+                        combo_box(
+                            &self.files,
+                            "Select Bible",
+                            // Some(&"IDK where this text is".to_string()),
+                            match &self.states[col_index].bible_selected {
+                                Some(b) => Some(&b.translation_name),
+                                None => None,
+                            },
+                            move |s| Message::BibleSelected(col_index, s)
+                        ),
+                        text_input("Search query, ie: Gen 1:1", &self.states[col_index].bible_search)
+                            .id(format!("tabId-{}", (col_index*2)+0))
+                            .on_input(move |s| Message::BibleSearchInput(col_index, s))
+                            .on_submit(Message::BibleSearchSubmit(col_index)),
+                        text_input("Word Search", &self.states[col_index].word_search)
+                            .id(format!("tabId-{}", (col_index*2)+1))
+                            .on_input(move |s| Message::WordSearchInput(col_index, s))
+                            .on_submit(Message::SubmitWordSearch(col_index)),
+
+                        // Horizontal Row just above scripture
+                        row![
+                            button("Clear All")
+                                .on_press_with(move || Message::Clear(col_index))
+                                .style(button::secondary),
+                            button("Copy Scripture")
+                                .on_press_with(move || Message::CopyText(col_index))
+                                .style(button::primary),
+                            button("Delete Column")
+                                .on_press_with(move || Message::DeleteColumn(col_index))
+                                .style(button::danger),
+                            text(format!("{}", self.states[col_index].error.clone().unwrap_or(String::new())))
+                                .style(text::danger),
+                        ]
+                        .spacing(5),
+                        // Body
+                        row![
+                            // Word search results
+                            scrollable(
+                                column(
+                                    self.states[col_index]
+                                        .word_search_results
+                                        .clone()
+                                        .unwrap_or(Vec::new())
+                                        .into_iter()
+                                        .enumerate()
+                                        .map(|(idx,i)| {
+                                            let style = if i.1 {
+                                                button::secondary
+                                            } else {
+                                                button::primary
+                                            };
+                                            button(text(i.0.clone()))
+                                                .style(style)
+                                                .on_press_with(move || Message::QuickSearch(
+                                                    col_index,
+                                                    i.0.to_owned(),
+                                                    idx
+                                                ))
+                                                .into()
+                                        })
+                                )
+                                .padding([5, 5])
+                            )
+                            .height(max_height)
+                            .spacing(5),
+                            // Scripture
+                            scrollable(
+                                if let Some(body) = &self.states[col_index].scripture_body {
+                                    column(body.split("\n").enumerate().map(|(i, msg)| {
+                                        // Color every other verse slightly differently
+                                        let msg = parse(msg);
+                                        if i & 1 == 0 {
+                                            text(msg.to_owned()).color(color![0xFFFFFF]).into()
+                                        } else {
+                                            text(msg.to_owned()).color(color![0xAAAAAA]).into()
+                                        }
+                                    }))
+                                } else {
+                                    column(
+                                        Vec::<String>::new()
+                                            .iter()
+                                            .map(|_| text(String::new()).into()),
+                                    )
+                                }
+                            )
+                            .height(max_height)
+                            .spacing(5)
+                        ],
+                        // Notes
+                        text_editor(&self.states[col_index].notes)
+                            .placeholder("Notes...")
+                            .on_action(move |a| Message::NoteInput(col_index, a))
+                            .height(100)
+                            // .id(format!("tabId-{}", (col_index*2)+2))
+                    ]
+                    .spacing(5)
+                    .width(800.)
+                    .into()
+                })),
+                // Right most vertical buttons
+                button(text("+").center())
+                    .height(Length::Fixed(200.))
+                    .style(button::primary)
+                    .on_press(Message::AddColRight)
+            ]
+            // 5 pixles css-like padding
+            .padding([5, 5])
+            // space elements inside this 5 pixels apart
+            .spacing(5),
+        )
+        .direction(Direction::Horizontal(Scrollbar::new()))
         ]
         .into()
     }
@@ -135,7 +525,7 @@ fn parse(input: &str) -> String {
         .bytes()
         .into_iter()
         .enumerate()
-        .map_windows(|[(ai, a), (bi, b)]| {
+        .map_windows(|[(ai, a), (_, b)]| {
             // 27 91 is the start sequence for a color/style
             if *a == 27 && *b == 91 {
                 Some(*ai)
@@ -200,11 +590,11 @@ fn parse(input: &str) -> String {
     to_remove.reverse();
     let mut modified = input.to_owned();
 
-    for (s,e) in to_remove {
+    for (s, e) in to_remove {
         let front = modified[..s].to_string();
-        let back = modified[e+1..].to_string();
+        let back = modified[e + 1..].to_string();
         modified = front + &back;
     }
-    
+
     modified
 }

src/texts/bible.rs

@@ -1,7 +1,7 @@
 use inline_colorization::*;
-use std::{fmt::Display, fs, path::PathBuf};
+use regex::Regex;
+use std::fmt::Display;
 
-use quick_xml::de::from_str;
 use serde::Deserialize;
 
 pub const BOOKS_IN_ORDER: [&str; 66] = [
@@ -13,12 +13,12 @@ pub const BOOKS_IN_ORDER: [&str; 66] = [
     "Joshua",
     "Judges",
     "Ruth",
-    "1 Samuel",
+    "1-Samuel",
-    "2 Samuel",
+    "2-Samuel",
-    "1 Kings",
+    "1-Kings",
-    "2 Kings",
+    "2-Kings",
-    "1 Chronicles",
+    "1-Chronicles",
-    "2 Chronicles",
+    "2-Chronicles",
     "Ezra",
     "Nehemiah",
     "Esther",
@@ -26,7 +26,7 @@ pub const BOOKS_IN_ORDER: [&str; 66] = [
     "Psalms",
     "Proverbs",
     "Ecclesiastes",
-    "Song of Solomon",
+    "Song-of-Solomon",
     "Isaiah",
     "Jeremiah",
     "Lamentations",
@@ -50,30 +50,107 @@ pub const BOOKS_IN_ORDER: [&str; 66] = [
     "John",
     "Acts",
     "Romans",
-    "1 Corinthians",
+    "1-Corinthians",
-    "2 Corinthians",
+    "2-Corinthians",
     "Galations",
     "Ephesians",
     "Philippians",
     "Colossians",
-    "1 Thessalonians",
+    "1-Thessalonians",
-    "2 Thessalonians",
+    "2-Thessalonians",
-    "1 Timothy",
+    "1-Timothy",
-    "2 Timothy",
+    "2-Timothy",
     "Titus",
     "Philemon",
     "Hebrews",
     "James",
-    "1 Peter",
+    "1-Peter",
-    "2 Peter",
+    "2-Peter",
-    "1 John",
+    "1-John",
-    "2 John",
+    "2-John",
-    "3 John",
+    "3-John",
     "Jude",
     "Revelation",
 ];
 
-pub fn get(book: &str, chap_and_ver: &str, from_files: Vec<PathBuf>) -> Option<String> {
+pub fn search_for_word(word: &str, from_files: &Bible) -> Vec<String> {
+    let mut found = Vec::new();
+    let regex = match Regex::new(&word.to_lowercase()) {
+        Ok(re) => re,
+        Err(err) => {
+            eprintln!("{}", err);
+
+            #[cfg(debug_assertions)]
+            todo!("IDK what to do yet if building regex engine fails");
+
+            #[cfg(not(debug_assertions))]
+            return Vec::new()
+        },
+    };
+
+    for test in &from_files.testaments {
+        for book in &test.books {
+            for chapter in &book.chapters {
+                for verse in &chapter.verses {
+                    if regex.is_match(&verse.text.to_lowercase()) {
+                        found.push(format!("{} {}:{}", BOOKS_IN_ORDER[book.number-1], chapter.number, verse.number));
+                    }
+                }
+            }
+        }
+    }
+    found
+}
+
+fn parse_book(book: &str) -> Result<(usize, &str), String> {
+    // Go thru the list of books and see which
+    // match the passed book str
+    let res = BOOKS_IN_ORDER
+        .iter()
+        .enumerate()
+        .filter(|(_, lbook)| lbook
+            .to_lowercase()
+            .starts_with(&book
+                .trim()
+                .replace(" ", "-")
+                .to_lowercase()
+                )
+            )
+        .collect::<Vec<(usize, &&str)>>();
+
+    let (book_idx, book_name) = match res.len() {
+        // there is one option for what book it is
+        1 => res[0],
+        // there are >1 options for what book it is
+        2.. => {
+            eprintln!("Err: Ambigious input '{book}', could be any of:");
+            for (_, i) in &res {
+                eprintln!("\t{i}");
+            }
+            return Err(format!("Ambigious input '{book}'"));
+        }
+        _ => {
+            eprintln!("'{book}' is not a book");
+            return Err(format!("'{book}' is not a book"));
+        }
+    };
+    Ok((book_idx, book_name))
+}
+
+fn parse_chapter<'a>(chapter_num: &str, book: &'a Book) -> Result<&'a Chapter, String> {
+    let chapter = if let Ok(idx) = chapter_num.parse::<usize>() {
+        if let Some(chapter) = book.get_chapter_by_index(idx) {
+            chapter
+        } else {
+            return Err(format!("Chapter {idx} doesn't exist in book {}", BOOKS_IN_ORDER[book.number-1]));
+        }
+    } else {
+        return Err(format!("Chapter number could not be parsed from {chapter_num}"));
+    };
+    Ok(chapter)
+}
+
+pub fn get(book: &str, chap_and_ver: &str, bible: &Bible) -> Result<String, String> {
     // expecting query to be in format:
     // Gen 1:2
     // Gen 1:2-5
@@ -81,65 +158,27 @@ pub fn get(book: &str, chap_and_ver: &str, from_files: Vec<PathBuf>) -> Option<S
     // The book name needs to be just long enough to be unique
 
     let mut splits = chap_and_ver.split(':');
-    let chapter = splits.next();
+    let chapter_num = splits.next();
-    let verse = splits.next();
+    let verse_num = splits.next();
-
     // ###########################################
-    // Figure out what book they are talking about
-    let res = BOOKS_IN_ORDER
-        .iter()
-        .enumerate()
-        .filter(|(_, lbook)| lbook.to_lowercase().contains(&book.trim().to_lowercase()))
-        .collect::<Vec<(usize, &&str)>>();
 
-    let (book_idx, book_name) = match res.len() {
+    // Figure out what book they are talking about
-        1 => res[0],
+    let (book_idx, book_name) = parse_book(book)?;
-        2.. => {
+
-            eprintln!("Err: Ambigious input '{book}', could be any of:");
+    let book = match bible.get_book_by_index(book_idx+1) {
-            for (_, i) in &res {
+        Some(s) => s,
-                eprintln!("\t{i}");
+        None => return Err(format!("Selected Bible {} doesn't contain book {book_name}", bible.translation_name)),
-            }
-            return None;
-        }
-        _ => {
-            eprintln!("'{book}' is not a book");
-            return None;
-        }
     };
 
-    // Load Bibles into memory
+    // Figure out what chapter they are talking about
-    let bibles = from_files 
+    let chapter = if let Some(ch) = chapter_num {
-        .iter()
+        parse_chapter(ch, book)?
-        .filter_map(|path| fs::read_to_string(path).ok())
-        .filter_map(|contents| from_str::<Bible>(&contents).ok())
-        .collect::<Vec<Bible>>();
-    // Select the book in each Bible
-    let books = bibles
-        .iter()
-        // Book are 1 indexed in the xml spec
-        .map(|bible| (bible, bible.get_book_by_index(book_idx + 1)))
-        .filter(|(_,e)| e.is_some())
-        .map(|(bible,book)| (bible,book.unwrap()))
-        .collect::<Vec<(&Bible,&Book)>>();
-
-    // Select the chapter in each Bible
-    let chapters = if let Some(chapter) = chapter {
-        if let Ok(ch_num) = chapter.parse::<usize>() {
-            books
-                .iter()
-                .map(|(bible,book)| (bible, book, book.get_chapter_by_index(ch_num)))
-                .filter(|(_,_,book)| book.is_some())
-                .map(|(bible,book,chapter)| (*bible,*book,chapter.unwrap()))
-                .collect::<Vec<(&Bible, &Book, &Chapter)>>()
-        } else {
-            return None;
-        }
     } else {
-        return None;
+        return Err("No chapter number was passed".to_string());
     };
 
     // Get the verse in each Bible
-    match verse {
+    match verse_num {
         Some(verse) => {
             let mut splits = verse.split("-");
             let start = splits.next();
@@ -150,53 +189,50 @@ pub fn get(book: &str, chap_and_ver: &str, from_files: Vec<PathBuf>) -> Option<S
                 (Some(sn), Some(en)) => {
                     if let (Ok(start), Ok(end)) = (sn.parse::<usize>(), en.parse::<usize>()) {
                         let mut buf = String::new();
+
+                        let translation = &bible.translation_name;
+
+                        buf += &format!("{style_bold}[{translation}] {style_underline}{book_name} {}:{start}-{end}{style_reset}:\n", chapter.number);
                         for num in start..=end {
-                            for (bible, _book, chapter) in &chapters {
+                            if let Some(verse) = chapter.get_verse_by_index(num) {
-                                if let Some(verse) = chapter.get_verse_by_index(num) {
+                                buf += &format!(
-                                    buf += &format!(
+                                    "{}: {verse}\n", verse.number
-                                        "{style_bold}[{}] {style_underline}{book_name} {}:{}{style_reset}: {verse}\n",
+                                );
-                                        bible.translation_name, chapter.number, verse.number
-                                    );
-                                }
                             }
                         }
-                        return Some(buf);
+                        return Ok(buf);
                     }
-                    return None;
+                    return Err(format!("Could not parse '{sn}' or '{en}' into numbers"));
                 }
                 // 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) {
-                            if let Some(verse) = chapter.get_verse_by_index(num) {
+                            buf += &format!(
-                                buf += &format!(
+                                "{style_bold}[{}] {style_underline}{book_name} {}:{}{style_reset}:\n{verse}\n",
-                                    "{style_bold}[{}] {style_underline}{book_name} {}:{}{style_reset}: {verse}\n",
+                                bible.translation_name, chapter.number, verse.number
-                                    bible.translation_name, chapter.number, verse.number
+                            );
-                                );
-                            }
                         }
-                        return Some(buf);
+                        return Ok(buf);
                     }
-                    return None;
+                    return Err(format!("Could not parse '{ver_num}' into a number"));
                 }
                 _ => {
                     // couldn't parse verse
-                    return None;
+                    return Err(format!("Couldn't parse '{:?}' or '{:?}' into verse numbers", start, end));
                 }
             }
         }
         None => {
             // only chapter
             let mut buf = String::new();
-            for (bible, _, chapter) in chapters {
+            buf += &format!(
-                buf += &format!(
+                "{style_bold}[{}] {style_underline}{book_name} {}{style_reset}:\n",
-                    "{style_bold}[{}] {style_underline}{book_name} {}{style_reset}:\n",
+                bible.translation_name, chapter.number
-                    bible.translation_name, chapter.number
+            );
-                );
+            buf += &format!("{}", chapter);
-                buf += &format!("{}", chapter);
+            return Ok(buf);
-            }
-            return Some(buf);
         }
     }
 }
@@ -237,9 +273,9 @@ impl Chapter {
 }
 
 #[derive(Deserialize)]
-struct Bible {
+pub struct Bible {
     #[serde(rename = "@translation")]
-    translation_name: String,
+    pub translation_name: String,
     #[serde(rename = "testament")]
     testaments: Vec<Testament>,
 }
@@ -256,6 +292,7 @@ struct Testament {
 #[derive(Deserialize)]
 struct Book {
     #[serde(rename = "@number")]
+    /// Genesis is book 1
     number: usize,
     #[serde(rename = "chapter")]
     chapters: Vec<Chapter>,