replaced justfile with xtask

Author: schell

.cargo/config.toml

@@ -0,0 +1,3 @@
+[alias]
+xtask = "run --package xtask --"
+build-test-shader = "xtask test-build"

.github/workflows/push.yaml

@@ -35,7 +35,7 @@ jobs:
           rustup update
       - run: cargo test
       - name: Run a full build
-        run: just build-shader-template
+        run: cargo xtask test-build
 
 
   lints:
@@ -45,5 +45,7 @@ jobs:
       - uses: moonrepo/setup-rust@v1
       - uses: extractions/setup-just@v2
       - uses: cargo-bins/cargo-binstall@main
-      - run: just setup-lints
-      - run: just lints
+      - run: cargo binstall cargo-shear
+      - run: cargo clippy -- --deny warnings
+      - run: cargo fmt --check
+      - run: cargo shear

Cargo.lock

@@ -1,6 +1,7 @@
 [workspace]
 members = [
-    "crates/cargo-gpu",
+    "crates/cargo-gpu", 
+		"crates/xtask",
 ]
 
 exclude = [
@@ -30,6 +31,7 @@ relative-path = "1.9.3"
 serde = { version = "1.0.214", features = ["derive"] }
 serde_json = "1.0.132"
 toml = "0.8.19"
+tempdir = "0.3.7"
 test-log = "0.2.16"
 
 [workspace.lints.rust]

Cargo.toml

@@ -1,2 +1,3 @@
 allow-unwrap-in-tests = true
 allow-panic-in-tests = true
+allow-shadow-reuse = true

clippy.toml

@@ -173,7 +173,7 @@ mod test {
             // For some reason running a full build (`build.run()`) inside tests fails on Windows.
             // The error is in the `build.rs` step of compiling `spirv-tools-sys`. It is not clear
             // from the logged error what the problem is. For now we'll just run a full build
-            // outside the tests environment, see `justfile`'s `build-shader-template`.
+            // outside the tests environment, see `xtask`'s `test-build`.
         } else {
             panic!("was not a build command");
         }

crates/cargo-gpu/src/build.rs

@@ -0,0 +1,15 @@
+[package]
+name = "xtask"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+anyhow.workspace = true
+clap.workspace = true
+env_logger.workspace = true
+log.workspace = true
+tempdir.workspace = true
+toml.workspace = true
+
+[lints]
+workspace = true

crates/xtask/Cargo.toml

@@ -0,0 +1,119 @@
+//! Project/repository utilities.
+
+use anyhow::Context;
+use clap::Parser;
+
+/// Our xtask commands.
+#[derive(Debug, clap::Parser)]
+enum Cli {
+    /// Run a test build of the shader-crate-template project.
+    TestBuild,
+}
+
+fn cmd(args: impl IntoIterator<Item = impl AsRef<str>>) -> anyhow::Result<()> {
+    let mut args = args.into_iter();
+    let mut cmd = std::process::Command::new(args.next().context("no args")?.as_ref());
+    for arg in args {
+        cmd.arg(arg.as_ref());
+    }
+
+    let output = cmd
+        .stdout(std::process::Stdio::inherit())
+        .stderr(std::process::Stdio::inherit())
+        .output()
+        .context("cmd failed")?;
+    anyhow::ensure!(output.status.success());
+
+    Ok(())
+}
+
+struct ShaderCrateTemplateCargoTomlWriter {
+    original_shader_crate_template_str: String,
+    table: toml::Table,
+}
+
+impl Drop for ShaderCrateTemplateCargoTomlWriter {
+    fn drop(&mut self) {
+        log::info!("reverting overwrite of Cargo.toml");
+        std::fs::write(Self::PATH, &self.original_shader_crate_template_str).unwrap();
+    }
+}
+
+impl ShaderCrateTemplateCargoTomlWriter {
+    const PATH: &str = "crates/shader-crate-template/Cargo.toml";
+
+    fn new() -> Self {
+        let original_shader_crate_template_str = std::fs::read_to_string(Self::PATH).unwrap();
+        let table = toml::from_str::<toml::Table>(&original_shader_crate_template_str).unwrap();
+        Self {
+            original_shader_crate_template_str,
+            table,
+        }
+    }
+
+    fn replace_output_dir(&mut self, path: impl AsRef<std::path::Path>) -> anyhow::Result<()> {
+        let package = self
+            .table
+            .get_mut("package")
+            .unwrap()
+            .as_table_mut()
+            .unwrap();
+        let metadata = package.get_mut("metadata").unwrap().as_table_mut().unwrap();
+        let rust_gpu = metadata
+            .get_mut("rust-gpu")
+            .unwrap()
+            .as_table_mut()
+            .unwrap();
+        let build = rust_gpu.get_mut("build").unwrap().as_table_mut().unwrap();
+        let output_dir = build.get_mut("output-dir").unwrap();
+        *output_dir = toml::Value::String(format!("{}", path.as_ref().display()));
+        std::fs::write(
+            Self::PATH,
+            toml::to_string_pretty(&self.table).context("could not serialize")?,
+        )
+        .context("could not overwrite path")?;
+        Ok(())
+    }
+}
+
+/// Run the xtask.
+fn main() {
+    env_logger::builder().init();
+
+    let cli = Cli::parse();
+
+    match cli {
+        Cli::TestBuild => {
+            log::info!("installing cargo gpu");
+            cmd(["cargo", "install", "--path", "crates/cargo-gpu"]).unwrap();
+
+            log::info!("installing cargo gpu artifacts");
+            cmd([
+                "cargo",
+                "gpu",
+                "install",
+                "--shader-crate",
+                "crates/shader-crate-template",
+                "--auto-install-rust-toolchain",
+            ])
+            .unwrap();
+
+            let dir = tempdir::TempDir::new("test-shader-output").unwrap();
+            let mut overwriter = ShaderCrateTemplateCargoTomlWriter::new();
+            overwriter.replace_output_dir(dir.path()).unwrap();
+
+            cmd([
+                "cargo",
+                "gpu",
+                "build",
+                "--shader-crate",
+                "crates/shader-crate-template",
+                "--force-spirv-cli-rebuild",
+            ])
+            .unwrap();
+
+            cmd(["ls", "-lah", dir.path().to_str().unwrap()]).unwrap();
+            cmd(["cat", dir.path().join("manifest.json").to_str().unwrap()]).unwrap();
+        }
+    }
+}