bare_config/

properties.rs

//! Properties format support for configuration content.
//!
//! This module provides the `PropertiesContent` type for working
//! with Java Properties configuration files.
//!
//! # Features
//!
//! - Full CRUD operations (select, insert, update, delete, upsert)
//! - Sorted output for consistent round-trip serialization
//! - Support for both `=` and `:` as key-value separators
//!
//! # Example
//!
//! ```
//! use bare_config::properties::PropertiesContent;
//! use bare_config::{ConfigContent, key::Key};
//! use bare_config::value::Value;
//! use std::str::FromStr;
//!
//! // Parse Properties configuration
//! let config = PropertiesContent::from_str("database.url=localhost").unwrap();
//!
//! // Select a value
//! let value = config.select(&Key::from_str(".database.url").unwrap()).unwrap();
//! assert_eq!(value.as_str(), Some("localhost"));
//!
//! // Insert a new value
//! let mut config = PropertiesContent::from_str("").unwrap();
//! config.insert(&Key::from_str(".server.port").unwrap(), &Value::string("8080")).unwrap();
//!
//! // Format as string (sorted output)
//! let output = config.to_string();
//! println!("{}", output);
//! ```

use core::fmt;
use core::str::FromStr;

use crate::ConfigContent;
use crate::error::{ConfigError, ConfigResult};
use crate::key::{Key, KeySegment};
use crate::value::Value;
use std::collections::HashMap;

/// Properties configuration content.
///
/// This type provides CRUD operations for Properties configuration data.
#[derive(Debug, Clone)]
pub struct PropertiesContent {
    data: HashMap<String, String>,
}

impl PartialEq for PropertiesContent {
    fn eq(&self, other: &Self) -> bool {
        self.data == other.data
    }
}

#[allow(dead_code)]
impl PropertiesContent {
    /// Creates a new PropertiesContent from a HashMap.
    pub fn from_map(map: HashMap<String, String>) -> Self {
        Self { data: map }
    }

    /// Returns a reference to the underlying HashMap.
    pub fn as_map(&self) -> &HashMap<String, String> {
        &self.data
    }

    /// Converts to the underlying HashMap.
    pub fn into_map(self) -> HashMap<String, String> {
        self.data
    }

    fn parse_key(key: &Key) -> ConfigResult<String> {
        let segments = key.segments();

        if segments.is_empty() {
            return Err(ConfigError::InvalidKey("Empty key".to_string()));
        }

        let parts: Vec<String> = segments
            .iter()
            .filter_map(|s| match s {
                KeySegment::Key(s) => Some(s.clone()),
                KeySegment::Index(_) => None,
                KeySegment::Attribute(_) => None,
            })
            .collect();

        if parts.is_empty() {
            return Err(ConfigError::InvalidKey("Invalid key format".to_string()));
        }

        Ok(parts.join("."))
    }

    fn get_value_at_key(&self, key: &Key) -> ConfigResult<String> {
        let key_str = Self::parse_key(key)?;

        self.data
            .get(&key_str)
            .cloned()
            .ok_or_else(|| ConfigError::KeyNotFound(key.to_key_string()))
    }

    fn contains_key_at(&self, key: &Key) -> bool {
        if let Ok(key_str) = Self::parse_key(key) {
            self.data.contains_key(&key_str)
        } else {
            false
        }
    }

    fn keys_at(&self) -> Vec<Key> {
        self.data
            .keys()
            .filter_map(|k| Key::from_str(&format!(".{}", k)).ok())
            .collect()
    }

    fn len_at(&self) -> usize {
        self.data.len()
    }

    fn delete_at(&mut self, key: &Key) -> ConfigResult<()> {
        let key_str = Self::parse_key(key)?;

        if self.data.remove(&key_str).is_some() {
            Ok(())
        } else {
            Err(ConfigError::KeyNotFound(key.to_key_string()))
        }
    }

    fn upsert_at(&mut self, key: &Key, value: &Value) -> ConfigResult<()> {
        let key_str = Self::parse_key(key)?;
        let value_str = value.to_string_repr();

        drop(self.data.insert(key_str, value_str));
        Ok(())
    }
}

impl ConfigContent for PropertiesContent {
    fn select(&self, key: &Key) -> ConfigResult<Value> {
        let value = self.get_value_at_key(key)?;
        Ok(Value::String(value))
    }

