closes #11

src/main.rs

@@ -12,6 +12,8 @@ use iced::{
     },
 };
 
+use std::fs::OpenOptions;
+use std::io::{BufWriter, Write};
 use std::{env, fs, path::PathBuf};
 use texts::*;
 
@@ -35,7 +37,7 @@ fn main() -> iced::Result {
                     if let Ok(f) = bible::get(
                         query,
                         second_query,
-                        vec![&bible],
+                        &bible,
                     ) {
                         println!("{}", f);
                     }
@@ -69,6 +71,7 @@ enum Message {
     SetErrorMessage(usize, String),
     RecievedEvent(Event),
     NoteInput(usize, text_editor::Action),
+    Save,
 }
 
 impl Message {
@@ -197,10 +200,45 @@ impl State {
         }
         // match normal messages
         match msg {
+            Message::Save => {
+                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;
@@ -295,7 +333,7 @@ impl State {
                 if let (Some(book), Some(chap_and_ver), Some(bible)) =
                     (book, location, &self.states[i].bible_selected)
                 {
-                    self.states[i].scripture_body = match bible::get(book, chap_and_ver, vec![bible]) {
+                    self.states[i].scripture_body = match bible::get(book, chap_and_ver, bible) {
                         Ok(s) => {
                             Some(s)
                         },
@@ -342,11 +380,24 @@ impl State {
     }
 
     fn view(&self) -> Element<Message> {
+
+        // 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![
+            row![
                 button("Cycle Themes")
                     .on_press(Message::CycleTheme)
-                .style(button::secondary),
+                    .style(button::secondary)
+                    ,
+                button("Save")
+                    .on_press(Message::Save)
+                    .style(button::secondary)
+                    ,
+            ],
        scrollable(
             row![
                 row((0..self.states.len()).map(|col_index| {
@@ -415,6 +466,7 @@ impl State {
                                 )
                                 .padding([5, 5])
                             )
+                            .height(max_height)
                             .spacing(5),
                             // Scripture
                             scrollable(
@@ -436,8 +488,7 @@ impl State {
                                     )
                                 }
                             )
-                            // TODO make this dynamic
-                            .height(600)
+                            .height(max_height)
                             .spacing(5)
                         ],
                         // Notes

src/texts/bible.rs

@@ -102,19 +102,9 @@ pub fn search_for_word(word: &str, from_files: &Bible) -> Vec<String> {
     found
 }
 
-pub fn get(book: &str, chap_and_ver: &str, bibles: Vec<&Bible>) -> Result<String, 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 = chap_and_ver.split(':');
-    let chapter = splits.next();
-    let verse = splits.next();
-
-    // ###########################################
-    // Figure out what book they are talking about
+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()
@@ -129,7 +119,9 @@ pub fn get(book: &str, chap_and_ver: &str, bibles: Vec<&Bible>) -> Result<String
         .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 {
@@ -142,34 +134,51 @@ pub fn get(book: &str, chap_and_ver: &str, bibles: Vec<&Bible>) -> Result<String
             return Err(format!("'{book}' is not a book"));
         }
     };
+    Ok((book_idx, book_name))
+}
 
-    // 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)>>()
+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 number could not be parsed from {chapter}"));
+            return Err(format!("Chapter {idx} doesn't exist in book {}", BOOKS_IN_ORDER[book.number-1]));
         }
     } else {
-        return Err(format!("A chapter was not passed"));
+        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
+    // Gen 1
+    // The book name needs to be just long enough to be unique
+
+    let mut splits = chap_and_ver.split(':');
+    let chapter_num = splits.next();
+    let verse_num = splits.next();
+    // ###########################################
+
+    // Figure out what book they are talking about
+    let (book_idx, book_name) = parse_book(book)?;
+
+    let book = match bible.get_book_by_index(book_idx+1) {
+        Some(s) => s,
+        None => return Err(format!("Selected Bible {} doesn't contain book {book_name}", bible.translation_name)),
+    };
+
+    // Figure out what chapter they are talking about
+    let chapter = if let Some(ch) = chapter_num {
+        parse_chapter(ch, book)?
+    } else {
+        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();
@@ -180,16 +189,17 @@ pub fn get(book: &str, chap_and_ver: &str, bibles: Vec<&Bible>) -> Result<String
                 (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) {
                                 buf += &format!(
-                                        "{style_bold}[{}] {style_underline}{book_name} {}:{}{style_reset}: {verse}\n",
-                                        bible.translation_name, chapter.number, verse.number
+                                    "{}: {verse}\n", verse.number
                                 );
                             }
                         }
-                        }
                         return Ok(buf);
                     }
                     return Err(format!("Could not parse '{sn}' or '{en}' into numbers"));
@@ -198,14 +208,12 @@ pub fn get(book: &str, chap_and_ver: &str, bibles: Vec<&Bible>) -> Result<String
                 (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!(
-                                    "{style_bold}[{}] {style_underline}{book_name} {}:{}{style_reset}: {verse}\n",
+                                "{style_bold}[{}] {style_underline}{book_name} {}:{}{style_reset}:\n{verse}\n",
                                 bible.translation_name, chapter.number, verse.number
                             );
                         }
-                        }
                         return Ok(buf);
                     }
                     return Err(format!("Could not parse '{ver_num}' into a number"));
@@ -219,13 +227,11 @@ pub fn get(book: &str, chap_and_ver: &str, bibles: Vec<&Bible>) -> Result<String
         None => {
             // only chapter
             let mut buf = String::new();
-            for (bible, _, chapter) in chapters {
             buf += &format!(
                 "{style_bold}[{}] {style_underline}{book_name} {}{style_reset}:\n",
                 bible.translation_name, chapter.number
             );
             buf += &format!("{}", chapter);
-            }
             return Ok(buf);
         }
     }
@@ -286,6 +292,7 @@ struct Testament {
 #[derive(Deserialize)]
 struct Book {
     #[serde(rename = "@number")]
+    /// Genesis is book 1
     number: usize,
     #[serde(rename = "chapter")]
     chapters: Vec<Chapter>,