releasor 1.7.0

A CLI that automates release tasks for Rust 🦀 projects, streamlining builds, .tar.gz packaging, and binary verification for a fast and consistent workflow.
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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

use arboard::Clipboard;
use clap::Parser;

use crate::output_command::OutputCommand;
use crate::progress;
use crate::status::Status;

#[derive(Parser)]
struct Args {
    #[arg(short, long)]
    file_name: String,
}

pub struct Cli;

impl Cli {
    pub fn start_release() {
        Self::print_header();
        Self::generate_tar_gz();
    }

    fn print_header() {
        println!("╔══════════════════════════════════╗");
        println!("║           🚀 releasor            ║");
        println!("║   Rust Release Automation Tool   ║");
        println!("╚══════════════════════════════════╝");
        println!();
    }

    fn generate_tar_gz() {
        let project_name = Self::parse_and_validate_project_name();
        let tar_file = Self::tar_file_name(&project_name);

        let progress_handle = progress::animate_to(25, "Build project");
        Self::run_cargo_release();
        progress::wait_animate(progress_handle);

        let progress_handle = progress::animate_to(50, "creating tar.gz");
        Self::create_tar_gz(&tar_file, &project_name);
        progress::wait_animate(progress_handle);

        let progress_handle = progress::animate_to(75, "Get shasum");
        let shasum_output = Self::compute_shasum(&tar_file);
        progress::wait_animate(progress_handle);

        let progress_handle = progress::animate_to(100, "Copy shasum to clipboard");
        let shasum = Self::setup_copy_shasum_quiet(&shasum_output);
        progress::wait_animate(progress_handle);

        progress::show(100, "Done");
        std::thread::sleep(std::time::Duration::from_millis(300));
        progress::finish();

        println!();

        Self::print_results(&shasum);
    }

    fn parse_and_validate_project_name() -> String {
        let args = Args::parse();
        let project_name = args.file_name.trim().to_string();

        if let Err(msg) = Self::validate_project_name(&project_name) {
            eprintln!("❌ {msg}");
            std::process::exit(1);
        }

        project_name
    }

    /// Validates project name. Returns Ok(()) if valid, Err(message) otherwise.
    pub fn validate_project_name(project_name: &str) -> Result<(), String> {
        if project_name.is_empty() {
            return Err("Project name can't be empty".into());
        }

        if project_name.contains('/') || project_name.contains('\\') {
            return Err("Project name must not contain path separators".into());
        }

        Ok(())
    }

    /// Returns the tar.gz filename for a project name.
    pub fn tar_file_name(project_name: &str) -> String {
        format!("{project_name}.tar.gz")
    }

    fn run_cargo_release() {
        let release = OutputCommand::cargo_release_output();
        Status::check_quiet(&release, "Running cargo release");
    }

    fn create_tar_gz(tar_file: &str, project_name: &str) {
        let tar = OutputCommand::tar_output(tar_file, project_name);

        if !tar.status.success() {
            let _ = std::fs::remove_file(tar_file);
        }

        Status::check_quiet(&tar, "creating tar.gz");
    }

    fn compute_shasum(tar_file: &str) -> std::process::Output {
        let shasum = OutputCommand::get_shasum_output(tar_file);
        Status::check_shasum_quiet(&shasum);
        shasum
    }

    /// Copies shasum to clipboard without printing. Returns the shasum string and clipboard success.
    pub fn setup_copy_shasum_quiet(shasum_output: &std::process::Output) -> (String, bool) {
        let shasum_raw = String::from_utf8_lossy(&shasum_output.stdout);
        let shasum = shasum_raw
            .split_whitespace()
            .next()
            .unwrap_or("")
            .to_string();

        let copied = match Clipboard::new() {
            Ok(mut clipboard) => match clipboard.set_text(shasum.clone()) {
                Ok(()) => true,
                Err(err) => {
                    eprintln!("❌ Failed to copy to clipboard: {err}");
                    false
                }
            },
            Err(err) => {
                eprintln!("❌ Could not access clipboard: {err}");
                false
            }
        };
        (shasum, copied)
    }

    /// Print all results after the progress bar is done.
    fn print_results(shasum: &(String, bool)) {
        let (hash, copied) = shasum;
        println!("✅ Running cargo release");
        println!("✅ creating tar.gz");
        println!("✅ Get shasum {}", hash.trim_end());

        if *copied {
            println!("✅ Shasum copied to clipboard!");
        }

        println!();
        println!("🎉 All tasks completed successfully!");
    }
}