[Feat::CLI] supports that users can defined their own config to generate snapshot (#8)

Author: mistricky

cli/src/code.rs

@@ -5,18 +5,19 @@ use codesnap::config::{Breadcrumbs, Code, CodeBuilder, HighlightLine};
 
 use crate::CLI;
 
-pub fn create_code(cli: &CLI) -> anyhow::Result<Code> {
+pub fn create_code(cli: &CLI, config_code: Code) -> anyhow::Result<Code> {
     let code_snippet = get_code_snippet(cli)?;
-    let mut code_builder = CodeBuilder::default();
-    let mut code = code_builder
-        .content(&code_snippet)
-        .theme(&cli.code_theme)
-        .font_family(&cli.code_font_family)
-        .build()?;
+    let mut code_builder = CodeBuilder::from_code(config_code.clone());
+    let mut code = code_builder.content(&code_snippet).build()?;
 
-    code.file_path = cli.file.clone();
-    code.language = cli.language.clone();
-    code.breadcrumbs = create_breadcrumbs(&cli);
+    code.theme = cli.code_theme.clone().unwrap_or(config_code.theme);
+    code.font_family = cli
+        .code_font_family
+        .clone()
+        .unwrap_or(config_code.font_family);
+    code.file_path = cli.file.clone().or(config_code.file_path);
+    code.language = cli.language.clone().or(config_code.language);
+    code.breadcrumbs = create_breadcrumbs(&cli).or(config_code.breadcrumbs);
     code.highlight_lines = create_highlight_lines(&cli)?;
 
     Ok(code)

cli/src/main.rs

@@ -3,12 +3,13 @@ mod logger;
 mod watermark;
 mod window;
 
+use std::fs::read_to_string;
+
 use clap::Parser;
 use clap::Subcommand;
 use code::create_code;
 use codesnap::config::CodeSnap;
 use codesnap::config::SnapshotConfig;
-use codesnap::config::DEFAULT_WINDOW_MARGIN;
 use codesnap::snapshot::snapshot::Snapshot;
 use watermark::create_watermark;
 use window::create_window;
@@ -38,12 +39,12 @@ struct CLI {
     to_clipboard: bool,
 
     /// Font family for the code snippet
-    #[arg(long, default_value = "CaskaydiaCove Nerd Font")]
-    code_font_family: String,
+    #[arg(long)]
+    code_font_family: Option<String>,
 
     /// Code theme for the code snippet
-    #[arg(long, default_value = "base16-ocean.dark")]
-    code_theme: String,
+    #[arg(long)]
+    code_theme: Option<String>,
 
     /// Breadcrumbs is a useful and unique feature in CodeSnap, it shows the path of the file
     /// so that users can know where the code snippet comes from.
@@ -100,12 +101,12 @@ struct CLI {
     watermark_color: String,
 
     /// Set window shadow radius
-    #[arg(long, default_value_t = 20.)]
-    shadow: f32,
+    #[arg(long)]
+    shadow: Option<f32>,
 
     /// Display MacOS style window bar
-    #[arg(long, default_value_t = true)]
-    mac_window_bar: bool,
+    #[arg(long)]
+    mac_window_bar: Option<bool>,
 
     /// Display window border
     #[arg(long, default_value_t = true)]
@@ -116,12 +117,12 @@ struct CLI {
     border_color: String,
 
     /// Set horizontal margin of window
-    #[arg(long, default_value_t = DEFAULT_WINDOW_MARGIN)]
-    margin_x: f32,
+    #[arg(long)]
+    margin_x: Option<f32>,
 
     /// Set vertical margin of window
-    #[arg(long, default_value_t = DEFAULT_WINDOW_MARGIN)]
-    margin_y: f32,
+    #[arg(long)]
+    margin_y: Option<f32>,
 
     /// Set title of the window
     #[arg(long)]
@@ -155,6 +156,9 @@ struct CLI {
     /// To generate ASCII snapshot ranther than image snapshot
     #[arg(long)]
     ascii: bool,
+
+    #[arg(long)]
+    config: Option<String>,
 }
 
 #[derive(Subcommand)]
@@ -171,18 +175,24 @@ struct Args {
 
 fn generate_snapshot() -> anyhow::Result<()> {
     let cli = CLI::parse();
-    let code = create_code(&cli)?;
-    let watermark = create_watermark(&cli)?;
-    let window = create_window(&cli)?;
-    let mut codesnap = CodeSnap::default()
-        .code(code)
-        .watermark(watermark)
-        .window(window)
+
+    let mut codesnap_default = if let Some(ref config) = cli.config {
+        let content = read_to_string(config)?;
+
+        CodeSnap::from_config(&content)?
+    } else {
+        CodeSnap::default()
+    };
+
+    let mut codesnap = codesnap_default
+        .map_code(|code| create_code(&cli, code))?
+        .map_watermark(|watermark| create_watermark(&cli, watermark))?
+        .map_window(|window| create_window(&cli, window))?
         .scale_factor(cli.scale_factor)
         .build()?;
 
-    codesnap.themes_folder = cli.themes_folder.clone();
-    codesnap.fonts_folder = cli.fonts_folder.clone();
+    codesnap.themes_folder = cli.themes_folder.clone().or(codesnap.themes_folder);
+    codesnap.fonts_folder = cli.fonts_folder.clone().or(codesnap.fonts_folder);
 
     if cli.ascii {
         execute(&cli, codesnap.create_ascii_snapshot()?, codesnap)?;

cli/src/watermark.rs

@@ -1,18 +1,26 @@
-use codesnap::config::{Code, CodeBuilder, Watermark, WatermarkBuilder, Window};
+use codesnap::config::{Watermark, WatermarkBuilder};
 
 use crate::CLI;
 
-pub fn create_watermark(cli: &CLI) -> anyhow::Result<Option<Watermark>> {
-    if let Some(ref watermark) = cli.watermark {
-        let mut watermark_builder = WatermarkBuilder::default();
-        let watermark = watermark_builder
+pub fn create_watermark(
+    cli: &CLI,
+    config_watermark: Option<Watermark>,
+) -> anyhow::Result<Option<Watermark>> {
+    if cli.watermark.is_none() && config_watermark.is_none() {
+        return Ok(None);
+    }
+
+    let watermark = if let Some(ref watermark) = cli.watermark {
+        let watermark = WatermarkBuilder::default()
             .color(&cli.watermark_color)
             .content(watermark)
             .font_family(&cli.watermark_font_family)
             .build()?;
 
-        return Ok(Some(watermark));
-    }
+        Some(watermark)
+    } else {
+        None
+    };
 
-    Ok(None)
+    Ok(config_watermark.or(watermark))
 }

cli/src/window.rs

@@ -1,18 +1,16 @@
-use codesnap::config::{Border, Code, CodeBuilder, Margin, TitleConfig, Window, WindowBuilder};
+use codesnap::config::{Border, Margin, TitleConfig, Window, WindowBuilder};
 
 use crate::CLI;
 
-pub fn create_window(cli: &CLI) -> anyhow::Result<Window> {
-    let mut window_builder = WindowBuilder::default();
-    let mut window = window_builder
-        .mac_window_bar(cli.mac_window_bar)
-        .shadow(cli.shadow)
-        .margin(Margin {
-            x: cli.margin_x,
-            y: cli.margin_y,
-        })
-        .build()?;
+pub fn create_window(cli: &CLI, config_window: Window) -> anyhow::Result<Window> {
+    let mut window = WindowBuilder::from_window(config_window.clone()).build()?;
 
+    window.margin = Margin {
+        x: cli.margin_x.unwrap_or(config_window.margin.x),
+        y: cli.margin_y.unwrap_or(config_window.margin.y),
+    };
+    window.shadow = cli.shadow.unwrap_or(config_window.shadow);
+    window.mac_window_bar = cli.mac_window_bar.unwrap_or(config_window.mac_window_bar);
     window.title = create_title(cli);
     window.border = create_border(cli);
 

core/src/config.rs

@@ -348,35 +348,35 @@ impl CodeSnap {
         serde_json::from_str::<CodeSnap>(config)
     }
 
-    pub fn map_code<F>(&mut self, f: F) -> Result<&mut Self, CodeBuilderError>
+    pub fn map_code<F>(&mut self, f: F) -> anyhow::Result<&mut Self>
     where
-        F: Fn(Code) -> Result<Code, CodeBuilderError>,
+        F: Fn(Code) -> anyhow::Result<Code>,
     {
-        if let Some(ref code) = self.code {
-            self.code = Some(f(code.clone())?);
-        }
+        self.code = Some(f(self
+            .code
+            .clone()
+            .unwrap_or(CodeBuilder::default().content("").build()?))?);
 
         Ok(self)
     }
 
-    pub fn map_window<F>(&mut self, f: F) -> Result<&mut Self, WindowBuilderError>
+    pub fn map_window<F>(&mut self, f: F) -> anyhow::Result<&mut Self>
     where
-        F: Fn(Window) -> Result<Window, WindowBuilderError>,
+        F: Fn(Window) -> anyhow::Result<Window>,
     {
-        if let Some(ref window) = self.window {
-            self.window = Some(f(window.clone())?);
-        }
+        self.window = Some(f(self
+            .window
+            .clone()
+            .unwrap_or(WindowBuilder::default().build()?))?);
 
         Ok(self)
     }
 
-    pub fn map_watermark<F>(&mut self, f: F) -> Result<&mut Self, WatermarkBuilderError>
+    pub fn map_watermark<F>(&mut self, f: F) -> anyhow::Result<&mut Self>
     where
-        F: Fn(Option<Watermark>) -> Result<Watermark, WatermarkBuilderError>,
+        F: Fn(Option<Watermark>) -> anyhow::Result<Option<Watermark>>,
     {
-        if let Some(ref watermark) = self.watermark {
-            self.watermark = Some(Some(f(watermark.clone())?));
-        }
+        self.watermark = Some(f(self.watermark.clone().unwrap_or(None))?);
 
         Ok(self)
     }