label-generator 0.2.0

Generate labels using components
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

use std::collections::HashMap;

use crate::{component::SvgComponentVariant, ignore_condition::IgnoreGroup};

#[derive(Debug, Clone)]
pub struct OutputVariant<'a> {
    pub component_variants: HashMap<&'a str, &'a SvgComponentVariant>,
}

impl<'a> OutputVariant<'a> {
    pub fn add_variants(
        self,
        component_name: &'a str,
        component_variants: &'a [SvgComponentVariant],
    ) -> Vec<OutputVariant<'a>> {
        let mut variants = Vec::new();

        for variant in component_variants {
            let mut new_components = self.component_variants.clone();
            new_components.insert(component_name, variant);
            variants.push(OutputVariant {
                component_variants: new_components,
            });
        }

        variants
    }

    pub fn should_ignore(&self, ignore_groups: &[IgnoreGroup]) -> bool {
        let v = self
            .component_variants
            .iter()
            .map(|e| (*e.0, e.1.name.as_ref()))
            .collect::<Vec<_>>();
        ignore_groups.iter().any(|group| group.matches(&v[..]))
    }

    pub fn get_sku(&self, template: &str) -> String {
        let mut sku = template.to_string();
        for (component_name, variant) in &self.component_variants {
            sku = sku.replace(&format!("{{{}}}", component_name), variant.name.as_ref());
        }
        sku
    }

    pub fn apply_to_svg(self, svg: &str) -> String {
        let mut svg = svg.to_string();

        for (component_name, component_variant) in self.component_variants {
            let component_name = component_name.to_string();

            svg = svg.replace(
                &format!("<!-- component:{} -->", component_name),
                &component_variant.data,
            );
        }

        svg
    }
}