added config file for some options

.gitignore

@@ -1,6 +1,6 @@
 /target
 dist
+/docs
 res/test/docs/slides/revealjs
-res/test/asciidocs/slides/revealjs
 res/test/result
 result

README.md

@@ -112,10 +112,6 @@ home.packages = with pkgs; [
 ]
 ```
 
-## Configuration
-
-You can configure some of the cli arguments with a config file. It is always located relatively to the current directory under `./docki.config.toml`. Available options and their defaults can be found in the [config.rs](src/app/config/config.rs) file. CLI arguments with the same names as in the config usually have also the same default values.
-
 ## Development
 
 ### Running it

res/test/asciidocs/index.adoc

@@ -1,16 +0,0 @@
-= My Project
-:toc:
-:toc-title:
-:toclevels: 2
-
-== Introduction
-
-This is my project.
-
-== Slides
-
-* link:slides/index.html[Presentation]
-
-== License
-
-This project is licensed under the MIT License - see the link:LICENSE[LICENSE] file for details.

res/test/asciidocs/slides/index.adoc

@@ -1,19 +0,0 @@
-# Slides
-
-## Slide 1
-
-* First
-* Second
-* Third
-
-## Slide 2
-
-* First
-* Second
-* Third
-
-### Slide 3
-
-* First
-* Second
-* Third

res/test/docki.config.toml

@@ -1,3 +1 @@
-docs_dir = "./docs"
 port = 6969
-offline_reveal = false

res/test/docs/index.adoc

@@ -1,16 +0,0 @@
-= My Project
-:toc:
-:toc-title:
-:toclevels: 2
-
-== Introduction
-
-This is my project.
-
-== Slides
-
-* link:slides/index.html[Presentation]
-
-== License
-
-This project is licensed under the MIT License - see the link:LICENSE[LICENSE] file for details.

res/test/docs/slides/index.adoc

@@ -1,19 +1,11 @@
-# Slides
+= My cool presentation
+:author: John Doe
+:email: john@doe.com
 
-## Slide 1
+== First slide
 
-* First
+Content
-* Second
-* Third
 
-## Slide 2
+== Second slide
 
-* First
+Content
-* Second
-* Third
-
-### Slide 3
-
-* First
-* Second
-* Third

src/app/build/asciidoctor.rs

@@ -12,13 +12,9 @@ fn exec_command(command: &mut process::Command) -> Result<(), String> {
         }
     } else {
         println!("{}", result.unwrap_err());
-
+        return Err(
-        let binary_name = command.get_program().to_str().unwrap_or("Something is");
+            "asciidoctor not installed. For more information run docki health!".to_string(),
-
+        );
-        return Err(format!(
-            "{} not installed. For more information run docki health!",
-            binary_name
-        ));
     }
 }
 

src/app/build/mod.rs

@@ -1 +1,54 @@
+use std::fs;
+
+use self::asciidoctor::{build_doc, build_slide};
+
+use super::fs_util;
+
 pub mod asciidoctor;
+
+pub fn docki_build(in_path: &str, offline_reveal: bool) -> DockiBuildResult {
+    let out_path = in_path.replace("/docs/", "/dist/");
+    let convert_out_path = out_path.replace(".adoc", ".html");
+
+    if in_path.starts_with("./docs/slides/") && in_path.ends_with(".adoc") {
+        if let Err(err) = build_slide(&in_path, &convert_out_path, offline_reveal) {
+            return DockiBuildResult::Err(err);
+        }
+
+        DockiBuildResult::Slide(convert_out_path)
+    } else if in_path.ends_with(".adoc") {
+        if let Err(err) = build_doc(&in_path, &convert_out_path) {
+            return DockiBuildResult::Err(err);
+        }
+
+        DockiBuildResult::Doc(convert_out_path)
+    } else {
+		if in_path.starts_with("./docs/slides/revealjs") && !offline_reveal {
+			return DockiBuildResult::Silent;
+		}
+
+        if let Err(err) = copy(&in_path, &out_path) {
+            return DockiBuildResult::Err(err);
+        }
+
+        DockiBuildResult::Copy(out_path)
+    }
+}
+
+fn copy(in_path: &str, out_path: &str) -> Result<(), String> {
+    fs_util::create_parent_dir_recursive(out_path);
+
+    if let Err(err) = fs::copy(in_path, out_path) {
+        return Err(err.to_string());
+    }
+
+    Ok(())
+}
+
+pub enum DockiBuildResult {
+    Slide(String),
+    Doc(String),
+    Copy(String),
+    Err(String),
+	Silent,
+}

src/app/commands/build.rs

@@ -1,10 +1,6 @@
-use crate::app::config::config::Config;
-
 use super::executions::build_execution::BuildExecution;
 
-pub async fn build(config: &Config) -> () {
+pub async fn build(offline_reveal: bool) -> () {
-    let mut build_execution = BuildExecution::new(config);
+    let mut build_execution = BuildExecution::new();
-
+    build_execution.execute(offline_reveal).await.expect("build failed")
-	build_execution.prepare().await.expect("could not prepare for build");
-    build_execution.build_dir().expect("build failed")
 }

src/app/commands/executions/build_execution.rs

@@ -1,41 +1,52 @@
 use std::{
-    fs, io::Cursor, path::PathBuf
+    io::Cursor,
+    path::PathBuf
 };
 
 use crate::app::{
-    build::{asciidoctor::build_slide, asciidoctor::build_doc}, config::config::Config, fs_util::{self, create_dir_recursive}, log::display_status
+    build::{docki_build, DockiBuildResult},
+    fs_util::{self, create_dir_recursive}, log::display_status,
 };
 
-pub struct BuildExecution<'a> {
+pub struct BuildExecution {
     progress: usize,
     goal: usize,
-	config: &'a Config
 }
 
-impl <'a> BuildExecution <'a> {
+impl BuildExecution {
-    pub fn new(config: &'a Config) -> Self {
+    pub fn new() -> Self {
-        return Self {
+        return BuildExecution {
             progress: 0,
             goal: 0,
-			config: config
         };
     }
 
-    pub async fn prepare(&self) -> Result<(), String> {
+    pub async fn execute(&mut self, offline_reveal: bool) -> Result<(), String> {
-        if !fs_util::directory_exists(&self.config.input_dir) {
+        let path = "./docs/".to_string();
+
+        if !fs_util::directory_exists(&path) {
             return Err(
                 "docs directory does not exist it. Create it or use the template".to_string(),
             );
         }
 
-		if !self.config.offline_reveal {
+        if let Err(error) = Self::prepare(offline_reveal).await {
+            return Err(error);
+        }
+
+        return self.build_dir(&path, offline_reveal);
+    }
+
+
+    async fn prepare(offline_reveal: bool) -> Result<(), String> {
+		if !offline_reveal {
 			return Ok(())
 		}
 
         let reveal_version = "5.2.1";
         let target = format!("https://github.com/hakimel/reveal.js/archive/{reveal_version}.zip");
 
-        create_dir_recursive(format!("{}/slides", self.config.input_dir).as_str());
+        create_dir_recursive("./docs/slides");
 
 		reqwest::get(target.clone()).await.unwrap();
         let Ok(response) = reqwest::get(target).await else {
@@ -46,7 +57,7 @@ impl <'a> BuildExecution <'a> {
             return Err("could not extract bytes".to_string())
         };
 
-        let out = PathBuf::from(format!("{}/slides/revealjs", self.config.input_dir));
+        let out = PathBuf::from("./docs/slides/revealjs");
 
         if zip_extract::extract(Cursor::new(bytes), &out, true).is_err() {
             return Err("could not write extracted archive to disk".to_string());
@@ -55,83 +66,36 @@ impl <'a> BuildExecution <'a> {
         return Ok(());
     }
 
-    pub fn build_dir(&mut self) -> Result<(), String> {
+    fn build_dir(&mut self, path: &str, offline_reveal: bool) -> Result<(), String> {
-        let result = fs_util::fetch_paths_recursive(&self.config.input_dir);
+        let result = fs_util::fetch_paths_recursive(&path);
+
         let Ok(paths) = result else {
             return Err(result.unwrap_err())
         };
 
-		let reveal_dir = format!("{}/slides/revealjs", self.config.input_dir);
-		let paths = paths.into_iter()
-			.filter(|path| self.config.offline_reveal || !path.starts_with(reveal_dir.as_str()))
-			.collect::<Vec<String>>();
-
-		self.goal = paths.len();
-
         for (index, in_path) in paths.iter().enumerate() {
             self.progress = index + 1;
-            let result = self.build_file(&in_path);
+            self.goal = paths.len();
+            let result = docki_build(&in_path, offline_reveal);
 
             match result {
                 DockiBuildResult::Err(err) => {
-                    self.display_building_status("Error", &in_path, "");
+                    self.display_building_status("Error", in_path, "");
                     println!("{}", err)
                 },
                 DockiBuildResult::Copy(out_path) => self.display_building_status("Copy", &in_path, &out_path),
                 DockiBuildResult::Slide(out_path) => self.display_building_status("Slide", &in_path, &out_path),
                 DockiBuildResult::Doc(out_path) => self.display_building_status("Doc", &in_path, &out_path),
+				DockiBuildResult::Silent => ()
             }
         }
 
         return Ok(());
     }
 
-	pub fn build_file(&mut self, path: &str) -> DockiBuildResult {
-		let out_path = path.replace(&self.config.input_dir, "./dist");
-		let convert_out_path = out_path.replace(".adoc", ".html");
-
-		if path.starts_with(format!("{}/slides/", &self.config.input_dir).as_str()) && path.ends_with(".adoc") {
-			if let Err(err) = build_slide(&path, &convert_out_path, self.config.offline_reveal) {
-				return DockiBuildResult::Err(err);
-			}
-
-			DockiBuildResult::Slide(convert_out_path)
-		} else if path.ends_with(".adoc") {
-			if let Err(err) = build_doc(&path, &convert_out_path) {
-				return DockiBuildResult::Err(err);
-			}
-
-			DockiBuildResult::Doc(convert_out_path)
-		} else {
-			if let Err(err) = Self::copy(&path, &out_path) {
-				return DockiBuildResult::Err(err);
-			}
-
-			DockiBuildResult::Copy(out_path)
-		}
-	}
-
-	fn copy(in_path: &str, out_path: &str) -> Result<(), String> {
-		fs_util::create_parent_dir_recursive(out_path);
-
-		if let Err(err) = fs::copy(in_path, out_path) {
-			return Err(err.to_string());
-		}
-
-		Ok(())
-	}
-
     fn display_building_status(&self, status_type: &str, in_path: &str, out_path: &str) -> () {
         let progress_str = format!("{} / {}", self.progress, self.goal);
         display_status(&progress_str, status_type, in_path, out_path);
     }
 
 }
-
-
-pub enum DockiBuildResult {
-    Slide(String),
-    Doc(String),
-    Copy(String),
-    Err(String),
-}

src/app/commands/serve.rs

@@ -7,35 +7,23 @@ use notify::{
 };
 use std::{env, path::Path};
 
-use crate::app::{ commands::executions::build_execution::{self, BuildExecution, DockiBuildResult}, config::config::Config, log::display_status, watcher::watcher};
+use crate::app::{ watcher::watcher, build::{docki_build, DockiBuildResult}, commands::build::build, log::display_status};
 
-pub async fn serve(config: &Config) {
+
-	let build_execution = BuildExecution::new(config);
+pub async fn serve(port: u16) {
-	let mut server = Server::new(build_execution, config);
+    build(false).await;
-	server.serve().await;
+    tokio::join!(watch_and_build(), start_server(port));
 }
 
-struct Server<'a> {
+async fn watch_and_build() {
-	build_execution: BuildExecution<'a>,
+    watch(Path::new("./docs"))
-	config: &'a Config,
+        .await
+        .expect("something went wrong")
 }
 
-impl <'a> Server <'a> {
-	pub fn new(build_execution: BuildExecution<'a>, config: &'a Config) -> Self {
-		return Self {
-			build_execution: build_execution,
-			config: config
-		}
-	}
 
-	async fn serve(&mut self) {
+async fn start_server(port: u16) {
-		self.build_execution.prepare().await.expect("could not prepare for build");
+	let link = &format!("http://localhost:{}", port);
-		self.build_execution.build_dir().expect("build failed");
-		tokio::join!(self.start_server(), self.watch_and_build());
-	}
-
-	async fn start_server(&self) {
-		let link = &format!("http://localhost:{}", self.config.port);
 	let hyperlink = Green.paint(link).hyperlink(link);
 
     println!(
@@ -43,40 +31,32 @@ impl <'a> Server <'a> {
         hyperlink
     );
 
-		let Ok(()) = listen("localhost", self.config.port, "./dist").await else {
+    let Ok(()) = listen("localhost", port, "./dist").await else {
         panic!("could not start server")
     };
-	}
+}
 
-	async fn watch_and_build(&mut self) {
+async fn watch(path: &Path) -> notify::Result<()> {
-		self.watch()
-			.await
-			.expect("something went wrong")
-	}
-
-	async fn watch(&mut self) -> notify::Result<()> {
-		let path = Path::new(&self.config.input_dir);
     let (mut watcher, mut rx) = watcher()?;
 
     watcher.watch(path.as_ref(), RecursiveMode::Recursive)?;
 
     while let Some(res) = rx.next().await {
         let event = res.expect("watching failed");
-			self.file_change(event)
+        file_change(event)
     }
 
     Ok(())
+}
 
-	}
+fn file_change(event: Event) {
-
-	fn file_change(&mut self, event: Event) {
     match event.kind {
-			EventKind::Modify(ModifyKind::Data(_)) => self.build_file(event.paths),
+        EventKind::Modify(ModifyKind::Data(_)) => build_file(event.paths),
         _ => (),
     }
-	}
+}
 
-	fn build_file(&mut self, paths: Vec<std::path::PathBuf>) {
+fn build_file(paths: Vec<std::path::PathBuf>) {
     let invalid_path_message = "changed path is invalid";
     let in_path = paths
         .first()
@@ -87,7 +67,7 @@ impl <'a> Server <'a> {
         .expect(invalid_path_message);
 
 	let in_path = format!("./{}", in_path);
-		let result = self.build_execution.build_file(&in_path);
+    let result = docki_build(&in_path, false);
 
     match result {
         DockiBuildResult::Slide(out_path) => display_rebuilding_status("Slide", &in_path, &out_path),
@@ -97,15 +77,10 @@ impl <'a> Server <'a> {
             display_rebuilding_status("Error", &in_path, "");
             println!("{}", err);
         },
-		}
+		DockiBuildResult::Silent => ()
     }
 }
 
-
-
-
-
-
 fn display_rebuilding_status(context: &str, in_path: &str, out_path: &str) {
     display_status("Rebuildng", context, in_path, out_path)
 }

src/app/config/arguments.rs

@@ -1,27 +1,13 @@
+use super::config::Config;
 use clap::{Parser, Subcommand};
-use nu_ansi_term::{AnsiGenericString, Style};
-
-fn github_hyperlink() -> AnsiGenericString<'static, str> {
-    return Style::new()
-        .bold()
-        .underline()
-        .paint("https://github.com/quirinecker/docki")
-        .hyperlink("https://github.com/quirinecker/docki");
-}
 
 #[derive(Parser)]
-#[command(after_help = format!("More information like defaults can be found at {}", github_hyperlink()))]
 pub struct Args {
     #[command(subcommand)]
     pub command: CommandArg,
 
-    /// The directory where the documentation is located
+    #[arg(short, long)]
-    #[arg(short, long, global = true)]
+    pub docs_dir: Option<String>,
-    pub input_dir: Option<String>,
-
-    /// The directory where the documentation will be built
-    #[arg(short, long, global = true)]
-    pub output_dir: Option<String>,
 }
 
 #[derive(Subcommand)]

src/app/config/config.rs

@@ -6,13 +6,13 @@ use crate::app::config::arguments::CommandArg;
 #[serde(default)]
 pub struct Config {
 	pub port: u16,
-    pub input_dir: String,
+	pub docs_dir: String,
 	pub offline_reveal: bool,
-	pub output_dir: String
 }
 
 impl Config {
     pub fn load() -> Result<Self, config::ConfigError> {
+
         let s = config::Config::builder()
             .add_source(config::File::with_name("./docki.config.toml"))
             .build()?;
@@ -25,15 +25,14 @@ impl Config {
 				CommandArg::Serve { port } => port.unwrap_or(self.port),
 				_ => self.port,
 			},
-            input_dir: args.input_dir.clone().unwrap_or(self.input_dir),
+			docs_dir: args.docs_dir.clone().unwrap_or(self.docs_dir),
-			output_dir: args.output_dir.clone().unwrap_or(self.output_dir),
 			offline_reveal: {
 				if let CommandArg::Build { offline_reveal } = args.command {
 					offline_reveal
 				} else {
 					self.offline_reveal
 				}
-            },
+			}
 		}
 	}
 }
@@ -42,8 +41,7 @@ impl Default for Config {
 	fn default() -> Self {
 		Self {
 			port: 8080,
-            input_dir: "./docs".to_string(),
+			docs_dir: "./docs".to_string(),
-			output_dir: "./dist".to_string(),
 			offline_reveal: false,
 		}
 	}

src/app/mod.rs

@@ -26,10 +26,10 @@ impl App {
         Self::setup_environment_variables();
 
         match args.command {
-            CommandArg::Build { .. } => build(&config).await,
+            CommandArg::Build { .. } => build(config.offline_reveal).await,
             CommandArg::Health => health(),
             CommandArg::InstallReveal => install_reveal().await,
-            CommandArg::Serve { .. } => serve(&config).await,
+            CommandArg::Serve { .. } => serve(config.port).await,
             CommandArg::Completions { shell } => completions(shell)
         };
     }