andax 0.1.2

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

use color_eyre::Result;
use rhai::{CustomType, EvalAltResult};
use std::{
    fs,
    path::{Path, PathBuf},
};
use tracing::info;

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RPMSpec {
    pub name: String,
    pub chkupdate: PathBuf,
    pub spec: PathBuf,
    pub f: String,
    pub changed: bool,
}

impl RPMSpec {
    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(),
        }
    }
    pub fn reset_release(&mut self) -> Result<(), Box<EvalAltResult>> {
        self.release("1")
    }
    pub fn release(&mut self, rel: &str) -> Result<(), Box<EvalAltResult>> {
        let re = regex::Regex::new(r"Release:(\s+)([\.\d]+)\n").unwrap();
        let m = re.captures(self.f.as_str());
        if let Some(m) = m {
            self.f = re.replace(&self.f, format!("Release:{}{rel}%{{?dist}}", &m[1])).to_string();
            self.changed = true;
            return Ok(());
        }
        Err("No preamble in spec".into())
    }
    pub fn version(&mut self, ver: &str) -> Result<(), Box<EvalAltResult>> {
        let re = regex::Regex::new(r"Version:(\s+)([\.\d]+)\n").unwrap();
        let m = re.captures(self.f.as_str());
        if m.is_none() {
            return Err("No version preamble in spec".into());
        }
        let m = unsafe { m.unwrap_unchecked() };
        if ver != &m[2] {
            info!("{}: {} —→ {ver}", self.name, &m[2]);
            self.f = re.replace(&self.f, format!("Version:{}{ver}\n", &m[1])).to_string();
            self.reset_release()?;
        }
        Ok(())
    }
    pub fn define(&mut self, name: &str, val: &str) -> Result<(), Box<EvalAltResult>> {
        let re = regex::Regex::new(r"(?m)%define(\s+)(\S+)(\s+)(\S+)$").unwrap();
        if let Some(cap) = re.captures_iter(self.f.as_str()).find(|cap| &cap[2] == name) {
            self.f = self.f.replace(&cap[0], &format!("%define{}{name}{}{val}", &cap[1], &cap[3]));
            self.changed = true;
            return Ok(());
        }
        Err(format!("No `%define {name}` in spec").into())
    }
    pub fn global(&mut self, name: &str, val: &str) -> Result<(), Box<EvalAltResult>> {
        let re = regex::Regex::new(r"(?m)%global(\s+)(\S+)(\s+)(\S+)$").unwrap();
        if let Some(cap) = re.captures_iter(self.f.as_str()).find(|cap| &cap[2] == name) {
            self.f = self.f.replace(&cap[0], &format!("%global{}{name}{}{val}", &cap[1], &cap[3]));
            self.changed = true;
            return Ok(());
        }
        Err(format!("No `%global {name}` in spec").into())
    }
    pub fn source(&mut self, i: i64, p: &str) -> Result<(), Box<EvalAltResult>> {
        let re = regex::Regex::new(r"Source(\d+):(\s+)([^\n]+)\n").unwrap();
        let mut capw = None;
        let si = i.to_string();
        for cap in re.captures_iter(self.f.as_str()).filter(|cap| cap[1] == si) {
            info!("{}: Source{i}: {p}", self.name);
            capw = Some(cap);
        }
        if capw.is_none() {
            return Err("No source preamble in spec".into());
        }
        let cap = capw.unwrap();
        self.f = self.f.replace(&cap[0], &format!("Source{i}:{}{p}\n", &cap[2]));
        self.changed = true;
        Ok(())
    }
    pub fn write(self) -> std::io::Result<()> {
        if self.changed {
            fs::write(self.spec, self.f)?;
        }
        Ok(())
    }
    pub fn get(&mut self) -> String {
        self.f.clone()
    }
    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);
    }
}