refactor: clean up comment numbering and formatting across codebase

Author: Hakanbaban53

rcman-derive/src/lib.rs

@@ -290,11 +290,17 @@ fn generate_accessor_methods(
         ));
     };
 
-    if attrs.nested || attrs.flatten || is_nested_struct(&field.ty) {
+    let is_structural = match attrs.nesting {
+        Nesting::Flatten | Nesting::Nested => true,
+        Nesting::Object => false,
+        Nesting::Auto => is_nested_struct(&field.ty),
+    };
+
+    if is_structural {
         return Ok(None);
     }
 
-    let category = resolve_field_category(attrs, container_attrs)?;
+    let category = resolve_field_category(attrs, container_attrs);
     let key_name = attrs
         .rename
         .clone()
@@ -324,27 +330,15 @@ fn generate_accessor_methods(
         format!("{category}.{key_name}")
     };
 
-    let snapshot_method = if cfg_attrs.is_empty() {
-        quote! {
-            pub fn #getter_name(&self) -> &#field_type {
-                &self.#field_name
-            }
-
-            pub fn #setter_name(&mut self, value: #field_type) {
-                self.#field_name = value;
-            }
+    let snapshot_method = quote! {
+        #(#cfg_attrs)*
+        pub fn #getter_name(&self) -> &#field_type {
+            &self.#field_name
         }
-    } else {
-        quote! {
-            #(#cfg_attrs)*
-            pub fn #getter_name(&self) -> &#field_type {
-                &self.#field_name
-            }
 
-            #(#cfg_attrs)*
-            pub fn #setter_name(&mut self, value: #field_type) {
-                self.#field_name = value;
-            }
+        #(#cfg_attrs)*
+        pub fn #setter_name(&mut self, value: #field_type) {
+            self.#field_name = value;
         }
     };
 
@@ -355,41 +349,22 @@ fn generate_accessor_methods(
         return Ok(Some((snapshot_method, quote! {}, quote! {})));
     }
 
