Templates require Scheme enum wrapping struct instance

- Remove anyhow crate from tinted-builder lib

CHANGELOG.md

@@ -4,10 +4,16 @@
 
 ## Changed
 
+- Breaking change: `tinted-builder` library includes an API change and
+  `tinted-builder-rust` now exports the new `tinted-builder` API
 - Breaking change: Use `SchemeSystem` and `SchemeVariant` enums for
   scheme `system` and `variant` properties respectively instead of using
   string values
 
+## Removed
+
+- Remove deprecated `render_to_file` `Template` method
+
 ## [0.9.5] - 2024-08-24
 
 ## Fixed

README.md

@@ -103,11 +103,11 @@ use std::fs::read_to_string;
 
 let template_str = read_to_string("path/to/template.mustache").unwrap();
 let scheme_str = read_to_string("path/to/scheme.yml").unwrap();
-let scheme: Scheme = serde_yaml::from_str(&scheme_str).unwrap();
-let template = Template::new(template_str, scheme.system.clone());
+let scheme = Scheme::Base16(serde_yaml::from_str(&scheme_str).unwrap());
+let template = Template::new(template_str, scheme);
 
 template
-    .render_to_file("path/to/rendered/template", &scheme)
+    .render()
     .unwrap();
 ```
 

tinted-builder-rust/README.md

@@ -42,7 +42,7 @@ Download the relevant binary from the [repository releases] page.
 
 ## Basic Usage
 
-```shell
+```sh
 tinted-builder-rust sync # To sync with latest schemes
 tinted-builder-rust build path/to/base16-template
 ```

tinted-builder-rust/src/lib.rs

@@ -1,7 +1,8 @@
 // With the new split of tinted-builder-rust (cli) and
-// tinted-builder (lib), tinted-builder is exported here for bakward
+// tinted-builder (lib), tinted-builder is exported here for backward
 // compatibility for a time. Everyone should move to using
 // tinted-builder as the rust library.
