releasor 1.3.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

use demand::{Dialog, DialogButton, Input};
use std::process;

use crate::output_command::OutputCommand;
use crate::status::Status;
use copypasta::{ClipboardContext, ClipboardProvider};

/// Orchestrates the release workflow: prompt, build, archive, checksum, and report.
pub struct Controller;

impl Controller {
    /// Starts the release flow and exits with code 1 if any step fails.
    pub fn start_release() {
        println!("Releasor\n");
        let project_name = Self::get_project_name();
        Self::generate_tar_gz(project_name.as_str());
    }

    /// Prompts the user for the project name and returns a validated non-empty string.
    fn get_project_name() -> String {
        let input = Input::new("What's your project name?")
            .placeholder("Enter the project name");
        let name = match input.run() {
            Ok(value) => value.trim().to_string(),
            Err(e) => {
                if e.kind() == std::io::ErrorKind::Interrupted {
                    println!("Input cancelled");
                    process::exit(1);
                } else {
                    panic!("Error: {}", e);
                }
            }
        };

        if name.is_empty() {
            eprintln!("❌ Project name can't be empty");
            process::exit(1);
        }
        if name.contains('/') || name.contains('\\') {
            eprintln!("❌ Project name must not contain path separators");
            process::exit(1);
        }

        name
    }

    /// Builds the release binary, creates `<name>.tar.gz`, computes SHA-256, and prints status.
    fn generate_tar_gz(project_name: &str) {
        let tar_file = format!("{}.tar.gz", project_name);

        let release = OutputCommand::cargo_release_output();
        let tar = OutputCommand::tar_output(&tar_file, project_name);
        let shasum = OutputCommand::get_shasum_output(&tar_file);

        Status::print_status(release, tar, shasum.clone());
        Self::setup_copy_shasum(&shasum);
    }

    /// Shows a dialog to copy the generated SHA256 to the clipboard.
    fn setup_copy_shasum(shasum_output: &std::process::Output) {
        const BUTTON_LABEL: &str = "Copy Shasum";

        let response = Dialog::new("Copy shasum?")
            .description("This button will copy the release's SHA256 to your clipboard.")
            .buttons(vec![DialogButton::new(BUTTON_LABEL)])
            .selected_button(0)
            .run()
            .unwrap_or_else(|e| {
                eprintln!("❌ Error running shasum dialog: {e}");
                std::process::exit(1);
            });

        if response == BUTTON_LABEL {
            let shasum = String::from_utf8_lossy(&shasum_output.stdout)
                .trim()
                .to_string();

            match ClipboardContext::new() {
                Ok(mut clipboard) => {
                    if let Err(err) = clipboard.set_contents(shasum.clone()) {
                        eprintln!("❌ Failed to copy to clipboard: {err}");
                    } else {
                        println!("✅ Shasum copied to clipboard!");
                    }
                }
                Err(err) => {
                    eprintln!("❌ Could not access clipboard: {err}");
                }
            }
        }
    }
}