rename managed to required

ripytide · Dec 23, 2024 · e469a27 · e469a27
1 parent e1483fd
commit e469a27
Show file tree

Hide file tree

Showing 15 changed files with 55 additions and 55 deletions.
diff --git a/src/backends/all.rs b/src/backends/all.rs
@@ -173,10 +173,10 @@ macro_rules! options {
             is_empty!($(($upper_backend, $lower_backend)),*);
             to_package_ids!($(($upper_backend, $lower_backend)),*);
 
-            pub fn map_managed_packages(mut self, config: &Config) -> Result<Self> {
+            pub fn map_required(mut self, config: &Config) -> Result<Self> {
                 $(
                     if is_enabled(AnyBackend::$upper_backend, config) {
-                        self.$lower_backend = $upper_backend::map_managed_packages(self.$lower_backend, config)?;
+                        self.$lower_backend = $upper_backend::map_required(self.$lower_backend, config)?;
                     }
                 )*
 

diff --git a/src/backends/apt.rs b/src/backends/apt.rs
@@ -15,7 +15,7 @@ pub struct AptOptions {}
 impl Backend for Apt {
     type Options = AptOptions;
 
-    fn map_managed_packages(
+    fn map_required(
         packages: BTreeMap<String, Self::Options>,
         _: &Config,
     ) -> Result<BTreeMap<String, Self::Options>> {
@@ -84,12 +84,12 @@ impl Backend for Apt {
     }
 
     fn missing(
-        managed: Self::Options,
+        required: Self::Options,
         installed: Option<Self::Options>,
     ) -> Option<Self::Options> {
         match installed {
             Some(_) => None,
-            None => Some(managed),
+            None => Some(required),
         }
     }
 }
diff --git a/src/backends/arch.rs b/src/backends/arch.rs
@@ -16,7 +16,7 @@ pub struct ArchOptions {}
 impl Backend for Arch {
     type Options = ArchOptions;
 
-    fn map_managed_packages(
+    fn map_required(
         mut packages: BTreeMap<String, Self::Options>,
         config: &Config,
     ) -> Result<BTreeMap<String, Self::Options>> {
@@ -235,10 +235,10 @@ impl Backend for Arch {
         )
     }
 
-    fn missing(managed: Self::Options, installed: Option<Self::Options>) -> Option<Self::Options> {
+    fn missing(required: Self::Options, installed: Option<Self::Options>) -> Option<Self::Options> {
         match installed {
             Some(_) => None,
-            None => Some(managed),
+            None => Some(required),
         }
     }
 }
diff --git a/src/backends/brew.rs b/src/backends/brew.rs
@@ -15,7 +15,7 @@ pub struct BrewOptions {}
 impl Backend for Brew {
     type Options = BrewOptions;
 
-    fn map_managed_packages(
+    fn map_required(
         packages: BTreeMap<String, Self::Options>,
         _: &Config,
     ) -> Result<BTreeMap<String, Self::Options>> {
@@ -80,12 +80,12 @@ impl Backend for Brew {
     }
 
     fn missing(
-        managed: Self::Options,
+        required: Self::Options,
         installed: Option<Self::Options>,
     ) -> Option<Self::Options> {
         match installed {
             Some(_) => None,
-            None => Some(managed),
+            None => Some(required),
         }
     }
 }
diff --git a/src/backends/cargo.rs b/src/backends/cargo.rs
@@ -31,7 +31,7 @@ pub struct CargoOptions {
 impl Backend for Cargo {
     type Options = CargoOptions;
 
-    fn map_managed_packages(
+    fn map_required(
         packages: BTreeMap<String, Self::Options>,
         _: &Config,
     ) -> Result<BTreeMap<String, Self::Options>> {
@@ -117,10 +117,10 @@ impl Backend for Cargo {
         run_command_for_stdout(["cargo", "--version"], Perms::Same, false)
     }
 
-    fn missing(managed: Self::Options, installed: Option<Self::Options>) -> Option<Self::Options> {
+    fn missing(required: Self::Options, installed: Option<Self::Options>) -> Option<Self::Options> {
         match installed {
             Some(_) => None,
-            None => Some(managed),
+            None => Some(required),
         }
     }
 }

diff --git a/src/backends/dnf.rs b/src/backends/dnf.rs
@@ -18,7 +18,7 @@ pub struct DnfOptions {
 impl Backend for Dnf {
     type Options = DnfOptions;
 
-    fn map_managed_packages(
+    fn map_required(
         packages: BTreeMap<String, Self::Options>,
         _: &Config,
     ) -> Result<BTreeMap<String, Self::Options>> {
@@ -129,10 +129,10 @@ impl Backend for Dnf {
         run_command_for_stdout(["dnf", "--version"], Perms::Same, false)
     }
 
-    fn missing(managed: Self::Options, installed: Option<Self::Options>) -> Option<Self::Options> {
+    fn missing(required: Self::Options, installed: Option<Self::Options>) -> Option<Self::Options> {
         match installed {
             Some(_) => None,
-            None => Some(managed),
+            None => Some(required),
         }
     }
 }

diff --git a/src/backends/flatpak.rs b/src/backends/flatpak.rs
@@ -19,7 +19,7 @@ pub struct FlatpakOptions {
 impl Backend for Flatpak {
     type Options = FlatpakOptions;
 
-    fn map_managed_packages(
+    fn map_required(
         packages: BTreeMap<String, Self::Options>,
         _: &Config,
     ) -> Result<BTreeMap<String, Self::Options>> {
@@ -202,10 +202,10 @@ impl Backend for Flatpak {
         run_command_for_stdout(["flatpak", "--version"], Perms::Same, false)
     }
 
-    fn missing(managed: Self::Options, installed: Option<Self::Options>) -> Option<Self::Options> {
+    fn missing(required: Self::Options, installed: Option<Self::Options>) -> Option<Self::Options> {
         match installed {
             Some(_) => None,
-            None => Some(managed),
+            None => Some(required),
         }
     }
 }
diff --git a/src/backends/mod.rs b/src/backends/mod.rs
@@ -43,7 +43,7 @@ pub struct StringPackageStruct {
 pub trait Backend {
     type Options;
 
-    fn map_managed_packages(
+    fn map_required(
         packages: BTreeMap<String, Self::Options>,
         config: &Config,
     ) -> Result<BTreeMap<String, Self::Options>>;
@@ -66,5 +66,5 @@ pub trait Backend {
 
     fn version(config: &Config) -> Result<String>;
 
-    fn missing(managed: Self::Options, installed: Option<Self::Options>) -> Option<Self::Options>;
+    fn missing(required: Self::Options, installed: Option<Self::Options>) -> Option<Self::Options>;
 }
diff --git a/src/backends/pipx.rs b/src/backends/pipx.rs
@@ -20,7 +20,7 @@ pub struct PipxOptions {}
 impl Backend for Pipx {
     type Options = PipxOptions;
 
-    fn map_managed_packages(
+    fn map_required(
         packages: BTreeMap<String, Self::Options>,
         _: &Config,
     ) -> Result<BTreeMap<String, Self::Options>> {
@@ -83,12 +83,12 @@ impl Backend for Pipx {
     }
 
     fn missing(
-        managed: Self::Options,
+        required: Self::Options,
         installed: Option<Self::Options>,
     ) -> Option<Self::Options> {
         match installed {
             Some(_) => None,
-            None => Some(managed),
+            None => Some(required),
         }
     }
 }

diff --git a/src/backends/rustup.rs b/src/backends/rustup.rs
@@ -21,7 +21,7 @@ pub struct RustupOptions {
 impl Backend for Rustup {
     type Options = RustupOptions;
 
-    fn map_managed_packages(
+    fn map_required(
         packages: BTreeMap<String, Self::Options>,
         _: &Config,
     ) -> Result<BTreeMap<String, Self::Options>> {
@@ -123,10 +123,10 @@ impl Backend for Rustup {
         run_command_for_stdout(["rustup", "--version"], Perms::Same, true)
     }
 
-    fn missing(managed: Self::Options, installed: Option<Self::Options>) -> Option<Self::Options> {
+    fn missing(required: Self::Options, installed: Option<Self::Options>) -> Option<Self::Options> {
         match installed {
             Some(installed) => {
-                let missing = managed
+                let missing = required
                     .components
                     .difference(&installed.components)
                     .cloned()
@@ -139,7 +139,7 @@ impl Backend for Rustup {
                     })
                 }
             }
-            None => Some(managed),
+            None => Some(required),
         }
     }
 }
diff --git a/src/backends/snap.rs b/src/backends/snap.rs
@@ -15,7 +15,7 @@ pub struct SnapOptions {}
 impl Backend for Snap {
     type Options = SnapOptions;
 
-    fn map_managed_packages(
+    fn map_required(
         packages: BTreeMap<String, Self::Options>,
         _: &Config,
     ) -> Result<BTreeMap<String, Self::Options>> {
@@ -86,10 +86,10 @@ impl Backend for Snap {
         })
     }
 
-    fn missing(managed: Self::Options, installed: Option<Self::Options>) -> Option<Self::Options> {
+    fn missing(required: Self::Options, installed: Option<Self::Options>) -> Option<Self::Options> {
         match installed {
             Some(_) => None,
-            None => Some(managed),
+            None => Some(required),
         }
     }
 }
diff --git a/src/backends/winget.rs b/src/backends/winget.rs
@@ -17,7 +17,7 @@ pub struct WinGetOptions {}
 impl Backend for WinGet {
     type Options = WinGetOptions;
 
-    fn map_managed_packages(
+    fn map_required(
         packages: BTreeMap<String, Self::Options>,
         _: &Config,
     ) -> Result<BTreeMap<String, Self::Options>> {
@@ -102,12 +102,12 @@ impl Backend for WinGet {
     }
 
     fn missing(
-        managed: Self::Options,
+        required: Self::Options,
         installed: Option<Self::Options>,
     ) -> Option<Self::Options> {
         match installed {
             Some(_) => None,
-            None => Some(managed),
+            None => Some(required),
         }
     }
 }
diff --git a/src/backends/xbps.rs b/src/backends/xbps.rs
@@ -17,7 +17,7 @@ pub struct XbpsOptions {}
 impl Backend for Xbps {
     type Options = XbpsOptions;
 
-    fn map_managed_packages(
+    fn map_required(
         packages: BTreeMap<String, Self::Options>,
         _: &Config,
     ) -> Result<BTreeMap<String, Self::Options>> {
@@ -96,12 +96,12 @@ impl Backend for Xbps {
     }
 
     fn missing(
-        managed: Self::Options,
+        required: Self::Options,
         installed: Option<Self::Options>,
     ) -> Option<Self::Options> {
         match installed {
             Some(_) => None,
-            None => Some(managed),
+            None => Some(required),
         }
     }
 }
diff --git a/src/cli.rs b/src/cli.rs
@@ -76,7 +76,7 @@ pub struct SyncCommand {
 
 #[derive(Args)]
 #[command(visible_alias("u"))]
-/// show explicitly installed packages not managed by metapac
+/// show explicitly installed packages not required by metapac
 ///
 /// the output is in valid toml group file format to allow writing
 /// the output to a file which can help in importing packages

diff --git a/src/core.rs b/src/core.rs
@@ -36,23 +36,23 @@ impl MainArguments {
         let groups = Groups::load(&group_dir, &hostname, &config)
             .wrap_err("failed to load package install options from groups")?;
 
-        let managed = groups.to_options().map_managed_packages(&config)?;
+        let required = groups.to_options().map_required(&config)?;
 
         match self.subcommand {
-            MainSubcommand::Clean(clean) => clean.run(&managed, &config),
+            MainSubcommand::Clean(clean) => clean.run(&required, &config),
             MainSubcommand::Add(add) => add.run(&group_dir, &groups),
-            MainSubcommand::Review(review) => review.run(&managed, &config),
-            MainSubcommand::Sync(sync) => sync.run(&managed, &config),
-            MainSubcommand::Unmanaged(unmanaged) => unmanaged.run(&managed, &config),
+            MainSubcommand::Review(review) => review.run(&required, &config),
+            MainSubcommand::Sync(sync) => sync.run(&required, &config),
+            MainSubcommand::Unmanaged(unmanaged) => unmanaged.run(&required, &config),
             MainSubcommand::Backends(found_backends) => found_backends.run(&config),
             MainSubcommand::CleanCache(backends) => backends.run(&config),
         }
     }
 }
 
 impl CleanCommand {
-    fn run(self, managed: &Options, config: &Config) -> Result<()> {
-        let unmanaged = unmanaged(managed, config)?;
+    fn run(self, required: &Options, config: &Config) -> Result<()> {
+        let unmanaged = unmanaged(required, config)?;
 
         if unmanaged.is_empty() {
             eprintln!("nothing to clean since there are no unmanaged packages");
@@ -133,8 +133,8 @@ impl ReviewCommand {
 }
 
 impl SyncCommand {
-    fn run(self, managed: &Options, config: &Config) -> Result<()> {
-        let missing = missing(managed, config)?;
+    fn run(self, required: &Options, config: &Config) -> Result<()> {
+        let missing = missing(required, config)?;
 
         if missing.is_empty() {
             log::info!("nothing to do as there are no missing packages");
@@ -162,8 +162,8 @@ impl SyncCommand {
 }
 
 impl UnmanagedCommand {
-    fn run(self, managed: &Options, config: &Config) -> Result<()> {
-        let unmanaged = unmanaged(managed, config)?;
+    fn run(self, required: &Options, config: &Config) -> Result<()> {
+        let unmanaged = unmanaged(required, config)?;
 
         if unmanaged.is_empty() {
             eprintln!("no unmanaged packages");
@@ -217,21 +217,21 @@ impl CleanCacheCommand {
     }
 }
 
-fn unmanaged(managed: &Options, config: &Config) -> Result<PackageIds> {
+fn unmanaged(required: &Options, config: &Config) -> Result<PackageIds> {
     Options::query(config)
-        .map(|x| x.to_package_ids().difference(&managed.to_package_ids()))
+        .map(|x| x.to_package_ids().difference(&required.to_package_ids()))
 }
-fn missing(managed: &Options, config: &Config) -> Result<Options> {
+fn missing(required: &Options, config: &Config) -> Result<Options> {
     let installed = Options::query(config)?;
 
     let mut missing = Options::default();
 
     macro_rules! x {
         ($(($upper_backend:ident, $lower_backend:ident)),*) => {
             $(
-                for (package_id, managed_options) in managed.$lower_backend.iter() {
+                for (package_id, required_options) in required.$lower_backend.iter() {
                     if let Some(missing_options) =
-                        $upper_backend::missing(managed_options.clone(), installed.$lower_backend.get(package_id).cloned())
+                        $upper_backend::missing(required_options.clone(), installed.$lower_backend.get(package_id).cloned())
                     {
                         missing.$lower_backend.insert(package_id.clone(), missing_options);
                     }