Step 0.2: Add context and errors

Author: lucasgelfond

.codex/rules/default.rules

@@ -0,0 +1,16 @@
+prefix_rule(pattern = ["git", "status"], decision = "allow")
+prefix_rule(pattern = ["git", "add"], decision = "allow")
+prefix_rule(pattern = ["git", "diff"], decision = "allow")
+prefix_rule(pattern = ["git", "commit"], decision = "allow")
+prefix_rule(pattern = ["git", "restore"], decision = "allow")
+prefix_rule(pattern = ["git", "checkout"], decision = "allow")
+
+prefix_rule(pattern = ["jj"], decision = "allow")
+
+prefix_rule(pattern = ["cargo", "add"], decision = "allow")
+prefix_rule(pattern = ["cargo", "fmt"], decision = "allow")
+prefix_rule(pattern = ["cargo", "test"], decision = "allow")
+prefix_rule(pattern = ["cargo", "check"], decision = "allow")
+prefix_rule(pattern = ["cargo", "clippy"], decision = "allow")
+prefix_rule(pattern = ["cargo", "build"], decision = "allow")
+prefix_rule(pattern = ["cargo", "run"], decision = "allow")

zb_core/src/context.rs

@@ -0,0 +1,116 @@
+use std::path::PathBuf;
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Paths {
+    pub root: PathBuf,
+    pub store: PathBuf,
+    pub cellar: PathBuf,
+    pub cache: PathBuf,
+    pub db: PathBuf,
+    pub locks: PathBuf,
+}
+
+impl Paths {
+    pub fn from_root(root: PathBuf) -> Self {
+        let store = root.join("store");
+        let cellar = root.join("cellar");
+        let cache = root.join("cache");
+        let db = root.join("db").join("zb.sqlite3");
+        let locks = root.join("locks");
+
+        Self {
+            root,
+            store,
+            cellar,
+            cache,
+            db,
+            locks,
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ConcurrencyLimits {
+    pub download: usize,
+    pub unpack: usize,
+    pub materialize: usize,
+}
+
+impl Default for ConcurrencyLimits {
+    fn default() -> Self {
+        Self {
+            download: 16,
+            unpack: 4,
+            materialize: 4,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum LogLevel {
+    Info,
+    Warn,
+    Error,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct LoggerHandle {
+    pub level: LogLevel,
+}
+
+impl Default for LoggerHandle {
+    fn default() -> Self {
+        Self {
+            level: LogLevel::Info,
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Context {
+    pub paths: Paths,
+    pub concurrency: ConcurrencyLimits,
+    pub logger: LoggerHandle,
+}
+
+impl Context {
+    pub fn from_defaults() -> Self {
+        Self {
+            paths: Paths::from_root(PathBuf::from("/opt/zerobrew")),
+            concurrency: ConcurrencyLimits::default(),
+            logger: LoggerHandle::default(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn from_defaults_sets_expected_paths() {
+        let context = Context::from_defaults();
+
+        assert_eq!(context.paths.root, PathBuf::from("/opt/zerobrew"));
+        assert_eq!(
+            context.paths.store,
+            PathBuf::from("/opt/zerobrew").join("store")
+        );
+        assert_eq!(
+            context.paths.cellar,
+            PathBuf::from("/opt/zerobrew").join("cellar")
+        );
+        assert_eq!(
+            context.paths.cache,
+            PathBuf::from("/opt/zerobrew").join("cache")
+        );
+        assert_eq!(
+            context.paths.db,
+            PathBuf::from("/opt/zerobrew").join("db").join("zb.sqlite3")
+        );
+        assert_eq!(
+            context.paths.locks,
+            PathBuf::from("/opt/zerobrew").join("locks")
+        );
+    }
+}

zb_core/src/errors.rs

@@ -0,0 +1,45 @@
+use std::fmt;
+use std::path::PathBuf;
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum Error {
+    UnsupportedBottle { name: String },
+    ChecksumMismatch { expected: String, actual: String },
+    LinkConflict { path: PathBuf },
+    StoreCorruption { message: String },
+    NetworkFailure { message: String },
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Error::UnsupportedBottle { name } => {
+                write!(f, "unsupported bottle for formula '{name}'")
+            }
+            Error::ChecksumMismatch { expected, actual } => {
+                write!(f, "checksum mismatch (expected {expected}, got {actual})")
+            }
+            Error::LinkConflict { path } => {
+                write!(f, "link conflict at '{}'", path.to_string_lossy())
+            }
+            Error::StoreCorruption { message } => write!(f, "store corruption: {message}"),
+            Error::NetworkFailure { message } => write!(f, "network failure: {message}"),
+        }
+    }
+}
+
+impl std::error::Error for Error {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn unsupported_bottle_display_includes_name() {
+        let err = Error::UnsupportedBottle {
+            name: "libheif".to_string(),
+        };
+
+        assert!(err.to_string().contains("libheif"));
+    }
+}

zb_core/src/lib.rs

@@ -1,14 +1,5 @@
-pub fn add(left: u64, right: u64) -> u64 {
-    left + right
-}
+pub mod context;
+pub mod errors;
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn it_works() {
-        let result = add(2, 2);
-        assert_eq!(result, 4);
-    }
-}
+pub use context::{ConcurrencyLimits, Context, LogLevel, LoggerHandle, Paths};
+pub use errors::Error;