Add slides package builder

Author: hdoordt

Diff for: modmod/src/book.rs

@@ -12,6 +12,7 @@ use crate::{
 };
 
 #[derive(Debug, Default)]
+#[non_exhaustive]
 pub struct RenderBookError;
 
 impl fmt::Display for RenderBookError {

Diff for: modmod/src/exercises.rs

@@ -0,0 +1,40 @@
+use std::{fmt, path::{PathBuf, Path}};
+
+#[non_exhaustive]
+#[derive(Debug, Default)]
+pub struct RenderExercisesError;
+
+impl fmt::Display for RenderExercisesError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("unable to render exercises")
+    }
+}
+
+impl error_stack::Context for RenderExercisesError {}
+
+pub struct ExerciseCollection {}
+
+impl ExerciseCollection {
+    pub fn builder() -> ExerciseCollectionBuilder {
+        todo!()
+    }
+
+    pub fn render(&self, output_dir: impl AsRef<Path>) -> Result<(), RenderExercisesError> {
+        todo!();
+    }
+}
+
+pub struct UnitExercises {}
+
+pub struct Exercise {
+    name: String,
+    path: PathBuf,
+    description: PathBuf,
+    includes: Vec<String>,
+}
+
+
+pub struct ExerciseCollectionBuilder {
+    units: Vec<UnitExercises>,
+}
+

Diff for: modmod/src/lib.rs

@@ -1,16 +1,19 @@
 mod book;
 mod io;
 mod load;
+mod exercises;
+mod slides;
 
 use self::{
     book::{Book, BookBuilder, ChapterBuilder, SectionBuilder},
     load::{Load, TrackDef},
 };
 use error_stack::{IntoReport, Report, Result, ResultExt};
 use io::{copy, create_dir_all, create_file, get_dir_content, read_to_string, write_all};
+use slides::{SlidesPackage, SlidesPackageBuilder};
 use std::{
     fmt,
-    fs::{self},
+    fs,
     path::{Path, PathBuf},
 };
 
@@ -50,10 +53,15 @@ impl Track {
 
         // Render the modules in the track
         let mut book_builder = Book::builder(&self.name);
+        let mut slides_builder = SlidesPackage::builder(self.name);
         for (module, index) in self.modules.iter().zip(1..) {
-            module.render(&mut book_builder, index, output_dir)?;
+            module.render(&mut book_builder, &mut slides_builder, index, output_dir)?;
         }
 
+        // Build and render the slides package
+        let slides_package = slides_builder.build();
+        slides_package.render(output_dir).change_context(LoadTrackError)?;
+
         // Build and render the exercise book
         let book = book_builder.build();
         book.render(output_dir).change_context(LoadTrackError)?;
@@ -72,16 +80,18 @@ impl Module {
     fn render(
         &self,
         book_builder: &mut BookBuilder,
+        slides: &mut SlidesPackageBuilder,
         index: i32,
         output_dir: impl AsRef<Path>,
     ) -> Result<(), LoadTrackError> {
         let module_tag = to_numbered_tag(&self.name, index);
         let module_out_dir = output_dir.as_ref().join(Path::new(&module_tag));
         create_dir_all(&module_out_dir)?;
+
         let mut chapter = book_builder.chapter(&self.name);
 
         for (unit, index) in self.units.iter().zip(1..) {
-            unit.render(&mut chapter, index, &module_out_dir)?;
+            unit.render(&mut chapter, slides, index, &module_out_dir)?;
         }
         chapter.add();
         Ok(())
@@ -99,9 +109,11 @@ impl Unit {
     fn render(
         &self,
         chapter: &mut ChapterBuilder,
+        slides: &mut SlidesPackageBuilder,
         index: i32,
         output_dir: impl AsRef<Path>,
     ) -> Result<(), LoadTrackError> {
+        let mut deck = slides.deck(&self.name, self.template.clone());
         let mut section = chapter.section(&self.name);
         let unit_tag = to_numbered_tag(&self.name, index);
         let unit_out_dir = output_dir.as_ref().join(unit_tag);

Diff for: modmod/src/slides.rs

@@ -0,0 +1,122 @@
+#![allow(dead_code)]
+use std::path::{PathBuf, Path};
+use std::fmt;
+
+use error_stack::Result;
+
+
+#[derive(Debug, Default)]
+#[non_exhaustive]
+pub struct RenderSlidesError;
+
+impl fmt::Display for RenderSlidesError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("unable to render slides")
+    }
+}
+
+impl error_stack::Context for RenderSlidesError {}
+
+pub struct SlidesPackage {
+    /// Name of the package, corresponds to the name of the track
+    name: String,
+    decks: Vec<SlideDeck>,
+}
+
+impl SlidesPackage {
+    pub fn builder(name: &str) -> SlidesPackageBuilder {
+        SlidesPackageBuilder {
+            package: SlidesPackage {
+                name: name.to_string(),
+                decks: vec![],
+            },
+        }
+    }
+
+    pub fn render(&self, out_dir: impl AsRef<Path>) -> Result<(), RenderSlidesError> {
+        todo!()
+    }
+}
+
+pub struct SlideDeck {
+    /// Name of the slide deck, corresponds to the name of the unit in the module
+    name: String,
+    template: PathBuf,
+    sections: Vec<Section>,
+}
+
+pub struct Section {
+    content: PathBuf,
+    objectives: Vec<String>,
+    summary: Vec<String>,
+    further_reading: Vec<String>,
+}
+
+pub struct SlidesPackageBuilder {
+    package: SlidesPackage,
+}
+
+impl SlidesPackageBuilder {
+    pub fn deck(&mut self, name: &str, template: PathBuf) -> SlideDeckBuilder<'_> {
+        SlideDeckBuilder {
+            package_builder: self,
+            slide_deck: SlideDeck {
+                name: name.to_string(),
+                template,
+                sections: vec![],
+            },
+        }
+    }
+
+    pub fn build(self) -> SlidesPackage {
+        self.package
+    }
+}
+
+pub struct SlideDeckBuilder<'p> {
+    package_builder: &'p mut SlidesPackageBuilder,
+    slide_deck: SlideDeck,
+}
+
+impl<'p> SlideDeckBuilder<'p> {
+    fn section(&mut self, content: PathBuf) -> SectionBuilder<'p, '_> {
+        SectionBuilder {
+            deck_builder: self,
+            section: Section {
+                content,
+                objectives: vec![],
+                summary: vec![],
+                further_reading: vec![],
+            },
+        }
+    }
+
+    fn add(self) -> &'p mut SlidesPackageBuilder {
+        self.package_builder.package.decks.push(self.slide_deck);
+        self.package_builder
+    }
+}
+
+pub struct SectionBuilder<'p, 'd> {
+    deck_builder: &'d mut SlideDeckBuilder<'p>,
+    section: Section,
+}
+
+impl<'p, 'd> SectionBuilder<'p, 'd> {
+    pub fn objective(&mut self, objective: &str) {
+        self.section.objectives.push(objective.to_string());
+    }
+
+    pub fn summary(&mut self, summary: String) {
+        self.section.summary.push(summary);
+    }
+
+    pub fn further_reading(&mut self, further_reading: String) {
+        self.section.further_reading.push(further_reading);
+    }
+
+    pub fn add(self) -> &'d mut SlideDeckBuilder<'p> {
+        self.deck_builder.slide_deck.sections.push(self.section);
+        self.deck_builder
+    }
+}