Works on remaining missing tests

.github/actions/prepare-node/action.yml

@@ -33,6 +33,11 @@ runs:
         chmod +x ${{inputs.link}}
         yarn switch link ${{inputs.link}}
 
+    - name: Install pnpm
+      shell: bash
+      run: |
+        npm install --global pnpm@10
+
     - name: Install dependencies
       shell: bash
       run: |

packages/zpm-config/schema.json

@@ -76,6 +76,11 @@
       "description": "Whether to keep the packages in a global cache rather than inside the project",
       "default": true
     },
+    "enableMirror": {
+      "type": "boolean",
+      "description": "Whether to mirror local cache entries into the global cache",
+      "default": true
+    },
     "enableLocalCacheCleanup": {
       "type": "boolean",
       "description": "Whether to remove unused packages from the local cache after each install",
@@ -196,16 +201,33 @@
       "type": ["string", "null"],
       "description": "Define a proxy to use when making an HTTPS request"
     },
-    "localCacheFolderName": {
-      "type": "string",
-      "description": "The name of the folder where the local cache will be stored inside the .yarn folder",
-      "default": "cache"
-    },
     "networkConcurrency": {
       "type": "usize",
       "description": "The number of concurrent network requests Yarn can perform",
       "default": 100
     },
+    "logFilters": {
+      "type": "array",
+      "description": "Filters that can discard log entries or change their reported level",
+      "items": {
+        "type": "object",
+        "title": "LogFilter",
+        "properties": {
+          "text": {
+            "type": ["string", "null"],
+            "description": "Exact log text to match"
+          },
+          "pattern": {
+            "type": ["zpm_utils::Glob", "null"],
+            "description": "Glob pattern to match against log text"
+          },
+          "level": {
+            "type": "crate::types::LogLevel",
+            "description": "Level to assign to matching log entries"
+          }
+        }
+      }
+    },
     "networkSettings": {
       "type": "object",
       "description": "Configuration specific to each network setting",
@@ -219,6 +241,18 @@
           "enableNetwork": {
             "type": ["boolean", "null"],
             "description": "Whether to allow network access for this specific glob"
+          },
+          "httpsCaFilePath": {
+            "type": ["zpm_utils::Path", "null"],
+            "description": "Path to a file containing one or multiple Certificate Authority signing certificates"
+          },
+          "httpsCertFilePath": {
+            "type": ["zpm_utils::Path", "null"],
+            "description": "Path to a file containing a certificate chain in PEM format"
+          },
+          "httpsKeyFilePath": {
+            "type": ["zpm_utils::Path", "null"],
+            "description": "Path to a file containing a private key in PEM format"
           }
         }
       }
@@ -464,6 +498,11 @@
       "description": "Whether to use interactive prompts by default when running yarn commands",
       "default": false
     },
