merged with main

version bump to 0.5.0
added xml, properties and ini
2026-03-18 15:39:09 +01:00 · 2026-03-18 15:34:00 +01:00 · 2026-03-18 15:30:14 +01:00 · 2026-03-18 15:25:53 +01:00 · 2026-03-18 15:25:37 +01:00 · 2026-03-18 15:22:24 +01:00
10 changed files with 882 additions and 164 deletions
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -247,6 +247,26 @@ dependencies = [
 "static_assertions",
 ]

+[[package]]
+name = "const-random"
+version = "0.1.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87e00182fe74b066627d63b85fd550ac2998d4b0bd86bfed477a0ae4c7c71359"
+dependencies = [
+ "const-random-macro",
+]
+
+[[package]]
+name = "const-random-macro"
+version = "0.1.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9d839f2a20b0aee515dc581a6172f2321f96cab76c1a38a4c584a194955390e"
+dependencies = [
+ "getrandom 0.2.17",
+ "once_cell",
+ "tiny-keccak",
+]
+
 [[package]]
 name = "convert_case"
 version = "0.10.0"
@@ -292,6 +312,12 @@ dependencies = [
 "winapi",
 ]

+[[package]]
+name = "crunchy"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
+
 [[package]]
 name = "crypto-common"
 version = "0.1.7"
@@ -414,6 +440,15 @@ dependencies = [
 "windows-sys",
 ]

+[[package]]
+name = "dlv-list"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "442039f5147480ba31067cb00ada1adae6892028e40e45fc5de7b7df6dcc1b5f"
+dependencies = [
+ "const-random",
+]
+
 [[package]]
 name = "document-features"
 version = "0.2.12"
@@ -429,6 +464,15 @@ version = "1.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"

+[[package]]
+name = "encoding_rs"
+version = "0.8.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3"
+dependencies = [
+ "cfg-if",
+]
+
 [[package]]
 name = "env_filter"
 version = "1.0.0"
@@ -580,6 +624,12 @@ dependencies = [
 "wasip3",
 ]

+[[package]]
+name = "hashbrown"
+version = "0.14.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
+
 [[package]]
 name = "hashbrown"
 version = "0.15.5"
@@ -679,6 +729,17 @@ version = "1.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"

+[[package]]
+name = "java-properties"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37bf6f484471c451f2b51eabd9e66b3fa7274550c5ec4b6c3d6070840945117f"
+dependencies = [
+ "encoding_rs",
+ "lazy_static",
+ "regex",
+]
+
 [[package]]
 name = "jiff"
 version = "0.2.23"
