feat(placeholder): add conversion from Android-style to iOS-style placeholders

- Implemented `to_ios_placeholders` function to convert Android-style string placeholders (%s, %1$s) to iOS-style (%@).
- Updated `strings.rs` and `xcstrings.rs` to utilize the new conversion function during entry processing.
- Added tests to ensure correct conversion of placeholders in both string and xcstrings formats.

Author: WendellXY

langcodec/src/formats/strings.rs

@@ -504,7 +504,7 @@ impl TryFrom<Entry> for Pair {
         match entry.value {
             Translation::Singular(value) => Ok(Pair {
                 key: entry.id,
-                value,
+                value: crate::placeholder::to_ios_placeholders(&value),
                 comment: entry.comment,
             }),
             Translation::Plural(_) => Err(Error::DataMismatch(
@@ -628,6 +628,28 @@ mod tests {
         assert!(out_str.contains(r#""key2" = "Can\\'t accept";"#));
     }
 
+    #[test]
+    fn test_strings_writer_ios_placeholder_conversion() {
+        // Build a Resource with Android-style placeholders and ensure writer converts to iOS style
+        let resource = Resource {
+            metadata: Metadata {
+                language: "en".to_string(),
+                domain: String::new(),
+                custom: HashMap::new(),
+            },
+            entries: vec![Entry {
+                id: "g".to_string(),
+                value: Translation::Singular("Hi %1$s and %s".to_string()),
+                comment: None,
+                status: EntryStatus::Translated,
+                custom: HashMap::new(),
+            }],
+        };
+        let fmt = Format::try_from(resource).unwrap();
+        assert_eq!(fmt.pairs.len(), 1);
+        assert_eq!(fmt.pairs[0].value, "Hi %1$@ and %@");
+    }
+
     #[test]
     fn test_multiline_value_with_embedded_newlines_and_whitespace() {
         let content = r#"

langcodec/src/formats/xcstrings.rs

@@ -186,7 +186,7 @@ impl Item {
                     Localization {
                         string_unit: Some(StringUnit {
                             state: entry.status,
-                            value,
+                            value: crate::placeholder::to_ios_placeholders(&value),
                         }),
                         variations: None,
                     },
@@ -200,7 +200,7 @@ impl Item {
                         PluralVariation {
                             string_unit: Some(StringUnit {
                                 state: entry.status.clone(),
-                                value,
+                                value: crate::placeholder::to_ios_placeholders(&value),
                             }),
                         },
                     );
@@ -344,3 +344,69 @@ pub struct PluralVariation {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub string_unit: Option<StringUnit>,
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_ios_placeholder_conversion_in_writer() {
+        // Build resources that contain Android-style placeholders
+        let res = Resource {
+            metadata: Metadata {
+                language: "en".to_string(),
+                domain: String::new(),
+                custom: {
+                    let mut m = HashMap::new();
+                    m.insert("source_language".into(), "en".into());
+                    m.insert("version".into(), "1.0".into());
+                    m
+                },
+            },
+            entries: vec![
+                Entry {
+                    id: "greet".into(),
+                    value: Translation::Singular("Hello %1$s and %s".into()),
+                    comment: None,
+                    status: EntryStatus::Translated,
+                    custom: HashMap::new(),
+                },
+                Entry {
+                    id: "files".into(),
+                    value: Translation::Plural(Plural {
+                        id: "files".into(),
+                        forms: {
+                            let mut f = std::collections::BTreeMap::new();
+                            f.insert(PluralCategory::One, "%1$s file".into());
+                            f.insert(PluralCategory::Other, "%1$s files".into());
+                            f
+                        },
+                    }),
+                    comment: None,
+                    status: EntryStatus::Translated,
+                    custom: HashMap::new(),
+                },
+            ],
+        };
+
+        let fmt = Format::try_from(vec![res]).expect("xcstrings from resources");
+        // greet
+        let item = fmt.strings.get("greet").expect("greet item");
+        let en = item.localizations.get("en").expect("en loc");
+        let val = en.string_unit.as_ref().unwrap().value.clone();
+        assert!(val.contains("%1$@") && val.contains("%@"));
+
+        // plurals
+        let files = fmt.strings.get("files").expect("files item");
+        let en_p = files.localizations.get("en").expect("en loc");
+        let plural_map = en_p.variations.as_ref().unwrap().plural.as_ref().unwrap();
+        assert!(plural_map
+            .get(&PluralCategory::One)
+            .unwrap()
+            .string_unit
+            .as_ref()
+            .unwrap()
+            .value
+            .contains("%1$@"));
+    }
+}

langcodec/src/placeholder.rs

@@ -126,6 +126,77 @@ pub fn normalize_placeholders(input: &str) -> String {
     out.replace("%lu", "%u")
 }
 
+/// Convert canonical/Android-style string placeholders to iOS-style.
+/// - %s   -> %@
+/// - %1$s -> %1$@
+/// Leaves numeric specifiers (e.g., %d, %u, %ld) unchanged.
+pub fn to_ios_placeholders(input: &str) -> String {
+    let bytes = input.as_bytes();
+    let mut i = 0usize;
+    let mut out = String::with_capacity(input.len());
+    while i < bytes.len() {
+        if bytes[i] != b'%' {
+            out.push(bytes[i] as char);
+            i += 1;
+            continue;
+        }
+        // Escaped percent '%%'
+        if i + 1 < bytes.len() && bytes[i + 1] == b'%' {
+            out.push('%');
+            out.push('%');
+            i += 2;
+            continue;
+        }
+
+        // Examine potential placeholder
+        let mut j = i + 1;
+        // Optional positional index digits+$
+        let start_digits = j;
+        while j < bytes.len() && bytes[j].is_ascii_digit() {
+            j += 1;
+        }
+        let mut had_positional = false;
+        if j > start_digits && j < bytes.len() && bytes[j] == b'$' {
+            had_positional = true;
+            j += 1; // skip '$'
+        } else {
+            // reset if not positional
+            j = i + 1;
+        }
+
+        // Optional length modifiers (l/ll). We will drop them when converting %s -> %@.
+        let mut k = j;
+        while k < bytes.len() && bytes[k] == b'l' {
+            k += 1;
+        }
+        if k >= bytes.len() {
+            // not a complete placeholder, copy '%' and advance
+            out.push('%');
+            i += 1;
+            continue;
+        }
+
+        let ty = bytes[k] as char;
+        if ty == 's' {
+            // Emit converted iOS placeholder
+            out.push('%');
+            if had_positional {
+                // copy the digits we saw
+                out.push_str(&input[start_digits..(if start_digits < j { j - 1 } else { start_digits })]);
+                out.push('$');
+            }
+            out.push('@');
+            i = k + 1;
+            continue;
+        }
+
+        // Not a string placeholder, emit one byte and continue (simple path)
+        out.push('%');
+        i += 1;
+    }
+    out
+}
+
 /// Build a normalized signature (sequence of tokens) for comparison.
 pub fn signature(input: &str) -> Vec<String> {
     extract_placeholders(&normalize_placeholders(input))