apdev-rs 0.1.0

Shared development tools for Rust projects - character validation, release automation, and more
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

use clap::{Parser, Subcommand};
use std::env;
use std::path::PathBuf;
use std::process::Command;

use crate::check_chars::{check_paths, resolve_charsets};

#[derive(Parser)]
#[command(name = "apdev-rs", about = "Shared development tools for Rust projects", version)]
struct Cli {
    #[command(subcommand)]
    command: Option<Commands>,
}

#[derive(Subcommand)]
enum Commands {
    /// Validate files contain only allowed characters
    CheckChars {
        /// Files or directories to check (defaults to src/, tests/, examples/)
        files: Vec<PathBuf>,

        /// Extra charset preset to enable (repeatable, e.g. --charset chinese)
        #[arg(long = "charset", action = clap::ArgAction::Append)]
        charset: Vec<String>,

        /// Path to custom charset JSON file (repeatable)
        #[arg(long = "charset-file", action = clap::ArgAction::Append)]
        charset_files: Vec<String>,
    },

    /// Interactive release automation (build, tag, GitHub release, upload)
    Release {
        /// Auto-accept all defaults (silent mode)
        #[arg(long, short = 'y')]
        yes: bool,

        /// Version to release (auto-detected from Cargo.toml if omitted)
        version: Option<String>,
    },
}

pub fn run() -> i32 {
    let cli = Cli::parse();

    match cli.command {
        None => {
            use clap::CommandFactory;
            Cli::command().print_help().ok();
            0
        }

        Some(Commands::CheckChars {
            files,
            mut charset,
            mut charset_files,
        }) => {
            // Fall back to APDEV_EXTRA_CHARS env var if no CLI args
            if charset.is_empty() && charset_files.is_empty() {
                if let Ok(env_val) = env::var("APDEV_EXTRA_CHARS") {
                    for item in env_val.split(',') {
                        let item = item.trim();
                        if item.is_empty() {
                            continue;
                        }
                        if item.contains(std::path::MAIN_SEPARATOR) || item.ends_with(".json") {
                            charset_files.push(item.to_string());
                        } else {
                            charset.push(item.to_string());
                        }
                    }
                }
            }

            let (extra_ranges, dangerous) = match resolve_charsets(&charset, &charset_files) {
                Ok(v) => v,
                Err(e) => {
                    eprintln!("Error: {}", e);
                    return 1;
                }
            };

            check_paths(files, &extra_ranges, &dangerous)
        }

        Some(Commands::Release { yes, version }) => {
            // Look for release.sh in current directory
            let script = PathBuf::from("release.sh");
            if !script.is_file() {
                eprintln!("Error: release.sh not found in current directory");
                eprintln!("Hint: copy the release.sh from the rust/ directory of apdev");
                return 1;
            }
            let mut cmd = Command::new("bash");
            cmd.arg(&script);
            if yes {
                cmd.arg("--yes");
            }
            if let Some(v) = version {
                cmd.arg(v);
            }
            match cmd.status() {
                Ok(status) => status.code().unwrap_or(1),
                Err(e) => {
                    eprintln!("Error running release.sh: {}", e);
                    1
                }
            }
        }
    }
}