@@ -853,15 +914,18 @@ dependencies = [

 [[package]]
 name = "mould"
-version = "0.4.2"
+version = "0.4.3"
 dependencies = [
 "anyhow",
 "clap",
 "crossterm",
 "dirs",
 "env_logger",
+ "java-properties",
 "log",
+ "quick-xml",
 "ratatui",
+ "rust-ini",
 "serde",
 "serde_json",
 "serde_yaml",
@@ -956,6 +1020,16 @@ dependencies = [
 "num-traits",
 ]

+[[package]]
+name = "ordered-multimap"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49203cdcae0030493bad186b28da2fa25645fa276a51b6fec8010d281e02ef79"
+dependencies = [
+ "dlv-list",
+ "hashbrown 0.14.5",
+]
+
 [[package]]
 name = "parking_lot"
 version = "0.12.5"
@@ -1114,6 +1188,16 @@ dependencies = [
 "unicode-ident",
 ]

+[[package]]
+name = "quick-xml"
+version = "0.39.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "958f21e8e7ceb5a1aa7fa87fab28e7c75976e0bfe7e23ff069e0a260f894067d"
+dependencies = [
+ "memchr",
+ "serde",
+]
+
 [[package]]
 name = "quote"
 version = "1.0.45"
@@ -1284,6 +1368,16 @@ version = "0.8.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a"

+[[package]]
+name = "rust-ini"
+version = "0.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "796e8d2b6696392a43bea58116b667fb4c29727dc5abd27d6acf338bb4f688c7"
+dependencies = [
+ "cfg-if",
+ "ordered-multimap",
+]
+
 [[package]]
 name = "rustc_version"
 version = "0.4.1"
@@ -1642,10 +1736,19 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7694e1cfe791f8d31026952abf09c69ca6f6fa4e1a1229e18988f06a04a12dca"

 [[package]]
-name = "toml"
-version = "1.0.6+spec-1.1.0"
+name = "tiny-keccak"
+version = "2.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "399b1124a3c9e16766831c6bba21e50192572cdd98706ea114f9502509686ffc"
+checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237"
+dependencies = [
+ "crunchy",
+]
+
+[[package]]
+name = "toml"
+version = "1.0.7+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd28d57d8a6f6e458bc0b8784f8fdcc4b99a437936056fa122cb234f18656a96"
 dependencies = [
 "indexmap",
 "serde_core",
@@ -1658,27 +1761,27 @@ dependencies = [

 [[package]]
 name = "toml_datetime"
-version = "1.0.0+spec-1.1.0"
+version = "1.0.1+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32c2555c699578a4f59f0cc68e5116c8d7cabbd45e1409b989d4be085b53f13e"
+checksum = "9b320e741db58cac564e26c607d3cc1fdc4a88fd36c879568c07856ed83ff3e9"
 dependencies = [
 "serde_core",
 ]

 [[package]]
 name = "toml_parser"
-version = "1.0.9+spec-1.1.0"
+version = "1.0.10+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "702d4415e08923e7e1ef96cd5727c0dfed80b4d2fa25db9647fe5eb6f7c5a4c4"
+checksum = "7df25b4befd31c4816df190124375d5a20c6b6921e2cad937316de3fccd63420"
 dependencies = [
 "winnow",
 ]

 [[package]]
 name = "toml_writer"
-version = "1.0.6+spec-1.1.0"
+version = "1.0.7+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab16f14aed21ee8bfd8ec22513f7287cd4a91aa92e44edfe2c17ddd004e92607"
+checksum = "f17aaa1c6e3dc22b1da4b6bba97d066e354c7945cac2f7852d4e4e7ca7a6b56d"

 [[package]]
 name = "tui-input"
@@ -1990,9 +2093,9 @@ dependencies = [

 [[package]]
 name = "winnow"
-version = "0.7.15"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df79d97927682d2fd8adb29682d1140b343be4ac0f08fd68b7765d9c059d3945"
+checksum = "a90e88e4667264a994d34e6d1ab2d26d398dcdca8b7f52bec8668957517fc7d8"

 [[package]]
 name = "wit-bindgen"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,3 +1,9 @@
+[package]
+authors = ["Nils Pukropp <nils@narl.io>"]
+edition = "2024"
+name = "mould"
+version = "0.5.0"
+
 [[bin]]
 name = "mould"
 path = "src/main.rs"
@@ -7,12 +13,15 @@ anyhow = "1.0.102"
 crossterm = "0.29.0"
 dirs = "6.0.0"
 env_logger = "0.11.9"
+java-properties = "2.0.0"
 log = "0.4.29"
+quick-xml = { version = "0.39.2", features = ["serde", "serialize"] }
 ratatui = "0.30.0"
+rust-ini = "0.21.3"
 serde_json = "1.0.149"
 serde_yaml = "0.9.34"
 thiserror = "2.0.18"
-toml = "1.0.6"
+toml = "1.0.7"
 tui-input = "0.15.0"

 [dependencies.clap]
@@ -25,9 +34,3 @@ version = "1.0.228"

 [dev-dependencies]
 tempfile = "3.27.0"
-
-[package]
-authors = ["Nils Pukropp <nils@narl.io>"]
-edition = "2024"
-name = "mould"
-version = "0.4.2"
--- a/README.md
+++ b/README.md
@@ -1,12 +1,13 @@
 # mould

-mould is a modern Terminal User Interface (TUI) tool designed for interactively generating and editing configuration files from templates. Whether you are setting up a `.env` file from an example, creating a `docker-compose.override.yml`, or editing nested `JSON`, `YAML`, or `TOML` configurations, mould provides a fast, Vim-inspired workflow to get your environment ready.
+mould is a modern Terminal User Interface (TUI) tool designed for interactively generating and editing configuration files from templates. Whether you are setting up a `.env` file from an example, creating a `docker-compose.override.yml`, or editing nested `JSON`, `YAML`, `TOML`, `XML`, `INI`, or `Properties` configurations, mould provides a fast, Vim-inspired workflow to get your environment ready.

 ## Features

- **Universal Format Support**: Handle `.env`, `JSON`, `YAML`, and `TOML` seamlessly.
- **Tree View Navigation**: Edit nested data structures (JSON, YAML, TOML) in a beautiful, depth-colored tree view.
- **Smart Template Comparison**: Automatically discovers `.env.example` vs `.env` relationships and highlights missing or modified keys.
+- **Universal Format Support**: Handle `.env`, `JSON`, `YAML`, `TOML`, `XML`, `INI`, and `Properties` seamlessly.
+- **Tree View Navigation**: Edit nested data structures in a beautiful, depth-colored tree view.
+- **Smart Template Discovery**: Rule-based resolver automatically discovers relationships (e.g., `.env.example` vs `.env`, `config.template.properties` vs `config.properties`) and highlights differences.
+- **Strict Type Preservation**: Intelligently preserves data types (integers, booleans, strings) during edit-save cycles, ensuring your configuration stays valid.
 - **Add Missing Keys**: Instantly pull missing keys and their default values from your template into your active configuration with a single keystroke.
 - **Neovim Integration**: Comes with a built-in Neovim plugin for seamless in-editor configuration management.
 - **Docker Compose Integration**: Automatically generate `docker-compose.override.yml` from `docker-compose.yml`.
--- a/config.toml
+++ b/config.toml
@@ -0,0 +1,37 @@
+[keybinds]
+append_item = "o"
+delete_item = "dd"
+down = "j"
+edit = "i"
+edit_append = "A"
+edit_substitute = "S"
+jump_bottom = "G"
+jump_top = "gg"
+next_match = "n"
+normal_mode = "Esc"
+prepend_item = "O"
+previous_match = "N"
+quit = ":q"
+save = ":w"
+search = "/"
+undo = "u"
+up = "k"
+
+[theme]
+bg_active = "#a6e3a1"
+bg_highlight = "#89b4fa"
+bg_normal = "#1e1e2e"
+bg_search = "#cba6f7"
+border_active = "#a6e3a1"
+border_normal = "#45475a"
+fg_accent = "#b4befe"
+fg_dimmed = "#6c7086"
+fg_highlight = "#1e1e2e"
+fg_modified = "#fab387"
+fg_normal = "#cdd6f4"
+fg_warning = "#f38ba8"
+transparent = true
+tree_depth_1 = "#b4befe"
+tree_depth_2 = "#cba6f7"
+tree_depth_3 = "#89b4fa"
+tree_depth_4 = "#fab387"
--- a/src/format/hierarchical.rs
+++ b/src/format/hierarchical.rs
@@ -22,6 +22,8 @@ impl HierarchicalHandler {
                .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?,
            FormatType::Toml => toml::from_str(&content)
                .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?,
+            FormatType::Xml => xml_to_json(&content)
+                .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?,
            _ => unreachable!(),
        };
        Ok(value)
@@ -47,12 +49,124 @@ impl HierarchicalHandler {
                    ));
                }
            }
+            FormatType::Xml => json_to_xml(value),
            _ => unreachable!(),
        };
        fs::write(path, content)
    }
 }

