chore: autogen CI

.github/workflows/ci.yml

@@ -0,0 +1,30 @@
+name: CI
+env:
+  RUSTFLAGS: -Dwarnings
+on:
+  push:
+    branches:
+    - main
+  pull_request:
+    types:
+    - opened
+    - synchronize
+    - reopened
+    branches:
+    - main
+permissions:
+  contents: read
+jobs:
+  build:
+    name: Build and Test
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout Code
+      uses: actions/checkout@v4
+    - uses: actions-rust-lang/setup-rust-toolchain@v1
+      with:
+        toolchain: stable, nightly
+        components: clippy, rustfmt
+    - run: cargo test --all-features --workspace
+    - run: cargo +nightly fmt --check
+    - run: cargo +nightly clippy --all-features --workspace

.vscode/settings.json

@@ -1,3 +1,8 @@
 {
-  "cSpell.words": ["Gollum", "quicktype", "rustfmt"]
+  "cSpell.words": [
+    "Awarnings",
+    "Gollum",
+    "quicktype",
+    "rustfmt"
+  ]
 }

workspace/gh-workflow-gen/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "gh-workflow-gen"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+
+serde_json = "1.0.132"
+indexmap = "2.6.0"
+gh-workflow = { path = "../gh-workflow" }

workspace/gh-workflow-gen/src/main.rs

@@ -0,0 +1,42 @@
+use gh_workflow::{Component, Job, Permissions, RustFlags, Step, Toolchain, Workflow};
+
+fn main() {
+    let rust_flags = RustFlags::deny("warnings");
+
+    let build = Job::new("Build and Test")
+        .add_step(Step::checkout())
+        .add_step(
+            Step::setup_rust()
+                .add_toolchain(Toolchain::Stable)
+                .add_toolchain(Toolchain::Nightly)
+                .components(vec![Component::Clippy, Component::Rustfmt]),
+        )
+        .add_step(Step::cargo("test", vec!["--all-features", "--workspace"]))
+        .add_step(Step::cargo_nightly("fmt", vec!["--check"]))
+        .add_step(Step::cargo_nightly(
+            "clippy",
+            vec!["--all-features", "--workspace"],
+        ));
+
+    Workflow::new("CI")
+        .env(rust_flags)
+        .permissions(Permissions::read())
+        .on(vec![
+            // TODO: enums
+            ("push", vec![("branches", vec!["main"])]),
+            (
+                "pull_request",
+                vec![
+                    ("types", vec!["opened", "synchronize", "reopened"]),
+                    ("branches", vec!["main"]),
+                ],
+            ),
+        ])
+        .add_job("build", build)
+        .unwrap()
+        .generate(format!(
+            "{}/../../.github/workflows/ci.yml",
+            env!("CARGO_MANIFEST_DIR")
+        ))
+        .unwrap();
+}

workspace/gh-workflow/src/lib.rs

@@ -1,4 +1,8 @@
 pub mod error;
+mod rust_flag;
 mod toolchain;
 pub(crate) mod workflow;
+
+pub use rust_flag::*;
+pub use toolchain::*;
 pub use workflow::*;

workspace/gh-workflow/src/rust_flag.rs

@@ -0,0 +1,93 @@
+//! A type-safe representation of the Rust toolchain.
+
+use std::fmt::{Display, Formatter};
+
+use crate::{Job, SetEnv, Step, Workflow};
+
+#[derive(Clone)]
+pub enum RustFlags {
+    Lint(String, Lint),
+    Combine(Box<RustFlags>, Box<RustFlags>),
+}
+#[derive(Clone)]
+pub enum Lint {
+    Allow,
+    Warn,
+    Deny,
+    Forbid,
+    Codegen,
+    Experiment,
+}
+
+impl core::ops::Add for RustFlags {
+    type Output = RustFlags;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        RustFlags::Combine(Box::new(self), Box::new(rhs))
+    }
+}
+
+impl RustFlags {
+    pub fn allow<S: ToString>(name: S) -> Self {
+        RustFlags::Lint(name.to_string(), Lint::Allow)
+    }
+
+    pub fn warn<S: ToString>(name: S) -> Self {
+        RustFlags::Lint(name.to_string(), Lint::Warn)
+    }
+
+    pub fn deny<S: ToString>(name: S) -> Self {
+        RustFlags::Lint(name.to_string(), Lint::Deny)
+    }
+
+    pub fn forbid<S: ToString>(name: S) -> Self {
+        RustFlags::Lint(name.to_string(), Lint::Forbid)
+    }
+
+    pub fn codegen<S: ToString>(name: S) -> Self {
+        RustFlags::Lint(name.to_string(), Lint::Codegen)
+    }
+}
+
+impl Display for RustFlags {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            RustFlags::Lint(name, lint) => match lint {
+                Lint::Allow => write!(f, "-A{}", name),
+                Lint::Warn => write!(f, "-W{}", name),
+                Lint::Deny => write!(f, "-D{}", name),
+                Lint::Forbid => write!(f, "-F{}", name),
+                Lint::Codegen => write!(f, "-C{}", name),
+                Lint::Experiment => write!(f, "-Z{}", name),
+            },
+            RustFlags::Combine(lhs, rhs) => write!(f, "{} {}", lhs, rhs),
+        }
+    }
+}
+
+impl SetEnv<Job> for RustFlags {
+    fn apply(self, mut value: Job) -> Job {
+        let mut env = value.env.unwrap_or_default();
+        env.insert("RUSTFLAGS".to_string(), self.to_string());
+        value.env = Some(env);
+        value
+    }
+}
+
+impl SetEnv<Workflow> for RustFlags {
+    fn apply(self, mut value: Workflow) -> Workflow {
+        let mut env = value.env.unwrap_or_default();
+        env.insert("RUSTFLAGS".to_string(), self.to_string());
+        value.env = Some(env);
+        value
+    }
+}
+
+impl<T> SetEnv<Step<T>> for RustFlags {
+    fn apply(self, mut value: Step<T>) -> Step<T> {
+        let mut env = value.env.unwrap_or_default();
+        env.insert("RUSTFLAGS".to_string(), self.to_string());
+        value.env = Some(env);
+        value
+    }
+}