feat: hugr binary cli tool

hugr/Cargo.toml

@@ -23,6 +23,7 @@ path = "src/lib.rs"
 
 [features]
 extension_inference = []
+cli = ["dep:clap", "dep:clap-stdin"]
 
 [dependencies]
 portgraph = { workspace = true, features = ["serde", "petgraph"] }
@@ -52,6 +53,8 @@ delegate = "0.12.0"
 paste = "1.0"
 strum = "0.26.1"
 strum_macros = "0.26.1"
+clap = { version = "4.5.4", features = ["derive"], optional = true }
+clap-stdin = { version = "0.4.0", optional = true }
 
 [dev-dependencies]
 criterion = { version = "0.5.1", features = ["html_reports"] }
@@ -61,10 +64,18 @@ urlencoding = "2.1.2"
 cool_asserts = "2.0.3"
 insta = { workspace = true, features = ["yaml"] }
 jsonschema = "0.18.0"
-proptest = { version =  "1.4.0" }
-proptest-derive = { version =  "0.4.0"}
-regex-syntax = { version =  "0.8.3"}
+proptest = { version = "1.4.0" }
+proptest-derive = { version = "0.4.0" }
+regex-syntax = { version = "0.8.3" }
+assert_cmd = "2.0.14"
+predicates = "3.1.0"
+assert_fs = "1.1.1"
 
 [[bench]]
 name = "bench_main"
 harness = false
+
+
+[[bin]]
+name = "hugr"
+required-features = ["cli"]

hugr/src/cli.rs

@@ -0,0 +1,41 @@
+//! Standard command line tools, used by the hugr binary.
+
+use clap::Parser;
+use clap_stdin::FileOrStdin;
+
+use crate::{extension::ExtensionRegistry, Hugr, HugrView};
+/// Validate and visualise a HUGR file.
+#[derive(Parser, Debug)]
+#[clap(version = "1.0", long_about = None)]
+#[clap(about = "Validate a HUGR.")]
+struct CmdLineArgs {
+    input: FileOrStdin,
+    /// Visualise with mermaid.
+    #[arg(short, long, value_name = "MERMAID", help = "Visualise with mermaid.")]
+    mermaid: bool,
+
+    /// Skip validation.
+    #[arg(short, long, help = "Skip validation.")]
+    no_validate: bool,
+    // TODO YAML extensions
+}
+
+/// String to print when validation is successful.
+pub const VALID_PRINT: &str = "HUGR valid!";
+
+/// Run the HUGR cli and validate against an extension registry.
+pub fn run(registry: &ExtensionRegistry) -> Result<(), Box<dyn std::error::Error>> {
+    let opts = CmdLineArgs::parse();
+
+    let mut hugr: Hugr = serde_json::from_reader(opts.input.into_reader()?)?;
+    if opts.mermaid {
+        println!("{}", hugr.mermaid_string());
+    }
+
+    if !opts.no_validate {
+        hugr.update_validate(registry)?;
+
+        println!("{}", VALID_PRINT);
+    }
+    Ok(())
+}

hugr/src/lib.rs

@@ -157,5 +157,8 @@ pub use crate::core::{
 pub use crate::extension::Extension;
 pub use crate::hugr::{Hugr, HugrView, SimpleReplacement};
 
+#[cfg(feature = "cli")]
+pub mod cli;
+
 #[cfg(test)]
 pub mod proptest;

hugr/src/main.rs

@@ -0,0 +1,28 @@
+//! Validate serialized HUGR on the command line
+
+use hugr::std_extensions::arithmetic::{
+    conversions::EXTENSION as CONVERSIONS_EXTENSION, float_ops::EXTENSION as FLOAT_OPS_EXTENSION,
+    float_types::EXTENSION as FLOAT_TYPES_EXTENSION, int_ops::EXTENSION as INT_OPS_EXTENSION,
+    int_types::EXTENSION as INT_TYPES_EXTENSION,
+};
+use hugr::std_extensions::logic::EXTENSION as LOGICS_EXTENSION;
+
+use hugr::extension::{ExtensionRegistry, PRELUDE};
+
+use hugr::cli::run;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // validate with all std extensions
+    let reg = ExtensionRegistry::try_new([
+        PRELUDE.to_owned(),
+        INT_OPS_EXTENSION.to_owned(),
+        INT_TYPES_EXTENSION.to_owned(),
+        CONVERSIONS_EXTENSION.to_owned(),
+        FLOAT_OPS_EXTENSION.to_owned(),
+        FLOAT_TYPES_EXTENSION.to_owned(),
+        LOGICS_EXTENSION.to_owned(),
+    ])
+    .unwrap();
+
+    run(&reg)
+}

