mcmodbuild 0.1.1

Format for describing how mods should be built and automatically building them from a file.
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

mod binary;
mod cli;
mod installer;
mod macros;
mod structs;

use std::{
    env, fs,
    path::{Path, PathBuf},
    process,
};

use anyhow::{anyhow, Result};
use binary::deserialize;
use clap::Parser;
use colored::Colorize;
use installer::Installer;
use oxfmt::Serializable;
use structs::ModBuild;

use crate::cli::{McModBuild, Subcommands};

fn main() {
    if let Err(err) = __main() {
        eprintln!("{}", err.to_string().red().bold());
        process::exit(1);
    }
}

fn __main() -> Result<()> {
    let cli = McModBuild::parse();

    match cli.subcommand {
        Subcommands::Build { file, destination } => build(file, destination),
        Subcommands::Install { file, destination } => install(file, destination),
        Subcommands::Init { destination } => {
            init(destination).map_err(|err| anyhow!("Failed to create files: {err}"))
        }
    }
}

fn init(destination: Option<PathBuf>) -> Result<()> {
    let destination = destination.unwrap_or(env::current_dir()?);

    fs::write(
        destination.join("mymod.yml"),
        serde_yml::to_string(&ModBuild::default())?,
    )?;

    println!(
        "{}{}",
        "Successfully created build file at ".green(),
        destination.to_string_lossy().bright_green().bold()
    );

    Ok(())
}

fn build(file: PathBuf, destination: Option<PathBuf>) -> Result<()> {
    let content = fs::read_to_string(file)?;
    let build: ModBuild = serde_yml::from_str(&content)?;

    let id = build.id.clone();
    let name = format!("{id}.mcmodbuild");
    let path: PathBuf = destination.unwrap_or(PathBuf::from(&name));

    fs::write(path, build.serialize()?)?;

    Ok(())
}

fn install(file: PathBuf, destination: Option<PathBuf>) -> Result<()> {
    let content = fs::read_to_string(file)?;
    let build = deserialize(content.as_bytes())?;

    let id = build.id.clone();
    let branch = build.branch.clone();
    let name = format!("{id}-{branch}.jar");
    let destination = destination.unwrap_or(Path::new(&name).to_path_buf());

    let installer = Installer::new(build)?;
    installer.install(destination)?;

    Ok(())
}

#[cfg(test)]
mod tests {
    use crate::structs::{BuildType, ExcludePair, ExcludeType};

    use super::*;

    #[test]
    fn roundtrip_serialize_deserialize() {
        let build = ModBuild {
            id: "testmod".into(),
            name: "Test mod".into(),
            git: "https://repo.git".into(),
            branch: "1.21.7".into(),
            build: BuildType::Cmd,
            cmd: Some("./gradlew build".into()),
            out: "@/target/".into(),
            exclude: vec![
                ExcludePair {
                    type_name: ExcludeType::Ends,
                    value: "-source.jar".into(),
                },
                ExcludePair {
                    type_name: ExcludeType::Starts,
                    value: "dev-".into(),
                },
            ],
        };

        let serialized = build.clone().serialize().unwrap();
        println!("Serialized: {serialized:?}");
        let deserialized = deserialize(&serialized).unwrap();
        println!("Deserialized: {deserialized:?}");
        assert_eq!(build, deserialized);
    }
}