Add transformer module for manifest transformation logic

- Introduced `transformer.rs` with a structured approach for parsing and applying transformation rules.
- Added support for operations like `add`, `default`, `delete`, `drop`, `edit`, `emit`, and `set` on attributes, files, directories, and other targets.
- Implemented regex-based matching for patterns and backreference handling in transformations.
- Enhanced manifest modification functionality, including attribute/facet operations and deferred action emission.
- Added comprehensive unit tests to validate transformation rules and their applications.

Author: Toasterson

libips/src/lib.rs

@@ -10,9 +10,14 @@ pub mod fmri;
 pub mod image;
 pub mod payload;
 pub mod repository;
+pub mod publisher;
+pub mod transformer;
 pub mod solver;
 mod test_json_manifest;
 
+#[cfg(test)]
+mod publisher_tests;
+
 #[cfg(test)]
 mod tests {
 

libips/src/publisher.rs

@@ -0,0 +1,176 @@
+//  This Source Code Form is subject to the terms of
+//  the Mozilla Public License, v. 2.0. If a copy of the
+//  MPL was not distributed with this file, You can
+//  obtain one at https://mozilla.org/MPL/2.0/.
+
+use std::path::{Path, PathBuf};
+use std::fs;
+
+use miette::Diagnostic;
+use thiserror::Error;
+
+use crate::actions::{File as FileAction, Manifest, Transform as TransformAction};
+use crate::repository::{ReadableRepository, RepositoryError, WritableRepository};
+use crate::repository::file_backend::{FileBackend, Transaction};
+use crate::transformer;
+
+/// Error type for high-level publishing operations
+#[derive(Debug, Error, Diagnostic)]
+pub enum PublisherError {
+    #[error(transparent)]
+    #[diagnostic(transparent)]
+    Repository(#[from] RepositoryError),
+
+    #[error(transparent)]
+    #[diagnostic(transparent)]
+    Transform(#[from] transformer::TransformError),
+
+    #[error("I/O error: {0}")]
+    #[diagnostic(code(ips::publisher_error::io), help("Check the path and permissions"))]
+    Io(String),
+
+    #[error("invalid root path: {0}")]
+    #[diagnostic(code(ips::publisher_error::invalid_root_path), help("Ensure the directory exists and is readable"))]
+    InvalidRoot(String),
+}
+
+pub type Result<T> = std::result::Result<T, PublisherError>;
+
+/// High-level Publisher client that keeps a repository handle and an open transaction.
+///
+/// This is intended to simplify software build/publish flows: instantiate once with a
+/// repository path and publisher, then build/transform manifests and publish.
+pub struct PublisherClient {
+    backend: FileBackend,
+    publisher: String,
+    tx: Option<Transaction>,
+    transform_rules: Vec<transformer::TransformRule>,
+}
+
+impl PublisherClient {
+    /// Open an existing repository located at `path` with a selected `publisher`.
+    pub fn open<P: AsRef<Path>>(path: P, publisher: impl Into<String>) -> Result<Self> {
+        let backend = FileBackend::open(path)?;
+        Ok(Self { backend, publisher: publisher.into(), tx: None, transform_rules: Vec::new() })
+    }
+
+    /// Open a transaction if not already open and return whether a new transaction was created.
+    pub fn open_transaction(&mut self) -> Result<bool> {
+        if self.tx.is_none() {
+            let tx = self.backend.begin_transaction()?;
+            self.tx = Some(tx);
+            return Ok(true);
+        }
+        Ok(false)
+    }
+
+    /// Build a new Manifest from a directory tree. Paths in the manifest are relative to `root`.
+    pub fn build_manifest_from_dir(&mut self, root: &Path) -> Result<Manifest> {
+        if !root.exists() {
+            return Err(PublisherError::InvalidRoot(root.display().to_string()));
+        }
+        let mut manifest = Manifest::new();
+        let root = root.canonicalize().map_err(|_| PublisherError::InvalidRoot(root.display().to_string()))?;
+
+        let walker = walkdir::WalkDir::new(&root).into_iter().filter_map(|e| e.ok());
+        // Ensure a transaction is open
+        if self.tx.is_none() {
+            self.open_transaction()?;
+        }
+        let tx = self.tx.as_mut().expect("transaction must be open");
+
+        for entry in walker {
+            let p = entry.path();
+            if p.is_file() {
+                // Create a File action from the absolute path
+                let mut f = FileAction::read_from_path(p).map_err(RepositoryError::from)?;
+                // Set path to be relative to root
+                let rel: PathBuf = p
+                    .strip_prefix(&root)
+                    .map_err(RepositoryError::from)?
+                    .to_path_buf();
+                f.path = rel.to_string_lossy().to_string();
+                // Add into manifest and stage via transaction
+                manifest.add_file(f.clone());
+                tx.add_file(f, p)?;
+            }
+        }
+        Ok(manifest)
+    }
+
+    /// Make a new empty manifest
+    pub fn new_empty_manifest(&self) -> Manifest {
+        Manifest::new()
+    }
+
+    /// Transform a manifest with a user-supplied rule function
+    pub fn transform_manifest<F>(&self, mut manifest: Manifest, rule: F) -> Manifest
+    where
+        F: FnOnce(&mut Manifest),
+    {
+        rule(&mut manifest);
+        manifest
+    }
+
+    /// Add a single AST transform rule
+    pub fn add_transform_rule(&mut self, rule: transformer::TransformRule) {
+        self.transform_rules.push(rule);
+    }
+
+    /// Add multiple AST transform rules
+    pub fn add_transform_rules(&mut self, rules: Vec<transformer::TransformRule>) {
+        self.transform_rules.extend(rules);
+    }
+
+    /// Clear all configured transform rules
+    pub fn clear_transform_rules(&mut self) {
+        self.transform_rules.clear();
+    }
+
+    /// Load transform rules from raw text (returns number of rules added)
+    pub fn load_transform_rules_from_text(&mut self, text: &str) -> Result<usize> {
+        let rules = transformer::parse_rules_ast(text)?;
+        let n = rules.len();
+        self.transform_rules.extend(rules);
+        Ok(n)
+    }
+
+    /// Load transform rules from a file (returns number of rules added)
+    pub fn load_transform_rules_from_file<P: AsRef<Path>>(&mut self, path: P) -> Result<usize> {
+        let p = path.as_ref();
+        let content = fs::read_to_string(p).map_err(|e| PublisherError::Io(e.to_string()))?;
+        self.load_transform_rules_from_text(&content)
+    }
+
+    /// Publish the given manifest. If no transaction is open, one will be opened.
+    /// The transaction will be updated with the provided manifest and committed.
+    /// If `rebuild_metadata` is true, repository metadata (catalog/index) will be rebuilt.
+    pub fn publish(&mut self, mut manifest: Manifest, rebuild_metadata: bool) -> Result<()> {
+        // Apply configured transform rules (if any)
+        if !self.transform_rules.is_empty() {
+            let rules: Vec<TransformAction> = self
+                .transform_rules
+                .clone()
+                .into_iter()
+                .map(Into::into)
+                .collect();
+            transformer::apply(&mut manifest, &rules)?;
+        }
+
+        // Ensure transaction exists
+        if self.tx.is_none() {
+            self.open_transaction()?;
+        }
+
+        // Take ownership of the transaction, update and commit
+        let mut tx = self.tx.take().expect("transaction must be open");
+        tx.set_publisher(&self.publisher);
+        tx.update_manifest(manifest);
+        tx.commit()?;
+        // Optionally rebuild repo metadata for the publisher
+        if rebuild_metadata {
+            self.backend.rebuild(Some(&self.publisher), false, false)?;
+        }
+        Ok(())
+    }
+}

libips/src/publisher_tests.rs

@@ -0,0 +1,119 @@
+//  This Source Code Form is subject to the terms of
+//  the Mozilla Public License, v. 2.0. If a copy of the
+//  MPL was not distributed with this file, You can
+//  obtain one at https://mozilla.org/MPL/2.0/.
+
+#[cfg(test)]
+mod tests {
+    use std::fs;
+    use std::io::Write;
+
+    use tempfile::TempDir;
+
+    use crate::publisher::PublisherClient;
+    use crate::repository::file_backend::FileBackend;
+    use crate::repository::{RepositoryVersion, WritableRepository};
+
+    #[test]
+    fn publisher_client_basic_flow() {
+        // Create a temporary repository directory
+        let tmp = TempDir::new().expect("tempdir");
+        let repo_path = tmp.path().to_path_buf();
+
+        // Initialize repository
+        let mut backend = FileBackend::create(&repo_path, RepositoryVersion::V4).expect("create repo");
+        backend.add_publisher("test").expect("add publisher");
+
+        // Prepare a prototype directory with a nested file
+        let proto_dir = repo_path.join("proto");
+        let nested = proto_dir.join("nested").join("dir");
+        fs::create_dir_all(&nested).expect("create proto dirs");
+        let file_path = nested.join("hello.txt");
+        let content = b"Hello PublisherClient!";
+        let mut f = fs::File::create(&file_path).expect("create file");
+        f.write_all(content).expect("write content");
+
+        // Use PublisherClient to publish
+        let mut client = PublisherClient::open(&repo_path, "test").expect("open client");
+        client.open_transaction().expect("open tx");
+        let manifest = client.build_manifest_from_dir(&proto_dir).expect("build manifest");
+        client.publish(manifest, true).expect("publish");
+
+        // Verify the manifest exists at the default path for unknown version
+        let manifest_path = FileBackend::construct_package_dir(&repo_path, "test", "unknown").join("manifest");
+        assert!(manifest_path.exists(), "manifest not found at {}", manifest_path.display());
+
+        // Verify at least one file was stored under publisher/test/file
+        let file_root = repo_path.join("publisher").join("test").join("file");
+        assert!(file_root.exists(), "file store root does not exist: {}", file_root.display());
+        let mut any_file = false;
+        if let Ok(entries) = fs::read_dir(&file_root) {
+            for entry in entries.flatten() {
+                let path = entry.path();
+                if path.is_dir() {
+                    if let Ok(files) = fs::read_dir(&path) {
+                        for f in files.flatten() {
+                            if f.path().is_file() {
+                                any_file = true;
+                                break;
+                            }
+                        }
+                    }
+                } else if path.is_file() {
+                    any_file = true;
+                }
+                if any_file { break; }
+            }
+        }
+        assert!(any_file, "no stored file found in file store");
+    }
+}
+
+
+#[cfg(test)]
+mod transform_rule_integration_tests {
+    use crate::actions::Manifest;
+    use crate::publisher::PublisherClient;
+    use crate::repository::file_backend::FileBackend;
+    use crate::repository::{RepositoryVersion, WritableRepository};
+    use std::fs;
+    use std::io::Write;
+    use tempfile::TempDir;
+
+    #[test]
+    fn publisher_client_applies_transform_rules_from_file() {
+        // Setup repository and publisher
+        let tmp = TempDir::new().expect("tempdir");
+        let repo_path = tmp.path().to_path_buf();
+        let mut backend = FileBackend::create(&repo_path, RepositoryVersion::V4).expect("create repo");
+        backend.add_publisher("test").expect("add publisher");
+
+        // Prototype directory with a file
+        let proto_dir = repo_path.join("proto2");
+        fs::create_dir_all(&proto_dir).expect("mkdir proto2");
+        let file_path = proto_dir.join("foo.txt");
+        let mut f = fs::File::create(&file_path).expect("create file");
+        f.write_all(b"data").expect("write");
+
+        // Create a rules file that emits a pkg.summary attribute
+        let rules_path = repo_path.join("rules.txt");
+        let rules_text = "<transform file match_type=path pattern=.* operation=emit -> set name=pkg.summary value=\"Added via rules\">\n";
+        fs::write(&rules_path, rules_text).expect("write rules");
+
+        // Use PublisherClient to load rules, build manifest and publish
+        let mut client = PublisherClient::open(&repo_path, "test").expect("open client");
+        let loaded = client.load_transform_rules_from_file(&rules_path).expect("load rules");
+        assert!(loaded >= 1, "expected at least one rule loaded");
+        client.open_transaction().expect("open tx");
+        let manifest = client.build_manifest_from_dir(&proto_dir).expect("build manifest");
+        client.publish(manifest, false).expect("publish");
+
+        // Read stored manifest and verify attribute
+        let manifest_path = FileBackend::construct_package_dir(&repo_path, "test", "unknown").join("manifest");
+        assert!(manifest_path.exists(), "manifest missing: {}", manifest_path.display());
+        let json = fs::read_to_string(&manifest_path).expect("read manifest");
+        let parsed: Manifest = serde_json::from_str(&json).expect("parse manifest json");
+        let has_summary = parsed.attributes.iter().any(|a| a.key == "pkg.summary" && a.values.iter().any(|v| v == "Added via rules"));
+        assert!(has_summary, "pkg.summary attribute added via rules not found");
+    }
+}

libips/src/repository/file_backend.rs

@@ -565,12 +565,17 @@ impl Transaction {
         }
 
         // Construct the manifest path using the helper method
-        let pkg_manifest_path = FileBackend::construct_manifest_path(
-            &self.repo,
-            &publisher,
-            &package_stem,
-            &package_version,
-        );
+        let pkg_manifest_path = if package_version.is_empty() {
+            // If no version was provided, store as a default manifest file
+            FileBackend::construct_package_dir(&self.repo, &publisher, &package_stem).join("manifest")
+        } else {
+            FileBackend::construct_manifest_path(
+                &self.repo,
+                &publisher,
+                &package_stem,
+                &package_version,
+            )
+        };
         debug!("Manifest path: {}", pkg_manifest_path.display());
 
         // Create parent directories if they don't exist

libips/src/repository/mod.rs

@@ -204,7 +204,7 @@ impl From<bincode::error::EncodeError> for RepositoryError {
     }
 }
 pub mod catalog;
-mod file_backend;
+pub(crate) mod file_backend;
 mod obsoleted;
 pub mod progress;
 mod rest_backend;