refactor(package): expose package config layers

Author: HaoZeke

src/main.rs

@@ -7,7 +7,7 @@ use eb_stack::campaign::{
     CampaignStatus, FindingResolution,
 };
 use eb_stack::package::{StackPolicy, STACK_POLICY_SCHEMA_VERSION};
-use eb_stack::package_config::ProfileConfigLayer;
+use eb_stack::package_config::PackageConfigLayer;
 use eb_stack::target::{doctor_target, resolve_target_layers, BuildTarget, TargetConfigLayer};
 use eb_stack::{
     check_recipe_deps, format_style, format_style_file, inspect_new_package, lint_style,
@@ -82,8 +82,8 @@ struct PackageInspectArgs {
     toolchain_name: String,
     #[arg(long)]
     toolchain_version: String,
-    #[arg(long = "profile-config")]
-    profile_configs: Vec<PathBuf>,
+    #[arg(long = "package-config")]
+    package_configs: Vec<PathBuf>,
     #[arg(long)]
     out_dir: PathBuf,
 }
@@ -273,7 +273,7 @@ fn run_package(command: PackageCommand) -> Result<()> {
     match command {
         PackageCommand::Inspect(args) => {
             let toolchain = toolchain(&args.toolchain_name, &args.toolchain_version);
-            let layers = load_profile_layers(&args.profile_configs)?;
+            let layers = load_package_layers(&args.package_configs)?;
             let (plan, sbom) = inspect_new_package(
                 &args.source,
                 parse_format(&args.format)?,
@@ -304,7 +304,7 @@ fn run_package(command: PackageCommand) -> Result<()> {
                 format: parse_format(&args.inspect.format)?,
                 toolchain,
                 source_checksums: args.source_checksums,
-                profile_layers: load_profile_layers(&args.inspect.profile_configs)?,
+                package_layers: load_package_layers(&args.inspect.package_configs)?,
                 easyconfig_roots: args.easyconfigs,
                 stack_policy,
             })?;
@@ -581,11 +581,11 @@ fn parse_format(value: &str) -> Result<Option<ForeignFormat>> {
     }
 }
 
-fn load_profile_layers(paths: &[PathBuf]) -> Result<Vec<ProfileConfigLayer>> {
+fn load_package_layers(paths: &[PathBuf]) -> Result<Vec<PackageConfigLayer>> {
     paths
         .iter()
         .map(|path| {
-            ProfileConfigLayer::from_path(path)
+            PackageConfigLayer::from_path(path)
                 .with_context(|| format!("load profile config {}", path.display()))
         })
         .collect()

src/mcp.rs

@@ -11,7 +11,7 @@ use crate::eb_parse::{
 use crate::eb_style::{format_style_file, lint_style};
 use crate::foreign::ForeignFormat;
 use crate::package::{StackPolicy, STACK_POLICY_SCHEMA_VERSION};
-use crate::package_config::ProfileConfigLayer;
+use crate::package_config::PackageConfigLayer;
 use crate::package_workflow::{
     inspect_new_package, plan_new_package, plan_package_bump, write_package_bundle,
     BumpPackageRequest, NewPackageRequest, PackageBundle,
@@ -96,14 +96,19 @@ pub fn handle_message(message: &Value) -> Option<Value> {
 
 fn tool_catalog() -> Vec<Value> {
     vec![
-        tool(
+        tool_with_optional(
             "eb_package_inspect",
             "Parse a conda-forge or Spack recipe into a canonical build manifest and planned CycloneDX SBOM.",
             &[
                 ("source", "string"),
                 ("toolchain_version", "string"),
                 ("out_dir", "string"),
             ],
+            &[
+                ("format", "string"),
+                ("toolchain_name", "string"),
+                ("package_configs", "array"),
+            ],
         ),
         tool_with_optional(
             "eb_package_plan",
@@ -118,7 +123,7 @@ fn tool_catalog() -> Vec<Value> {
             &[
                 ("format", "string"),
                 ("toolchain_name", "string"),
-                ("profile_configs", "array"),
+                ("package_configs", "array"),
                 ("source_checksums", "array"),
             ],
         ),
@@ -252,9 +257,9 @@ fn call_tool(name: &str, arguments: &Value) -> Result<Value, String> {
 fn package_inspect(arguments: &Value) -> Result<Value, String> {
     let source = required_path(arguments, "source")?;
     let toolchain = toolchain(arguments)?;
-    let profiles = profile_layers(arguments)?;
+    let configs = package_layers(arguments)?;
     let (plan, sbom) =
-        inspect_new_package(&source, foreign_format(arguments)?, &toolchain, &profiles)
+        inspect_new_package(&source, foreign_format(arguments)?, &toolchain, &configs)
             .map_err(|error| error.to_string())?;
     let output = required_path(arguments, "out_dir")?;
     let written = write_package_bundle(
@@ -283,7 +288,7 @@ fn package_plan(arguments: &Value) -> Result<Value, String> {
         format: foreign_format(arguments)?,
         toolchain: toolchain(arguments)?,
         source_checksums: string_array(arguments, "source_checksums")?,
-        profile_layers: profile_layers(arguments)?,
+        package_layers: package_layers(arguments)?,
         easyconfig_roots: path_array(arguments, "easyconfigs")?,
         stack_policy,
     };
@@ -474,11 +479,11 @@ fn load_targets(arguments: &Value) -> Result<Vec<BuildTarget>, String> {
     resolve_target_layers(&layers).map_err(|error| error.to_string())
 }
 
-fn profile_layers(arguments: &Value) -> Result<Vec<ProfileConfigLayer>, String> {
-    string_array(arguments, "profile_configs")?
+fn package_layers(arguments: &Value) -> Result<Vec<PackageConfigLayer>, String> {
+    string_array(arguments, "package_configs")?
         .iter()
         .map(|path| {
-            ProfileConfigLayer::from_path(Path::new(path)).map_err(|error| error.to_string())
+            PackageConfigLayer::from_path(Path::new(path)).map_err(|error| error.to_string())
         })
         .collect()
 }

src/package_config.rs

@@ -6,11 +6,11 @@ use std::collections::BTreeMap;
 use std::path::Path;
 use thiserror::Error;
 
-pub const PROFILE_CONFIG_SCHEMA_VERSION: u32 = 1;
+pub const PACKAGE_CONFIG_SCHEMA_VERSION: u32 = 1;
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(deny_unknown_fields)]
-pub struct ProfileConfigLayer {
+pub struct PackageConfigLayer {
     pub schema_version: u32,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub package: Option<PackagePatch>,
@@ -72,26 +72,26 @@ pub struct ProfilePatch {
     pub verification_commands: Option<Vec<VerificationCommand>>,
 }
 
-impl ProfileConfigLayer {
-    pub fn from_toml_str(input: &str) -> Result<Self, ProfileConfigError> {
+impl PackageConfigLayer {
+    pub fn from_toml_str(input: &str) -> Result<Self, PackageConfigError> {
         let layer: Self = toml::from_str(input)?;
         layer.validate()?;
         Ok(layer)
     }
 
-    pub fn from_path(path: &Path) -> Result<Self, ProfileConfigError> {
+    pub fn from_path(path: &Path) -> Result<Self, PackageConfigError> {
         let input = std::fs::read_to_string(path)
-            .map_err(|error| ProfileConfigError::Io(path.display().to_string(), error))?;
+            .map_err(|error| PackageConfigError::Io(path.display().to_string(), error))?;
         Self::from_toml_str(&input)
     }
 
-    fn validate(&self) -> Result<(), ProfileConfigError> {
-        if self.schema_version != PROFILE_CONFIG_SCHEMA_VERSION {
-            return Err(ProfileConfigError::UnsupportedSchema(self.schema_version));
+    fn validate(&self) -> Result<(), PackageConfigError> {
+        if self.schema_version != PACKAGE_CONFIG_SCHEMA_VERSION {
+            return Err(PackageConfigError::UnsupportedSchema(self.schema_version));
         }
         for profile in &self.profiles {
             if profile.name.trim().is_empty() {
-                return Err(ProfileConfigError::EmptyProfileName);
+                return Err(PackageConfigError::EmptyProfileName);
             }
         }
         if self
@@ -100,40 +100,40 @@ impl ProfileConfigLayer {
             .and_then(|package| package.name.as_deref())
             .is_some_and(|name| name.trim().is_empty())
         {
-            return Err(ProfileConfigError::EmptyPackageName);
+            return Err(PackageConfigError::EmptyPackageName);
         }
         if self
             .package
             .as_ref()
             .and_then(|package| package.version.as_deref())
             .is_some_and(|version| version.trim().is_empty())
         {
-            return Err(ProfileConfigError::EmptyPackageVersion);
+            return Err(PackageConfigError::EmptyPackageVersion);
         }
         if self
             .build
             .as_ref()
             .and_then(|build| build.easyblock.as_deref())
             .is_some_and(|easyblock| easyblock.trim().is_empty())
         {
-            return Err(ProfileConfigError::EmptyEasyblock);
+            return Err(PackageConfigError::EmptyEasyblock);
         }
         if self
             .build
             .as_ref()
             .and_then(|build| build.moduleclass.as_deref())
             .is_some_and(|moduleclass| moduleclass.trim().is_empty())
         {
-            return Err(ProfileConfigError::EmptyModuleclass);
+            return Err(PackageConfigError::EmptyModuleclass);
         }
         Ok(())
     }
 }
 
-pub fn apply_profile_layers(
+pub fn apply_package_layers(
     plan: &mut PackagePlan,
-    layers: &[ProfileConfigLayer],
-) -> Result<(), ProfileConfigError> {
+    layers: &[PackageConfigLayer],
+) -> Result<(), PackageConfigError> {
     for layer in layers {
         layer.validate()?;
         if let Some(package) = &layer.package {
@@ -183,7 +183,7 @@ pub fn apply_profile_layers(
                         .iter()
                         .find(|profile| profile.name == parent)
                         .cloned()
-                        .ok_or_else(|| ProfileConfigError::MissingParent {
+                        .ok_or_else(|| PackageConfigError::MissingParent {
                             profile: patch.name.clone(),
                             parent: parent.to_string(),
                         })?;
@@ -234,7 +234,7 @@ pub fn apply_profile_layers(
         .filter(|profile| profile.default)
         .count();
     if default_count != 1 {
-        return Err(ProfileConfigError::DefaultProfileCount(default_count));
+        return Err(PackageConfigError::DefaultProfileCount(default_count));
     }
     let stack = plan.build.toolchain.label();
     plan.outputs = plan
@@ -249,12 +249,12 @@ pub fn apply_profile_layers(
 }
 
 #[derive(Debug, Error)]
-pub enum ProfileConfigError {
-    #[error("unsupported profile config schema version {0}")]
+pub enum PackageConfigError {
+    #[error("unsupported package config schema version {0}")]
     UnsupportedSchema(u32),
-    #[error("profile config TOML: {0}")]
+    #[error("package config TOML: {0}")]
     Toml(#[from] toml::de::Error),
-    #[error("read profile config {0}: {1}")]
+    #[error("read package config {0}: {1}")]
     Io(String, std::io::Error),
     #[error("profile name cannot be empty")]
     EmptyProfileName,

src/package_workflow.rs

@@ -13,7 +13,7 @@ use crate::package::{
     Residual, ResidualSeverity, ResidualStage, SourceArtifact, StackPin, StackPinMode, StackPolicy,
     PACKAGE_SCHEMA_VERSION,
 };
-use crate::package_config::{apply_profile_layers, ProfileConfigLayer};
+use crate::package_config::{apply_package_layers, PackageConfigLayer};
 use crate::package_emit::{emit_profile_easyconfigs, EmittedEasyconfig};
 use crate::package_solve::{solve_package_profile, solve_package_profile_with_hierarchy};
 use serde_json::Value;
@@ -28,7 +28,7 @@ pub struct NewPackageRequest {
     pub toolchain: Toolchain,
     /// Positional SHA-256 overrides, one for every canonical source artifact.
     pub source_checksums: Vec<String>,
-    pub profile_layers: Vec<ProfileConfigLayer>,
+    pub package_layers: Vec<PackageConfigLayer>,
     pub easyconfig_roots: Vec<PathBuf>,
     pub stack_policy: StackPolicy,
 }
@@ -65,13 +65,13 @@ pub fn inspect_new_package(
     source: &Path,
     format: Option<ForeignFormat>,
     toolchain: &Toolchain,
-    profile_layers: &[ProfileConfigLayer],
+    package_layers: &[PackageConfigLayer],
 ) -> Result<(PackagePlan, Value), PackageWorkflowError> {
     let recipe = parse_foreign_path(source, format)
         .map_err(|error| PackageWorkflowError::Foreign(error.to_string()))?;
     let mut plan = package_plan_from_foreign(&recipe, toolchain);
-    if !profile_layers.is_empty() {
-        apply_profile_layers(&mut plan, profile_layers)
+    if !package_layers.is_empty() {
+        apply_package_layers(&mut plan, package_layers)
             .map_err(|error| PackageWorkflowError::Config(error.to_string()))?;
     }
     let sbom = package_plan_to_cyclonedx(&plan)
@@ -89,7 +89,7 @@ pub fn plan_new_package(
         &request.source,
         request.format,
         &request.toolchain,
-        &request.profile_layers,
+        &request.package_layers,
     )?;
     if !request.source_checksums.is_empty() {
         apply_source_checksums(&mut plan, &request.source_checksums)?;

tests/goal_scenario.rs

@@ -1,7 +1,7 @@
 //! End-to-end acceptance for the two motivating foreign package workflows.
 
 use eb_stack::package::{StackPolicy, STACK_POLICY_SCHEMA_VERSION};
-use eb_stack::package_config::ProfileConfigLayer;
+use eb_stack::package_config::PackageConfigLayer;
 use eb_stack::version::matches_req;
 use eb_stack::{
     inspect_new_package, plan_new_package, resolve_easyconfig_file, write_package_bundle,
@@ -84,7 +84,7 @@ fn run_package(
     source_checksums: Vec<String>,
 ) {
     let source = repo().join(source);
-    let profile = ProfileConfigLayer::from_path(&repo().join(profile_config)).expect("profiles");
+    let profile = PackageConfigLayer::from_path(&repo().join(profile_config)).expect("profiles");
     let (inspected, inspected_sbom) = inspect_new_package(
         &source,
         Some(format),
@@ -105,7 +105,7 @@ fn run_package(
         format: Some(format),
         toolchain: toolchain(),
         source_checksums,
-        profile_layers: vec![profile],
+        package_layers: vec![profile],
         easyconfig_roots: vec![robot],
         stack_policy: policy(),
     })

tests/manifest_requires_resolvo.rs

@@ -54,7 +54,7 @@ dependencies = [('zlib', '1.2')]
         format: Some(ForeignFormat::CondaForge),
         toolchain: toolchain.clone(),
         source_checksums: Vec::new(),
-        profile_layers: Vec::new(),
+        package_layers: Vec::new(),
         easyconfig_roots: vec![robot],
         stack_policy: StackPolicy {
             schema_version: STACK_POLICY_SCHEMA_VERSION,