+fn xml_to_json(content: &str) -> io::Result<Value> {
+    use quick_xml::reader::Reader;
+    use quick_xml::events::Event;
+
+    let mut reader = Reader::from_str(content);
+    reader.config_mut().trim_text(true);
+    let mut buf = Vec::new();
+    
+    fn parse_recursive(reader: &mut Reader<&[u8]>) -> io::Result<Value> {
+        let mut map = Map::new();
+        let mut text = String::new();
+        let mut buf = Vec::new();
+
+        loop {
+            match reader.read_event_into(&mut buf) {
+                Ok(Event::Start(e)) => {
+                    let name = String::from_utf8_lossy(e.name().as_ref()).to_string();
+                    let val = parse_recursive(reader)?;
+                    
+                    if let Some(existing) = map.get_mut(&name) {
+                        if let Some(arr) = existing.as_array_mut() {
+                            arr.push(val);
+                        } else {
+                            let old = existing.take();
+                            *existing = Value::Array(vec![old, val]);
+                        }
+                    } else {
+                        map.insert(name, val);
+                    }
+                }
+                Ok(Event::End(_)) => break,
+                Ok(Event::Text(e)) => {
+                    text.push_str(&String::from_utf8_lossy(e.as_ref()));
+                }
+                Ok(Event::Eof) => break,
+                _ => {}
+            }
+            buf.clear();
+        }
+
+        if map.is_empty() {
+            if text.is_empty() {
+                Ok(Value::Null)
+            } else {
+                Ok(Value::String(text))
+            }
+        } else {
+            if !text.is_empty() {
+                map.insert("$text".to_string(), Value::String(text));
+            }
+            Ok(Value::Object(map))
+        }
+    }
+
+    // Move to the first start tag
+    loop {
+        match reader.read_event_into(&mut buf) {
+            Ok(Event::Start(e)) => {
+                let name = String::from_utf8_lossy(e.name().as_ref()).to_string();
+                let val = parse_recursive(&mut reader)?;
+                let mut root = Map::new();
+                root.insert(name, val);
+                return Ok(Value::Object(root));
+            }
+            Ok(Event::Eof) => break,
+            _ => {}
+        }
+        buf.clear();
+    }
+
+    Ok(Value::Object(Map::new()))
+}
+
+fn json_to_xml(value: &Value) -> String {
+    match value {
+        Value::Object(map) => {
+            let mut s = String::new();
+            for (k, v) in map {
+                if k == "$text" {
+                    s.push_str(&v.as_str().unwrap_or(""));
+                } else if let Some(arr) = v.as_array() {
+                    for item in arr {
+                        s.push_str(&format!("<{}>", k));
+                        s.push_str(&json_to_xml(item));
+                        s.push_str(&format!("</{}>", k));
+                    }
+                } else {
+                    s.push_str(&format!("<{}>", k));
+                    s.push_str(&json_to_xml(v));
+                    s.push_str(&format!("</{}>", k));
+                }
+            }
+            s
+        }
+        Value::Array(arr) => {
+            let mut s = String::new();
+            for v in arr {
+                s.push_str(&json_to_xml(v));
+            }
+            s
+        }
+        Value::String(v) => v.clone(),
+        Value::Number(v) => v.to_string(),
+        Value::Bool(v) => v.to_string(),
+        Value::Null => "".to_string(),
+    }
+}
+
+// remove unused get_xml_root_name
+// fn get_xml_root_name(content: &str) -> Option<String> { ... }
+
 fn flatten(value: &Value, prefix: &str, depth: usize, key_name: &str, vars: &mut Vec<ConfigItem>) {
    let path = if prefix.is_empty() {
        key_name.to_string()
@@ -322,7 +436,7 @@ mod tests {
    use super::*;

    #[test]
-    fn test_flatten_unflatten() {
+    fn test_json_flatten_unflatten() {
        let mut vars = Vec::new();
        let json = serde_json::json!({
            "services": {
@@ -350,4 +464,129 @@ mod tests {
        assert!(unflattened_json.contains("\"8080:80\""));
        assert!(unflattened_json.contains("true"));
    }
+
+    #[test]
+    fn test_type_preservation() {
+        let mut vars = Vec::new();
+        // A JSON with various tricky types
+        let json = serde_json::json!({
+            "port_num": 8080,
+            "port_str": "8080",
+            "is_enabled": true,
+            "is_enabled_str": "true",
+            "float_num": 3.14,
+            "float_str": "3.14"
+        });
+
+        flatten(&json, "", 0, "", &mut vars);
+        
+        let mut root = Value::Object(Map::new());
+        for var in vars {
+            if !var.is_group {
+                insert_into_value(&mut root, &var.path, var.value.as_deref().unwrap_or(""), var.value_type);
+            }
+        }
+
+        // Validate that types are exactly preserved after re-assembling
+        let unflattened = root.as_object().unwrap();
+        
+        assert!(unflattened["port_num"].is_number(), "port_num should be a number");
+        assert_eq!(unflattened["port_num"].as_i64(), Some(8080));
+        
+        assert!(unflattened["port_str"].is_string(), "port_str should be a string");
+        assert_eq!(unflattened["port_str"].as_str(), Some("8080"));
+        
+        assert!(unflattened["is_enabled"].is_boolean(), "is_enabled should be a boolean");
+        assert_eq!(unflattened["is_enabled"].as_bool(), Some(true));
+        
+        assert!(unflattened["is_enabled_str"].is_string(), "is_enabled_str should be a string");
+        assert_eq!(unflattened["is_enabled_str"].as_str(), Some("true"));
+        
+        assert!(unflattened["float_num"].is_number(), "float_num should be a number");
+        assert_eq!(unflattened["float_num"].as_f64(), Some(3.14));
+        
+        assert!(unflattened["float_str"].is_string(), "float_str should be a string");
+        assert_eq!(unflattened["float_str"].as_str(), Some("3.14"));
+    }
+
+    #[test]
+    fn test_yaml_flatten_unflatten() {
+        let yaml_str = "
+server:
+  port: 8080
+  port_str: \"8080\"
+  enabled: true
+";
+        let yaml_val: Value = serde_yaml::from_str(yaml_str).unwrap();
+        let mut vars = Vec::new();
+        flatten(&yaml_val, "", 0, "", &mut vars);
+        
+        let mut root = Value::Object(Map::new());
+        for var in vars {
+            if !var.is_group {
+                insert_into_value(&mut root, &var.path, var.value.as_deref().unwrap_or(""), var.value_type);
+            }
+        }
+        
+        let unflattened_yaml = serde_yaml::to_string(&root).unwrap();
+        assert!(unflattened_yaml.contains("port: 8080"));
+        // Serde YAML might output '8080' or "8080"
+        assert!(unflattened_yaml.contains("port_str: '8080'") || unflattened_yaml.contains("port_str: \"8080\""));
+        assert!(unflattened_yaml.contains("enabled: true"));
+    }
+
+    #[test]
+    fn test_toml_flatten_unflatten() {
+        let toml_str = "
+[server]
+port = 8080
+port_str = \"8080\"
+enabled = true
+";
+        // parse to toml Value, then convert to serde_json Value to reuse the same flatten path
+        let toml_val: toml::Value = toml::from_str(toml_str).unwrap();
+        let json_val: Value = serde_json::to_value(toml_val).unwrap();
+
+        let mut vars = Vec::new();
+        flatten(&json_val, "", 0, "", &mut vars);
+        
+        let mut root = Value::Object(Map::new());
+        for var in vars {
+            if !var.is_group {
+                insert_into_value(&mut root, &var.path, var.value.as_deref().unwrap_or(""), var.value_type);
+            }
+        }
+        
+        // Convert back to TOML
+        let toml_root: toml::Value = serde_json::from_value(root).unwrap();
+        let unflattened_toml = toml::to_string(&toml_root).unwrap();
+        
+        assert!(unflattened_toml.contains("port = 8080"));
+        assert!(unflattened_toml.contains("port_str = \"8080\""));
+        assert!(unflattened_toml.contains("enabled = true"));
+    }
+
+    #[test]
+    fn test_xml_flatten_unflatten() {
+        let xml_str = "<config><server><port>8080</port><enabled>true</enabled></server></config>";
+        
+        let json_val = xml_to_json(xml_str).unwrap();
+
+        let mut vars = Vec::new();
+        flatten(&json_val, "", 0, "", &mut vars);
+        
+        let mut root = Value::Object(Map::new());
+        for var in vars {
+            if !var.is_group {
+                insert_into_value(&mut root, &var.path, var.value.as_deref().unwrap_or(""), var.value_type);
+            }
+        }
+        
+        println!("Reconstructed root: {:?}", root);
+        let unflattened_xml = json_to_xml(&root);
+
+        assert!(unflattened_xml.contains("<port>8080</port>"));
+        assert!(unflattened_xml.contains("<enabled>true</enabled>"));
+        assert!(unflattened_xml.contains("<config>") && unflattened_xml.contains("</config>"));
+    }
 }
--- a/src/format/ini.rs
+++ b/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")));
+    }
+}
--- a/src/format/mod.rs
+++ b/src/format/mod.rs
@@ -3,6 +3,8 @@ use std::path::Path;

 pub mod env;
 pub mod hierarchical;
+pub mod ini;
+pub mod properties;

 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum ItemStatus {
@@ -39,6 +41,9 @@ pub enum FormatType {
    Json,
    Yaml,
    Toml,
+    Xml,
+    Ini,
+    Properties,
 }

 pub trait FormatHandler {
@@ -54,6 +59,9 @@ pub fn detect_format(path: &Path, override_format: Option<String>) -> FormatType
            "json" => return FormatType::Json,
            "yaml" | "yml" => return FormatType::Yaml,
            "toml" => return FormatType::Toml,
+            "xml" => return FormatType::Xml,
+            "ini" => return FormatType::Ini,
+            "properties" => return FormatType::Properties,
            _ => {}
        }
    }
@@ -65,6 +73,12 @@ pub fn detect_format(path: &Path, override_format: Option<String>) -> FormatType
        FormatType::Yaml
    } else if file_name.ends_with(".toml") {
        FormatType::Toml
+    } else if file_name.ends_with(".xml") {
+        FormatType::Xml
+    } else if file_name.ends_with(".ini") {
+        FormatType::Ini
+    } else if file_name.ends_with(".properties") {
+        FormatType::Properties
    } else {
        FormatType::Env
    }
@@ -76,5 +90,8 @@ pub fn get_handler(format: FormatType) -> Box<dyn FormatHandler> {
        FormatType::Json => Box::new(hierarchical::HierarchicalHandler::new(FormatType::Json)),
        FormatType::Yaml => Box::new(hierarchical::HierarchicalHandler::new(FormatType::Yaml)),
        FormatType::Toml => Box::new(hierarchical::HierarchicalHandler::new(FormatType::Toml)),
+        FormatType::Xml => Box::new(hierarchical::HierarchicalHandler::new(FormatType::Xml)),
+        FormatType::Ini => Box::new(ini::IniHandler),
+        FormatType::Properties => Box::new(properties::PropertiesHandler),
    }
 }
--- a/src/format/properties.rs
+++ b/src/format/properties.rs
@@ -0,0 +1,129 @@
+use super::{ConfigItem, FormatHandler, ItemStatus, ValueType};
+use java_properties::{read, write};
+use std::collections::HashMap;
+use std::fs::File;
+use std::io::{self, BufReader};
+use std::path::Path;
+
+pub struct PropertiesHandler;
+
+impl FormatHandler for PropertiesHandler {
+    fn parse(&self, path: &Path) -> io::Result<Vec<ConfigItem>> {
+        let file = File::open(path)?;
+        let reader = BufReader::new(file);
+        let props = read(reader)
+            .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
+
+        let mut vars = Vec::new();
+        let mut groups = std::collections::HashSet::new();
+
+        for (path, value) in &props {
+            // Add groups based on dot notation
+            let parts: Vec<&str> = path.split('.').collect();
+            let mut current_path = String::new();
+            
+            for i in 0..parts.len() - 1 {
+                if !current_path.is_empty() {
+                    current_path.push('.');
+                }
+                current_path.push_str(parts[i]);
+                
+                if groups.insert(current_path.clone()) {
+                    vars.push(ConfigItem {
+                        key: parts[i].to_string(),
+                        path: current_path.clone(),
+                        value: None,
+                        template_value: None,
+                        default_value: None,
+                        depth: i,
+                        is_group: true,
+                        status: ItemStatus::Present,
+                        value_type: ValueType::Null,
+                    });
+                }
+            }
+
+            vars.push(ConfigItem {
+                key: parts.last().unwrap().to_string(),
+                path: path.clone(),
+                value: Some(value.clone()),
+                template_value: Some(value.clone()),
+                default_value: Some(value.clone()),
+                depth: parts.len() - 1,
+                is_group: false,
+                status: ItemStatus::Present,
+                value_type: ValueType::String,
+            });
+        }
+
+        // Sort by path to keep it organized
+        vars.sort_by(|a, b| a.path.cmp(&b.path));
+        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(vars.sort_by(|a, b| a.path.cmp(&b.path)))
+    }
+
+    fn write(&self, path: &Path, vars: &[ConfigItem]) -> io::Result<()> {
+        let mut props = HashMap::new();
+        for var in vars {
+            if !var.is_group {
+                let val = var.value.as_deref()
+                    .or(var.template_value.as_deref())
+                    .unwrap_or("");
+                props.insert(var.path.clone(), val.to_string());
+            }
+        }
+
+        let file = File::create(path)?;
+        write(file, &props).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_properties() {
+        let mut file = NamedTempFile::new().unwrap();
+        writeln!(file, "server.port=8080\ndatabase.host=localhost").unwrap();
+        
+        let handler = PropertiesHandler;
+        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")));
+    }
+}
--- a/src/main.rs
+++ b/src/main.rs
@@ -5,6 +5,7 @@ mod error;
 mod format;
 mod runner;
 mod ui;
+mod resolver;

 use app::App;
 use config::load_config;
@@ -13,7 +14,6 @@ use format::{detect_format, get_handler};
 use log::{error, info, warn};
 use runner::AppRunner;
 use std::io;
-use std::path::{Path, PathBuf};

 use crossterm::{
    event::{DisableMouseCapture, EnableMouseCapture},
@@ -22,114 +22,6 @@ use crossterm::{
 };
 use ratatui::{Terminal, backend::CrosstermBackend};

-/// Helper to automatically determine the output file path based on common naming conventions.
-fn determine_output_path(input: &Path) -> PathBuf {
-    let file_name = input.file_name().unwrap_or_default().to_string_lossy();
-
-    // Standard mappings
-    if file_name == ".env.example" || file_name == ".env.template" {
-        return input.with_file_name(".env");
-    }
-
-    if file_name == "docker-compose.yml" || file_name == "compose.yml" {
-        return input.with_file_name("compose.override.yml");
-    }
-    if file_name == "docker-compose.yaml" || file_name == "compose.yaml" {
-        return input.with_file_name("compose.override.yaml");
-    }
-
-    // Pattern-based mappings
-    if let Some(base) = file_name.strip_suffix(".env.example") {
-        return input.with_file_name(format!("{}.env", base));
-    }
-    if let Some(base) = file_name.strip_suffix(".env.template") {
-        return input.with_file_name(format!("{}.env", base));
-    }
-    if let Some(base) = file_name.strip_suffix(".example.json") {
-        return input.with_file_name(format!("{}.json", base));
-    }
-    if let Some(base) = file_name.strip_suffix(".template.json") {
-        return input.with_file_name(format!("{}.json", base));
-    }
-    if let Some(base) = file_name.strip_suffix(".example.yml") {
-        return input.with_file_name(format!("{}.yml", base));
-    }
-    if let Some(base) = file_name.strip_suffix(".template.yml") {
-        return input.with_file_name(format!("{}.yml", base));
-    }
-    if let Some(base) = file_name.strip_suffix(".example.yaml") {
-        return input.with_file_name(format!("{}.yaml", base));
-    }
-    if let Some(base) = file_name.strip_suffix(".template.yaml") {
-        return input.with_file_name(format!("{}.yaml", base));
-    }
-    if let Some(base) = file_name.strip_suffix(".example.toml") {
-        return input.with_file_name(format!("{}.toml", base));
-    }
-    if let Some(base) = file_name.strip_suffix(".template.toml") {
-        return input.with_file_name(format!("{}.toml", base));
-    }
-
-    input.with_extension(format!(
-        "{}.out",
-        input.extension().unwrap_or_default().to_string_lossy()
-    ))
-}
-
-/// Discovers common configuration template files in the current directory.
-fn find_input_file() -> Option<PathBuf> {
-    let candidates = [
-        ".env.example",
-        "compose.yml",
-        "docker-compose.yml",
-        ".env.template",
-        "compose.yaml",
-        "docker-compose.yaml",
-    ];
-
-    // Priority 1: Exact matches for well-known defaults
-    for name in &candidates {
-        let path = PathBuf::from(name);
-        if path.exists() {
-            return Some(path);
-        }
-    }
-
-    // Priority 2: Pattern matches
-    if let Ok(entries) = std::fs::read_dir(".") {
-        let mut fallback = None;
-        for entry in entries.flatten() {
-            let name = entry.file_name();
-            let name_str = name.to_string_lossy();
-
-            if name_str.ends_with(".env.example")
-                || name_str.ends_with(".env.template")
-                || name_str.ends_with(".example.json")
-                || name_str.ends_with(".template.json")
-                || name_str.ends_with(".example.yml")
-                || name_str.ends_with(".template.yml")
-                || name_str.ends_with(".example.yaml")
-                || name_str.ends_with(".template.yaml")
-                || name_str.ends_with(".example.toml")
-                || name_str.ends_with(".template.toml")
-            {
-                // Prefer .env.* or compose.* if multiple matches
-                if name_str.contains(".env") || name_str.contains("compose") {
-                    return Some(entry.path());
-                }
-                if fallback.is_none() {
-                    fallback = Some(entry.path());
-                }
-            }
-        }
-        if let Some(path) = fallback {
-            return Some(path);
-        }
-    }
-
-    None
-}
-
 fn main() -> anyhow::Result<()> {
    let args = cli::parse();

@@ -152,7 +44,7 @@ fn main() -> anyhow::Result<()> {
            }
            path
        }
-        None => match find_input_file() {
+        None => match resolver::find_input_file() {
            Some(path) => {
                info!("Discovered template: {}", path.display());
                path
@@ -172,38 +64,11 @@ fn main() -> anyhow::Result<()> {
    let handler = get_handler(format_type);

    // Smart Comparison Logic
-    let input_name = input_path.file_name().unwrap_or_default().to_string_lossy();
-    let is_template_input = input_name.contains(".example") || input_name.contains(".template") || input_name == "compose.yml" || input_name == "docker-compose.yml";
-    
-    let mut template_path = None;
-    let mut active_path = None;
-
-    if is_template_input {
-        template_path = Some(input_path.clone());
-        let expected_active = determine_output_path(&input_path);
-        if expected_active.exists() {
-            active_path = Some(expected_active);
-        }
-    } else {
-        // Input is likely an active config (e.g., .env)
-        active_path = Some(input_path.clone());
-        // Try to find a template
-        let possible_templates = [
-            format!("{}.example", input_name),
-            format!("{}.template", input_name),
-        ];
-        for t in possible_templates {
-            let p = input_path.with_file_name(t);
-            if p.exists() {
-                template_path = Some(p);
-                break;
-            }
-        }
-    }
+    let (active_path, template_path) = resolver::resolve_paths(&input_path);

    let output_path = args
        .output
-        .unwrap_or_else(|| active_path.clone().unwrap_or_else(|| determine_output_path(&input_path)));
+        .unwrap_or_else(|| active_path.clone().unwrap_or_else(|| resolver::determine_output_path(&input_path)));

    info!("Output: {}", output_path.display());

@@ -283,4 +148,4 @@ fn main() -> anyhow::Result<()> {
            Err(e.into())
        }
    }
-}
+}
--- a/src/resolver.rs
+++ b/src/resolver.rs
@@ -0,0 +1,199 @@
+use std::path::{Path, PathBuf};
+
+pub struct Rule {
+    pub template_suffix: &'static str,
+    pub active_suffix: &'static str,
+    pub is_exact_match: bool,
+}
+
+pub const RULES: &[Rule] = &[
+    // Exact matches
+    Rule { template_suffix: "compose.yml", active_suffix: "compose.override.yml", is_exact_match: true },
+    Rule { template_suffix: "compose.yaml", active_suffix: "compose.override.yaml", is_exact_match: true },
+    Rule { template_suffix: "docker-compose.yml", active_suffix: "docker-compose.override.yml", is_exact_match: true },
+    Rule { template_suffix: "docker-compose.yaml", active_suffix: "docker-compose.override.yaml", is_exact_match: true },
+    
+    // Pattern matches
+    Rule { template_suffix: ".env.example", active_suffix: ".env", is_exact_match: false },
+    Rule { template_suffix: ".env.template", active_suffix: ".env", is_exact_match: false },
+    Rule { template_suffix: ".example.json", active_suffix: ".json", is_exact_match: false },
+    Rule { template_suffix: ".template.json", active_suffix: ".json", is_exact_match: false },
+    Rule { template_suffix: ".example.yml", active_suffix: ".yml", is_exact_match: false },
+    Rule { template_suffix: ".template.yml", active_suffix: ".yml", is_exact_match: false },
+    Rule { template_suffix: ".example.yaml", active_suffix: ".yaml", is_exact_match: false },
+    Rule { template_suffix: ".template.yaml", active_suffix: ".yaml", is_exact_match: false },
+    Rule { template_suffix: ".example.toml", active_suffix: ".toml", is_exact_match: false },
+    Rule { template_suffix: ".template.toml", active_suffix: ".toml", is_exact_match: false },
+    Rule { template_suffix: ".example.xml", active_suffix: ".xml", is_exact_match: false },
+    Rule { template_suffix: ".template.xml", active_suffix: ".xml", is_exact_match: false },
+    Rule { template_suffix: ".example.ini", active_suffix: ".ini", is_exact_match: false },
+    Rule { template_suffix: ".template.ini", active_suffix: ".ini", is_exact_match: false },
+    Rule { template_suffix: ".example.properties", active_suffix: ".properties", is_exact_match: false },
+    Rule { template_suffix: ".template.properties", active_suffix: ".properties", is_exact_match: false },
+];
+
+pub const DEFAULT_CANDIDATES: &[&str] = &[
+    ".env.example",
+    "compose.yml",
+    "docker-compose.yml",
+    ".env.template",
+    "compose.yaml",
+    "docker-compose.yaml",
+];
+
+/// Helper to automatically determine the output file path based on common naming conventions.
+pub fn determine_output_path(input: &Path) -> PathBuf {
+    let file_name = input.file_name().unwrap_or_default().to_string_lossy();
+
+    for rule in RULES {
+        if rule.is_exact_match {
+            if file_name == rule.template_suffix {
+                return input.with_file_name(rule.active_suffix);
+            }
+        } else {
+            if file_name == rule.template_suffix {
+                return input.with_file_name(rule.active_suffix);
+            } else if let Some(base) = file_name.strip_suffix(rule.template_suffix) {
+                return input.with_file_name(format!("{}{}", base, rule.active_suffix));
+            }
+        }
+    }
+
+    input.with_extension(format!(
+        "{}.out",
+        input.extension().unwrap_or_default().to_string_lossy()
+    ))
+}
+
+/// Discovers common configuration template files in the current directory.
+pub fn find_input_file() -> Option<PathBuf> {
+    // Priority 1: Exact matches for well-known defaults
+    for &name in DEFAULT_CANDIDATES {
+        let path = PathBuf::from(name);
+        if path.exists() {
+            return Some(path);
+        }
+    }
+
+    // Priority 2: Pattern matches
+    if let Ok(entries) = std::fs::read_dir(".") {
+        let mut fallback = None;
+        for entry in entries.flatten() {
+            let name = entry.file_name();
+            let name_str = name.to_string_lossy();
+
+            for rule in RULES {
+                if !rule.is_exact_match && name_str.ends_with(rule.template_suffix) {
+                    if name_str.contains(".env") || name_str.contains("compose") {
+                        return Some(entry.path());
+                    }
+                    if fallback.is_none() {
+                        fallback = Some(entry.path());
+                    }
+                    break;
+                }
+            }
+        }
+        if let Some(path) = fallback {
+            return Some(path);
+        }
+    }
+
+    None
+}
+
+/// Resolves the active and template paths given an input path.
+/// Returns `(active_path, template_path)`.
+pub fn resolve_paths(input: &Path) -> (Option<PathBuf>, Option<PathBuf>) {
+    let file_name = input.file_name().unwrap_or_default().to_string_lossy();
+    
+    // Check if the input matches any known template pattern
+    let mut is_template = false;
+    for rule in RULES {
+        if rule.is_exact_match {
+            if file_name == rule.template_suffix {
+                is_template = true;
+                break;
+            }
+        } else if file_name.ends_with(rule.template_suffix) {
+            is_template = true;
+            break;
+        }
+    }
+
+    // Fallback template detection
+    if !is_template && (file_name.contains(".example") || file_name.contains(".template")) {
+        is_template = true;
+    }
+
+    if is_template {
+        let expected_active = determine_output_path(input);
+        let active = if expected_active.exists() {
+            Some(expected_active)
+        } else {
+            None
+        };
+        (active, Some(input.to_path_buf()))
+    } else {
+        // Input is treated as the active config
+        let active = Some(input.to_path_buf());
+        let mut template = None;
+        
+        // Try to reverse match rules to find a template
+        for rule in RULES {
+            if rule.is_exact_match {
+                if file_name == rule.active_suffix {
+                    let t = input.with_file_name(rule.template_suffix);
+                    if t.exists() {
+                        template = Some(t);
+                        break;
+                    }
+                }
+            } else if file_name.ends_with(rule.active_suffix) {
+                if file_name == rule.active_suffix {
+                    let t = input.with_file_name(rule.template_suffix);
+                    if t.exists() {
+                        template = Some(t);
+                        break;
+                    }
+                } else if let Some(base) = file_name.strip_suffix(rule.active_suffix) {
+                    let t = input.with_file_name(format!("{}{}", base, rule.template_suffix));
+                    if t.exists() {
+                        template = Some(t);
+                        break;
+                    }
+                }
+            }
+        }
+        
+        // Fallback reverse detection
+        if template.is_none() {
+            let possible_templates = [
+                format!("{}.example", file_name),
+                format!("{}.template", file_name),
+            ];
+            for t in possible_templates {
+                let p = input.with_file_name(t);
+                if p.exists() {
+                    template = Some(p);
+                    break;
+                }
+            }
+        }
+
+        (active, template)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_determine_output_path() {
+        assert_eq!(determine_output_path(Path::new(".env.example")), PathBuf::from(".env"));
+        assert_eq!(determine_output_path(Path::new("compose.yml")), PathBuf::from("compose.override.yml"));
+        assert_eq!(determine_output_path(Path::new("config.template.json")), PathBuf::from("config.json"));
+        assert_eq!(determine_output_path(Path::new("config.example")), PathBuf::from("config.example.out"));
+    }
+}
Author	SHA1	Message	Date
Nils Pukropp	b88d93c800	merged with main All checks were successful Version Check / check-version (pull_request) Successful in 3s Details	2026-03-18 15:39:09 +01:00
Nils Pukropp	a58906a2a4	version bump to 0.5.0 All checks were successful Version Check / check-version (pull_request) Successful in 3s Details	2026-03-18 15:34:00 +01:00
Nils Pukropp	cffea6d806	added xml, properties and ini All checks were successful Version Check / check-version (pull_request) Successful in 3s Details	2026-03-18 15:30:14 +01:00
nvrl	fca84f5820	Merge pull request 'Update Cargo.toml' (#14 ) from nvrl-patch-1 into main All checks were successful Release / Build and Release (push) Successful in 54s Details Reviewed-on: #14	2026-03-18 15:25:53 +01:00
nvrl	1bc4c00e23	Update Cargo.toml All checks were successful Version Check / check-version (pull_request) Successful in 3s Details	2026-03-18 15:25:37 +01:00
nvrl	0d15c61d67	Merge pull request 'release/0.4.3' (#13 ) from release/0.4.3 into main All checks were successful Release / Build and Release (push) Successful in 56s Details Reviewed-on: #13	2026-03-18 15:22:24 +01:00
Nils Pukropp	0f26f7ac76	merged with main All checks were successful Version Check / check-version (pull_request) Successful in 3s Details	2026-03-18 15:22:28 +01:00
Nils Pukropp	184386a96b	updated rule based logic for finding and outputting files All checks were successful Version Check / check-version (pull_request) Successful in 4s Details	2026-03-18 11:26:40 +01:00
nvrl	69d4963e4f	Merge pull request 'Update Cargo.toml' (#12 ) from nvrl-patch-1 into main All checks were successful Release / Build and Release (push) Successful in 58s Details Reviewed-on: #12	2026-03-17 15:06:41 +01:00
nvrl	87ced5a47c	Update Cargo.toml All checks were successful Version Check / check-version (pull_request) Successful in 3s Details	2026-03-17 15:06:32 +01:00
nvrl	f85dac3b25	Merge pull request 'release/0.4.2' (#11 ) from release/0.4.2 into main All checks were successful Release / Build and Release (push) Successful in 55s Details Reviewed-on: #11	2026-03-17 14:33:34 +01:00
nvrl	e09cc3f2d7	Merge pull request 'fixed tests case' (#9 ) from release/0.4.0 into main All checks were successful Release / Build and Release (push) Successful in 53s Details Reviewed-on: #9	2026-03-17 12:39:27 +01:00
nvrl	c270d37585	Merge pull request 'release/0.4.0' (#8 ) from release/0.4.0 into main All checks were successful Release / Build and Release (push) Successful in 57s Details Reviewed-on: #8	2026-03-17 12:30:13 +01:00