Drop the bitflags dependency

Cargo.toml

@@ -1,19 +1,12 @@
 [workspace]
-members = [
-    "boulder",
-    "moss",
-    "crates/*",
-]
-default-members = [
-    "moss"
-]
+members = ["boulder", "moss", "crates/*"]
+default-members = ["moss"]
 resolver = "2"
 
 [workspace.package]
 edition = "2021"
 
 [workspace.dependencies]
-bitflags = "2.4.1"
 bytes = "1.5.0"
 chrono = "0.4.30"
 clap = { version = "4.4.11", features = ["derive", "string"] }
@@ -28,11 +21,23 @@ glob = "0.3.1"
 hex = "0.4.3"
 log = "0.4"
 nom = "7.1.3"
-nix = { version = "0.27.1", features = ["user", "fs", "sched", "process", "mount", "hostname", "signal", "term"] }
+nix = { version = "0.27.1", features = [
+    "user",
+    "fs",
+    "sched",
+    "process",
+    "mount",
+    "hostname",
+    "signal",
+    "term",
+] }
 once_cell = "1.19.0"
 petgraph = "0.6.4"
 rayon = "1.8"
-reqwest = { version = "0.11.23", default-features = false, features = ["rustls-tls", "stream"] }
+reqwest = { version = "0.11.23", default-features = false, features = [
+    "rustls-tls",
+    "stream",
+] }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 serde_yaml = "0.9"

moss/Cargo.toml

@@ -10,7 +10,6 @@ stone = { path = "../crates/stone" }
 tui = { path = "../crates/tui" }
 vfs = { path = "../crates/vfs" }
 
-bitflags.workspace = true
 bytes.workspace = true
 chrono.workspace = true
 clap.workspace = true

moss/src/cli/info.rs

