Merge pull request #71 from serpent-os/feat/explicit-selection

Mark selections as explicit

Author: ikeycode

moss/src/cli/install.rs

@@ -10,6 +10,7 @@ use moss::{
     client::{self, Client},
     package::{self, Flags},
     registry::transaction,
+    state::Selection,
     Package,
 };
 use thiserror::Error;
@@ -87,14 +88,20 @@ pub async fn handle(args: &ArgMatches, root: &Path) -> Result<(), Error> {
 
     // Calculate the new state of packages (old_state + missing)
     let new_state_pkgs = {
-        let previous_state_pkgs = match active_state {
-            Some(id) => client.state_db.get(&id).await?.packages,
+        let previous_selections = match active_state {
+            Some(id) => client.state_db.get(&id).await?.selections,
             None => vec![],
         };
-        missing
-            .iter()
-            .map(|p| p.id.clone())
-            .chain(previous_state_pkgs)
+        let missing_selections = missing.iter().map(|p| Selection {
+            package: p.id.clone(),
+            // Package is explicit if it was one of the input
+            // packages provided by the user
+            explicit: input.iter().any(|id| *id == p.id),
+            reason: None,
+        });
+
+        missing_selections
+            .chain(previous_selections)
             .collect::<Vec<_>>()
     };
 

moss/src/cli/remove.rs

@@ -11,6 +11,7 @@ use moss::{
     client::{self, Client},
     package::Flags,
     registry::transaction,
+    state::Selection,
 };
 use thiserror::Error;
 use tui::{pretty::print_to_columns, Stylize};
@@ -93,10 +94,38 @@ pub async fn handle(args: &ArgMatches, root: &Path) -> Result<(), Error> {
         );
     }
 
+    // Map finalized state to a [`Selection`] by referencing
+    // it's value from the previous state
+    let new_state_pkgs = {
+        let previous_selections = match client.installation.active_state {
+            Some(id) => client.state_db.get(&id).await?.selections,
+            None => vec![],
+        };
+
+        finalized
+            .into_iter()
+            .map(|id| {
+                previous_selections
+                    .iter()
+                    .find(|s| s.package == id)
+                    .cloned()
+                    // Should be unreachable since new state from removal
+                    // is always a subset of the previous state
+                    .unwrap_or_else(|| {
+                        eprintln!("Unreachable: previous selection not found during removal for package {id:?}, marking as not explicit");
+
+                        Selection {
+                            package: id,
+                            explicit: false,
+                            reason: None,
+                        }
+                    })
+            })
+            .collect::<Vec<_>>()
+    };
+
     // Apply state
-    client
-        .apply_state(&finalized.into_iter().collect::<Vec<_>>(), "Remove")
-        .await?;
+    client.apply_state(&new_state_pkgs, "Remove").await?;
 
     Ok(())
 }

moss/src/cli/state.rs

@@ -77,7 +77,7 @@ fn print_state(state: state::State) {
     );
     // TODO: List packages?
     // TODO: Start with normal list, compute diff, reverse to print ?
-    println!("{} {}", "Packages:".bold(), state.packages.len());
+    println!("{} {}", "Packages:".bold(), state.selections.len());
     println!();
 }
 

moss/src/client/mod.rs

@@ -22,7 +22,9 @@ use self::prune::prune;
 use crate::{
     db, environment, package,
     registry::plugin::{self, Plugin},
-    repository, state, Installation, Package, Registry, State,
+    repository,
+    state::{self, Selection},
+    Installation, Package, Registry, State,
 };
 
 pub mod cache;
