Align core crates with workspace lint policy (#200)

Cargo.toml

@@ -20,6 +20,7 @@ rust-version = "1.89.0"
 [workspace.dependencies]
 arrow-array = "59.2.0"
 arrow-schema = "59.2.0"
+num-traits = "0.2.19"
 parquet = "59.2.0"
 
 [workspace.lints.clippy]
@@ -83,10 +84,19 @@ missing_panics_doc                  = "deny"
 error_impl_error                    = "deny"
 result_large_err                    = "deny"
 
+# 9. documentation coverage
+missing_docs_in_private_items       = "deny"
+
 [workspace.lints.rust]
 unknown_lints                       = "deny"
 renamed_and_removed_lints           = "deny"
 missing_docs                        = "deny"
+unexpected_cfgs = { level = "warn", check-cfg = [
+    'cfg(kani)',
+    'cfg(coverage)',
+    'cfg(nightly)',
+    'cfg(dylint_lib, values(any()))',
+] }
 
 [workspace.lints.rustdoc]
 missing_crate_level_docs            = "deny"

chutoro-bench-datasets/src/context.rs

@@ -4,8 +4,11 @@ use crate::{Fetcher, Publisher, Storage};
 
 /// Borrowed port bundle supplied to recipe phases.
 pub struct RecipeContext<'a> {
+    /// Port that retrieves the recipe's source artefacts.
     fetcher: &'a dyn Fetcher,
+    /// Port that persists validated and prepared artefacts.
     storage: &'a dyn Storage,
+    /// Port that publishes the completed dataset representation.
     publisher: &'a dyn Publisher,
 }
 

chutoro-bench-datasets/src/driver.rs

@@ -61,6 +61,7 @@ pub fn run_recipe<R: DatasetRecipe>(
     )
 }
 
+/// Run one recipe phase and initiate cleanup when it fails.
 fn execute_phase<R, T>(
     recipe: &R,
     ctx: &RecipeContext<'_>,
@@ -85,13 +86,17 @@ where
         })
 }
 