@@ -45,7 +45,7 @@ pub async fn handle(args: &ArgMatches) -> Result<(), Error> {
         let lookup = Provider::from_name(&pkg).unwrap();
         let resolved = client
             .registry
-            .by_provider(&lookup, Flags::NONE)
+            .by_provider(&lookup, Flags::default())
             .collect::<Vec<_>>()
             .await;
         if resolved.is_empty() {
@@ -54,7 +54,7 @@ pub async fn handle(args: &ArgMatches) -> Result<(), Error> {
         for candidate in resolved {
             print_package(&candidate);
 
-            if candidate.flags.contains(Flags::INSTALLED) && show_files {
+            if candidate.flags.installed && show_files {
                 let vfs = client.vfs([&candidate.id]).await?;
                 print_files(vfs);
             }

moss/src/cli/list.rs

@@ -50,12 +50,12 @@ pub async fn handle(args: &ArgMatches) -> Result<(), Error> {
     let root = args.get_one::<PathBuf>("root").unwrap().clone();
 
     let (filter_flags, sync) = match args.subcommand() {
-        Some(("available", _)) => (Flags::AVAILABLE, None),
+        Some(("available", _)) => (Flags::new().with_available(), None),
         Some(("installed", args)) => {
             let flags = if *args.get_one::<bool>("explicit").unwrap() {
-                Flags::INSTALLED | Flags::EXPLICIT
+                Flags::new().with_installed().with_explicit()
             } else {
-                Flags::INSTALLED
+                Flags::new().with_installed()
             };
             (flags, None)
         }
@@ -66,7 +66,7 @@ pub async fn handle(args: &ArgMatches) -> Result<(), Error> {
                 Sync::All
             };
 
-            (Flags::INSTALLED, Some(sync))
+            (Flags::new().with_installed(), Some(sync))
         }
         _ => unreachable!(),
     };
@@ -76,7 +76,11 @@ pub async fn handle(args: &ArgMatches) -> Result<(), Error> {
     let pkgs = client.registry.list(filter_flags).collect::<Vec<_>>().await;
 
     let sync_available = if sync.is_some() {
-        client.registry.list(Flags::AVAILABLE).collect::<Vec<_>>().await
+        client
+            .registry
+            .list(Flags::new().with_available())
+            .collect::<Vec<_>>()
+            .await
     } else {
         vec![]
     };
@@ -114,8 +118,8 @@ pub async fn handle(args: &ArgMatches) -> Result<(), Error> {
                     release: p.meta.source_release.to_string(),
                 },
                 summary: p.meta.summary,
-                explicit: if filter_flags == Flags::INSTALLED {
-                    p.flags.contains(Flags::EXPLICIT)
+                explicit: if filter_flags == Flags::new().with_installed() {
+                    p.flags.explicit
                 } else {
                     true
                 },

moss/src/cli/remove.rs

@@ -43,7 +43,11 @@ pub async fn handle(args: &ArgMatches, root: &Path) -> Result<(), Error> {
     // Grab a client for the target, enumerate packages
     let client = Client::new(environment::NAME, root).await?;
 
-    let installed = client.registry.list_installed(Flags::NONE).collect::<Vec<_>>().await;
+    let installed = client
+        .registry
+        .list_installed(Flags::default())
+        .collect::<Vec<_>>()
+        .await;
     let installed_ids = installed.iter().map(|p| p.id.clone()).collect::<HashSet<_>>();
 
     // Separate packages between installed / not installed (or invalid)

moss/src/cli/sync.rs

@@ -13,7 +13,7 @@ use moss::registry::transaction;
 use moss::state::Selection;
 use moss::{
     client::{self, Client},
-    package::{self, Flags},
+    package::{self},
     Package,
 };
 use thiserror::Error;
@@ -53,7 +53,7 @@ pub async fn handle(args: &ArgMatches, root: &Path) -> Result<(), Error> {
     // Grab all the existing installed packages
     let installed = client
         .registry
-        .list_installed(package::Flags::NONE)
+        .list_installed(package::Flags::default())
         .collect::<Vec<_>>()
         .await;
     if installed.is_empty() {
@@ -180,15 +180,15 @@ async fn resolve_with_sync(
     let with_sync = stream::iter(packages.iter())
         .filter(|p| async {
             match resolution {
-                Resolution::Explicit => p.flags.contains(Flags::EXPLICIT),
+                Resolution::Explicit => p.flags.explicit,
                 Resolution::All => true,
             }
         })
         .map(|p| async {
             // Get first available = use highest priority
             if let Some(lookup) = client
                 .registry
-                .by_name(&p.meta.name, package::Flags::AVAILABLE)
+                .by_name(&p.meta.name, package::Flags::new().with_available())
                 .boxed()
                 .next()
                 .await

moss/src/client/install.rs

@@ -30,7 +30,11 @@ pub async fn install(client: &mut Client, pkgs: &[&str], yes: bool) -> Result<()
     let resolved = client.resolve_packages(tx.finalize()).await?;
 
     // Get installed packages to check against
-    let installed = client.registry.list_installed(Flags::NONE).collect::<Vec<_>>().await;
+    let installed = client
+        .registry
+        .list_installed(Flags::default())
+        .collect::<Vec<_>>()
+        .await;
     let is_installed = |p: &Package| installed.iter().any(|i| i.meta.name == p.meta.name);
 
     // Get missing packages that are:
@@ -128,7 +132,7 @@ async fn find_packages<'a>(id: &'a str, client: &Client) -> (String, Option<Pack
     let provider = Provider::from_name(id).unwrap();
     let result = client
         .registry
-        .by_provider(&provider, Flags::AVAILABLE)
+        .by_provider(&provider, Flags::new().with_available())
         .collect::<Vec<_>>()
         .await;
 

moss/src/package/mod.rs

@@ -2,7 +2,6 @@
 //
 // SPDX-License-Identifier: MPL-2.0
 
-use bitflags::bitflags;
 use itertools::Itertools;
 
 pub use self::meta::{Meta, MissingMetaFieldError, Name};
@@ -67,20 +66,56 @@ impl Ord for Package {
     }
 }
 
-bitflags! {
-    /// Flags indicating the status of a [`Package`]
-    #[derive(Debug, Clone,Copy, PartialEq, Eq)]
-    pub struct Flags: u8 {
-        /// No filter flags
-        const NONE = 0;
-        /// Package is available for installation
-        const AVAILABLE = 1 << 1;
-        /// Package is already installed
-        const INSTALLED = 1 << 2;
-        /// Available as from-source build
-        const SOURCE = 1 << 3;
-        /// Package is explicitly installed (use with [`Flags::INSTALLED`])
-        const EXPLICIT = 1 << 4;
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub struct Flags {
+    /// Package is available for installation.
+    pub available: bool,
+    /// Package is already installed.
+    pub installed: bool,
+    /// Available as from-source build.
+    pub source: bool,
+    /// Package is explicitly installed (use with [`Flags::installed`]).
+    pub explicit: bool,
+}
+
+impl Flags {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Returns a copy of [`Flags`] with available set to true.
+    pub fn with_available(self) -> Self {
+        Self {
+            available: true,
+            ..self
+        }
+    }
+
+    /// Returns a copy of [`Flags`] with installed set to true.
+    pub fn with_installed(self) -> Self {
+        Self {
+            installed: true,
+            ..self
+        }
+    }
+
+    /// Returns a copy of [`Flags`] with source set to true.
+    pub fn with_source(self) -> Self {
+        Self { source: true, ..self }
+    }
+
+    /// Returns a copy of [`Flags`] with explicit set to true.
+    pub fn with_explicit(self) -> Self {
+        Self { explicit: true, ..self }
+    }
+
+    /// Returns whether this flag set contains another flag set.
+    pub fn contains(&self, other: Self) -> bool {
+        (self.bits() & other.bits()) == other.bits()
+    }
+
+    fn bits(&self) -> u32 {
+        (self.available as u32) | (self.installed as u32) << 1 | (self.source as u32) << 2 | (self.explicit as u32) << 3
     }
 }
 

moss/src/registry/mod.rs

@@ -88,12 +88,12 @@ impl Registry {
 
     /// Return a sorted stream of installed [`Package`]
     pub fn list_installed(&self, flags: package::Flags) -> impl Stream<Item = Package> + '_ {
-        self.list(flags | package::Flags::INSTALLED)
+        self.list(flags.with_installed())
     }
 
     /// Return a sorted stream of available [`Package`]
     pub fn list_available(&self, flags: package::Flags) -> impl Stream<Item = Package> + '_ {
-        self.list(flags | package::Flags::AVAILABLE)
+        self.list(flags.with_available())
     }
 
     /// Return a new transaction for this registry
@@ -139,7 +139,7 @@ mod test {
                 hash: Default::default(),
                 download_size: Default::default(),
             },
-            flags: package::Flags::NONE,
+            flags: package::Flags::default(),
         };
 
         registry.add_plugin(Plugin::Test(plugin::Test::new(
@@ -154,7 +154,7 @@ mod test {
             vec![package("c", 50), package("d", 1)],
         )));
 
-        let mut query = registry.list(package::Flags::NONE).enumerate().boxed();
+        let mut query = registry.list(package::Flags::default()).enumerate().boxed();
 
         // Packages are sorted by plugin priority, desc -> release number, desc
         while let Some((idx, package)) = query.next().await {
@@ -199,18 +199,24 @@ mod test {
         registry.add_plugin(Plugin::Test(plugin::test::Test::new(
             1,
             vec![
-                package("a", package::Flags::INSTALLED),
-                package("b", package::Flags::AVAILABLE),
-                package("c", package::Flags::SOURCE),
-                package("d", package::Flags::SOURCE | package::Flags::INSTALLED),
-                package("e", package::Flags::SOURCE | package::Flags::AVAILABLE),
+                package("a", package::Flags::new().with_installed()),
+                package("b", package::Flags::new().with_available()),
+                package("c", package::Flags::new().with_source()),
+                package("d", package::Flags::new().with_source().with_installed()),
+                package("e", package::Flags::new().with_source().with_available()),
             ],
         )));
 
-        let installed = registry.list_installed(package::Flags::NONE).collect().await;
-        let available = registry.list_available(package::Flags::NONE).collect().await;
-        let installed_source = registry.list_installed(package::Flags::SOURCE).collect().await;
-        let available_source = registry.list_available(package::Flags::SOURCE).collect().await;
+        let installed = registry.list_installed(package::Flags::default()).collect().await;
+        let available = registry.list_available(package::Flags::default()).collect().await;
+        let installed_source = registry
+            .list_installed(package::Flags::new().with_source())
+            .collect()
+            .await;
+        let available_source = registry
+            .list_available(package::Flags::new().with_source())
+            .collect()
+            .await;
 
         fn matches(actual: Vec<Package>, expected: &[&'static str]) -> bool {
             let actual = actual

moss/src/registry/plugin/active.rs

@@ -41,7 +41,7 @@ impl Active {
 
     /// Query, restricted to state
     async fn query(&self, flags: package::Flags, filter: Option<db::meta::Filter>) -> Vec<Package> {
-        if flags.contains(package::Flags::INSTALLED) || flags == package::Flags::NONE {
+        if flags.installed || flags == package::Flags::default() {
             // TODO: Error handling
             let packages = match self.db.query(filter).await {
                 Ok(packages) => packages,
@@ -55,13 +55,7 @@ impl Active {
                 .into_iter()
                 .filter_map(|(id, meta)| self.installed_package(id, meta))
                 // Filter for explicit only packages, if applicable
-                .filter(|package| {
-                    if flags.contains(package::Flags::EXPLICIT) {
-                        package.flags.contains(package::Flags::EXPLICIT)
-                    } else {
-                        true
-                    }
-                })
+                .filter(|package| if flags.explicit { package.flags.explicit } else { true })
                 .collect()
         } else {
             vec![]
@@ -99,9 +93,9 @@ impl Active {
                     id,
                     meta,
                     flags: if selection.explicit {
-                        package::Flags::INSTALLED | package::Flags::EXPLICIT
+                        package::Flags::new().with_installed().with_explicit()
                     } else {
-                        package::Flags::INSTALLED
+                        package::Flags::new().with_installed()
                     },
                 }),
             None => None,