Move lesson to state

compare with is_empty instead of ""

tmp

Author: gintsgints

src/config.rs

@@ -10,7 +10,7 @@ use thiserror::Error;
 use crate::{environment, Result};
 pub use index::IndexRecord;
 pub use lesson::Exercise;
-use lesson::{Lesson, LessonPage};
+pub use lesson::Lesson;
 
 #[derive(Deserialize, Serialize, Default)]
 pub struct Configuration {
@@ -26,12 +26,11 @@ pub struct Configuration {
 
 #[derive(Debug, Clone, Default)]
 pub struct Config {
-    pub lesson: Lesson,
     pub index: Index,
     pub current_keyboard: String,
-    current_lesson: String,
-    current_page: usize,
-    current_exercise: usize,
+    pub current_lesson: String,
+    pub current_page: usize,
+    pub current_exercise: usize,
 }
 
 impl Config {
@@ -67,15 +66,13 @@ impl Config {
         } else {
             Configuration {
                 current_keyboard: "querty".to_string(),
-                current_lesson: "l01_intro".to_string(),
+                current_lesson: "".to_string(),
                 ..Configuration::default()
             }
         };
 
-        let lesson = Lesson::load(Self::data_dir().join(format!("{}.yaml", current_lesson)))?;
         let index = Index::load(Self::data_dir().join("index.yaml"))?;
         Ok(Config {
-            lesson,
             index,
             current_keyboard,
             current_lesson,
@@ -100,30 +97,19 @@ impl Config {
         Ok(())
     }
 
-    pub fn get_page(&self) -> Option<&LessonPage> {
-        self.lesson.pages.get(self.current_page)
-    }
-
     // If current_page goes out of index, lesson is considered finished
     // and index page is shown.
     pub fn next_page(&mut self) {
         self.current_exercise = 0;
         self.current_page += 1;
     }
 
-    pub fn load_lesson(&mut self, file_name: &str) -> Result<()> {
-        self.lesson = Lesson::load(Self::data_dir().join(format!("{}.yaml", file_name)))?;
+    pub fn load_lesson(&mut self, file_name: &str) -> Result<Lesson> {
+        let lesson = Lesson::load(Self::data_dir().join(format!("{}.yaml", file_name)))?;
         self.current_lesson = file_name.to_string();
         self.current_exercise = 0;
         self.current_page = 0;
-        Ok(())
-    }
-
-    pub fn get_exercise(&self) -> Option<&Exercise> {
-        match self.get_page() {
-            Some(page) => page.exercises.get(self.current_exercise),
-            None => None,
-        }
+        Ok(lesson)
     }
 }
 

src/config/lesson.rs

@@ -33,6 +33,17 @@ impl Lesson {
             serde_yaml::from_str(&content).map_err(|e| Error::Parse(e.to_string()))?;
         Ok(lesson)
     }
+
+    pub fn get_page(&self, page_index: usize) -> Option<&LessonPage> {
+        self.pages.get(page_index)
+    }
+
+    pub fn get_exercise(&self, current_page: usize, current_exercise: usize) -> Option<&Exercise> {
+        match self.get_page(current_page) {
+            Some(page) => page.exercises.get(current_exercise),
+            None => None,
+        }
+    }
 }
 
 #[derive(Debug, Error, Clone)]

src/main.rs

@@ -16,7 +16,7 @@ use iced::{
 };
 use serde_json::json;
 
-use crate::keyboard_config::KeyboardConfig;
+use crate::{config::Lesson, keyboard_config::KeyboardConfig};
 
 mod config;
 mod environment;
@@ -44,6 +44,7 @@ fn main() -> iced::Result {
 #[derive(Default)]
 struct Raiti {
     config: Config,
+    lesson: Option<Lesson>,
     exercise: Vec<Exercise>,
     was_errors: u64,
     was_wpm: f64,
@@ -73,9 +74,19 @@ impl Raiti {
         )
         .expect("Error loading keyboard config");
 
+        let lesson = if !config.current_lesson.is_empty() {
+            Some(
+                Lesson::load(Config::data_dir().join(format!("{}.yaml", config.current_lesson)))
+                    .expect("Error loading lesson"),
+            )
+        } else {
+            None
+        };
+
         (
             Self {
                 config: config.clone(),
+                lesson,
                 exercise: vec![],
                 keyboard: KeyboardComponent::new(keyboard_config),
                 ..Default::default()
@@ -155,7 +166,11 @@ impl Raiti {
             }
             Message::LessonSelected(lesson) => {
                 // TODO: find a way to fail lesson load without unwrap
-                self.config.load_lesson(&lesson.file).unwrap();
+                self.lesson = Some(
+                    self.config
+                        .load_lesson(&lesson.file)
+                        .expect("Error loading lesson"),
+                );
                 Task::none()
             }
             Message::Confirm => self.exit_with_save(),
@@ -183,7 +198,10 @@ impl Raiti {
                 .center_y(Length::Fill)
                 .into();
         }
-        if let Some(page) = self.config.get_page() {
+        if let Some(lesson) = &self.lesson {
+            let page = lesson
+                .get_page(self.config.current_page)
+                .expect("No page found");
             let title = text(&page.title).size(25);
             let mut page_content = column![title];
             let reg = Handlebars::new();
@@ -243,30 +261,37 @@ impl Raiti {
         self.exercise.clear();
         self.keyboard.update(keyboard_component::Message::ClearKeys);
         self.config.next_page();
-        if let Some(page) = self.config.get_page() {
+        if let Some(lesson) = &self.lesson {
+            let page = lesson
+                .get_page(self.config.current_page)
+                .expect("No page found");
             if !page.show_keys.is_empty() {
                 self.keyboard
                     .update(keyboard_component::Message::SetShowKeys(
                         page.show_keys.clone(),
                     ))
             }
         }
-        if let Some(ex) = self.config.get_exercise() {
-            match ex {
-                config::Exercise::None => {}
-                config::Exercise::OneLineNoEnter(line) => {
-                    self.exercise.push(Exercise::new(line));
-                }
-                config::Exercise::Multiline(lines) => {
-                    for line in lines.lines() {
-                        let mut ex = Exercise::new(line);
-                        if self.exercise.is_empty() {
-                            ex.update(exercise::Message::SetFocus(true))
+        if let Some(lesson) = &self.lesson {
+            if let Some(ex) =
+                lesson.get_exercise(self.config.current_page, self.config.current_exercise)
+            {
+                match ex {
+                    config::Exercise::None => {}
+                    config::Exercise::OneLineNoEnter(line) => {
+                        self.exercise.push(Exercise::new(line));
+                    }
+                    config::Exercise::Multiline(lines) => {
+                        for line in lines.lines() {
+                            let mut ex = Exercise::new(line);
+                            if self.exercise.is_empty() {
+                                ex.update(exercise::Message::SetFocus(true))
+                            }
+                            self.exercise.push(ex);
                         }
-                        self.exercise.push(ex);
                     }
                 }
-            }
+            };
         }
     }