...

parts/mos/Cargo.toml

@@ -0,0 +1,21 @@
+cargo-features = ["profile-rustflags"]
+
+[package]
+name = "mize-part-mos"
+version = "0.1.0"
+edition = "2024"
+
+[lib]
+name = "mize_part_mos"
+crate-type = [ "cdylib", "rlib" ]
+
+[dependencies]
+log = "0.4.34"
+mize = { workspace = true }
+
+
+[profile.dev]
+rustflags = ["-C", "prefer-dynamic", "-C", "link-args=-Wl,--export-dynamic"]
+  
+[profile.release]
+rustflags = ["-C", "prefer-dynamic"]

parts/mos/src/generated.rs

@@ -0,0 +1,70 @@
+use mize::prelude::*;
+
+
+pub struct CliPart {
+  id: MizeId
+}
+
+impl MizePart for CliPart {
+  fn id(&self) -> MizeId {
+      self.id.clone()
+  }
+}
+
+impl CliPart {
+  pub fn get(name: &str) -> MizeResult<CliPart> {
+    let mut mize = get_global_mize()?;
+    let part = mize.get_part(name)?;
+    Ok(CliPart { id: part.id() })
+  }
+  pub fn run(&self, cmdline: Vec<String>) -> MizeResult<()> {
+    let cmdline = cmdline.into_item_data();
+    let mut args = ItemData::new();
+    args.set_path("0", cmdline)?;
+    dyn_call(self.id.clone(), "run", args)?;
+    Ok(())
+  }
+  pub fn set_command(&self, name: &str) -> MizeResult<()> {
+    let name = name.into_item_data();
+    let mut args = ItemData::new();
+    args.set_path("0", name)?;
+    dyn_call(self.id.clone(), "set_command", args)?;
+    Ok(())
+  }
+  pub fn subcommand<T: Fn(ArgMatches) -> MizeResult<()> + Send + Sync + 'static>(&self, subcmd: Command, action: T) -> MizeResult<()> {
+    let mut subcmd_arg = ItemData::new();
+    subcmd_arg.set_path("_native", subcmd.native_id)?;
+    let mut action_arg = ItemData::from_native(action)?;
+    let mut args = ItemData::new();
+    args.set_path("0", subcmd_arg)?;
+    args.set_path("1", action_arg)?;
+    dyn_call(self.id.clone(), "subcommand", args)?;
+    Ok(())
+  }
+}
+
+// the clap::Command native stuff
+pub struct Command {
+  native_id: u32
+}
+
+pub struct ArgMatches {
+  native_id: u32
+}
+
+pub struct Action {
+  native_id: u32
+}
+
+impl Command {
+  pub fn new(name: &str) -> MizeResult<Command> {
+    let name = name.into_item_data();
+    let mut args = ItemData::new();
+    args.set_path("0", name)?;
+    let mut mize = get_global_mize()?;
+    let id = mize.id_new_dots("cli.Command")?;
+    let data = dyn_call(id.clone(), "new", args)?;
+    let native_id: u32 = data.get_path("_native")?.native_take()?;
+    Ok(Command { native_id })
+  }
+}

parts/mos/src/lib.rs

@@ -0,0 +1,63 @@
+use std::fs::create_dir_all;
+use mize::prelude::*;
+use cmd_lib::run_cmd as sh;
+use mize::tracing::info;
+
+// a static version of what would be generated.
+// as we need mize.dev to generate anything.
+mod generated;
+use generated::*;
+
+// spacetime gen command: sh!(RUST_LOG=error RUST_BACKTRACE=0 spacetime generate --build-options="--lint-dir=" -p $SRC/mize/marts/spacetime -o $SRC/mize/marts/generated/src/spacetime --lang rust)?;
+
+#[unsafe(no_mangle)]
+extern "C" fn part_dev() -> MizeResult<()> {
+  let mut mize = get_global_mize()?;
+  let mut cli = generated::CliPart::get("cli")?;
+  cli.set_command("dev");
+
+  cli.subcommand(Command::new("test")?, |_| {println!("hello from test command"); Ok(())})?;
+  //cli.subcommand(Command::new("publish").alias("p"), publish_mize)?;
+  //cli.subcommand(Command::new("genBindings").alias("b"), gen_bindings)?;
+  
+  Ok(())
+}
+
+pub fn publish_mize(_ : &ArgMatches, mut mize: Mize) -> MizeResult<()> {
+  let mize_src = mize.get_config("mize.src")?.value_string()?;
+  let cargo_dir = std::env::home_dir().unwrap().join(".cargo");
+
+  let targets = vec![
+    "x86_64-pc-windows-gnu",
+    "aarch64-pc-windows-gnullvm",
+    
+    "x86_64-unknown-linux-gnu",
+    "aarch64-unknown-linux-gnu",
+    "armv7-unknown-linux-gnueabihf",
+    "arm-unknown-linux-gnueabi",
+
+    "aarch64-apple-darwin",
+    "x86_64-apple-darwin",
+  ];
+  
+  for target_name in targets {
+    let docker_image = match target_name {
+      "aarch64-apple-darwin" => "darwin",
+      "x86_64-apple-darwin" => "darwin",
+      _ => "base",
+    };
+    sh!(docker build -t mize-build-$docker_image  $mize_src/parts/mize.dev/targets/$docker_image)?;
+    let res = sh!(docker run -it --rm -v $cargo_dir/registry:/usr/local/cargo/registry -v $cargo_dir/git:/usr/local/cargo/git -v $mize_src:/src -v $mize_src/target:/src/target mize-build-$docker_image cargo build --target $target_name --release);
+    if res.is_err() {
+      info!("build for {target_name} failed...");
+    }
+  };
+  
+  
+  Ok(())
+}
+
+pub fn gen_bindings(_ : &ArgMatches, mize: Mize) -> MizeResult<()> {
+  
+  Ok(())
+}