+#[doc = include_str!("../README.md")]
 
 mod operations {
     pub mod build;
@@ -10,8 +11,7 @@ mod utils;
 
 pub use crate::operations::build as operation_build;
 
-/// # Add tinted-builder library test since tinted-builder-rust is
-/// exporting the structs
+/// Add tinted-builder library test since tinted-builder-rust is exporting the structs
 ///
 /// ```
 /// use tinted_builder_rust::{Scheme, Template};
@@ -40,15 +40,14 @@ pub use crate::operations::build as operation_build;
 ///   base0D: "6a9eb5"
 ///   base0E: "78a38f"
 ///   base0F: "a3a079""#;
-/// let scheme: Scheme = serde_yaml::from_str(&scheme_str).unwrap();
-/// let template = Template::new(template, scheme.system.clone());
+/// let scheme = Scheme::Base16(serde_yaml::from_str(&scheme_str).unwrap());
+/// let template = Template::new(template, scheme);
 /// let output = template
-///     .render(&scheme)
+///     .render()
 ///     .unwrap();
 ///
 ///  assert_eq!(output, r#"/* Some CSS file with UwUnicorn theme */
 /// .someCssSelector { background-color: #241b26 }
 /// .someOtherCssSelector { background-color: #a3a079 }"#);
 /// ```
-pub use tinted_builder::Scheme;
-pub use tinted_builder::Template;
+pub use tinted_builder::{Base16Scheme, Scheme, Template, TintedBuilderError};

tinted-builder-rust/src/operations/build.rs

@@ -3,8 +3,7 @@ use serde::Deserialize;
 use std::collections::HashMap;
 use std::fs::{self, create_dir_all, read_to_string};
 use std::path::{Path, PathBuf};
-use tinted_builder::Template;
-use tinted_builder::{Scheme, SchemeSystem};
+use tinted_builder::{Base16Scheme, Scheme, SchemeSystem, Template};
 
 use crate::utils::write_to_file;
 
@@ -20,7 +19,7 @@ fn get_theme_template_path(theme_template_path: &Path) -> Result<PathBuf> {
 }
 
 fn generate_theme(
-    template: &Template,
+    template_content: &str,
     output_dir: &PathBuf,
     scheme_path: &PathBuf,
     system: SchemeSystem,
@@ -38,7 +37,7 @@ fn generate_theme(
             .and_then(|s| s.to_str())
             .unwrap_or_default();
         let scheme_str = read_to_string(scheme_path)?;
-        let scheme: Scheme = serde_yaml::from_str(&scheme_str)?;
+        let scheme: Base16Scheme = serde_yaml::from_str(&scheme_str)?;
         let output_path = output_dir.join(format!("{}-{}.{}", &scheme.system, slug, extension));
 
         if scheme.system != system {
@@ -49,7 +48,19 @@ fn generate_theme(
             fs::create_dir_all(output_dir)?;
         }
 
-        let output = template.render(&scheme.clone())?;
+        let scheme = match system {
+            SchemeSystem::Base16 => Scheme::Base16(scheme.clone()),
+            SchemeSystem::Base24 => Scheme::Base24(scheme.clone()),
+            _ => {
+                // This error should be previously caught during deserialization
+                return Err(anyhow!(
+                    "Unknown `system` variant defined in `templates/config.yaml`"
+                ));
+            }
+        };
+        let template = Template::new(template_content.to_string(), scheme);
+        let output = template.render()?;
+
         write_to_file(&output_path, &output)?;
     }
 
@@ -133,13 +144,12 @@ pub fn build(theme_template_path: &Path, user_schemes_path: &Path, is_quiet: boo
         }
 
         for (system, schemes_path) in scheme_path_vec {
-            let template = Template::new(template_content.clone(), system.clone());
             for item_result in fs::read_dir(schemes_path)? {
                 let scheme_direntry = item_result?;
                 let scheme_file_path = scheme_direntry.path();
 
                 generate_theme(
-                    &template,
+                    &template_content,
                     &output_path,
                     &scheme_file_path,
                     system.clone(),

tinted-builder-rust/tests/operation_build.rs

@@ -394,3 +394,58 @@ fn test_operation_build_mixed() -> Result<()> {
 
     Ok(())
 }
+
+/// Tests error message when invalid scheme system is provided in config.yaml
+#[test]
+fn test_operation_build_invalid_system() -> Result<()> {
+    // -------
+    // Arrange
+    // -------
+    let system = "invalid-system";
+    let name = "operation_build_invalid_system";
+    let template_theme_path = PathBuf::from(format!("./template-{}", name));
+    let template_templates_path = template_theme_path.join("templates");
+    let template_config_path = template_templates_path.join("config.yaml");
+    let schemes_path = template_theme_path.join("schemes");
+    let base16_config_file_content = format!(
+        r#"
+invalid:
+  extension: .md
+  output: output-themes
+  supported-systems: [{}]"#,
+        system
+    );
+
+    if template_theme_path.is_dir() {
+        fs::remove_dir_all(&template_theme_path)?;
+    }
+    fs::create_dir(&template_theme_path)?;
+    fs::create_dir(&schemes_path)?;
+    fs::create_dir(&template_templates_path)?;
+    write_to_file(&template_config_path, &base16_config_file_content)?;
+
+    // ---
+    // Act
+    // ---
+    let (stdout, stderr) = utils::run_command(vec![
+        COMMAND_NAME.to_string(),
+        "build".to_string(),
+        template_theme_path.display().to_string(),
+        format!("--schemes-dir={}", schemes_path.display()),
+    ])
+    .unwrap();
+
+    // ------
+    // Assert
+    // ------
+    assert!(
+        stderr.contains(format!("unknown variant `{}`", system).as_str()),
+        "stderr does not contain the expected output"
+    );
+    assert!(
+        stdout.is_empty(),
+        "stdout does not contain the exptected output"
+    );
+
+    Ok(())
+}

tinted-builder/CHANGELOG.md

@@ -2,11 +2,23 @@
 
 ## Unreleased
 
+## Added
+
+- Add basic documentation for docs.rs
+
 ## Changed
 
+- Require schemes to be wrapped in `Scheme` enum when creating a
+  `Template` struct instance to easily extend builder to support
+  different scheme systems
 - Use `SchemeSystem` and `SchemeVariant` enums for scheme `system` and
   `variant` properties respectively instead of using string values
 
+## Removed
+
+- `anyhow` crate moved to dev-dependency for tests, but replaced with
+  `TintedBuilderError` enum with `thiserror` macros in API
+
 ## 0.5.1 - 2024-08-24
 
 ## Fixed

tinted-builder/Cargo.toml

@@ -13,14 +13,16 @@ categories = ["command-line-utilities", "template-engine"]
 rust-version = "1.74.0"
 
 [dependencies]
-anyhow = "1.0.80"
 clap = "4.5.2"
 dirs = "5.0.1"
+quick-xml = { version = "0.36.1", features = ["serialize"] }
 regex = "1.10.4"
 ribboncurls = "0.2.1"
 serde = { version = "1.0.197", features = ["derive"] }
 serde_yaml = "0.9.32"
+thiserror = "1.0.63"
 unicode-normalization = "0.1.23"
 
 [dev-dependencies]
+anyhow = "1.0.86"
 strip-ansi-escapes = "0.2.0"

tinted-builder/README.md

@@ -22,7 +22,7 @@ cargo add tinted-builder
 ## Usage
 
 ```rust
-use tinted_builder::{Scheme, SchemeType, Template};
+use tinted_builder::{Scheme, Template};
 
 let template = String::from(r#"/* Some CSS file with {{scheme-name}} theme */
 .someCssSelector { background-color: #{{base00-hex}} }
@@ -48,48 +48,29 @@ palette:
   base0D: "6a9eb5"
   base0E: "78a38f"
   base0F: "a3a079""#;
-let scheme: Scheme = serde_yaml::from_str(&scheme_str).unwrap();
-let template = Template::new(template, scheme.system.clone());
-let scheme_type = SchemeType::Yaml(scheme);
+let scheme = Scheme::Base16(serde_yaml::from_str(&scheme_str).unwrap());
+let template = Template::new(template, scheme);
 let output = template
-  .render(&scheme_type)
+  .render()
   .unwrap();
 
   assert_eq!(output, r#"/* Some CSS file with UwUnicorn theme */
 .someCssSelector { background-color: #241b26 }
 .someOtherCssSelector { background-color: #a3a079 }"#);
 ```
 
-The Scheme struct is as follows:
-
-```rust
-use std::collections::HashMap;
-use tinted_builder::{SchemeSystem, SchemeVariant};
-
-pub struct Scheme {
-    pub system: SchemeSystem,
-    pub name: String,
-    pub slug: String,
-    pub author: String,
-    pub description: Option<String>,
-    pub variant: SchemeVariant,
-    pub palette: HashMap<String, Color>,
-}
-
-pub struct Color {
-    pub hex: (String, String, String),
-    pub rgb: (u8, u8, u8),
-    pub dec: (f32, f32, f32),
-}
-```
-
-`Template::new`
-The `Template` struct simply sets the content provided to it via
-`Template::new`.
-
-`template.render(&scheme)` takes the scheme, generates the variables
-defined in the `0.11.0` [builder specification] and returns a new
-string.
+1. Create a scheme (`Scheme`) enum variant while providing the
+   deserialized data into into the variant:
+   `Scheme::Base16(serde_yaml::from_str(&scheme_str).unwrap())` in this
+   case
+2. Create a template by passing the serialized mustache text and the
+   `Scheme` variant in step 1 into the `Template` struct:
+   `Template::new(mustache_text, scheme)`. The `template.render()`
+   method takes the scheme, generates the variables defined in the 
+   `0.11.0` [builder specification] and returns a new string.
+3. Render the template by running a method which returns a
+   `Result<String, TintedBuilderError>` type: 
+   `let output = template.render().unwrap();`
 
 ## Contributing