+    "preferTruncatedLines": {
+      "type": "boolean",
+      "description": "Whether to prefer truncating lines in the terminal output",
+      "default": false
+    },
     "preferReuse": {
       "type": "boolean",
       "description": "Whether to prefer reusing dependencies from the lockfile when running `yarn add`",

packages/zpm-config/src/lib.rs

@@ -1,4 +1,4 @@
-use std::{collections::BTreeMap, fmt::Display, ops::Deref, sync::Arc, time::UNIX_EPOCH};
+use std::{collections::{BTreeMap, BTreeSet}, fmt::Display, ops::Deref, sync::Arc, time::UNIX_EPOCH};
 
 use serde::{Deserialize, Deserializer, Serialize, Serializer, de};
 use zpm_utils::{AbstractValue, Container, Cpu, DataType, FromFileString, IoResultExt, LastModifiedAt, Libc, Os, Path, RawString, Serialized, System, ToFileString, ToHumanString, tree};
@@ -900,6 +900,145 @@ struct RcFile {
     text: Option<String>,
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum ConflictMode {
+    Extend,
+    Reset,
+}
+
+fn parse_conflict_mode(value: &serde_yaml::Value) -> Option<ConflictMode> {
+    let serde_yaml::Value::String(value) = value else {
+        return None;
+    };
+
+    match value.as_str() {
+        "extend" => Some(ConflictMode::Extend),
+        "reset" => Some(ConflictMode::Reset),
+        _ => None,
+    }
+}
+
+fn normalize_conflict_metadata(value: &mut serde_yaml::Value) -> (Option<ConflictMode>, BTreeMap<String, ConflictMode>) {
+    let serde_yaml::Value::Mapping(mapping) = value else {
+        return (None, BTreeMap::new());
+    };
+
+    let on_conflict_key
+        = serde_yaml::Value::String("onConflict".to_string());
+    let value_key
+        = serde_yaml::Value::String("value".to_string());
+
+    let root_mode
+        = mapping.remove(&on_conflict_key)
+            .as_ref()
+            .and_then(parse_conflict_mode);
+
+    let mut field_modes
+        = BTreeMap::new();
+
+    let mut fields_to_remove
+        = Vec::new();
+
+    for (key, field_value) in mapping.iter_mut() {
+        let serde_yaml::Value::String(key) = key else {
+            continue;
+        };
+
+        let serde_yaml::Value::Mapping(field_mapping) = field_value else {
+            continue;
+        };
+
+        let Some(mode) = field_mapping
+            .remove(&on_conflict_key)
+            .as_ref()
+            .and_then(parse_conflict_mode) else {
+                continue;
+            };
+
+        field_modes.insert(key.clone(), mode);
+
+        if let Some(value) = field_mapping.remove(&value_key) {
+            *field_value = value;
+        } else if field_mapping.is_empty() {
+            fields_to_remove.push(key.clone());
+        }
+    }
+
+    for key in fields_to_remove {
+        mapping.remove(serde_yaml::Value::String(key));
+    }
+
+    (root_mode, field_modes)
+}
+
+fn retain_user_conflict_fields(value: &mut serde_yaml::Value, root_mode: Option<ConflictMode>, field_modes: &BTreeMap<String, ConflictMode>) {
+    let serde_yaml::Value::Mapping(mapping) = value else {
+        return;
+    };
+
+    let retained_fields = field_modes
+        .iter()
+        .filter_map(|(key, mode)| (*mode == ConflictMode::Extend).then_some(key.as_str()))
+        .collect::<BTreeSet<_>>();
+
+    if root_mode == Some(ConflictMode::Reset) {
+        mapping.retain(|key, _| {
+            let serde_yaml::Value::String(key) = key else {
+                return false;
+            };
+
+            retained_fields.contains(key.as_str())
+        });
+    } else {
+        for (key, mode) in field_modes {
+            if *mode == ConflictMode::Reset {
+                mapping.remove(serde_yaml::Value::String(key.clone()));
+            }
+        }
+    }
+}
+
+fn deserialize_rc_pair(user_rc: Option<&RcFile>, project_rc: Option<&RcFile>) -> Result<(Partial<intermediate::Settings>, Partial<intermediate::Settings>), ConfigurationError> {
+    let mut user_value = user_rc
+        .and_then(|rc| rc.text.as_ref())
+        .map(|text| serde_yaml::from_str::<serde_yaml::Value>(text))
+        .transpose()?;
+
+    let mut project_value = project_rc
+        .and_then(|rc| rc.text.as_ref())
+        .map(|text| serde_yaml::from_str::<serde_yaml::Value>(text))
+        .transpose()?;
+
+    let user_field_modes = user_value
+        .as_mut()
+        .map(normalize_conflict_metadata);
+
+    if let Some((root_mode, field_modes)) = user_field_modes {
+        retain_user_conflict_fields(user_value.as_mut().unwrap(), root_mode, &field_modes);
+    }
+
+    let (project_root_mode, project_field_modes) = project_value
+        .as_mut()
+        .map(normalize_conflict_metadata)
+        .unwrap_or((None, BTreeMap::new()));
+
+    if let Some(user_value) = user_value.as_mut() {
+        retain_user_conflict_fields(user_value, project_root_mode, &project_field_modes);
+    }
+
+    let user = match user_value {
+        Some(value) => Partial::Value(serde_yaml::from_value(value)?),
+        None => Partial::Missing,
+    };
+
+    let project = match project_value {
+        Some(value) => Partial::Value(serde_yaml::from_value(value)?),
+        None => Partial::Missing,
+    };
+
+    Ok((user, project))
+}
+
 impl RcFile {
     fn try_read(dir: Option<&Path>, rc_filename: &str, last_modified_at: &mut LastModifiedAt) -> Result<Option<Self>, ConfigurationError> {
         let Some(dir) = dir else {
@@ -930,12 +1069,6 @@ impl RcFile {
         Ok(Some(RcFile {path, text: Some(text)}))
     }
 
-    fn deserialize(&self) -> Option<Result<intermediate::Settings, ConfigurationError>> {
-        self.text.as_ref().map(|text| {
-            Ok(serde_yaml::from_str(text)?)
-        })
-    }
-
     /// Extract the `injectEnvironmentFiles` value from the raw YAML text.
     /// Uses a minimal struct to avoid full deserialization, which would fail
     /// if config values reference env vars not yet loaded from .env files.
@@ -1079,15 +1212,8 @@ impl Configuration {
             = project_rc.as_ref()
                 .map(|rc| rc.path.clone());
 
-        let intermediate_user_config = match user_rc.and_then(|rc| rc.deserialize()) {
-            Some(result) => Partial::Value(result?),
-            None => Partial::Missing,
-        };
-
-        let intermediate_project_config = match project_rc.and_then(|rc| rc.deserialize()) {
-            Some(result) => Partial::Value(result?),
-            None => Partial::Missing,
-        };
+        let (intermediate_user_config, intermediate_project_config)
+            = deserialize_rc_pair(user_rc.as_ref(), project_rc.as_ref())?;
 
         let mut settings = Settings::merge(
             &enriched_context,
@@ -1189,10 +1315,12 @@ merge_settings!(crate::types::PnpFallbackMode, |s: &str| FromFileString::from_fi
 merge_settings!(crate::types::NmHoistingLimits, |s: &str| FromFileString::from_file_string(s).unwrap());
 merge_settings!(crate::types::NmMode, |s: &str| FromFileString::from_file_string(s).unwrap());
 merge_settings!(crate::types::WinLinkType, |s: &str| FromFileString::from_file_string(s).unwrap());
+merge_settings!(crate::types::LogLevel, |s: &str| FromFileString::from_file_string(s).unwrap());
 merge_optional_settings!(crate::types::NodeLinker);
 merge_optional_settings!(crate::types::IslandLinker);
 merge_optional_settings!(crate::types::PnpFallbackMode);
 merge_optional_settings!(crate::types::NmHoistingLimits);
 merge_optional_settings!(crate::types::NmMode);
 merge_optional_settings!(crate::types::WinLinkType);
+merge_optional_settings!(crate::types::LogLevel);
 merge_optional_settings!(Path);

packages/zpm-config/src/types.rs

@@ -86,3 +86,19 @@ pub enum WinLinkType {
     #[literal("junctions")]
     Junctions,
 }
+
+#[zpm_enum(error = ConfigurationError, or_else = |s| Err(ConfigurationError::EnumError(s.to_string())))]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum LogLevel {
+    #[literal("discard")]
+    Discard,
+
+    #[literal("info")]
+    Info,
+
+    #[literal("warning")]
+    Warning,
+
+    #[literal("error")]
+    ErrorLevel,
+}

packages/zpm-parsers/src/yaml_doc.rs

@@ -302,8 +302,15 @@ impl YamlDocument {
     }
 
     fn insert_top_level_key(&mut self, new_key: &str, value: Value) -> Result<(), Error> {
+        let (self_indent, style)
+            = self.paths.iter()
+                .filter(|(path, _)| path.is_direct_child_of(&Path::new()))
+                .filter_map(|(_, offset)| self.find_indent_at(*offset))
+                .min_by_key(|(indent, _)| *indent)
+                .unwrap_or((0, IndentStyle::Spaces));
+
         let top_level_indent
-            = Indent::with_style(Some(0), Some(2), IndentStyle::Spaces);
+            = Indent::with_style(Some(self_indent), Some(self_indent + 2), style);
 
         self.insert_at(0, &Path::new(), new_key, top_level_indent, value)
     }
@@ -1123,6 +1130,7 @@ mod tests {
 
     // Insert new top-level keys
     #[case(b"existing: value\n", vec!["new_key"], Value::String("another".to_string()), b"existing: value\nnew_key: another\n")]
+    #[case(b"        existing: value\n", vec!["new_key"], Value::String("another".to_string()), b"        existing: value\n        new_key: another\n")]
 
     // Insert nested keys
     #[case(b"parent:\n  existing: value\n", vec!["parent", "new_child"], Value::String("new".to_string()), b"parent:\n  existing: value\n  new_child: new\n")]