mould-rs/src/format/properties.rs

use super::{ConfigItem, FormatHandler, ValueType, PathSegment};
use java_properties::{LineContent, PropertiesIter, PropertiesWriter};
use std::fs::File;
use std::io::{BufReader, BufWriter};
use std::path::Path;

pub struct PropertiesHandler;

impl FormatHandler for PropertiesHandler {
    fn parse(&self, path: &Path) -> anyhow::Result<Vec<ConfigItem>> {
        let file = File::open(path)?;
        let reader = BufReader::new(file);
        let iter = PropertiesIter::new(reader);

        let mut vars = Vec::new();
        let mut groups = std::collections::HashSet::new();

        for line_result in iter {
            let line = line_result?;
            
            if let LineContent::KVPair(path, value) = line.consume_content() {
                // Add groups based on dot notation
                let parts: Vec<&str> = path.split('.').collect();
                let mut current_path = Vec::new();
                
                for (i, part) in parts.iter().enumerate().take(parts.len().saturating_sub(1)) {
                    current_path.push(PathSegment::Key(part.to_string()));
                    
                    if groups.insert(current_path.clone()) {
                        vars.push(ConfigItem::group(*part, current_path.clone(), i));
                    }
                }

                let mut final_path = current_path.clone();
                let last_key = parts.last().unwrap_or(&"").to_string();
                final_path.push(PathSegment::Key(last_key.clone()));

                vars.push(ConfigItem::leaf(
                    last_key,
                    final_path,
                    value,
                    parts.len().saturating_sub(1),
                    ValueType::String,
                ));
            }
        }


        Ok(vars)
    }

    fn write(&self, path: &Path, vars: &[ConfigItem]) -> anyhow::Result<()> {
        let file = File::create(path)?;
        let writer = BufWriter::new(file);
        let mut prop_writer = PropertiesWriter::new(writer);
        
        for var in vars {
            if var.should_write() {
                prop_writer.write(&var.path_string(), var.write_value())?;
            }
        }

        prop_writer.finish()?;
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use tempfile::NamedTempFile;

    #[test]
    fn test_group_rename_write() {
        let handler = PropertiesHandler;
        let mut vars = vec![
            ConfigItem::group("server", vec![PathSegment::Key("server".to_string())], 0),
            ConfigItem::leaf(
                "port",
                vec![PathSegment::Key("server".to_string()), PathSegment::Key("port".to_string())],
                "8080",
                1,
                ValueType::String,
            ),
        ];

        // Rename "server" to "srv"
        vars[0].key = "srv".to_string();
        vars[0].path = vec![PathSegment::Key("srv".to_string())];
        
        // Update child path
        vars[1].path = vec![PathSegment::Key("srv".to_string()), PathSegment::Key("port".to_string())];
        
        let file = NamedTempFile::new().unwrap();
        handler.write(file.path(), &vars).unwrap();
        
        let content = std::fs::read_to_string(file.path()).unwrap();
        assert!(content.contains("srv.port=8080"));
        assert!(!content.contains("server.port=8080"));
    }
}