Oliver/bible
1
0
Fork 0
Code Issues 4 Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: Oliver:165d946e0dc703532a8f4cffadec12f21a692ec9
Branches Tags
Oliver:master
..
compare: Oliver:035bd214662da184bad83f6d7d5125582c756f71
Branches Tags
Oliver:master

No commits in common. "165d946e0dc703532a8f4cffadec12f21a692ec9" and "035bd214662da184bad83f6d7d5125582c756f71" have entirely different histories.
165d946e0d ... 035bd21466

2 changed files with 62 additions and 114 deletions
Show Stats Expand all files Collapse all files

59
src/main.rs
View File

@ -12,8 +12,6 @@ use iced::{
}, },
}; };
use std::fs::{File, OpenOptions};
use std::io::{BufWriter, Write};
use std::{env, fs, path::PathBuf}; use std::{env, fs, path::PathBuf};
use texts::*; use texts::*;
@ -37,7 +35,7 @@ fn main() -> iced::Result {
if let Ok(f) = bible::get( if let Ok(f) = bible::get(
query, query,
second_query, second_query,
&bible, vec![&bible],
) { ) {
println!("{}", f); println!("{}", f);
} }
@ -71,7 +69,6 @@ enum Message {
SetErrorMessage(usize, String), SetErrorMessage(usize, String),
RecievedEvent(Event), RecievedEvent(Event),
NoteInput(usize, text_editor::Action), NoteInput(usize, text_editor::Action),
Save,
} }
impl Message { impl Message {
@ -200,45 +197,10 @@ impl State {
} }
// match normal messages // match normal messages
match msg { 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) => { Message::NoteInput(i, action) => {
let notes = &mut self.states[i].notes; let notes = &mut self.states[i].notes;
notes.perform(action); notes.perform(action);
}, }
Message::CycleTheme => { Message::CycleTheme => {
let len = self.themes.len(); let len = self.themes.len();
let i = &mut self.theme_idx; let i = &mut self.theme_idx;
@ -333,7 +295,7 @@ impl State {
if let (Some(book), Some(chap_and_ver), Some(bible)) = if let (Some(book), Some(chap_and_ver), Some(bible)) =
(book, location, &self.states[i].bible_selected) (book, location, &self.states[i].bible_selected)
{ {
self.states[i].scripture_body = match bible::get(book, chap_and_ver, bible) { self.states[i].scripture_body = match bible::get(book, chap_and_ver, vec![bible]) {
Ok(s) => { Ok(s) => {
Some(s) Some(s)
}, },
@ -382,17 +344,10 @@ impl State {
fn view(&self) -> Element<Message> { fn view(&self) -> Element<Message> {
// Header bar, static, doesn't scroll // Header bar, static, doesn't scroll
column![ column![
row![ button("Cycle Themes")
button("Cycle Themes") .on_press(Message::CycleTheme)
.on_press(Message::CycleTheme) .style(button::secondary),
.style(button::secondary) scrollable(
,
button("Save")
.on_press(Message::Save)
.style(button::secondary)
,
],
scrollable(
row![ row![
row((0..self.states.len()).map(|col_index| { row((0..self.states.len()).map(|col_index| {
column![ column![

117
src/texts/bible.rs
View File

@ -102,9 +102,19 @@ pub fn search_for_word(word: &str, from_files: &Bible) -> Vec<String> {
found found
} }
fn parse_book(book: &str) -> Result<(usize, &str), String> { pub fn get(book: &str, chap_and_ver: &str, bibles: Vec<&Bible>) -> Result<String, String> {
// Go thru the list of books and see which // expecting query to be in format:
// match the passed book str // 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
let res = BOOKS_IN_ORDER let res = BOOKS_IN_ORDER
.iter() .iter()
.enumerate() .enumerate()
@ -119,9 +129,7 @@ fn parse_book(book: &str) -> Result<(usize, &str), String> {
.collect::<Vec<(usize, &&str)>>(); .collect::<Vec<(usize, &&str)>>();
let (book_idx, book_name) = match res.len() { let (book_idx, book_name) = match res.len() {
// there is one option for what book it is
1 => res[0], 1 => res[0],
// there are >1 options for what book it is
2.. => { 2.. => {
eprintln!("Err: Ambigious input '{book}', could be any of:"); eprintln!("Err: Ambigious input '{book}', could be any of:");
for (_, i) in &res { for (_, i) in &res {
@ -134,51 +142,34 @@ fn parse_book(book: &str) -> Result<(usize, &str), String> {
return Err(format!("'{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> { // Select the book in each Bible
let chapter = if let Ok(idx) = chapter_num.parse::<usize>() { let books = bibles
if let Some(chapter) = book.get_chapter_by_index(idx) { .iter()
chapter // 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 { } else {
return Err(format!("Chapter {idx} doesn't exist in book {}", BOOKS_IN_ORDER[book.number-1])); return Err(format!("Chapter number could not be parsed from {chapter}"));
} }
} else { } else {
return Err(format!("Chapter number could not be parsed from {chapter_num}")); return Err(format!("A chapter was not passed"));
};
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 // Get the verse in each Bible
match verse_num { match verse {
Some(verse) => { Some(verse) => {
let mut splits = verse.split("-"); let mut splits = verse.split("-");
let start = splits.next(); let start = splits.next();
@ -189,15 +180,14 @@ pub fn get(book: &str, chap_and_ver: &str, bible: &Bible) -> Result<String, Stri
(Some(sn), Some(en)) => { (Some(sn), Some(en)) => {
if let (Ok(start), Ok(end)) = (sn.parse::<usize>(), en.parse::<usize>()) { if let (Ok(start), Ok(end)) = (sn.parse::<usize>(), en.parse::<usize>()) {
let mut buf = String::new(); let mut buf = String::new();
let translation = &bible.translation_name;
buf += &format!("{style_bold}[{translation}] {style_underline}{book_name}:{start}-{end}{style_reset}:\n");
for num in start..=end { for num in start..=end {
if let Some(verse) = chapter.get_verse_by_index(num) { for (bible, _book, chapter) in &chapters {
buf += &format!( if let Some(verse) = chapter.get_verse_by_index(num) {
"{}: {verse}\n", verse.number buf += &format!(
); "{style_bold}[{}] {style_underline}{book_name} {}:{}{style_reset}: {verse}\n",
bible.translation_name, chapter.number, verse.number
);
}
} }
} }
return Ok(buf); return Ok(buf);
@ -208,11 +198,13 @@ pub fn get(book: &str, chap_and_ver: &str, bible: &Bible) -> Result<String, Stri
(Some(ver_num), None) => { (Some(ver_num), None) => {
if let Ok(num) = ver_num.parse::<usize>() { if let Ok(num) = ver_num.parse::<usize>() {
let mut buf = String::new(); let mut buf = String::new();
if let Some(verse) = chapter.get_verse_by_index(num) { for (bible, _book, chapter) in chapters {
buf += &format!( if let Some(verse) = chapter.get_verse_by_index(num) {
"{style_bold}[{}] {style_underline}{book_name} {}:{}{style_reset}:\n{verse}\n", buf += &format!(
bible.translation_name, chapter.number, verse.number "{style_bold}[{}] {style_underline}{book_name} {}:{}{style_reset}: {verse}\n",
); bible.translation_name, chapter.number, verse.number
);
}
} }
return Ok(buf); return Ok(buf);
} }
@ -227,11 +219,13 @@ pub fn get(book: &str, chap_and_ver: &str, bible: &Bible) -> Result<String, Stri
None => { None => {
// only chapter // only chapter
let mut buf = String::new(); let mut buf = String::new();
buf += &format!( for (bible, _, chapter) in chapters {
"{style_bold}[{}] {style_underline}{book_name} {}{style_reset}:\n", buf += &format!(
bible.translation_name, chapter.number "{style_bold}[{}] {style_underline}{book_name} {}{style_reset}:\n",
); bible.translation_name, chapter.number
buf += &format!("{}", chapter); );
buf += &format!("{}", chapter);
}
return Ok(buf); return Ok(buf);
} }
} }
@ -292,7 +286,6 @@ struct Testament {
#[derive(Deserialize)] #[derive(Deserialize)]
struct Book { struct Book {
#[serde(rename = "@number")] #[serde(rename = "@number")]
/// Genesis is book 1
number: usize, number: usize,
#[serde(rename = "chapter")] #[serde(rename = "chapter")]
chapters: Vec<Chapter>, chapters: Vec<Chapter>,