moss: Add flag to disable system-model warning

Author: tarkah

moss/src/cli/mod.rs

@@ -161,6 +161,7 @@ pub fn process() -> Result<(), Error> {
     let matches = command().get_matches_from(args);
 
     let show_version = matches.get_one::<bool>("version").is_some_and(|v| *v);
+    let verbose = matches.get_flag("verbose");
 
     if show_version {
         println!("moss {}", tools_buildinfo::get_full_version());
@@ -185,7 +186,7 @@ pub fn process() -> Result<(), Error> {
     }
 
     // Print the version, but not if the user is using the version subcommand
-    if matches.get_flag("verbose")
+    if verbose
         && let Some(command) = matches.subcommand_name()
         && command != "version"
     {
@@ -197,8 +198,12 @@ pub fn process() -> Result<(), Error> {
 
     let installation = Installation::open(root, cache.cloned())?;
 
-    if installation.system_model.is_some() {
-        print_system_model_warning(&installation);
+    if let Some(system_model) = installation.system_model.as_ref() {
+        if !system_model.disable_warning {
+            print_system_model_warning(&installation, false);
+        } else if verbose {
+            print_system_model_warning(&installation, true);
+        }
     }
 
     match matches.subcommand() {
@@ -265,20 +270,23 @@ fn replace_aliases(args: env::Args) -> Vec<String> {
     args
 }
 
-fn print_system_model_warning(installation: &Installation) {
-    eprintln!(
-        "{}: {path:?} is present & therefore active.
-Hence:
+fn print_system_model_warning(installation: &Installation, first_line_only: bool) {
+    let path = installation.system_model_path();
+
+    eprintln!("{}: {path:?} is present & therefore active.", "INFO".green());
+
+    if !first_line_only {
+        eprintln!(
+            "Hence:
 - The system-model is the source of truth and defines all
   repositories & installed packages.
 - Any changes made via `moss` commands will be temporary
   until the system-model is updated.
 - The system state can be reverted to match the system-model state
   by doing a `moss sync`.
 - To disable the system-model, remove or rename {path:?}.",
-        "INFO".green(),
-        path = installation.system_model_path(),
-    );
+        );
+    }
 }
 
 #[derive(Debug, Error)]

moss/src/system_model.rs

@@ -16,6 +16,7 @@ mod update;
 
 #[derive(Debug, Clone)]
 pub struct SystemModel {
+    pub disable_warning: bool,
     pub repositories: repository::Map,
     pub packages: BTreeSet<dependency::Provider>,
     encoded: String,
@@ -43,6 +44,7 @@ pub fn create(repositories: repository::Map, packages: BTreeSet<dependency::Prov
     let encoded = encode(&repositories, &packages);
 
     SystemModel {
+        disable_warning: false,
         repositories,
         packages,
         encoded,

moss/src/system_model/decode.rs

@@ -6,6 +6,15 @@ use crate::{Provider, Repository, SystemModel, dependency, repository};
 pub fn decode(content: &str) -> Result<SystemModel, Error> {
     let document: KdlDocument = content.parse().map_err(Error::ParseKdlDocument)?;
 
+    let disable_warning = document
+        .get_arg("disable_warning")
+        .map(|value| {
+            value
+                .as_bool()
+                .ok_or(Error::InvalidRootValue("disable_warning", "bool", value.to_string()))
+        })
+        .transpose()?;
+
     let packages = document
         .get("packages")
         .map(|node| node.iter_children().map(decode_package).collect::<Result<_, _>>())
@@ -19,6 +28,7 @@ pub fn decode(content: &str) -> Result<SystemModel, Error> {
         .unwrap_or_default();
 
     Ok(SystemModel {
+        disable_warning: disable_warning.unwrap_or_default(),
         repositories,
         packages,
         encoded: content.to_owned(),
@@ -35,7 +45,7 @@ fn decode_repository(node: &KdlNode) -> Result<(repository::Id, Repository), Err
 
     let description = get_child_value(node, "description")
         .map(|value| {
-            value.as_string().ok_or(Error::InvalidValue(
+            value.as_string().ok_or(Error::InvalidNodeValue(
                 "repository",
                 name.to_owned(),
                 "description",
@@ -47,7 +57,7 @@ fn decode_repository(node: &KdlNode) -> Result<(repository::Id, Repository), Err
         .unwrap_or_default();
     let uri = get_child_value(node, "uri")
         .map(|value| {
-            value.as_string().ok_or(Error::InvalidValue(
+            value.as_string().ok_or(Error::InvalidNodeValue(
                 "repository",
                 name.to_owned(),
                 "uri",
@@ -61,7 +71,7 @@ fn decode_repository(node: &KdlNode) -> Result<(repository::Id, Repository), Err
         .map_err(|err| Error::ParseRepositoryUri(err, name.to_owned()))?;
     let enabled = get_child_value(node, "enabled")
         .map(|value| {
-            value.as_bool().ok_or(Error::InvalidValue(
+            value.as_bool().ok_or(Error::InvalidNodeValue(
                 "repository",
                 name.to_owned(),
                 "uri",
@@ -73,7 +83,7 @@ fn decode_repository(node: &KdlNode) -> Result<(repository::Id, Repository), Err
         .unwrap_or(true);
     let priority = get_child_value(node, "priority")
         .map(|value| {
-            let int = value.as_integer().ok_or(Error::InvalidValue(
+            let int = value.as_integer().ok_or(Error::InvalidNodeValue(
                 "repository",
                 name.to_owned(),
                 "priority",
@@ -106,8 +116,10 @@ fn get_child_value<'a>(node: &'a KdlNode, name: &str) -> Option<&'a KdlValue> {
 
 #[derive(Debug, Error)]
 pub enum Error {
+    #[error("invalid value for {0}, expected {1} got {2}")]
+    InvalidRootValue(&'static str, &'static str, String),
     #[error("invalid value for {0} {1} {2}, expected {3} got {4}")]
-    InvalidValue(&'static str, String, &'static str, &'static str, String),
+    InvalidNodeValue(&'static str, String, &'static str, &'static str, String),
     #[error("missing {0} for {1} {2}")]
     MissingValue(&'static str, &'static str, String),
     #[error("parse as kdl document")]