hugr/tests/cli.rs

@@ -0,0 +1,95 @@
+#![cfg(feature = "cli")]
+
+use assert_cmd::Command;
+use assert_fs::{fixture::FileWriteStr, NamedTempFile};
+use hugr::{
+    builder::{Dataflow, DataflowHugr},
+    extension::prelude::BOOL_T,
+    type_row,
+    types::FunctionType,
+    Hugr,
+};
+use predicates::prelude::*;
+use rstest::{fixture, rstest};
+
+use hugr::cli::VALID_PRINT;
+#[fixture]
+fn cmd() -> Command {
+    Command::cargo_bin(env!("CARGO_PKG_NAME")).unwrap()
+}
+
+#[fixture]
+fn test_hugr() -> Hugr {
+    use hugr::builder::DFGBuilder;
+
+    let df = DFGBuilder::new(FunctionType::new_endo(type_row![BOOL_T])).unwrap();
+    let [i] = df.input_wires_arr();
+    df.finish_prelude_hugr_with_outputs([i]).unwrap()
+}
+
+#[fixture]
+fn test_hugr_string(test_hugr: Hugr) -> String {
+    serde_json::to_string(&test_hugr).unwrap()
+}
+
+#[fixture]
+fn test_hugr_file(test_hugr_string: String) -> NamedTempFile {
+    // TODO use proptests?
+    let file = assert_fs::NamedTempFile::new("sample.hugr").unwrap();
+    file.write_str(&test_hugr_string).unwrap();
+    file
+}
+
+#[rstest]
+fn test_doesnt_exist(mut cmd: Command) -> Result<(), Box<dyn std::error::Error>> {
+    cmd.arg("foobar");
+    cmd.assert()
+        .failure()
+        .stderr(predicate::str::contains("No such file or directory"));
+
+    Ok(())
+}
+
+#[rstest]
+fn test_validate(
+    test_hugr_file: NamedTempFile,
+    mut cmd: Command,
+) -> Result<(), Box<dyn std::error::Error>> {
+    cmd.arg(test_hugr_file.path());
+    cmd.assert()
+        .success()
+        .stdout(predicate::str::contains(VALID_PRINT));
+
+    Ok(())
+}
+
+#[rstest]
+fn test_stdin(
+    test_hugr_string: String,
+    mut cmd: Command,
+) -> Result<(), Box<dyn std::error::Error>> {
+    cmd.write_stdin(test_hugr_string);
+    cmd.arg("-");
+
+    cmd.assert()
+        .success()
+        .stdout(predicate::str::contains(VALID_PRINT));
+
+    Ok(())
+}
+
+#[rstest]
+fn test_mermaid(
+    test_hugr_file: NamedTempFile,
+    mut cmd: Command,
+) -> Result<(), Box<dyn std::error::Error>> {
+    const MERMAID: &str = "graph LR\n    subgraph 0 [\"(0) DFG\"]";
+    cmd.arg(test_hugr_file.path());
+    cmd.arg("--mermaid");
+    cmd.arg("--no-validate");
+    cmd.assert()
+        .success()
+        .stdout(predicate::str::contains(MERMAID));
+
+    Ok(())
+}