+/// Progress metadata for a recipe phase being run.
 #[derive(Clone, Copy, Debug)]
 struct PhaseExecution {
+    /// Last phase known to have completed before the active phase started.
     highest_completed_phase: Option<Phase>,
+    /// Phase that is about to be executed.
     phase: Phase,
 }
 
 impl PhaseExecution {
+    /// Describe the active phase and its last completed predecessor.
     const fn new(highest_completed_phase: Option<Phase>, phase: Phase) -> Self {
         Self {
             highest_completed_phase,
@@ -100,14 +105,19 @@ impl PhaseExecution {
     }
 }
 
+/// Failure metadata retained while recipe cleanup runs.
 #[derive(Debug)]
 struct PhaseFailure {
+    /// Last phase known to have completed before the failure.
     highest_completed_phase: Option<Phase>,
+    /// Phase whose execution returned the original error.
     failed_phase: Phase,
+    /// Error returned by the failed phase before cleanup ran.
     original: RecipeError,
 }
 
 impl PhaseFailure {
+    /// Bundle the phase progress and error needed by cleanup.
     const fn new(
         highest_completed_phase: Option<Phase>,
         failed_phase: Phase,
@@ -121,6 +131,7 @@ impl PhaseFailure {
     }
 }
 
+/// Run recipe cleanup and preserve the original failure when cleanup succeeds.
 fn cleanup_after_error<R: DatasetRecipe>(
     recipe: &R,
     ctx: &RecipeContext<'_>,

chutoro-bench-datasets/src/newtypes/keys.rs

@@ -16,6 +16,7 @@ pub struct CacheKey(Utf8PathBuf);
 #[derive(Clone, Debug, Eq, Hash, PartialEq)]
 pub struct ObjectKey(Utf8PathBuf);
 
+/// Implement the common path-wrapper API for a recipe storage key type.
 macro_rules! impl_path_key {
     ($name:ident, $create_doc:literal, $example_path:literal) => {
         impl $name {

chutoro-bench-datasets/src/newtypes/mod.rs

@@ -106,6 +106,7 @@ impl Display for RecipeVersion {
     }
 }
 
+/// Parse one required unsigned component of a recipe version.
 fn parse_version_part(part: Option<&str>, value: &str) -> Result<u16, RecipeError> {
     part.ok_or_else(|| RecipeError::invalid_version(value))?
         .parse::<u16>()
@@ -156,10 +157,12 @@ impl Display for SourceUrl {
     }
 }
 
+/// Report whether `value` begins with one of the supported URL schemes.
 fn is_supported_source_scheme(value: &str) -> bool {
     value.starts_with("https://") || value.starts_with("s3://") || value.starts_with("file://")
 }
 
+/// Report whether `value` has content after its URL scheme separator.
 fn has_non_empty_source_remainder(value: &str) -> bool {
     value
         .split_once("://")

chutoro-bench-datasets/src/published.rs

@@ -14,6 +14,7 @@ use crate::ManifestDigest;
 mod sealed {
     //! Seals `PublishedArtefact` so only crate-owned artefact types implement it.
 
+    /// Private sealing trait implemented by crate-owned published artefacts.
     pub trait Sealed {}
 }
 
@@ -53,7 +54,9 @@ pub trait PublishedArtefact: sealed::Sealed + Send + Sync {
 #[non_exhaustive]
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct PublishedManifest {
+    /// UTF-8 path of the manifest produced by the recipe.
     manifest_uri: Utf8PathBuf,
+    /// Digest that identifies the produced manifest content.
     manifest_digest: ManifestDigest,
 }
 

chutoro-bench-datasets/src/testing/filesystem.rs

@@ -11,6 +11,7 @@ use crate::{Fetcher, PortName, RecipeError, SourceUrl};
 /// Fetcher that reads `file://` URLs relative to a fixture root.
 #[derive(Clone, Debug)]
 pub struct FilesystemFetcher {
+    /// Ambient fixture directory used as the fetcher's capability root.
     root: Utf8PathBuf,
 }
 
@@ -63,6 +64,7 @@ impl Fetcher for FilesystemFetcher {
     }
 }
 
+/// Validate and extract a relative file path from a `file://` source URL.
 fn relative_file_path(url: &SourceUrl) -> Result<&Utf8Path, RecipeError> {
     let value = url.as_ref();
     let relative = value

chutoro-bench-datasets/src/testing/in_memory.rs

@@ -12,7 +12,9 @@ use crate::{CacheKey, Fetcher, ObjectKey, PortName, Publisher, RecipeError, Sour
 /// In-memory source fetcher.
 #[derive(Clone, Debug, Default)]
 pub struct InMemoryFetcher {
+    /// Bytes available for each configured source URL.
     sources: Arc<HashMap<SourceUrl, Bytes>>,
+    /// Request order captured for fixture assertions.
     requested: Arc<Mutex<Vec<SourceUrl>>>,
 }
 
@@ -94,6 +96,7 @@ impl Fetcher for InMemoryFetcher {
 /// cross-process cache coordination.
 #[derive(Debug, Default)]
 pub struct InMemoryStorage {
+    /// Mutable cache records retained by the in-process adapter.
     records: Mutex<HashMap<CacheKey, Bytes>>,
 }
 
@@ -148,6 +151,7 @@ impl Storage for InMemoryStorage {
 /// In-memory publisher for final artefacts.
 #[derive(Debug, Default)]
 pub struct InMemoryPublisher {
+    /// Published object records retained by the in-process adapter.
     records: Mutex<HashMap<ObjectKey, Bytes>>,
 }
 

chutoro-bench-datasets/src/testing/stub_recipe.rs

@@ -8,14 +8,19 @@ use crate::{
     RecipeError, RecipeId, RecipeVersion, SourceSpec, SourceUrl,
 };
 
+/// Default per-source byte ceiling used by the deterministic stub recipe.
 const DEFAULT_MAX_BYTES: usize = 1024 * 1024;
 
 /// Simple recipe that fetches every source and publishes concatenated bytes.
 #[derive(Clone, Debug)]
 pub struct StubRecipe {
+    /// Stable identifier used by the fixture recipe.
     id: RecipeId,
+    /// Fixture recipe version returned to the driver.
     version: RecipeVersion,
+    /// Primary source specifications fetched by the fixture recipe.
     sources: Vec<SourceSpec>,
+    /// Per-source byte limit enforced by the fixture recipe.
     max_bytes: usize,
 }
 

chutoro-bench-datasets/tests/common/mod.rs

@@ -0,0 +1,23 @@
+//! Shared assertion helpers for `chutoro-bench-datasets` integration tests.
+//!
+//! This module lives in a `tests/common` subdirectory (rather than a bare
+//! `tests/common.rs`) so Cargo does not treat it as its own standalone test
+//! crate; consumers pull it in with `mod common;`.
+
+/// Asserts that `$expr` evaluates to `Err` and yields the wrapped error,
+/// panicking at the call site with the supplied message if it does not.
+///
+/// Implemented as a macro (rather than a helper function) so a failed
+/// assertion's panic location points at the calling test, matching the
+/// diagnostics produced by the `let Err(error) = ... else { panic!(...) };`
+/// idiom it replaces.
+macro_rules! expect_err {
+    ($expr:expr, $($panic_arg:tt)+) => {
+        match $expr {
+            Err(error) => error,
+            Ok(_) => panic!($($panic_arg)+),
+        }
+    };
+}
+
+pub(crate) use expect_err;

chutoro-bench-datasets/tests/newtypes.rs

@@ -3,23 +3,19 @@
 use chutoro_bench_datasets::{RecipeError, RecipeVersion, SourceRole, SourceSpec, SourceUrl};
 use rstest::rstest;
 
+mod common;
+use common::expect_err;
+
 #[rstest]
 #[case::https("https://")]
 #[case::s3("s3://")]
 #[case::file("file://")]
-fn source_url_rejects_scheme_without_source_remainder(#[case] value: &str) {
-    let Err(error) = SourceUrl::parse(value) else {
-        panic!("scheme-only source URL should fail");
-    };
-
-    assert!(matches!(error, RecipeError::InvalidSource(_)));
-}
-
-#[test]
-fn source_url_rejects_unsupported_scheme() {
-    let Err(error) = SourceUrl::parse("ftp://example.test/x") else {
-        panic!("unsupported source URL scheme should fail");
-    };
+#[case::ftp("ftp://example.test/x")]
+fn source_url_rejects_invalid_scheme(#[case] value: &str) {
+    let error = expect_err!(
+        SourceUrl::parse(value),
+        "invalid source URL should fail: {value}"
+    );
 
     assert!(matches!(error, RecipeError::InvalidSource(_)));
 }
@@ -30,9 +26,10 @@ fn source_url_rejects_unsupported_scheme() {
 #[case::non_numeric("a.b.c")]
 #[case::negative("-1.2.3")]
 fn recipe_version_rejects_malformed_input(#[case] value: &str) {
-    let Err(error) = RecipeVersion::parse(value) else {
-        panic!("malformed version should fail: {value}");
-    };
+    let error = expect_err!(
+        RecipeVersion::parse(value),
+        "malformed version should fail: {value}"
+    );
 
     assert!(matches!(error, RecipeError::InvalidVersion(_)));
 }