added xml, properties and ini

src/format/ini.rs

@@ -0,0 +1,125 @@
+use super::{ConfigItem, FormatHandler, ItemStatus, ValueType};
+use ini::Ini;
+use std::io;
+use std::path::Path;
+
+pub struct IniHandler;
+
+impl FormatHandler for IniHandler {
+    fn parse(&self, path: &Path) -> io::Result<Vec<ConfigItem>> {
+        let conf = Ini::load_from_file(path)
+            .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
+        let mut vars = Vec::new();
+
+        for (section, prop) in &conf {
+            let section_name = section.unwrap_or_default();
+            
+            if !section_name.is_empty() {
+                vars.push(ConfigItem {
+                    key: section_name.to_string(),
+                    path: section_name.to_string(),
+                    value: None,
+                    template_value: None,
+                    default_value: None,
+                    depth: 0,
+                    is_group: true,
+                    status: ItemStatus::Present,
+                    value_type: ValueType::Null,
+                });
+            }
+
+            for (key, value) in prop {
+                let path = if section_name.is_empty() {
+                    key.to_string()
+                } else {
+                    format!("{}.{}", section_name, key)
+                };
+
+                vars.push(ConfigItem {
+                    key: key.to_string(),
+                    path,
+                    value: Some(value.to_string()),
+                    template_value: Some(value.to_string()),
+                    default_value: Some(value.to_string()),
+                    depth: if section_name.is_empty() { 0 } else { 1 },
+                    is_group: false,
+                    status: ItemStatus::Present,
+                    value_type: ValueType::String,
+                });
+            }
+        }
+
+        Ok(vars)
+    }
+
+    fn merge(&self, path: &Path, vars: &mut Vec<ConfigItem>) -> io::Result<()> {
+        if !path.exists() {
+            return Ok(());
+        }
+
+        let existing_vars = self.parse(path).unwrap_or_default();
+
+        for var in vars.iter_mut() {
+            if let Some(existing) = existing_vars.iter().find(|v| v.path == var.path) {
+                if var.value != existing.value {
+                    var.value = existing.value.clone();
+                    var.status = ItemStatus::Modified;
+                }
+            } else {
+                var.status = ItemStatus::MissingFromActive;
+            }
+        }
+        
+        // Add items from active that are not in template
+        for existing in existing_vars {
+            if !vars.iter().any(|v| v.path == existing.path) {
+                let mut new_item = existing.clone();
+                new_item.status = ItemStatus::MissingFromTemplate;
+                new_item.template_value = None;
+                new_item.default_value = None;
+                vars.push(new_item);
+            }
+        }
+
+        Ok(())
+    }
+
+    fn write(&self, path: &Path, vars: &[ConfigItem]) -> io::Result<()> {
+        let mut conf = Ini::new();
+        for var in vars {
+            if !var.is_group {
+                let val = var.value.as_deref()
+                    .or(var.template_value.as_deref())
+                    .unwrap_or("");
+                
+                if let Some((section, key)) = var.path.split_once('.') {
+                    conf.with_section(Some(section)).set(key, val);
+                } else {
+                    conf.with_section(None::<String>).set(&var.path, val);
+                }
+            }
+        }
+        conf.write_to_file(path)
+            .map_err(|e| io::Error::new(io::ErrorKind::Other, e))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::NamedTempFile;
+    use std::io::Write;
+
+    #[test]
+    fn test_parse_ini() {
+        let mut file = NamedTempFile::new().unwrap();
+        writeln!(file, "[server]\nport=8080\n[database]\nhost=localhost").unwrap();
+        
+        let handler = IniHandler;
+        let vars = handler.parse(file.path()).unwrap();
+        
+        assert!(vars.iter().any(|v| v.path == "server" && v.is_group));
+        assert!(vars.iter().any(|v| v.path == "server.port" && v.value.as_deref() == Some("8080")));
+        assert!(vars.iter().any(|v| v.path == "database.host" && v.value.as_deref() == Some("localhost")));
+    }
+}