solar-core 1.0.1

Core library for cargo-solar command.
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

use crate::{Config, Global, SolarError, ToolTrait};
use clap::Parser;
use derive_getters::Getters;
use rust_dl::downloader::download_sync;
use serde::{Deserialize, Serialize};
use std::{
    fs,
    path::{Path, PathBuf},
};

static COMMIT_MSG_NAME: &str = "commit-msg";
static COMMIT_RULES_NAME: &str = "commit-rules";

#[derive(Parser, Clone, Default, PartialEq, Debug, Serialize, Deserialize, Getters)]
pub struct Commitalyzer {
    /// The working directory to use for installation.
    #[arg(short, long, default_value = ".")]
    #[serde(skip)]
    destination: PathBuf,

    /// The ruleset to install.
    #[arg(short, long)]
    ruleset: Option<String>,
}

impl Commitalyzer {
    pub fn new(destination: PathBuf, ruleset: Option<String>) -> Self {
        Self {
            destination,
            ruleset,
        }
    }
}

impl ToolTrait for Commitalyzer {
    fn set_dest(&mut self, dest: &Path) {
        self.destination = dest.to_path_buf();
    }

    fn install(&mut self) -> Result<(), SolarError> {
        let ruleset_name = self
            .ruleset
            .as_ref()
            .ok_or("A ruleset must be given for installation.")?;

        // Ensure working directory is a git repository.
        Global::git_init(&self.destination)?;

        // Update configuration file.
        let config = Config::load_or_default(&self.destination);
        config.set_commitalyzer(Some(self.clone())).save()?;

        // Download executable
        download_sync(
            Global::commitalyzer_exec_download()?,
            Global::git_hooks_path(&self.destination)?.join(COMMIT_MSG_NAME),
        )?;

        // Download commit rules
        let commit_rules_path = self.destination.join(COMMIT_RULES_NAME);
        fs::create_dir_all(&commit_rules_path)?;
        download_sync(
            Global::commitalyzer_conventional_commits_ruleset()?,
            commit_rules_path.join(format!("{}.yml", ruleset_name)),
        )?;

        Ok(())
    }

    fn upgrade(&mut self) -> Result<(), SolarError> {
        self.ruleset
            .as_ref()
            .ok_or("A ruleset must be given for installation.")?;
        self.uninstall()?;
        self.install()
    }

    fn uninstall(&mut self) -> Result<(), SolarError> {
        // Get configuration
        let config = Config::load_from(&self.destination)?;
        config
            .commitalyzer()
            .clone()
            .ok_or("Cannot uninstall commitalyzer - commitalyzer not found in configuration.")?;

        // Remove executable
        let exec_path = Global::git_hooks_path(&self.destination)?.join(COMMIT_MSG_NAME);
        if fs::exists(&exec_path)? {
            fs::remove_file(exec_path)?;
        }

        // Remove commit rules directory
        let commit_rules_path = self.destination.join(COMMIT_RULES_NAME);
        if fs::exists(&commit_rules_path)? {
            fs::remove_dir_all(commit_rules_path)?;
        }

        // Update configuration, remove if empty.
        let config = config.set_commitalyzer(None);
        match config.is_empty() {
            true => fs::remove_file(config.path())?,
            false => config.save()?,
        }

        Ok(())
    }
}