rlyx 0.3.1

rlyx is a fast release manager that automatically bumps versions, creates changelogs, tags commits, and publishes GitHub releases across JS, Rust, and Python projects with first class monorepos support.
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

use anyhow::{anyhow, Result};
use regex::Regex;
use std::process::{Command as StdCommand, Stdio};

pub async fn run_capture_async(
    cmd: &str,
    args: &[&str],
) -> Result<String> {
    let output = tokio::process::Command::new(cmd)
        .args(args)
        .output()
        .await?;
    if !output.status.success() {
        let err = String::from_utf8_lossy(&output.stderr);
        return Err(anyhow!(
            "{} {:?} failed: {}",
            cmd,
            args,
            err.trim()
        ));
    }
    Ok(String::from_utf8_lossy(&output.stdout).trim().to_string())
}

pub async fn run_quiet_async(
    cmd: &str,
    args: &[&str],
    _label: &str,
) -> Result<()> {
    let status = tokio::process::Command::new(cmd)
        .args(args)
        .stdout(Stdio::null())
        .stderr(Stdio::inherit())
        .status()
        .await?;
    if !status.success() {
        return Err(anyhow!("{} {:?} failed", cmd, args));
    }
    Ok(())
}

pub async fn run_status_async(cmd: &str, args: &[&str]) -> bool {
    tokio::process::Command::new(cmd)
        .args(args)
        .status()
        .await
        .map(|s| s.success())
        .unwrap_or(false)
}

pub fn run_capture(cmd: &str, args: &[&str]) -> Result<String> {
    let output = StdCommand::new(cmd).args(args).output()?;
    if !output.status.success() {
        let err = String::from_utf8_lossy(&output.stderr);
        return Err(anyhow!(
            "{} {:?} failed: {}",
            cmd,
            args,
            err.trim()
        ));
    }
    Ok(String::from_utf8_lossy(&output.stdout).trim().to_string())
}

pub fn run_quiet(
    cmd: &str,
    args: &[&str],
    _label: &str,
) -> Result<()> {
    let status = StdCommand::new(cmd)
        .args(args)
        .stdout(Stdio::null())
        .stderr(Stdio::inherit())
        .status()?;
    if !status.success() {
        return Err(anyhow!("{} {:?} failed", cmd, args));
    }
    Ok(())
}

pub fn run_status(cmd: &str, args: &[&str]) -> bool {
    StdCommand::new(cmd)
        .args(args)
        .status()
        .map(|s| s.success())
        .unwrap_or(false)
}

pub fn render_template(tpl: &str, pairs: &[(&str, &str)]) -> String {
    let re = Regex::new(r"\{\{\s*([a-zA-Z0-9_]+)\s*\}\}").unwrap();
    let mut map: std::collections::HashMap<&str, &str> =
        std::collections::HashMap::new();
    for (k, v) in pairs {
        map.insert(*k, *v);
    }
    let replaced = re.replace_all(tpl, |caps: &regex::Captures| {
        let k = &caps[1];
        map.get::<str>(k).copied().unwrap_or("")
    });
    let s = replaced.to_string();
    let s = Regex::new(r"\n{3,}")
        .unwrap()
        .replace_all(&s, "\n\n")
        .to_string();
    let s = s.trim().to_string();
    if s.is_empty() {
        s
    } else {
        format!("{}\n", s)
    }
}

pub async fn run_shell_interactive_async(
    cmdline: &str,
) -> Result<()> {
    let shell = crate::shell::detect_shell();
    let sh = shell.to_string_lossy().to_string();
    let status = tokio::process::Command::new(&sh)
        .args(["-lc", cmdline])
        .stdin(Stdio::inherit())
        .stdout(Stdio::inherit())
        .stderr(Stdio::inherit())
        .status()
        .await?;
    if !status.success() {
        return Err(anyhow!("shell command failed: {}", cmdline));
    }
    Ok(())
}