Merge pull request #14 from youknowedo/dev

dev

Author: youknowedo

.gitignore

@@ -1,6 +1,6 @@
 # Deck files
 deck.json
-.logs.json
+.log.json
 .progress.json
 
 # Added by cargo

src/commands/add.rs

@@ -4,7 +4,7 @@ use clap::Parser;
 use cursive::views::Dialog;
 use inquire::Confirm;
 
-use crate::config::Config;
+use crate::config::{Config, DeckEntry};
 
 #[derive(Parser, Debug, Clone)]
 pub struct AddArgs {
@@ -66,10 +66,7 @@ fn terminal(args: AddArgs) {
         }
     }
 
-    config.decks.push(crate::config::DeckEntry {
-        id,
-        path: path.to_str().unwrap().to_string(),
-    });
+    config.decks.push(DeckEntry::new(id.clone(), path.clone()));
     match config.save() {
         Ok(_) => {}
         Err(err) => panic!("Could not save config: {}", err),

src/commands/decks/add.rs

@@ -1,10 +1,13 @@
-use std::{fs, path::Path};
+use std::fs;
 
 use clap::Parser;
 use cursive::views::Dialog;
 use inquire::{Select, Text};
 
-use crate::{config::Config, deck::{Card, Deck}};
+use crate::{
+    config::Config,
+    deck::{Card, Deck},
+};
 
 #[derive(Parser, Debug, Clone)]
 pub struct AddArgs {
@@ -48,7 +51,7 @@ fn terminal(_deck_id: Option<String>, args: AddArgs) {
     let deck_entry = config.decks.iter().find(|deck| deck.id == deck_id).unwrap();
 
     // Check if the deck is in path
-    let deck_path = Path::new(deck_entry.path.as_str()).join("deck.json");
+    let deck_path = deck_entry.path.join("deck.json");
     if !deck_path.exists() {
         panic!("Deck not found in path: {}", deck_path.display());
     }

src/commands/decks/remove.rs

@@ -1,4 +1,4 @@
-use std::{fs, path::Path};
+use std::fs;
 
 use clap::Parser;
 use cursive::views::Dialog;
@@ -43,7 +43,7 @@ fn terminal(_deck_id: Option<String>, args: RemoveArgs) {
     let deck_entry = config.decks.iter().find(|deck| deck.id == deck_id).unwrap();
 
     // Check if the deck is in path
-    let deck_path = Path::new(deck_entry.path.as_str()).join("deck.json");
+    let deck_path = deck_entry.path.join("deck.json");
     if !deck_path.exists() {
         panic!("Deck not found in path: {}", deck_path.display());
     }

src/commands/decks/undo.rs

@@ -1,9 +1,7 @@
-use std::{fs, path::Path};
-
 use cursive::views::Dialog;
 use inquire::Select;
 
-use crate::{config::Config, deck::Log, progress::Progress};
+use crate::{config::Config, deck::Deck};
 
 pub fn run(_deck_id: Option<String>, siv: &mut Option<&mut cursive::Cursive>) {
     match siv {
@@ -19,13 +17,7 @@ fn terminal(_deck_id: Option<String>) {
     };
 
     let deck_id = match _deck_id {
-        Some(id) => {
-            if !config.decks.iter().any(|deck| deck.id == id) {
-                panic!("Deck not found: {}", id);
-            }
-
-            id
-        }
+        Some(id) => id,
         None => match Select::new("Select a deck", config.decks.clone()).prompt() {
             Ok(selection) => selection.id,
             Err(err) => {
@@ -34,65 +26,37 @@ fn terminal(_deck_id: Option<String>) {
         },
     };
 
-    let deck_entry = config.decks.iter().find(|deck| deck.id == deck_id).unwrap();
-
-    let progress_path = Path::new(deck_entry.path.as_str()).join(".progress.json");
-    if !progress_path.exists() {
-        panic!(
-            "Progress file not found in path: {}",
-            progress_path.display()
-        );
-    }
-    let logs_path = Path::new(deck_entry.path.as_str()).join(".logs.json");
-    if !logs_path.exists() {
-        panic!("Logs file not found in path: {}", logs_path.display());
-    }
+    let  deck = match Deck::get(deck_id.clone()) {
+        Ok(deck) => deck,
+        Err(err) => {
+            panic!("Could not get deck: {}", err);
+        }
+    };
 
-    let mut new_progress = match fs::read_to_string(&progress_path) {
-        Ok(contents) => match serde_json::from_str::<Progress>(&contents) {
-            Ok(deck) => deck,
-            Err(err) => {
-                panic!("Could not parse deck file: {}", err);
-            }
-        },
+    let mut progress = match deck.progress() {
+        Ok(progress) => progress,
         Err(err) => {
-            panic!("Could not read deck file: {}", err);
+            panic!("Could not get progress: {}", err);
         }
     };
-    let mut new_logs = match fs::read_to_string(&logs_path) {
-        Ok(contents) => match serde_json::from_str::<Vec<Log>>(&contents) {
-            Ok(deck) => deck,
-            Err(err) => {
-                panic!("Could not parse deck file: {}", err);
-            }
-        },
+    let mut log = match deck.log() {
+        Ok(log) => log,
         Err(err) => {
-            panic!("Could not read deck file: {}", err);
+            panic!("Could not get log: {}", err);
         }
     };
 
-    let last_log = new_logs.pop().unwrap();
+    let last_log = log.entries.pop().unwrap();
     let last_card = last_log.last_card;
 
     // Replace last_progress.card where id == last_card.id with last_card
-    let last_progress_card_index = new_progress
+    let last_progress_card_index: usize = progress
         .cards
         .iter_mut()
         .position(|card| card.id == last_card.id)
         .unwrap();
-    new_progress.cards[last_progress_card_index] = last_card;
+    progress.cards[last_progress_card_index] = last_card;
 
-    // write
-    match fs::write(progress_path, serde_json::to_string(&new_progress).unwrap()) {
-        Ok(_) => {}
-        Err(err) => {
-            panic!("Could not write progress file: {}", err);
-        }
-    }
-    match fs::write(logs_path, serde_json::to_string(&new_logs).unwrap()) {
-        Ok(_) => {}
-        Err(err) => {
-            panic!("Could not write logs file: {}", err);
-        }
-    }
+    progress.save();
+    log.save();
 }

src/commands/init.rs

@@ -3,7 +3,7 @@ use std::{env::current_dir, fs::create_dir_all};
 use clap::Parser;
 use inquire::{Confirm, Text};
 
-use crate::{config::Config, tui::init_deck::run as tui};
+use crate::{config::Config, deck::Deck, tui::init_deck::run as tui};
 
 #[derive(Parser, Debug, Clone)]
 pub struct InitArgs {
@@ -93,27 +93,21 @@ fn terminal(args: InitArgs) {
         }
     }
 
-    let deck = crate::deck::Deck {
-        config: Some(config.clone()),
-        id: id.clone(),
-        description: match Text::new("What description should the new deck have?").prompt() {
+    let deck = Deck::new(
+        id.clone(),
+        path.clone(),
+        match Text::new("What description should the new deck have?").prompt() {
             Ok(description) => description,
             Err(err) => panic!("Could not read description: {}", err),
         },
-        cards: Vec::new(),
-    };
+    );
 
-   match deck.save() {
+    match deck.save() {
         Ok(_) => {}
         Err(err) => panic!("Could not save deck: {}", err),
-   };
-
-    let deck_entry = crate::config::DeckEntry {
-        id,
-        path: path.to_str().unwrap().to_string(),
     };
 
-    config.decks.push(deck_entry);
+    config.decks.push(deck.to_entry());
 
     match config.save() {
         Ok(_) => {}

src/commands/list.rs

@@ -1,4 +1,4 @@
-use crate::{config::Config, tui::deck_select};
+use crate::{config::Config, deck::Deck, tui::deck_select};
 
 pub fn run(siv: &mut Option<&mut cursive::Cursive>) {
     let config = match Config::get() {
@@ -21,7 +21,10 @@ pub fn run(siv: &mut Option<&mut cursive::Cursive>) {
                 });
             }
             None => {
-                println!("{}", deck.id);
+                let deck = Deck::get(deck.id).unwrap();
+
+
+                println!("{}: {}", deck.id, deck.cards.len());
             }
         }
     }

src/commands/study.rs

@@ -1,13 +1,16 @@
-use std::{fs, path::Path};
+use std::fs;
 
 use chrono::Utc;
 use clap::Parser;
 use inquire::{Select, Text};
 use rs_fsrs::{Card as FSRSCard, Rating as FSRSRating, FSRS};
 
 use crate::config::Config;
-use crate::deck::{Deck, Log};
-use crate::progress::{Progress, ProgressCard, Rating};
+use crate::deck::log::LogEntry;
+use crate::deck::{
+    progress::{Progress, ProgressCard, Rating},
+    Deck,
+};
 use rand::seq::SliceRandom;
 
 use crate::tui::study::run as tui;
@@ -58,15 +61,11 @@ fn terminal(args: StudyArgs) {
             }
         },
     };
-    let deck_path = Path::new(deck_entry.path.as_str());
+    let deck_path = deck_entry.path;
 
     let deck: Deck = match fs::read_to_string(deck_path.join("deck.json")) {
         Ok(contents) => match serde_json::from_str::<Deck>(&contents) {
-            Ok(mut deck) => {
-                deck.config = Some(config);
-
-                deck
-            }
+            Ok(deck) => deck,
             Err(err) => {
                 panic!("Could not parse deck file: {}", err);
             }
@@ -82,7 +81,7 @@ fn terminal(args: StudyArgs) {
 
     let progress_path = deck_path.join(".progress.json");
 
-    let mut new_progress: Progress = match fs::read_to_string(&progress_path) {
+    let mut progress: Progress = match fs::read_to_string(&progress_path) {
         Ok(contents) => match serde_json::from_str(&contents) {
             Ok(progress) => progress,
             Err(err) => {
@@ -91,23 +90,28 @@ fn terminal(args: StudyArgs) {
         },
         Err(err) => {
             if err.kind() == std::io::ErrorKind::NotFound {
-                Progress { cards: Vec::new() }
+                match Progress::get(&deck) {
+                    Ok(progress) => progress,
+                    Err(err) => {
+                        panic!("Could not get progress: {}", err);
+                    }
+                }
             } else {
                 panic!("Could not read progress file: {}", err);
             }
         }
     };
 
     // Remove any cards that have been removed from the deck by checking ids
-    new_progress.cards.retain(|progress_card| {
+    progress.cards.retain(|progress_card| {
         deck.cards
             .iter()
             .find(|card| card.id == progress_card.id)
             .is_some()
     });
 
     // Get cards from progress whose due date is before now
-    let mut cards = new_progress
+    let mut cards = progress
         .cards
         .iter()
         .filter(|progress_card| progress_card.fsrs.due.clone() < now)
@@ -116,7 +120,7 @@ fn terminal(args: StudyArgs) {
 
     // Add any new cards to the progress file
     for card in deck.cards.iter() {
-        if new_progress
+        if progress
             .cards
             .iter()
             .find(|progress_card| progress_card.id == card.id)
@@ -127,12 +131,12 @@ fn terminal(args: StudyArgs) {
                 fsrs: FSRSCard::default(),
             };
 
-            new_progress.cards.push(progress_card.clone());
+            progress.cards.push(progress_card.clone());
             cards.push(progress_card);
         }
     }
 
-    let progress_json = serde_json::to_string_pretty(&new_progress).unwrap();
+    let progress_json = serde_json::to_string_pretty(&progress).unwrap();
     fs::write(&progress_path, progress_json).unwrap();
 
     if cards.is_empty() {
@@ -176,22 +180,27 @@ fn terminal(args: StudyArgs) {
         let new_schedule = schedules[&FSRSRating::from(rating)].clone();
 
         // Update card in progress
-        new_progress
+        progress
             .cards
             .iter_mut()
             .find(|progress_card| progress_card.id == card.id)
             .unwrap()
             .fsrs = new_schedule.card;
 
-        let progress_json = serde_json::to_string_pretty(&new_progress).unwrap();
-        fs::write(&progress_path, progress_json).unwrap();
+        progress.save();
+
+        let mut log = match deck.log() {
+            Ok(log) => log,
+            Err(err) => {
+                panic!("Could not get log: {}", err);
+            }
+        };
+
+        log.entries.push(LogEntry {
+            last_card: card.clone(),
+            log: new_schedule.review_log,
+        });
 
-        deck.add_log(
-            deck.id.clone(),
-            Log {
-                last_card: card.clone(),
-                log: new_schedule.review_log,
-            },
-        );
+        log.save();
     }
 }