format rust

rust/agama-lib/src/install_settings.rs

@@ -2,8 +2,8 @@
 //!
 //! This module implements the mechanisms to load and store the installation settings.
 use crate::{
- network::NetworkSettings, software::SoftwareSettings, storage::StorageSettings,
- users::UserSettings, product::ProductSettings
+ network::NetworkSettings, product::ProductSettings, software::SoftwareSettings,
+ storage::StorageSettings, users::UserSettings,
 };
 use agama_settings::Settings;
 use serde::{Deserialize, Serialize};

rust/agama-lib/src/lib.rs

@@ -27,8 +27,8 @@ pub mod error;
 pub mod install_settings;
 pub mod manager;
 pub mod network;
-pub mod profile;
 pub mod product;
+pub mod profile;
 pub mod software;
 pub mod storage;
 pub mod users;

rust/agama-lib/src/product/client.rs

@@ -1,7 +1,7 @@
 use std::collections::HashMap;
 
-use crate::software::proxies::SoftwareProductProxy;
 use crate::error::ServiceError;
+use crate::software::proxies::SoftwareProductProxy;
 use serde::Serialize;
 use zbus::Connection;
 
@@ -21,14 +21,14 @@ pub struct Product {
 /// D-Bus client for the software service
 pub struct ProductClient<'a> {
  product_proxy: SoftwareProductProxy<'a>,
- registration_proxy: RegistrationProxy<'a>
+ registration_proxy: RegistrationProxy<'a>,
 }
 
 impl<'a> ProductClient<'a> {
  pub async fn new(connection: Connection) -> Result<ProductClient<'a>, ServiceError> {
  Ok(Self {
  product_proxy: SoftwareProductProxy::new(&connection).await?,
- registration_proxy: RegistrationProxy::new(&connection).await?
+ registration_proxy: RegistrationProxy::new(&connection).await?,
  })
  }
 
@@ -76,19 +76,21 @@ impl<'a> ProductClient<'a> {
  }
 
  /// registration code used to register product
- pub async fn registration_code(&self) -> Result<String, ServiceError>{
+ pub async fn registration_code(&self) -> Result<String, ServiceError> {
  Ok(self.registration_proxy.reg_code().await?)
  }
 
  /// email used to register product
- pub async fn email(&self) -> Result<String, ServiceError>{
+ pub async fn email(&self) -> Result<String, ServiceError> {
  Ok(self.registration_proxy.email().await?)
  }
 
  /// register product
- pub async fn register(&self, code :&str, _email: &str) -> Result<(), ServiceError> {
+ pub async fn register(&self, code: &str, _email: &str) -> Result<(), ServiceError> {
  // TODO: handle email
- self.registration_proxy.register(code, HashMap::new()).await?;
+ self.registration_proxy
+ .register(code, HashMap::new())
+ .await?;
  Ok(())
  }
 }

rust/agama-lib/src/product/settings.rs

@@ -10,5 +10,5 @@ pub struct ProductSettings {
  /// ID of the product to install (e.g., "ALP", "Tumbleweed", etc.)
  pub id: Option<String>,
  pub registration_code: Option<String>,
- pub email: Option<String>
+ pub email: Option<String>,
 }

rust/agama-lib/src/product/store.rs

@@ -27,7 +27,7 @@ impl<'a> ProductStore<'a> {
  Ok(ProductSettings {
  id: Some(product),
  registration_code: Some(registration_code),
- email: Some(email)
+ email: Some(email),
  })
  }
 

rust/agama-lib/src/software/client.rs

@@ -17,7 +17,7 @@ pub struct Pattern {
  /// Pattern summary
  pub summary: String,
  /// Pattern order
- pub order: String
+ pub order: String,
 }
 
 /// D-Bus client for the software service
@@ -39,16 +39,16 @@ impl<'a> SoftwareClient<'a> {
  .list_patterns(filtered)
  .await?
  .into_iter()
- .map(|(id, (category, description, icon, summary, order))| {
- Pattern {
+ .map(
+ |(id, (category, description, icon, summary, order))| Pattern {
  id,
  category,
  icon,
  description,
  summary,
- order
- }
- })
+ order,
+ },
+ )
  .collect();
  Ok(patterns)
  }
@@ -61,20 +61,18 @@ impl<'a> SoftwareClient<'a> {
  .selected_patterns()
  .await?
  .into_iter()
- .filter(|(_id, reason)| {
- *reason == USER_SELECTED
- })
- .map(|(id, _reason)| {
- id
- })
+ .filter(|(_id, reason)| *reason == USER_SELECTED)
+ .map(|(id, _reason)| id)
  .collect();
  Ok(patterns)
  }
 
  /// Selects patterns by user
  pub async fn select_patterns(&self, patterns: &Vec<String>) -> Result<(), ServiceError> {
  let patterns: Vec<&str> = patterns.iter().map(AsRef::as_ref).collect();
- self.software_proxy.set_user_patterns(patterns.as_slice()).await?;
+ self.software_proxy
+ .set_user_patterns(patterns.as_slice())
+ .await?;
  Ok(())
  }
 }

rust/agama-lib/src/software/store.rs

@@ -18,13 +18,13 @@ impl<'a> SoftwareStore<'a> {
 
  pub async fn load(&self) -> Result<SoftwareSettings, ServiceError> {
  let patterns = self.software_client.user_selected_patterns().await?;
- Ok(SoftwareSettings {
- patterns,
- })
+ Ok(SoftwareSettings { patterns })
  }
 
  pub async fn store(&self, settings: &SoftwareSettings) -> Result<(), ServiceError> {
- self.software_client.select_patterns(&settings.patterns).await?;
+ self.software_client
+ .select_patterns(&settings.patterns)
+ .await?;
 
  Ok(())
  }

rust/agama-lib/src/store.rs

@@ -3,7 +3,8 @@
 use crate::error::ServiceError;
 use crate::install_settings::{InstallSettings, Scope};
 use crate::{
- network::NetworkStore, software::SoftwareStore, storage::StorageStore, users::UsersStore, product::ProductStore
+ network::NetworkStore, product::ProductStore, software::SoftwareStore, storage::StorageStore,
+ users::UsersStore,
 };
 use zbus::Connection;