andax 0.1.7

Andaman scripting runtime
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

use rhai::CustomType;
use std::{
    fs,
    path::{Path, PathBuf},
};
use tracing::{error, info};

lazy_static::lazy_static! {
    static ref RE_RELEASE: regex::Regex = regex::Regex::new(r"Release:(\s+)(.+?)\n").unwrap();
    static ref RE_VERSION: regex::Regex = regex::Regex::new(r"Version:(\s+)(\S+)\n").unwrap();
    static ref RE_DEFINE: regex::Regex = regex::Regex::new(r"(?m)%define(\s+)(\S+)(\s+)(\S+)$").unwrap();
    static ref RE_GLOBAL: regex::Regex = regex::Regex::new(r"(?m)%global(\s+)(\S+)(\s+)(\S+)$").unwrap();
    static ref RE_SOURCE: regex::Regex = regex::Regex::new(r"Source(\d+):(\s+)([^\n]+)\n").unwrap();
}

/// Update RPM spec files
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RPMSpec {
    /// Name of project
    pub name: String,
    /// AndaX chkupdate script of project
    pub chkupdate: PathBuf,
    /// Path to spec file
    pub spec: PathBuf,
    /// RPM spec file content
    pub f: String,
    /// Denotes if the spec file has been changed
    pub changed: bool,
}

impl RPMSpec {
    /// Creates a new RPMSpec file representation
    ///
    /// # Panics
    /// - spec file does not exist / cannot read spec to string
    pub fn new<T, U>(name: String, chkupdate: T, spec: U) -> Self
    where
        T: Into<PathBuf> + AsRef<Path>,
        U: Into<PathBuf> + AsRef<Path>,
    {
        Self {
            name,
            chkupdate: chkupdate.into(),
            changed: false,
            f: fs::read_to_string(&spec).expect("Cannot read spec to string"),
            spec: spec.into(),
        }
    }
    /// Resets the release number to 1
    pub fn reset_release(&mut self) {
        self.release("1");
    }
    /// Sets the release number in the spec file
    pub fn release(&mut self, rel: &str) {
        let m = RE_RELEASE.captures(self.f.as_str());
        let Some(m) = m else { return error!("No `Release:` preamble for {}", self.name) };
        self.f =
            RE_RELEASE.replace(&self.f, format!("Release:{}{rel}%{{?dist}}\n", &m[1])).to_string();
        self.changed = true;
    }
    /// Sets the version in the spec file
    pub fn version(&mut self, ver: &str) {
        let Some(m) = RE_VERSION.captures(self.f.as_str()) else {
            return error!("No `Version:` preamble for {}", self.name);
        };
        let ver = ver.strip_prefix('v').unwrap_or(ver).replace('-', ".");
        if ver != m[2] {
            info!("{}: {} —→ {ver}", self.name, &m[2]);
            self.f = RE_VERSION.replace(&self.f, format!("Version:{}{ver}\n", &m[1])).to_string();
            self.reset_release();
        }
    }
    /// Change the value of a `%define` macro by the name
    pub fn define(&mut self, name: &str, val: &str) {
        let Some(cap) = RE_DEFINE.captures_iter(self.f.as_str()).find(|cap| &cap[2] == name) else {
            return error!("No `Version:` preamble for {}", self.name);
        };
        self.f = self.f.replace(&cap[0], &format!("%define{}{name}{}{val}", &cap[1], &cap[3]));
        self.changed = true;
    }
    /// Change the value of a `%global` macro by the name
    pub fn global(&mut self, name: &str, val: &str) {
        let Some(cap) = RE_GLOBAL.captures_iter(self.f.as_str()).find(|cap| &cap[2] == name) else {
            return error!("No `Version:` preamble for {}", self.name);
        };
        self.f = self.f.replace(&cap[0], &format!("%global{}{name}{}{val}", &cap[1], &cap[3]));
        self.changed = true;
    }
    /// Change the `SourceN:` preamble value by `N`
    pub fn source(&mut self, i: i64, p: &str) {
        let si = i.to_string();
        let Some(cap) = RE_SOURCE.captures_iter(self.f.as_str()).find(|cap| cap[1] == si) else {
            return error!("No `Source{i}:` preamble for {}", self.name);
        };
        info!("{}: Source{i}: {p}", self.name);
        self.f = self.f.replace(&cap[0], &format!("Source{i}:{}{p}\n", &cap[2]));
        self.changed = true;
    }
    /// Write the updated spec file content
    ///
    /// # Errors
    /// - happens only if the writing part failed :3
    pub fn write(self) -> std::io::Result<()> {
        if self.changed {
            fs::write(self.spec, self.f)?;
        }
        Ok(())
    }
    /// Get the spec file content
    pub fn get(&mut self) -> String {
        self.f.clone()
    }
    /// Override the spec file content manually
    pub fn set(&mut self, ff: String) {
        self.changed = true;
        self.f = ff;
    }
}

impl CustomType for RPMSpec {
    fn build(mut builder: rhai::TypeBuilder<'_, Self>) {
        builder
            .with_name("Rpm")
            .with_fn("version", Self::version)
            .with_fn("source", Self::source)
            .with_fn("define", Self::define)
            .with_fn("global", Self::global)
            .with_fn("release", Self::reset_release)
            .with_fn("release", Self::release)
            .with_get_set("f", Self::get, Self::set);
    }
}