sebuilder 0.1.1

Build Scratch Everywhere! from .sb3 files
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

pub mod cmake;
pub mod git;
pub mod utils;
pub mod zip;

use crate::cmake::update_cmake_set;
use crate::git::clone_tag;
use crate::utils::run_cross_platform;
use seahorse::{App, Context, Flag, FlagType};
use std::env;
use crate::zip::unzip_file;

fn main() {
    let mut args: Vec<String> = env::args().collect();

    if args.len() == 1 {
        args.push("--help".to_string());
    }

    let app = App::new(env!("CARGO_PKG_NAME"))
        .description(env!("CARGO_PKG_DESCRIPTION"))
        .version(env!("CARGO_PKG_VERSION"))
        .usage("cli [args]")
        .action(default_action)
        .flag(
            Flag::new("name", FlagType::String)
                .description("name flag")
                .alias("n"),
        )
        .flag(
            Flag::new("description", FlagType::String)
                .description("description flag")
                .alias("d"),
        )
        .flag(
            Flag::new("author", FlagType::String)
                .description("author flag")
                .alias("a"),
        )
        .flag(
            Flag::new("sb3", FlagType::String)
                .description("SB3 file to build")
                .alias("s"),
        )
        .flag(
            Flag::new("platform", FlagType::String)
                .description("Produced platform (3ds, wiiu, etc.)")
                .alias("p"),
        );

    app.run(args);
}

fn default_action(c: &Context) {
    // Example: calling your synchronous git module
    if let Ok(tag) = git::get_latest_se_tag() {
        println!("Latest SE tag: {}", tag);
    }

    // Process flags
    let name = c.string_flag("name").unwrap();
    let description = c.string_flag("description").unwrap();
    let author = c.string_flag("author").unwrap();
    let sb3_file = c.string_flag("sb3").unwrap();
    // Check if the platform flag is set
    let mut platform = c.string_flag("platform").unwrap_or_default();
    if platform.is_empty() {
        println!("Platform flag not set, defaulting to 3ds");
        platform.push_str("3ds");
    }

    // Check if ./se exists, if so delete it
    if std::path::Path::new("./se").exists() {
        std::fs::remove_dir_all("./se").expect("Failed to remove existing SE directory");
    }
    clone_tag(
        "https://github.com/ScratchEverywhere/ScratchEverywhere.git",
        None,
        "./se",
    )
    .expect("Failed to clone SE repo");

    update_cmake_set("./se/CMakeLists.txt", "SE_APP_NAME", &name)
        .expect("Failed to update CMake set");
    update_cmake_set("./se/CMakeLists.txt", "SE_APP_DESCRIPTION", &description)
        .expect("Failed to update CMake set");
    update_cmake_set("./se/CMakeLists.txt", "SE_APP_AUTHOR", &author)
        .expect("Failed to update CMake set");

    std::fs::create_dir_all("./se/romfs/project").expect("Failed to create project directory");
    // unzip the sb3 file into the project directory
    unzip_file(&sb3_file, "./se/romfs/project").expect("Failed to unzip SB3 file");

    // Build the project
    run_cross_platform(
        format!("docker build -f ./se/docker/Dockerfile.{} --target exporter -o ./se ./se", platform).as_str(),
    ).expect("Failed to run cross-platform command");
}