@@ -137,16 +139,17 @@ impl Client {
     /// Then blit the filesystem, promote it, finally archiving the active ID
     pub async fn apply_state(
         &self,
-        packages: &[package::Id],
+        selections: &[Selection],
         summary: impl ToString,
     ) -> Result<State, Error> {
         let old_state = self.installation.active_state;
-        self.blit_root(packages).await?;
+        self.blit_root(selections.iter().map(|s| &s.package))
+            .await?;
 
         // Add to db
         let state = self
             .state_db
-            .add(packages, Some(summary.to_string()), None)
+            .add(selections, Some(summary.to_string()), None)
             .await?;
 
         // Write state id
@@ -362,7 +365,10 @@ impl Client {
     }
 
     /// Blit the packages to a filesystem root
-    async fn blit_root(&self, packages: &[package::Id]) -> Result<(), Error> {
+    async fn blit_root(
+        &self,
+        packages: impl IntoIterator<Item = &package::Id>,
+    ) -> Result<(), Error> {
         let progress = ProgressBar::new(1).with_style(
             ProgressStyle::with_template("\n|{bar:20.red/blue}| {pos}/{len} {msg}")
                 .unwrap()
@@ -373,7 +379,7 @@ impl Client {
         progress.tick();
 
         let mut tbuild = TreeBuilder::new();
-        for id in packages {
+        for id in packages.into_iter() {
             let layouts = self.layout_db.query(id).await?;
             for layout in layouts {
                 tbuild.push(PendingFile {

moss/src/client/prune.rs

@@ -102,14 +102,18 @@ pub async fn prune(
         let state = state_db.get(status.id()).await?;
 
         // Increment each package
-        state.packages.iter().for_each(|pkg| {
-            *packages_counts.entry(pkg.clone()).or_default() += 1;
+        state.selections.iter().for_each(|selection| {
+            *packages_counts
+                .entry(selection.package.clone())
+                .or_default() += 1;
         });
 
         // Decrement if removal
         if status.is_removal() {
-            state.packages.iter().for_each(|pkg| {
-                *packages_counts.entry(pkg.clone()).or_default() -= 1;
+            state.selections.iter().for_each(|selection| {
+                *packages_counts
+                    .entry(selection.package.clone())
+                    .or_default() -= 1;
             });
             removals.push(state);
         }

moss/src/db/state/migrations/20230912172712_init.sql

@@ -7,9 +7,10 @@ CREATE TABLE IF NOT EXISTS state (
     description TEXT NULL
 );
 
-CREATE TABLE IF NOT EXISTS state_packages (
+CREATE TABLE IF NOT EXISTS state_selections (
     state_id INTEGER NOT NULL,  
     package_id TEXT NOT NULL,
+    explicit BOOLEAN NOT NULL,
     reason TEXT NULL,
     FOREIGN KEY(state_id) REFERENCES state(id) ON DELETE CASCADE
 );

moss/src/db/state/mod.rs

@@ -8,9 +8,8 @@ use sqlx::{Acquire, Executor, Pool, Sqlite};
 use thiserror::Error;
 
 use crate::db::Encoding;
-use crate::state::{self, Id};
-use crate::Installation;
-use crate::{package, State};
+use crate::state::{self, Id, Selection};
+use crate::{Installation, State};
 
 #[derive(Debug)]
 pub struct Database {
@@ -63,38 +62,44 @@ impl Database {
             ",
         )
         .bind(id.encode());
-        let packages_query = sqlx::query_as::<_, encoding::Package>(
+        let selections_query = sqlx::query_as::<_, encoding::Selection>(
             "
-            SELECT package_id
-            FROM state_packages
+            SELECT package_id,
+                   explicit,
+                   reason
+            FROM state_selections
             WHERE state_id = ?;
             ",
         )
         .bind(id.encode());
 
-        let (state, package_rows) = futures::try_join!(
+        let (state, selections_rows) = futures::try_join!(
             state_query.fetch_one(&self.pool),
-            packages_query.fetch_all(&self.pool)
+            selections_query.fetch_all(&self.pool)
         )?;
 
-        let packages = package_rows
+        let selections = selections_rows
             .into_iter()
-            .map(|row| row.package_id.0)
+            .map(|row| Selection {
+                package: row.package_id.0,
+                explicit: row.explicit,
+                reason: row.reason,
+            })
             .collect();
 
         Ok(State {
             id: state.id.0,
             summary: state.summary,
             description: state.description,
-            packages,
+            selections,
             created: state.created,
             kind: state.kind.0,
         })
     }
 
     pub async fn add(
         &self,
-        packages: &[package::Id],
+        selections: &[Selection],
         summary: Option<String>,
         description: Option<String>,
     ) -> Result<State, Error> {
@@ -113,18 +118,19 @@ impl Database {
         .fetch_one(transaction.acquire().await?)
         .await?;
 
-        if !packages.is_empty() {
+        if !selections.is_empty() {
             transaction
                 .execute(
                     sqlx::QueryBuilder::new(
                         "
-                    INSERT INTO state_packages (state_id, package_id, reason)
+                    INSERT INTO state_selections (state_id, package_id, explicit, reason)
                     ",
                     )
-                    .push_values(packages, |mut b, package| {
+                    .push_values(selections, |mut b, selection| {
                         b.push_bind(id.0.encode())
-                            .push_bind(package.encode())
-                            .push_bind(Option::<String>::None);
+                            .push_bind(selection.package.encode())
+                            .push_bind(selection.explicit)
+                            .push_bind(selection.reason.as_ref());
                     })
                     .build(),
                 )
@@ -202,8 +208,10 @@ mod encoding {
     }
 
     #[derive(FromRow)]
-    pub struct Package {
+    pub struct Selection {
         pub package_id: Decoder<package::Id>,
+        pub explicit: bool,
+        pub reason: Option<String>,
     }
 }
 
@@ -214,6 +222,7 @@ mod test {
     use chrono::Utc;
 
     use super::*;
+    use crate::package;
 
     #[tokio::test]
     async fn create_insert_select() {
@@ -222,15 +231,15 @@ mod test {
                 .await
                 .unwrap();
 
-        let packages = vec![
-            package::Id::from("pkg a".to_string()),
-            package::Id::from("pkg b".to_string()),
-            package::Id::from("pkg c".to_string()),
+        let selections = vec![
+            Selection::explicit(package::Id::from("pkg a".to_string())),
+            Selection::explicit(package::Id::from("pkg a".to_string())),
+            Selection::explicit(package::Id::from("pkg a".to_string())),
         ];
 
         let state = database
             .add(
-                &packages,
+                &selections,
                 Some("test".to_string()),
                 Some("test".to_string()),
             )
@@ -248,6 +257,6 @@ mod test {
         assert_eq!(state.summary.as_deref(), Some("test"));
         assert_eq!(state.description.as_deref(), Some("test"));
 
-        assert_eq!(state.packages, packages);
+        assert_eq!(state.selections, selections);
     }
 }

moss/src/package/mod.rs

@@ -90,6 +90,8 @@ bitflags! {
         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;
     }
 }