-    let manager_trait_method = if cfg_attrs.is_empty() {
-        quote! {
-            fn #getter_name(&self) -> rcman::Result<#field_type>;
-            fn #setter_name(&self, value: #field_type) -> rcman::Result<()>;
-        }
-    } else {
-        quote! {
-            #(#cfg_attrs)*
-            fn #getter_name(&self) -> rcman::Result<#field_type>;
-            #(#cfg_attrs)*
-            fn #setter_name(&self, value: #field_type) -> rcman::Result<()>;
-        }
+    let manager_trait_method = quote! {
+        #(#cfg_attrs)*
+        fn #getter_name(&self) -> rcman::Result<#field_type>;
+        #(#cfg_attrs)*
+        fn #setter_name(&self, value: #field_type) -> rcman::Result<()>;
     };
 
-    let manager_impl_method = if cfg_attrs.is_empty() {
-        quote! {
-            fn #getter_name(&self) -> rcman::Result<#field_type> {
-                self.get::<#field_type>(#full_key)
-            }
-
-            fn #setter_name(&self, value: #field_type) -> rcman::Result<()> {
-                self.save_setting(#category, #key_name, &rcman::serde_json::json!(value))
-            }
+    let manager_impl_method = quote! {
+        #(#cfg_attrs)*
+        fn #getter_name(&self) -> rcman::Result<#field_type> {
+            self.get::<#field_type>(#full_key)
         }
-    } else {
-        quote! {
-            #(#cfg_attrs)*
-            fn #getter_name(&self) -> rcman::Result<#field_type> {
-                self.get::<#field_type>(#full_key)
-            }
 
-            #(#cfg_attrs)*
-            fn #setter_name(&self, value: #field_type) -> rcman::Result<()> {
-                self.save_setting(#category, #key_name, &rcman::serde_json::json!(value))
-            }
+        #(#cfg_attrs)*
+        fn #setter_name(&self, value: #field_type) -> rcman::Result<()> {
+            self.save_setting(#category, #key_name, &rcman::serde_json::json!(value))
         }
     };
 
@@ -458,8 +433,14 @@ fn process_field(
 
     // Check if this is a nested struct.
     // We auto-detect simple structs, but allow explicit `nested`, `flatten` or explicit `object` override.
-    if !attrs.object && (attrs.flatten || attrs.nested || is_nested_struct(field_type)) {
-        let prefix = if attrs.flatten {
+    let is_structural = match attrs.nesting {
+        Nesting::Flatten | Nesting::Nested => true,
+        Nesting::Object => false,
+        Nesting::Auto => is_nested_struct(field_type),
+    };
+
+    if is_structural {
+        let prefix = if attrs.nesting == Nesting::Flatten {
             None
         } else {
             Some(field_name.to_string())
@@ -477,7 +458,7 @@ fn process_field(
 
     validate_field_type_constraints(field, type_info, attrs)?;
 
-    let category_str = resolve_field_category(attrs, container_attrs)?;
+    let category_str = resolve_field_category(attrs, container_attrs);
     let final_field_name = attrs
         .rename
         .clone()
@@ -634,16 +615,13 @@ fn validate_field_type_constraints(
     Ok(())
 }
 
-fn resolve_field_category(
-    attrs: &FieldAttrs,
-    container_attrs: &ContainerAttrs,
-) -> Result<String, syn::Error> {
-    Ok(attrs
+fn resolve_field_category(attrs: &FieldAttrs, container_attrs: &ContainerAttrs) -> String {
+    attrs
         .category
         .as_ref()
         .or(container_attrs.category.as_ref())
         .cloned()
-        .unwrap_or_default())
+        .unwrap_or_default()
 }
 
 fn generate_field_constructor(
@@ -728,19 +706,17 @@ fn parse_field_attrs(attrs: &[Attribute]) -> Result<FieldAttrs, syn::Error> {
                     match meta {
                         Meta::Path(path) => {
                             if path.is_ident("flatten") {
-                                result.flatten = true;
+                                result.nesting = Nesting::Flatten;
                             } else if path.is_ident("skip") {
                                 result.skip = true;
                             }
                         }
                         Meta::NameValue(nv) => {
                             if nv.path.is_ident("rename") && result.rename.is_none() {
-                                if let Ok(s) = parse_lit_str(&nv.value, "rename") {
-                                    result.rename = Some(s);
-                                }
+                                result.rename = parse_lit_str(&nv.value, "rename").ok();
                             }
                         }
-                        _ => {}
+                        Meta::List(_) => {}
                     }
                 }
             }
@@ -758,11 +734,11 @@ fn parse_single_field_attr(meta: Meta, result: &mut FieldAttrs) -> Result<(), sy
             } else if path.is_ident("skip") {
                 result.skip = true;
             } else if path.is_ident("nested") {
-                result.nested = true;
+                result.nesting = Nesting::Nested;
             } else if path.is_ident("object") {
-                result.object = true;
+                result.nesting = Nesting::Object;
             } else if path.is_ident("flatten") {
-                result.flatten = true;
+                result.nesting = Nesting::Flatten;
             }
         }
         Meta::NameValue(nv) => {
@@ -829,6 +805,15 @@ struct ContainerAttrs {
     category: Option<String>,
 }
 
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq)]
+enum Nesting {
+    #[default]
+    Auto,
+    Flatten,
+    Nested,
+    Object,
+}
+
 /// Field-level attributes from #[setting(...)]
 #[derive(Default)]
 struct FieldAttrs {
@@ -841,9 +826,7 @@ struct FieldAttrs {
     reserved: Vec<String>,
     secret: bool,
     skip: bool,
-    flatten: bool,
-    nested: bool, // Explicit marker for nested structs
-    object: bool, // Explicit marker to treat as a single object (disables auto-nesting)
+    nesting: Nesting,
     rename: Option<String>,
     // Dynamic metadata: any key=value that isn't a known constraint
     metadata_str: Vec<(String, String)>,
@@ -932,9 +915,8 @@ fn parse_metadata_value(
             Ok(())
         }
         Lit::Int(i) => {
-            if let Ok(val) = i.base10_parse::<i64>() {
-                #[allow(clippy::cast_precision_loss)]
-                result.metadata_num.push((key, val as f64));
+            if let Ok(val) = i.base10_parse::<f64>() {
+                result.metadata_num.push((key, val));
             }
             Ok(())
         }

src/backup/operations.rs

@@ -259,7 +259,7 @@ impl<'a, S: StorageBackend + 'static, Schema: SettingsSchema> BackupManager<'a,
         let mut contents = BackupContents::default();
         let mut total_size = 0u64;
 
-        // 1. Main settings
+        // Main settings
         let include_settings = (options.include_settings
             || matches!(options.export_type, ExportType::Full))
             && !matches!(options.export_type, ExportType::Single { .. });
@@ -271,7 +271,7 @@ impl<'a, S: StorageBackend + 'static, Schema: SettingsSchema> BackupManager<'a,
             contents.settings = true;
         }
 
-        // 2. Sub-settings
+        // Sub-settings
         let sub_settings_to_backup = match &options.export_type {
             ExportType::Full => {
                 if options.include_sub_settings.is_empty() {
@@ -326,7 +326,7 @@ impl<'a, S: StorageBackend + 'static, Schema: SettingsSchema> BackupManager<'a,
             }
         }
 
-        // 3. External configs
+        // External configs
         let include_external_configs = matches!(options.export_type, ExportType::Full)
             || !options.include_external_configs.is_empty();
 
@@ -544,9 +544,9 @@ impl<'a, S: StorageBackend + 'static, Schema: SettingsSchema> BackupManager<'a,
                 if let Some(creds) = creds_opt {
                     // Build the full credential key (prefix.field or just field if prefix is empty)
                     let credential_key = if prefix.is_empty() {
-                        full_key.to_string()
+                        full_key.clone()
                     } else {
-                        format!("{}.{}", prefix, full_key)
+                        format!("{prefix}.{full_key}")
                     };
 
                     // Try to get the secret
@@ -561,8 +561,7 @@ impl<'a, S: StorageBackend + 'static, Schema: SettingsSchema> BackupManager<'a,
                         Ok(None) => {}
                         Err(err) => {
                             debug!(
-                                "Failed to fetch secret '{}' (credential_key: '{}'): {err}",
-                                relative_key, credential_key
+                                "Failed to fetch secret '{relative_key}' (credential_key: '{credential_key}'): {err}"
                             );
                         }
                     }
@@ -656,7 +655,7 @@ impl<'a, S: StorageBackend + 'static, Schema: SettingsSchema> BackupManager<'a,
                 if let Some(obj) = root_value.as_object_mut() {
                     for (entry_name, entry_value) in obj.iter_mut() {
                         // Build credential key prefix: "sub.connections.Local"
-                        let credential_key_prefix = format!("sub.{}.{}", sub_type, entry_name);
+                        let credential_key_prefix = format!("sub.{sub_type}.{entry_name}");
                         self.inject_or_remove_secrets(
                             entry_value,
                             &credential_key_prefix,
@@ -699,7 +698,7 @@ impl<'a, S: StorageBackend + 'static, Schema: SettingsSchema> BackupManager<'a,
                     };
 
                     // Build credential key prefix: "sub.remotes.Google Drive"
-                    let credential_key_prefix = format!("sub.{}.{}", sub_type, name);
+                    let credential_key_prefix = format!("sub.{sub_type}.{name}");
 
                     self.inject_or_remove_secrets(
                         &mut value,

src/backup/restore.rs

@@ -119,13 +119,13 @@ impl<S: StorageBackend + 'static, Schema: SettingsSchema> super::BackupManager<'
             mode_str,
         };
 
-        // 1. Restore main settings
+        // Restore main settings
         ctx.restore_main_settings(&mut result)?;
 
-        // 2. Restore sub-settings
+        // Restore sub-settings
         ctx.restore_sub_settings_entries(&mut result)?;
 
-        // 3. Restore external configs
+        // Restore external configs
         ctx.restore_external_configs_entries(&mut result)?;
 
         info!(
@@ -1036,7 +1036,7 @@ fn load_settings_agnostic<S: StorageBackend>(
     stem: &str,
     storage: &S,
 ) -> Result<Option<(serde_json::Value, String)>> {
-    // 0. Try configured storage extension
+    // Try configured storage extension
     let current_ext = storage.extension();
     let current_path = dir.join(format!("{stem}.{current_ext}"));
     if current_path.exists() {

src/manager/operations.rs

@@ -378,7 +378,7 @@ impl<S: StorageBackend + 'static, Schema: SettingsSchema> SettingsManager<S, Sch
 
         let mut categories = Vec::new();
 
-        // 1. Main settings
+        // Main settings
         categories.push(ExportCategory {
             id: "settings".to_string(),
             name: "Application Settings".to_string(),
@@ -387,7 +387,7 @@ impl<S: StorageBackend + 'static, Schema: SettingsSchema> SettingsManager<S, Sch
             description: Some("Main application settings".to_string()),
         });
 
-        // 2. Sub-settings
+        // Sub-settings
         let sub_types = self.sub_settings_types();
         for sub_type in sub_types {
             categories.push(ExportCategory {
@@ -399,7 +399,7 @@ impl<S: StorageBackend + 'static, Schema: SettingsSchema> SettingsManager<S, Sch
             });
         }
 
-        // 3. External configs
+        // External configs
         for ext in &self.config.external_configs {
             categories.push(ExportCategory {
                 id: ext.id.clone(),