Reorganize fud2 directory (#1883)

* Reorganize `fud2` directory

* add tool metadata

* fix location for README

* reorg driver files

* extra some setup into functions

* create `fud-core` crate

* update desc

* add lisc

* bump version

Cargo.toml

@@ -12,7 +12,7 @@ members = [
     "tools/data_gen",
     "cider-dap",
     "fud2",
-    "fud2/fake",
+    "fud2/fud-core",
 ]
 exclude = ["site"]
 

fud2/Cargo.toml

@@ -1,8 +1,21 @@
 [package]
-name = "fud2"
-version.workspace = true
+name = "fud"
+version = "0.0.2"
 edition.workspace = true
+authors.workspace = true
+license-file.workspace = true
+repository.workspace = true
+homepage.workspace = true
+
+keywords = ["build-tool"]
+readme = "README.md"
+categories = ["build-tool"]
+description = "Compiler driver for the Calyx infrastructure"
 
 [dependencies]
-fake = { path = "fake" }
+fud-core = { path = "fud-core", version = "0.0.2" }
 anyhow.workspace = true
+
+[[bin]]
+name = "fud2"
+path = "src/main.rs"

fud2/README.md

@@ -0,0 +1,27 @@
+# `fud`: The Calyx Build Tool
+
+Reimplementation of the [fud][] compiler driver for Calyx.
+
+### Installation
+
+To install from source, run the following from `calyx/fud2`:
+```
+cargo install --path .
+```
+
+This will install the binary `fud2` to the default `cargo` binary location.
+
+### Configuration
+
+The minimal required configuration requires setting the `calyx.base` key so that `fud` knows where the Calyx compiler is. Open the configuration file by running:
+```
+fud edit-config
+```
+
+Add the path to the location of the Calyx compiler:
+```toml
+[calyx]
+base = "<path to calyx repo>"
+```
+
+[fud]: https://docs.calyxir.org/fud/index.html

fud2/fake/Cargo.toml → fud2/fud-core/Cargo.toml

@@ -1,7 +1,13 @@
 [package]
-name = "fake"
-version.workspace = true
+name = "fud-core"
+version = "0.0.2"
 edition.workspace = true
+license-file.workspace = true
+
+keywords = ["build-tool"]
+readme = "../README.md"
+categories = ["build-tool"]
+description = "Library for building declarative build tools"
 
 [dependencies]
 argh.workspace = true

fud2/fake/src/cli.rs → fud2/fud-core/src/cli.rs

@@ -1,5 +1,5 @@
 use crate::config;
-use crate::driver::{Driver, Request, StateRef};
+use crate::exec::{Driver, Request, StateRef};
 use crate::run::Run;
 use anyhow::{anyhow, bail};
 use argh::FromArgs;

fud2/fud-core/src/exec/data.rs

@@ -0,0 +1,58 @@
+use crate::run;
+use cranelift_entity::entity_impl;
+
+/// A State is a type of file that Operations produce or consume.
+pub struct State {
+    /// The name of the state, for the UI.
+    pub name: String,
+
+    /// The file extensions that this state can be represented by.
+    ///
+    /// The first extension in the list is used when generating a new filename for the state. If
+    /// the list is empty, this is a "pseudo-state" that doesn't correspond to an actual file.
+    /// Pseudo-states can only be final outputs; they are appropraite for representing actions that
+    /// interact directly with the user, for example.
+    pub extensions: Vec<String>,
+}
+
+impl State {
+    /// Check whether a filename extension indicates this state.
+    pub fn ext_matches(&self, ext: &str) -> bool {
+        self.extensions.iter().any(|e| e == ext)
+    }
+
+    /// Is this a "pseudo-state": doesn't correspond to an actual file, and must be an output state?
+    pub fn is_pseudo(&self) -> bool {
+        self.extensions.is_empty()
+    }
+}
+
+/// A reference to a State.
+#[derive(Copy, Clone, PartialEq, Eq, Hash)]
+pub struct StateRef(u32);
+entity_impl!(StateRef, "state");
+
+/// An Operation transforms files from one State to another.
+pub struct Operation {
+    pub name: String,
+    pub input: StateRef,
+    pub output: StateRef,
+    pub setups: Vec<SetupRef>,
+    pub emit: Box<dyn run::EmitBuild>,
+}
+
+/// A reference to an Operation.
+#[derive(Copy, Clone, PartialEq, Eq, Hash)]
+pub struct OpRef(u32);
+entity_impl!(OpRef, "op");
+
+/// A Setup runs at configuration time and produces Ninja machinery for Operations.
+pub struct Setup {
+    pub name: String,
+    pub emit: Box<dyn run::EmitSetup>,
+}
+
+/// A reference to a Setup.
+#[derive(Copy, Clone, PartialEq, Eq, Hash)]
+pub struct SetupRef(u32);
+entity_impl!(SetupRef, "setup");

fud2/fake/src/driver.rs → fud2/fud-core/src/exec/driver.rs

@@ -1,75 +1,7 @@
-use crate::run;
+use super::{OpRef, Operation, Request, Setup, SetupRef, State, StateRef};
+use crate::{run, utils};
 use camino::{Utf8Path, Utf8PathBuf};
-use cranelift_entity::{entity_impl, PrimaryMap, SecondaryMap};
-use pathdiff::diff_utf8_paths;
-
-/// A State is a type of file that Operations produce or consume.
-pub struct State {
-    /// The name of the state, for the UI.
-    pub name: String,
-
-    /// The file extensions that this state can be represented by.
-    ///
-    /// The first extension in the list is used when generating a new filename for the state. If
-    /// the list is empty, this is a "pseudo-state" that doesn't correspond to an actual file.
-    /// Pseudo-states can only be final outputs; they are appropraite for representing actions that
-    /// interact directly with the user, for example.
-    pub extensions: Vec<String>,
-}
-
-/// A reference to a State.
-#[derive(Copy, Clone, PartialEq, Eq, Hash)]
-pub struct StateRef(u32);
-entity_impl!(StateRef, "state");
-
-/// An Operation transforms files from one State to another.
-pub struct Operation {
-    pub name: String,
-    pub input: StateRef,
-    pub output: StateRef,
-    pub setups: Vec<SetupRef>,
-    pub emit: Box<dyn run::EmitBuild>,
-}
-
-/// A reference to an Operation.
-#[derive(Copy, Clone, PartialEq, Eq, Hash)]
-pub struct OpRef(u32);
-entity_impl!(OpRef, "op");
-
-/// A Setup runs at configuration time and produces Ninja machinery for Operations.
-pub struct Setup {
-    pub name: String,
-    pub emit: Box<dyn run::EmitSetup>,
-}
-
-/// A reference to a Setup.
-#[derive(Copy, Clone, PartialEq, Eq, Hash)]
-pub struct SetupRef(u32);
-entity_impl!(SetupRef, "setup");
-
-impl State {
-    /// Check whether a filename extension indicates this state.
-    fn ext_matches(&self, ext: &str) -> bool {
-        self.extensions.iter().any(|e| e == ext)
-    }
-
-    /// Is this a "pseudo-state": doesn't correspond to an actual file, and must be an output state?
-    fn is_pseudo(&self) -> bool {
-        self.extensions.is_empty()
-    }
-}
-
-/// Get a version of `path` that works when the working directory is `base`. This is
-/// opportunistically a relative path, but we can always fall back to an absolute path to make sure
-/// the path still works.
-pub fn relative_path(path: &Utf8Path, base: &Utf8Path) -> Utf8PathBuf {
-    match diff_utf8_paths(path, base) {
-        Some(p) => p,
-        None => path
-            .canonicalize_utf8()
-            .expect("could not get absolute path"),
-    }
-}
+use cranelift_entity::{PrimaryMap, SecondaryMap};
 
 #[derive(PartialEq)]
 enum Destination {
@@ -196,7 +128,7 @@ impl Driver {
 
         // Get the initial input filename and the stem to use to generate all intermediate filenames.
         let (stdin, start_file) = match req.start_file {
-            Some(path) => (false, relative_path(&path, &req.workdir)),
+            Some(path) => (false, utils::relative_path(&path, &req.workdir)),
             None => (true, "stdin".into()),
         };
         let stem = start_file.file_stem().unwrap();
@@ -211,7 +143,7 @@ impl Driver {
         let stdout = if let Some(end_file) = req.end_file {
             // TODO Can we just avoid generating the unused filename in the first place?
             let last_step = steps.last_mut().expect("no steps");
-            last_step.1 = relative_path(&end_file, &req.workdir);
+            last_step.1 = utils::relative_path(&end_file, &req.workdir);
             false
         } else {
             // Print to stdout if the last state is a real (non-pseudo) state.
@@ -350,28 +282,6 @@ impl DriverBuilder {
     }
 }
 
-/// A request to the Driver directing it what to build.
-#[derive(Debug)]
-pub struct Request {
-    /// The input format.
-    pub start_state: StateRef,
-
-    /// The output format to produce.
-    pub end_state: StateRef,
-
-    /// The filename to read the input from, or None to read from stdin.
-    pub start_file: Option<Utf8PathBuf>,
-
-    /// The filename to write the output to, or None to print to stdout.
-    pub end_file: Option<Utf8PathBuf>,
-
-    /// A sequence of operators to route the conversion through.
-    pub through: Vec<OpRef>,
-
-    /// The working directory for the build.
-    pub workdir: Utf8PathBuf,
-}
-
 #[derive(Debug)]
 pub struct Plan {
     /// The input to the first step.

fud2/fud-core/src/exec/mod.rs

@@ -0,0 +1,8 @@
+mod data;
+mod driver;
+mod request;
+
+pub use data::{OpRef, SetupRef, StateRef};
+pub(super) use data::{Operation, Setup, State};
+pub use driver::{Driver, DriverBuilder, Plan};
+pub use request::Request;

fud2/fud-core/src/exec/request.rs

@@ -0,0 +1,24 @@
+use super::{OpRef, StateRef};
+use camino::Utf8PathBuf;
+
+/// A request to the Driver directing it what to build.
+#[derive(Debug)]
+pub struct Request {
+    /// The input format.
+    pub start_state: StateRef,
+
+    /// The output format to produce.
+    pub end_state: StateRef,
+
+    /// The filename to read the input from, or None to read from stdin.
+    pub start_file: Option<Utf8PathBuf>,
+
+    /// The filename to write the output to, or None to print to stdout.
+    pub end_file: Option<Utf8PathBuf>,
+
+    /// A sequence of operators to route the conversion through.
+    pub through: Vec<OpRef>,
+
+    /// The working directory for the build.
+    pub workdir: Utf8PathBuf,
+}

fud2/fud-core/src/lib.rs

@@ -0,0 +1,7 @@
+pub mod cli;
+pub mod config;
+pub mod exec;
+pub mod run;
+pub mod utils;
+
+pub use exec::{Driver, DriverBuilder};

fud2/fake/src/run.rs → fud2/fud-core/src/run.rs

@@ -1,5 +1,6 @@
 use crate::config;
-use crate::driver::{relative_path, Driver, OpRef, Plan, SetupRef, StateRef};
+use crate::exec::{Driver, OpRef, Plan, SetupRef, StateRef};
+use crate::utils::relative_path;
 use camino::{Utf8Path, Utf8PathBuf};
 use std::collections::{HashMap, HashSet};
 use std::io::Write;

fud2/fud-core/src/utils.rs

@@ -0,0 +1,14 @@
+use camino::{Utf8Path, Utf8PathBuf};
+use pathdiff::diff_utf8_paths;
+
+/// Get a version of `path` that works when the working directory is `base`. This is
+/// opportunistically a relative path, but we can always fall back to an absolute path to make sure
+/// the path still works.
+pub fn relative_path(path: &Utf8Path, base: &Utf8Path) -> Utf8PathBuf {
+    match diff_utf8_paths(path, base) {
+        Some(p) => p,
+        None => path
+            .canonicalize_utf8()
+            .expect("could not get absolute path"),
+    }
+}