spawn-cli 0.6.0

A command-line tool for creating files and folders from a template.
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

use anyhow::{Error, Result};
use directories::ProjectDirs;
use log::info;
use serde::{Deserialize, Serialize};
use std::{collections::HashMap, path::PathBuf};

const IGNORE_GLOBAL_FILENAME: &str = ".spwnignore_global";

#[derive(Default, Deserialize, Serialize)]
pub struct Config {
    aliases: HashMap<String, String>,
}

impl Config {
    pub fn read() -> Config {
        let config_path = config_path();
        let Ok(config_data) = std::fs::read_to_string(&config_path) else {
            return Default::default();
        };

        info!("Using config file {config_path:?}");

        let config: Config = toml::from_str(&config_data).unwrap();

        config
    }

    pub fn write(&self) -> Result<()> {
        let config_data = toml::to_string(self).unwrap();
        let config_path = config_path();

        if let Some(parent) = config_path.parent() {
            std::fs::create_dir_all(parent)?;
        }

        info!("Writing config to {config_path:?}");

        std::fs::write(config_path, config_data).map_err(|_| Error::msg("Couldn't write config"))
    }

    pub fn resolve_alias(&self, uri: String) -> String {
        if let Some(uri) = self.aliases.get(&uri) {
            uri.clone()
        } else {
            uri
        }
    }

    pub fn get_aliases(&self) -> &HashMap<String, String> {
        &self.aliases
    }

    pub fn add_alias(&mut self, name: String, uri: String) -> &Self {
        self.aliases.insert(name, uri);

        self
    }

    pub fn remove_alias(&mut self, name: String) -> &Self {
        self.aliases.remove(&name);

        self
    }
}

pub(crate) fn init() -> Result<()> {
    let Some(config_dir) = config_dir() else {
        return Err(Error::msg("No config directory"));
    };

    if config_dir.is_dir() {
        return Ok(());
    }

    let config_dir = config_dir.as_path();

    info!("Initializing config at {config_dir:?}");

    std::fs::create_dir_all(config_dir)?;
    std::fs::write(
        config_dir.join(IGNORE_GLOBAL_FILENAME),
        include_str!("../.spwnignore_global"),
    )?;

    Ok(())
}

pub(crate) fn config_dir() -> Option<PathBuf> {
    ProjectDirs::from("com", "paulvandermeijs", "spwn")
        .map(|proj_dirs| proj_dirs.config_dir().to_path_buf())
}

pub(crate) fn cache_dir() -> Option<PathBuf> {
    ProjectDirs::from("com", "paulvandermeijs", "spwn")
        .map(|proj_dirs| proj_dirs.cache_dir().to_path_buf())
}

pub(crate) fn get_global_ignore() -> Result<Vec<String>> {
    let Some(mut global_ignore_file) = config_dir() else {
        return Err(Error::msg("No config directory"));
    };

    global_ignore_file.push(IGNORE_GLOBAL_FILENAME);

    if !global_ignore_file.is_file() {
        return Err(Error::msg("No global ignore file"));
    }

    info!(
        "Using global ignore file {:?}",
        global_ignore_file.display()
    );

    let lines = crate::fs::read_lines(global_ignore_file)?;

    Ok(lines)
}

fn config_path() -> PathBuf {
    let mut config_path = config_dir().unwrap();

    config_path.push("config.toml");

    config_path
}