    fn insert(&mut self, key: &Key, value: &Value) -> ConfigResult<()> {
        if self.contains_key_at(key) {
            return Err(ConfigError::KeyAlreadyExists(key.to_key_string()));
        }
        self.upsert_at(key, value)
    }

    fn update(&mut self, key: &Key, value: &Value) -> ConfigResult<()> {
        if !self.contains_key_at(key) {
            return Err(ConfigError::KeyDoesNotExist(key.to_key_string()));
        }
        self.upsert_at(key, value)
    }

    fn delete(&mut self, key: &Key) -> ConfigResult<()> {
        self.delete_at(key)
    }

    fn upsert(&mut self, key: &Key, value: &Value) -> ConfigResult<()> {
        self.upsert_at(key, value)
    }

    fn keys(&self) -> Vec<Key> {
        self.keys_at()
    }
}

impl FromStr for PropertiesContent {
    type Err = ConfigError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        // Pre-allocate: estimate based on non-empty, non-comment lines
        let estimated = s
            .lines()
            .map(|l| l.trim())
            .filter(|l| !l.is_empty() && !l.starts_with('#') && !l.starts_with('!'))
            .count();
        let mut map = HashMap::with_capacity(estimated);

        // Process lines with line continuation support
        let mut current_key: Option<String> = None;
        let mut current_value = String::new();

        // Pre-process: join lines with backslash-newline continuation
        let processed: String = {
            let mut result = String::new();
            let mut previous_backslash = false;

            for line in s.lines() {
                if previous_backslash {
                    // Continuation - append line (without the leading whitespace)
                    result.push_str(line);
                    previous_backslash = false;
                } else {
                    // New line
                    result.push('\n');
                    result.push_str(line);
                }

                // Check if this line ends with backslash
                let trimmed = line.trim_end();
                if trimmed.ends_with('\\') {
                    previous_backslash = true;
                    // Remove the trailing backslash
                    let _ = result.pop();
                }
            }
            result
        };

        for line in processed.lines() {
            let line = line.trim();

            if line.is_empty() || line.starts_with('#') || line.starts_with('!') {
                continue;
            }

            // Flush previous key-value if any
            if let Some(key) = current_key.take() {
                if !current_value.is_empty() || !map.contains_key(&key) {
                    drop(map.insert(key, current_value.clone()));
                }
                current_value.clear();
            }

            if let Some(pos) = line.find('=') {
                let key = line[..pos].trim().to_string();
                let value = line[pos + 1..].trim().to_string();
                drop(map.insert(key, value));
            } else if let Some(pos) = line.find(':') {
                let key = line[..pos].trim().to_string();
                let value = line[pos + 1..].trim().to_string();
                drop(map.insert(key, value));
            }
        }

        // Handle last key-value pair if exists
        if let Some(key) = current_key {
            if !current_value.is_empty() || !map.contains_key(&key) {
                drop(map.insert(key, current_value));
            }
        }

        Ok(Self { data: map })
    }
}

impl fmt::Display for PropertiesContent {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let mut keys: Vec<_> = self.data.keys().collect();
        keys.sort();

        for key in keys {
            if let Some(value) = self.data.get(key) {
                writeln!(f, "{}={}", key, value)?;
            }
        }

