oxvg 0.0.6

Vector image toolchain.
Documentation 
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
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

//! Types for the configuration file usable by OXVG
use std::{env::current_dir, fs::read_to_string, path::PathBuf};

use etcetera::{choose_base_strategy, BaseStrategy};
use oxvg_lint::Rules;
use oxvg_optimiser::Extends;
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize, Debug, Default)]
/// The configuration for optimisation
pub struct Optimise {
    /// The preset the jobs will extend
    #[serde(skip_serializing_if = "Option::is_none")]
    pub extends: Option<Extends>,
    /// The set of jobs to run
    pub jobs: oxvg_optimiser::Jobs,
    /// A list of jobs to exclude from running
    #[serde(skip_serializing_if = "Option::is_none")]
    pub omit: Option<Vec<String>>,
}

#[derive(Deserialize, Serialize, Debug, Default)]
#[serde(rename_all = "camelCase")]
/// The config for the CLI usage of OXVG
pub struct Config {
    /// The options for each job to override the specified preset.
    pub optimise: Option<Optimise>,
    /// The options for each lint to override the default configuration.
    pub lint: Option<Rules>,
}

impl Config {
    fn load_local() -> std::io::Result<(String, PathBuf)> {
        let mut path = current_dir()?;
        path.push("oxvgrc.json");
        Ok((read_to_string(&path)?, path))
    }

    fn load_base() -> std::io::Result<(String, PathBuf)> {
        let mut path = choose_base_strategy()
            .unwrap_or_else(|err| panic!("{err}"))
            .config_dir();
        path.push("oxvg");
        path.push("config.json");
        Ok((read_to_string(&path)?, path))
    }

    /// Tries loading the configuration from well-known paths
    ///
    /// # Errors
    /// When the config is missing
    ///
    /// # Panics
    /// When the config exists but cannot be parsed
    pub fn load() -> std::io::Result<Self> {
        let (file, path) = Self::load_local().or_else(|_| Self::load_base())?;
        Ok(serde_json::from_str(&file).unwrap_or_else(|err| {
            panic!(
                "Configuration at {} cannot be parsed: {err}",
                path.to_string_lossy()
            )
        }))
    }
}

impl Optimise {
    /// Creates a job configuration where the user-configured jobs extends the preset
    /// specified in `extends`
    pub fn resolve_jobs(&self) -> oxvg_optimiser::Jobs {
        let Some(extends) = &self.extends else {
            return self.jobs.clone();
        };
        let mut result = extends.extend(&self.jobs);
        if let Some(omit) = self.omit.as_ref() {
            for omit in omit {
                result.omit(omit);
            }
        }
        result
    }
}

#[test]
fn serde() -> anyhow::Result<()> {
    let config: Optimise = serde_json::from_str(
        r#"{
        "extends": "default",
        "jobs": {
            "removeComments": {}
        }
    }"#,
    )?;

    assert_eq!(
        serde_json::to_string(&config)?,
        String::from(r#"{"extends":"default","jobs":{"removeComments":{}}}"#),
        "preset should not affect deserialization of `jobs`"
    );

    Ok(())
}

#[test]
#[allow(clippy::default_trait_access)]
fn resolve_jobs() {
    let config = Optimise {
        extends: Some(Extends::Default),
        jobs: oxvg_optimiser::Jobs {
            precheck: Some(Default::default()),
            remove_scripts: Some(Default::default()),
            ..oxvg_optimiser::Jobs::none()
        },
        omit: Some(vec![
            String::from("precheck"),
            String::from("remove_doctype"),
        ]),
    };

    let resolved = config.resolve_jobs();
    assert!(resolved.precheck.is_none(), "omitted value should be None");
    assert!(
        resolved.remove_doctype.is_none(),
        "omitted value should be None"
    );
    assert!(
        resolved.remove_scripts.is_some(),
        "specified value should be Some"
    );
    assert!(
        resolved.remove_comments.is_some(),
        "extended value should be Some"
    );
}