chore: format code

benches/template.rs

@@ -1,7 +1,10 @@
-use std::hint::black_box;
 use criterion::{criterion_group, criterion_main, Criterion};
+use std::hint::black_box;
 
-use matugen::{scheme::{get_custom_color_schemes, get_schemes, SchemesEnum}, template_util::template::{self, get_render_data, render_template}};
+use matugen::{
+    scheme::{get_custom_color_schemes, get_schemes, SchemesEnum},
+    template_util::template::{self, get_render_data, render_template},
+};
 use template::add_engine_filters;
 use upon::{Engine, Syntax};
 
@@ -14,37 +17,37 @@ fn parse_template(data: &str) {
     add_engine_filters(&mut engine);
 
     let (scheme_dark, scheme_light) = get_schemes(source_color, &None, &None);
-    let schemes = get_custom_color_schemes(
+    let schemes =
-        source_color,
+        get_custom_color_schemes(source_color, scheme_dark, scheme_light, &None, &None, &None);
-        scheme_dark,
+    let render_data =
-        scheme_light,
+        get_render_data(&schemes, &source_color, &SchemesEnum::Dark, &None, None).unwrap();
-        &None,
-        &None,
-        &None
-    );
-    let render_data = get_render_data(&schemes, &source_color,&SchemesEnum::Dark, &None, None).unwrap();
 
-    engine.add_template("a", data.repeat(50)).expect("failed to add template");
+    engine
-    render_template(&engine, &"a".to_string(), &render_data, None).expect("failed to render template");
+        .add_template("a", data.repeat(50))
+        .expect("failed to add template");
+    render_template(&engine, &"a".to_string(), &render_data, None)
+        .expect("failed to render template");
 }
 
 fn criterion_benchmark(c: &mut Criterion) {
-    let data = 
+    let data = r#"
-    r#"
     <* for name, value in colors *>
         {{name}} {{value.default.rgba}};
     <* endfor *>
     "#;
-    let data_filter = 
+    let data_filter = r#"
-    r#"
     <* for name, value in colors *>
         {{name | replace: "_", "-" }} {{value.default.rgba | set_alpha: 0.7 | set_hue: -180.0 }};
     <* endfor *>
     "#;
 
-    c.bench_function("parse 20", |b| b.iter(|| parse_template(black_box(&data.repeat(20)))));
+    c.bench_function("parse 20", |b| {
-    c.bench_function("parse 20 filters", |b| b.iter(|| parse_template(black_box(&data_filter.repeat(20)))));
+        b.iter(|| parse_template(black_box(&data.repeat(20))))
+    });
+    c.bench_function("parse 20 filters", |b| {
+        b.iter(|| parse_template(black_box(&data_filter.repeat(20))))
+    });
 }
 
 criterion_group!(benches, criterion_benchmark);
-criterion_main!(benches);
+criterion_main!(benches);

src/scheme.rs

@@ -1,7 +1,7 @@
 use std::collections::HashMap;
 
-use std::collections::BTreeSet;
 use material_colors::scheme::Scheme;
+use std::collections::BTreeSet;
 
 use crate::color::color::{generate_dynamic_scheme, make_custom_color, OwnCustomColor};
 
@@ -115,7 +115,6 @@ pub fn get_schemes(
     (scheme_dark, scheme_light)
 }
 
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -125,12 +124,7 @@ mod tests {
     fn schemes_eq() {
         let source_color = material_colors::color::Argb::new(255, 255, 0, 0);
         assert_eq!(
-            Scheme::from(generate_dynamic_scheme(
+            Scheme::from(generate_dynamic_scheme(&None, source_color, true, None,)).primary,
-                &None,
-                source_color,
-                true,
-                None,
-            )).primary,
             Argb {
                 alpha: 255,
                 red: 255,
@@ -139,4 +133,4 @@ mod tests {
             }
         );
     }
-}
+}

src/template.rs

@@ -90,7 +90,13 @@ impl Template {
             Source::Color { .. } => None,
         };
 