        Ok(())
    }
}

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

    #[test]
    fn test_properties_from_str() {
        let content = PropertiesContent::from_str("key=value").expect("test should succeed");
        assert!(
            content
                .select(&Key::from_str(".key").expect("test should succeed"))
                .is_ok()
        );
    }

    #[test]
    fn test_properties_select() {
        let content = PropertiesContent::from_str("name=test").expect("test should succeed");
        let value = content
            .select(&Key::from_str(".name").expect("test should succeed"))
            .expect("test should succeed");
        assert_eq!(value.as_str(), Some("test"));
    }

    #[test]
    fn test_properties_nested() {
        let content =
            PropertiesContent::from_str("database.url=localhost").expect("test should succeed");
        let value = content
            .select(&Key::from_str(".database.url").expect("test should succeed"))
            .expect("test should succeed");
        assert_eq!(value.as_str(), Some("localhost"));
    }

    #[test]
    fn test_properties_insert() {
        let mut content = PropertiesContent::from_str("").expect("test should succeed");
        content
            .insert(
                &Key::from_str(".name").expect("test should succeed"),
                &Value::string("test"),
            )
            .expect("test should succeed");
        let value = content
            .select(&Key::from_str(".name").expect("test should succeed"))
            .expect("test should succeed");
        assert_eq!(value.as_str(), Some("test"));
    }

    #[test]
    fn test_properties_update() {
        let mut content = PropertiesContent::from_str("name=old").expect("test should succeed");
        content
            .update(
                &Key::from_str(".name").expect("test should succeed"),
                &Value::string("new"),
            )
            .expect("test should succeed");
        let value = content
            .select(&Key::from_str(".name").expect("test should succeed"))
            .expect("test should succeed");
        assert_eq!(value.as_str(), Some("new"));
    }

    #[test]
    fn test_properties_delete() {
        let mut content = PropertiesContent::from_str("name=test").expect("test should succeed");
        content
            .delete(&Key::from_str(".name").expect("test should succeed"))
            .expect("test should succeed");
        assert!(
            content
                .select(&Key::from_str(".name").expect("test should succeed"))
                .is_err()
        );
    }

    #[test]
    fn test_properties_upsert() {
        let mut content = PropertiesContent::from_str("").expect("test should succeed");
        content
            .upsert(
                &Key::from_str(".name").expect("test should succeed"),
                &Value::string("test"),
            )
            .expect("test should succeed");
        let value = content
            .select(&Key::from_str(".name").expect("test should succeed"))
            .expect("test should succeed");
        assert_eq!(value.as_str(), Some("test"));
    }

    #[test]
    fn test_properties_display_is_stable_and_sorted() {
        let content = PropertiesContent::from_str("z=1\na=2").expect("test should succeed");
        let first = content.to_string();
        let second = content.to_string();
        assert_eq!(first, second);
        assert_eq!(first.lines().next(), Some("a=2"));
    }

    #[test]
    fn test_properties_comment() {
        let content = PropertiesContent::from_str("# This is a comment\nkey=value")
            .expect("test should succeed");
        assert!(
            content
                .select(&Key::from_str(".key").expect("test should succeed"))
                .is_ok()
        );
    }

    #[test]
    fn test_properties_whitespace() {
        let content = PropertiesContent::from_str("key = value").expect("test should succeed");
        let value = content
            .select(&Key::from_str(".key").expect("test should succeed"))
            .expect("test should succeed");
        assert_eq!(value.as_str(), Some("value"));
    }

    #[test]
    fn test_properties_continuation() {
        let content =
            PropertiesContent::from_str("key=value1\\\nvalue2").expect("test should succeed");
        let value = content
            .select(&Key::from_str(".key").expect("test should succeed"))
            .expect("test should succeed");
        assert!(
            value
                .as_str()
                .expect("test should succeed")
                .contains("value1")
        );
    }

    #[test]
    fn test_properties_colon_separator() {
        let content = PropertiesContent::from_str("key:value").expect("test should succeed");
        let value = content
            .select(&Key::from_str(".key").expect("test should succeed"))
            .expect("test should succeed");
        assert_eq!(value.as_str(), Some("value"));
    }

    #[test]
    fn test_properties_update_existing() {
        let mut content = PropertiesContent::from_str("key=old").expect("test should succeed");
        content
            .update(
                &Key::from_str(".key").expect("test should succeed"),
                &Value::string("new"),
            )
            .expect("test should succeed");
        let value = content
            .select(&Key::from_str(".key").expect("test should succeed"))
            .expect("test should succeed");
        assert_eq!(value.as_str(), Some("new"));
    }

    #[test]
    fn test_properties_delete_existing() {
        let mut content = PropertiesContent::from_str("key=value").expect("test should succeed");
        content
            .delete(&Key::from_str(".key").expect("test should succeed"))
            .expect("test should succeed");
        assert!(
            content
                .select(&Key::from_str(".key").expect("test should succeed"))
                .is_err()
        );
    }

    #[test]
    fn test_properties_upsert_new() {
        let mut content = PropertiesContent::from_str("").expect("test should succeed");
        content
            .upsert(
                &Key::from_str(".key").expect("test should succeed"),
                &Value::string("value"),
            )
            .expect("test should succeed");
        let value = content
            .select(&Key::from_str(".key").expect("test should succeed"))
            .expect("test should succeed");
        assert_eq!(value.as_str(), Some("value"));
    }

    #[test]
    fn test_properties_special_characters() {
        let content =
            PropertiesContent::from_str(r#"path=C\:\\Windows"#).expect("test should succeed");
        let value = content
            .select(&Key::from_str(".path").expect("test should succeed"))
            .expect("test should succeed");
        assert!(value.as_str().is_some());
    }
}