chore(format): apply consistent code formatting across modules

libips/src/image/catalog.rs

@@ -189,7 +189,8 @@ impl ImageCatalog {
                 &catalog_parts_dir,
                 publisher,
                 shard_dir,
-            ).map_err(|e| {
+            )
+            .map_err(|e| {
                 CatalogError::Database(format!("Failed to build catalog shards: {}", e.message))
             })?;
         }

libips/src/image/installed.rs

@@ -102,7 +102,8 @@ impl InstalledPackages {
     pub fn get_db_stats(&self) -> Result<()> {
         let conn = Connection::open_with_flags(&self.db_path, OpenFlags::SQLITE_OPEN_READ_ONLY)?;
 
-        let installed_count: i64 = conn.query_row("SELECT COUNT(*) FROM installed", [], |row| row.get(0))?;
+        let installed_count: i64 =
+            conn.query_row("SELECT COUNT(*) FROM installed", [], |row| row.get(0))?;
 
         println!("Database path: {}", self.db_path.display());
         println!("Table statistics:");
@@ -164,7 +165,10 @@ impl InstalledPackages {
         }
 
         let tx = conn.transaction()?;
-        tx.execute("DELETE FROM installed WHERE fmri = ?1", rusqlite::params![key])?;
+        tx.execute(
+            "DELETE FROM installed WHERE fmri = ?1",
+            rusqlite::params![key],
+        )?;
         tx.commit()?;
 
         info!("Removed package from installed database: {}", key);
@@ -176,7 +180,10 @@ impl InstalledPackages {
         let conn = Connection::open_with_flags(&self.db_path, OpenFlags::SQLITE_OPEN_READ_ONLY)?;
 
         let query = if let Some(pattern) = pattern {
-            format!("SELECT fmri FROM installed WHERE fmri LIKE '%{}%'", pattern.replace('\'', "''"))
+            format!(
+                "SELECT fmri FROM installed WHERE fmri LIKE '%{}%'",
+                pattern.replace('\'', "''")
+            )
         } else {
             "SELECT fmri FROM installed".to_string()
         };
@@ -188,7 +195,10 @@ impl InstalledPackages {
         while let Some(row) = rows.next()? {
             let fmri_str: String = row.get(0)?;
             let fmri = Fmri::from_str(&fmri_str)?;
-            let publisher = fmri.publisher.clone().unwrap_or_else(|| "unknown".to_string());
+            let publisher = fmri
+                .publisher
+                .clone()
+                .unwrap_or_else(|| "unknown".to_string());
             results.push(InstalledPackageInfo { fmri, publisher });
         }
 

libips/src/image/mod.rs

@@ -559,8 +559,9 @@ impl Image {
         }
 
         let conn = Connection::open(&path)?;
-        conn.execute_batch(ACTIVE_SCHEMA)
+        conn.execute_batch(ACTIVE_SCHEMA).map_err(|e| {
-            .map_err(|e| ImageError::Database(format!("Failed to initialize catalog database: {}", e)))?;
+            ImageError::Database(format!("Failed to initialize catalog database: {}", e))
+        })?;
 
         Ok(())
     }

libips/src/repository/obsoleted.rs

@@ -823,11 +823,9 @@ impl SqliteObsoletedPackageIndex {
     fn len(&self) -> Result<usize> {
         let conn = Connection::open_with_flags(&self.db_path, OpenFlags::SQLITE_OPEN_READ_ONLY)?;
 
-        let count: i64 = conn.query_row(
+        let count: i64 = conn.query_row("SELECT COUNT(*) FROM obsoleted_packages", [], |row| {
-            "SELECT COUNT(*) FROM obsoleted_packages",
+            row.get(0)
-            [],
+        })?;
-            |row| row.get(0),
-        )?;
 
         Ok(count as usize)
     }
@@ -968,8 +966,8 @@ impl ObsoletedPackageManager {
 
         let index = {
             // Create or open the SQLite-based index
-            let sqlite_index =
+            let sqlite_index = SqliteObsoletedPackageIndex::create_or_open(&base_path)
-                SqliteObsoletedPackageIndex::create_or_open(&base_path).unwrap_or_else(|e| {
+                .unwrap_or_else(|e| {
                     // Log the error and create an empty SQLite index
                     error!("Failed to create or open SQLite-based index: {}", e);
                     SqliteObsoletedPackageIndex::empty()

libips/src/repository/shard_sync.rs

@@ -7,7 +7,7 @@
 //!
 //! Downloads catalog shards from the repository server and verifies their integrity.
 
-use crate::repository::sqlite_catalog::{ShardIndex, ShardEntry};
+use crate::repository::sqlite_catalog::{ShardEntry, ShardIndex};
 use miette::Diagnostic;
 use sha2::{Digest, Sha256};
 use std::fs;

libips/src/repository/sqlite_catalog.rs

@@ -249,11 +249,14 @@ pub fn build_shards(
                                         if let Some(name_part) = parts.get(1) {
                                             if let Some(key) = name_part.strip_prefix("name=") {
                                                 if let Some(value_part) = parts.get(2) {
-                                                    if let Some(mut value) = value_part.strip_prefix("value=") {
+                                                    if let Some(mut value) =
+                                                        value_part.strip_prefix("value=")
+                                                    {
                                                         // Remove quotes
                                                         value = value.trim_matches('"');
 
-                                                        let mut attr = crate::actions::Attr::default();
+                                                        let mut attr =
+                                                            crate::actions::Attr::default();
                                                         attr.key = key.to_string();
                                                         attr.values = vec![value.to_string()];
                                                         manifest.attributes.push(attr);
@@ -295,17 +298,28 @@ pub fn build_shards(
 
                         // Obsolete packages go only to obsolete.db, non-obsolete go to active.db
                         if is_obsolete {
-                            insert_obs.execute(rusqlite::params![publisher, pkg_name, pkg_version])?;
+                            insert_obs.execute(rusqlite::params![
+                                publisher,
+                                pkg_name,
+                                pkg_version
+                            ])?;
                         } else {
                             // Insert into packages table (active.db)
-                            insert_pkg.execute(rusqlite::params![pkg_name, pkg_version, publisher])?;
+                            insert_pkg.execute(rusqlite::params![
+                                pkg_name,
+                                pkg_version,
+                                publisher
+                            ])?;
 
                             // Extract and insert dependencies
                             for dep in &manifest.dependencies {
-                                if dep.dependency_type == "require" || dep.dependency_type == "incorporate" {
+                                if dep.dependency_type == "require"
+                                    || dep.dependency_type == "incorporate"
+                                {
                                     if let Some(dep_fmri) = &dep.fmri {
                                         let dep_stem = dep_fmri.stem();
-                                        let dep_version = dep_fmri.version.as_ref().map(|v| v.to_string());
+                                        let dep_version =
+                                            dep_fmri.version.as_ref().map(|v| v.to_string());
                                         insert_dep.execute(rusqlite::params![
                                             pkg_name,
                                             pkg_version,
@@ -353,11 +367,10 @@ pub fn build_shards(
     fts_tx.commit()?;
 
     // Count unique packages (stems)
-    let count: i64 = active_conn.query_row(
+    let count: i64 =
-        "SELECT COUNT(DISTINCT stem) FROM packages",
+        active_conn.query_row("SELECT COUNT(DISTINCT stem) FROM packages", [], |row| {
-        [],
+            row.get(0)
-        |row| row.get(0),
+        })?;
-    )?;
     package_count = count as usize;
 
     // Close connections

libips/src/solver/mod.rs

@@ -74,16 +74,12 @@ use crate::image::Image;
 impl<'a> IpsProvider<'a> {
     fn new(image: &'a Image) -> Result<Self, SolverError> {
         // Open active.db (catalog) read-only with WAL mode for better concurrency
-        let catalog_conn = Connection::open_with_flags(
+        let catalog_conn =
-            &image.active_db_path(),
+            Connection::open_with_flags(&image.active_db_path(), OpenFlags::SQLITE_OPEN_READ_ONLY)
-            OpenFlags::SQLITE_OPEN_READ_ONLY,
-        )
                 .map_err(|e| SolverError::new(format!("open catalog db: {}", e)))?;
 
         // Enable WAL mode for better concurrency (ignored if already set)
-        catalog_conn
+        catalog_conn.pragma_update(None, "journal_mode", "WAL").ok();
-            .pragma_update(None, "journal_mode", "WAL")
-            .ok();
 
         let mut prov = IpsProvider {
             image,
@@ -129,8 +125,8 @@ impl<'a> IpsProvider<'a> {
         let mut by_stem: BTreeMap<String, Vec<Fmri>> = BTreeMap::new();
 
         for row_result in collected_rows {
-            let (stem, version, publisher) = row_result
+            let (stem, version, publisher) =
-                .map_err(|e| SolverError::new(format!("read package row: {}", e)))?;
+                row_result.map_err(|e| SolverError::new(format!("read package row: {}", e)))?;
 
             // Parse version
             let ver_obj = crate::fmri::Version::parse(&version).ok();

pkg6depotd/src/repo.rs

@@ -105,10 +105,7 @@ impl DepotRepo {
     }
 
     pub fn shard_dir(&self, publisher: &str) -> PathBuf {
-        self.root
+        self.root.join("publisher").join(publisher).join("catalog2")
-            .join("publisher")
-            .join(publisher)
-            .join("catalog2")
     }
 
     pub fn get_catalog_file_path(&self, publisher: &str, filename: &str) -> Result<PathBuf> {