-        let mut render_data = get_render_data(schemes, source_color, default_scheme, custom_keywords, image)?;
+        let mut render_data = get_render_data(
+            schemes,
+            source_color,
+            default_scheme,
+            custom_keywords,
+            image,
+        )?;
 
         for (i, (name, template)) in templates.iter().enumerate() {
             let (input_path_absolute, output_path_absolute) =
@@ -256,4 +262,4 @@ fn export_template(
     );
 
     Ok(())
-}
+}

src/template_util/mod.rs

@@ -1 +1 @@
-pub mod template;
+pub mod template;

src/template_util/template.rs

@@ -5,13 +5,16 @@ use colorsys::{ColorAlpha, Hsl};
 use material_colors::color::Argb;
 use upon::{Engine, Value};
 
+use crate::color::format::{
+    format_hex, format_hex_stripped, format_hsl, format_hsla, format_rgb, format_rgba,
+    rgb_from_argb,
+};
 use crate::filters::alpha::set_alpha;
 use crate::filters::grayscale::grayscale;
 use crate::filters::hue::set_hue;
 use crate::filters::invert::invert;
 use crate::filters::lightness::set_lightness;
 use crate::scheme::{Schemes, SchemesEnum};
-use crate::color::format::{format_hex, format_hex_stripped, format_hsl, format_hsla, format_rgb, format_rgba, rgb_from_argb};
 
 #[derive(serde::Serialize, serde::Deserialize, Debug)]
 pub struct Color {
@@ -53,7 +56,12 @@ pub fn add_engine_filters(engine: &mut Engine) {
     });
 }
 
-pub fn render_template(engine: &Engine, name: &String, render_data: &Value, path: Option<&str>) -> Result<String, Report> {
+pub fn render_template(
+    engine: &Engine,
+    name: &String,
+    render_data: &Value,
+    path: Option<&str>,
+) -> Result<String, Report> {
     let data = engine
         .template(name)
         .render(render_data)
@@ -71,7 +79,13 @@ pub fn render_template(engine: &Engine, name: &String, render_data: &Value, path
     Ok(data)
 }
 
-pub fn get_render_data(schemes: &Schemes, source_color: &Argb, default_scheme: &SchemesEnum, custom_keywords: &Option<HashMap<String, String>>, image: Option<&String>) -> Result<Value, Report> {
+pub fn get_render_data(
+    schemes: &Schemes,
+    source_color: &Argb,
+    default_scheme: &SchemesEnum,
+    custom_keywords: &Option<HashMap<String, String>>,
+    image: Option<&String>,
+) -> Result<Value, Report> {
     let colors = generate_colors(schemes, source_color, default_scheme)?;
     let mut custom: HashMap<String, String> = Default::default();
     for entry in custom_keywords.iter() {
@@ -93,12 +107,24 @@ pub fn generate_colors(
     for ((field, color_light), (_, color_dark)) in std::iter::zip(&schemes.light, &schemes.dark) {
         hashmap.insert(
             field.to_string(),
-            generate_single_color(field, source_color, default_scheme, *color_light, *color_dark)?,
+            generate_single_color(
+                field,
+                source_color,
+                default_scheme,
+                *color_light,
+                *color_dark,
+            )?,
         );
     }
     hashmap.insert(
         String::from("source_color"),
-        generate_single_color("source_color", source_color, default_scheme, *source_color, *source_color)?,
+        generate_single_color(
+            "source_color",
+            source_color,
+            default_scheme,
+            *source_color,
+            *source_color,
+        )?,
     );
     Ok(hashmap)
 }
@@ -148,4 +174,4 @@ fn generate_color_strings(color: Argb) -> Color {
         lightness: format!("{:?}", &hsl_color.lightness()),
         saturation: format!("{:?}", &hsl_color.saturation()),
     }
-}
+}

src/util/color.rs

@@ -57,7 +57,7 @@ pub fn dump_json(schemes: &Schemes, source_color: &Argb, format: &Format) {
 
     let mut colors_normal_light: HashMap<&str, String> = HashMap::new();
     let mut colors_normal_dark: HashMap<&str, String> = HashMap::new();
-    
+
     for ((field, color_light), (_, color_dark)) in std::iter::zip(&schemes.light, &schemes.dark) {
         let color_light: Rgb = rgb_from_argb(*color_light);
         let color_dark: Rgb = rgb_from_argb(*color_dark);