899 lines
31 KiB
Rust
899 lines
31 KiB
Rust
use std::collections::BTreeMap;
|
||
|
||
use crate::mod_translation::error::{
|
||
Result, TranslateError, TranslateErrorCode,
|
||
};
|
||
|
||
/// 自由文本按行对齐用的内部键：/lines/000000。
|
||
pub fn localized_line_key(index: usize) -> String {
|
||
format!("/lines/{index:06}")
|
||
}
|
||
|
||
pub fn localized_line_index(key: &str) -> Option<usize> {
|
||
let rest = key.strip_prefix("/lines/")?;
|
||
rest.parse::<usize>()
|
||
.ok()
|
||
.filter(|index| *index < 10_000_000)
|
||
}
|
||
|
||
/// 自由文本文件的字节级布局快照。
|
||
#[derive(Debug, Clone)]
|
||
pub struct FreeTextSnapshot {
|
||
pub bom: bool,
|
||
pub eol: String,
|
||
pub trailing_newline: bool,
|
||
pub lines: Vec<String>,
|
||
}
|
||
|
||
impl FreeTextSnapshot {
|
||
pub fn parse(content: &str) -> Self {
|
||
let body = content.strip_prefix('\u{feff}').unwrap_or(content);
|
||
let bom = body.len() != content.len();
|
||
let eol = if body.contains("\r\n") { "\r\n" } else { "\n" };
|
||
let trailing_newline = body.ends_with("\r\n") || body.ends_with('\n');
|
||
let mut lines: Vec<String> = body
|
||
.split("\r\n")
|
||
.flat_map(|part| part.split('\n'))
|
||
.map(str::to_string)
|
||
.collect();
|
||
if trailing_newline {
|
||
lines.pop();
|
||
}
|
||
Self {
|
||
bom,
|
||
eol: eol.to_string(),
|
||
trailing_newline,
|
||
lines,
|
||
}
|
||
}
|
||
|
||
pub fn render(&self) -> String {
|
||
let mut out = String::new();
|
||
if self.bom {
|
||
out.push('\u{feff}');
|
||
}
|
||
out.push_str(&self.lines.join(&self.eol));
|
||
if self.trailing_newline {
|
||
out.push_str(&self.eol);
|
||
}
|
||
out
|
||
}
|
||
}
|
||
|
||
/// 保序 JSON 值，结构化资源写回时用（serde_json 默认 Map 是排序的，会打乱键序）。
|
||
#[derive(Debug, Clone)]
|
||
pub enum JsonValue {
|
||
Object(Vec<(String, JsonValue)>),
|
||
Array(Vec<JsonValue>),
|
||
String(String),
|
||
Number(f64),
|
||
Bool(bool),
|
||
Null,
|
||
}
|
||
|
||
impl JsonValue {
|
||
pub fn parse(content: &str) -> Result<Self> {
|
||
let mut parser = JsonParser {
|
||
bytes: content.as_bytes(),
|
||
position: 0,
|
||
};
|
||
let value = parser.parse_value()?;
|
||
parser.skip_whitespace();
|
||
if parser.position != content.len() {
|
||
return Err(TranslateError::new(
|
||
TranslateErrorCode::InvalidArchive,
|
||
"JSON document has trailing content",
|
||
));
|
||
}
|
||
Ok(value)
|
||
}
|
||
|
||
/// 按 JSON pointer 定位并写入，路径不存在就报错。
|
||
pub fn set_pointer(
|
||
&mut self,
|
||
pointer: &str,
|
||
translation: String,
|
||
) -> Result<()> {
|
||
if !pointer.starts_with('/') {
|
||
return Err(TranslateError::new(
|
||
TranslateErrorCode::Config,
|
||
format!("structured pointer must start with '/': {pointer}"),
|
||
));
|
||
}
|
||
if pointer == "/" {
|
||
if let JsonValue::String(value) = self {
|
||
*value = translation;
|
||
return Ok(());
|
||
}
|
||
return Err(TranslateError::new(
|
||
TranslateErrorCode::Config,
|
||
"structured pointer targets a non-string root",
|
||
));
|
||
}
|
||
let segments = pointer
|
||
.split('/')
|
||
.skip(1)
|
||
.map(decode_json_pointer_segment)
|
||
.collect::<Vec<_>>();
|
||
let mut cursor = self;
|
||
for (index, segment) in segments.iter().enumerate() {
|
||
let last = index == segments.len() - 1;
|
||
let child = match cursor {
|
||
JsonValue::Object(entries) => {
|
||
if let Some(position) =
|
||
entries.iter().position(|(key, _)| key == segment)
|
||
{
|
||
if last {
|
||
entries[position].1 =
|
||
JsonValue::String(translation.clone());
|
||
return Ok(());
|
||
}
|
||
&mut entries[position].1
|
||
} else {
|
||
return Err(TranslateError::new(
|
||
TranslateErrorCode::Config,
|
||
format!(
|
||
"structured pointer segment not found: {segment}"
|
||
),
|
||
));
|
||
}
|
||
}
|
||
JsonValue::Array(items) => {
|
||
let position = segment.parse::<usize>().map_err(|_| {
|
||
TranslateError::new(
|
||
TranslateErrorCode::Config,
|
||
format!("structured pointer segment is not an index: {segment}"),
|
||
)
|
||
})?;
|
||
if position >= items.len() {
|
||
return Err(TranslateError::new(
|
||
TranslateErrorCode::Config,
|
||
format!(
|
||
"structured pointer index out of range: {segment}"
|
||
),
|
||
));
|
||
}
|
||
if last {
|
||
items[position] =
|
||
JsonValue::String(translation.clone());
|
||
return Ok(());
|
||
}
|
||
&mut items[position]
|
||
}
|
||
_ => {
|
||
return Err(TranslateError::new(
|
||
TranslateErrorCode::Config,
|
||
format!(
|
||
"structured pointer traverses a scalar: {segment}"
|
||
),
|
||
));
|
||
}
|
||
};
|
||
cursor = child;
|
||
}
|
||
Err(TranslateError::new(
|
||
TranslateErrorCode::Config,
|
||
format!(
|
||
"structured pointer did not resolve to a string: {pointer}"
|
||
),
|
||
))
|
||
}
|
||
|
||
/// 两空格缩进序列化。
|
||
pub fn render_pretty(&self) -> String {
|
||
let mut out = String::new();
|
||
self.write_pretty(&mut out, 0);
|
||
out.push('\n');
|
||
out
|
||
}
|
||
|
||
fn write_pretty(&self, out: &mut String, indent: usize) {
|
||
match self {
|
||
JsonValue::Object(entries) => {
|
||
if entries.is_empty() {
|
||
out.push_str("{}");
|
||
return;
|
||
}
|
||
out.push_str("{\n");
|
||
for (index, (key, value)) in entries.iter().enumerate() {
|
||
out.push_str(&" ".repeat(indent + 1));
|
||
out.push_str(&json_escape(key));
|
||
out.push_str(": ");
|
||
value.write_pretty(out, indent + 1);
|
||
if index + 1 < entries.len() {
|
||
out.push(',');
|
||
}
|
||
out.push('\n');
|
||
}
|
||
out.push_str(&" ".repeat(indent));
|
||
out.push('}');
|
||
}
|
||
JsonValue::Array(items) => {
|
||
if items.is_empty() {
|
||
out.push_str("[]");
|
||
return;
|
||
}
|
||
out.push_str("[\n");
|
||
for (index, value) in items.iter().enumerate() {
|
||
out.push_str(&" ".repeat(indent + 1));
|
||
value.write_pretty(out, indent + 1);
|
||
if index + 1 < items.len() {
|
||
out.push(',');
|
||
}
|
||
out.push('\n');
|
||
}
|
||
out.push_str(&" ".repeat(indent));
|
||
out.push(']');
|
||
}
|
||
JsonValue::String(value) => out.push_str(&json_escape(value)),
|
||
JsonValue::Number(value) => {
|
||
if value.fract() == 0.0 && value.abs() < 9_007_199_254_740_992.0
|
||
{
|
||
out.push_str(&format!("{}", *value as i64));
|
||
} else {
|
||
out.push_str(&value.to_string());
|
||
}
|
||
}
|
||
JsonValue::Bool(value) => {
|
||
out.push_str(if *value { "true" } else { "false" })
|
||
}
|
||
JsonValue::Null => out.push_str("null"),
|
||
}
|
||
}
|
||
}
|
||
|
||
fn decode_json_pointer_segment(value: &str) -> String {
|
||
value.replace("~1", "/").replace("~0", "~")
|
||
}
|
||
|
||
fn json_escape(value: &str) -> String {
|
||
let mut out = String::with_capacity(value.len() + 2);
|
||
out.push('"');
|
||
for character in value.chars() {
|
||
match character {
|
||
'"' => out.push_str("\\\""),
|
||
'\\' => out.push_str("\\\\"),
|
||
'\n' => out.push_str("\\n"),
|
||
'\r' => out.push_str("\\r"),
|
||
'\t' => out.push_str("\\t"),
|
||
character if (character as u32) < 0x20 => {
|
||
out.push_str(&format!("\\u{:04x}", character as u32));
|
||
}
|
||
character => out.push(character),
|
||
}
|
||
}
|
||
out.push('"');
|
||
out
|
||
}
|
||
|
||
struct JsonParser<'a> {
|
||
bytes: &'a [u8],
|
||
position: usize,
|
||
}
|
||
|
||
impl<'a> JsonParser<'a> {
|
||
fn skip_whitespace(&mut self) {
|
||
while self.position < self.bytes.len()
|
||
&& matches!(self.bytes[self.position], b' ' | b'\t' | b'\n' | b'\r')
|
||
{
|
||
self.position += 1;
|
||
}
|
||
}
|
||
|
||
fn peek(&self) -> Option<u8> {
|
||
self.bytes.get(self.position).copied()
|
||
}
|
||
|
||
fn parse_value(&mut self) -> Result<JsonValue> {
|
||
self.skip_whitespace();
|
||
match self.peek() {
|
||
Some(b'{') => self.parse_object(),
|
||
Some(b'[') => self.parse_array(),
|
||
Some(b'"') => Ok(JsonValue::String(self.parse_string()?)),
|
||
Some(b't') => {
|
||
self.expect_literal("true")?;
|
||
Ok(JsonValue::Bool(true))
|
||
}
|
||
Some(b'f') => {
|
||
self.expect_literal("false")?;
|
||
Ok(JsonValue::Bool(false))
|
||
}
|
||
Some(b'n') => {
|
||
self.expect_literal("null")?;
|
||
Ok(JsonValue::Null)
|
||
}
|
||
Some(_) => self.parse_number(),
|
||
None => Err(TranslateError::new(
|
||
TranslateErrorCode::InvalidArchive,
|
||
"JSON document ended unexpectedly",
|
||
)),
|
||
}
|
||
}
|
||
|
||
fn parse_object(&mut self) -> Result<JsonValue> {
|
||
self.position += 1; // {
|
||
let mut entries = Vec::new();
|
||
self.skip_whitespace();
|
||
if self.peek() == Some(b'}') {
|
||
self.position += 1;
|
||
return Ok(JsonValue::Object(entries));
|
||
}
|
||
loop {
|
||
self.skip_whitespace();
|
||
if self.peek() != Some(b'"') {
|
||
return Err(TranslateError::new(
|
||
TranslateErrorCode::InvalidArchive,
|
||
"JSON object key must be a string",
|
||
));
|
||
}
|
||
let key = self.parse_string()?;
|
||
self.skip_whitespace();
|
||
if self.peek() != Some(b':') {
|
||
return Err(TranslateError::new(
|
||
TranslateErrorCode::InvalidArchive,
|
||
"JSON object key is missing a colon",
|
||
));
|
||
}
|
||
self.position += 1;
|
||
let value = self.parse_value()?;
|
||
entries.push((key, value));
|
||
self.skip_whitespace();
|
||
match self.peek() {
|
||
Some(b',') => {
|
||
self.position += 1;
|
||
}
|
||
Some(b'}') => {
|
||
self.position += 1;
|
||
return Ok(JsonValue::Object(entries));
|
||
}
|
||
_ => {
|
||
return Err(TranslateError::new(
|
||
TranslateErrorCode::InvalidArchive,
|
||
"JSON object is missing a closing brace",
|
||
));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
fn parse_array(&mut self) -> Result<JsonValue> {
|
||
self.position += 1; // [
|
||
let mut items = Vec::new();
|
||
self.skip_whitespace();
|
||
if self.peek() == Some(b']') {
|
||
self.position += 1;
|
||
return Ok(JsonValue::Array(items));
|
||
}
|
||
loop {
|
||
items.push(self.parse_value()?);
|
||
self.skip_whitespace();
|
||
match self.peek() {
|
||
Some(b',') => {
|
||
self.position += 1;
|
||
}
|
||
Some(b']') => {
|
||
self.position += 1;
|
||
return Ok(JsonValue::Array(items));
|
||
}
|
||
_ => {
|
||
return Err(TranslateError::new(
|
||
TranslateErrorCode::InvalidArchive,
|
||
"JSON array is missing a closing bracket",
|
||
));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
fn parse_string(&mut self) -> Result<String> {
|
||
self.skip_whitespace();
|
||
if self.peek() != Some(b'"') {
|
||
return Err(TranslateError::new(
|
||
TranslateErrorCode::InvalidArchive,
|
||
"JSON string is missing an opening quote",
|
||
));
|
||
}
|
||
self.position += 1;
|
||
let mut out = String::new();
|
||
loop {
|
||
let Some(byte) = self.bytes.get(self.position).copied() else {
|
||
return Err(TranslateError::new(
|
||
TranslateErrorCode::InvalidArchive,
|
||
"JSON string is unterminated",
|
||
));
|
||
};
|
||
self.position += 1;
|
||
match byte {
|
||
b'"' => return Ok(out),
|
||
b'\\' => {
|
||
let Some(escape) = self.bytes.get(self.position).copied()
|
||
else {
|
||
return Err(TranslateError::new(
|
||
TranslateErrorCode::InvalidArchive,
|
||
"JSON string escape is unterminated",
|
||
));
|
||
};
|
||
self.position += 1;
|
||
match escape {
|
||
b'"' => out.push('"'),
|
||
b'\\' => out.push('\\'),
|
||
b'/' => out.push('/'),
|
||
b'b' => out.push('\u{0008}'),
|
||
b'f' => out.push('\u{000c}'),
|
||
b'n' => out.push('\n'),
|
||
b'r' => out.push('\r'),
|
||
b't' => out.push('\t'),
|
||
b'u' => {
|
||
if self.position + 4 > self.bytes.len() {
|
||
return Err(TranslateError::new(
|
||
TranslateErrorCode::InvalidArchive,
|
||
"JSON unicode escape is truncated",
|
||
));
|
||
}
|
||
let hex = std::str::from_utf8(
|
||
&self.bytes[self.position..self.position + 4],
|
||
)
|
||
.map_err(|_| {
|
||
TranslateError::new(
|
||
TranslateErrorCode::InvalidArchive,
|
||
"JSON unicode escape is invalid",
|
||
)
|
||
})?;
|
||
let code =
|
||
u16::from_str_radix(hex, 16).map_err(|_| {
|
||
TranslateError::new(
|
||
TranslateErrorCode::InvalidArchive,
|
||
"JSON unicode escape is invalid",
|
||
)
|
||
})?;
|
||
self.position += 4;
|
||
out.push(
|
||
char::from_u32(code as u32)
|
||
.unwrap_or('\u{fffd}'),
|
||
);
|
||
}
|
||
_ => {
|
||
return Err(TranslateError::new(
|
||
TranslateErrorCode::InvalidArchive,
|
||
format!(
|
||
"JSON string contains an unknown escape: \\{}",
|
||
escape as char
|
||
),
|
||
));
|
||
}
|
||
}
|
||
}
|
||
byte if byte < 0x20 => {
|
||
return Err(TranslateError::new(
|
||
TranslateErrorCode::InvalidArchive,
|
||
"JSON string contains a control character",
|
||
));
|
||
}
|
||
_ => {
|
||
// Preserve UTF-8 sequences byte by byte.
|
||
let length = utf8_sequence_length(byte);
|
||
if self.position + length - 1 > self.bytes.len() {
|
||
return Err(TranslateError::new(
|
||
TranslateErrorCode::InvalidArchive,
|
||
"JSON string contains truncated UTF-8",
|
||
));
|
||
}
|
||
let slice = &self.bytes
|
||
[self.position - 1..self.position - 1 + length];
|
||
let text = std::str::from_utf8(slice).map_err(|_| {
|
||
TranslateError::new(
|
||
TranslateErrorCode::InvalidArchive,
|
||
"JSON string contains invalid UTF-8",
|
||
)
|
||
})?;
|
||
out.push_str(text);
|
||
self.position += length - 1;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
fn parse_number(&mut self) -> Result<JsonValue> {
|
||
let start = self.position;
|
||
while self.position < self.bytes.len()
|
||
&& matches!(
|
||
self.bytes[self.position],
|
||
b'0'..=b'9' | b'-' | b'+' | b'.' | b'e' | b'E'
|
||
)
|
||
{
|
||
self.position += 1;
|
||
}
|
||
if self.position == start {
|
||
return Err(TranslateError::new(
|
||
TranslateErrorCode::InvalidArchive,
|
||
"JSON contains an invalid token",
|
||
));
|
||
}
|
||
let text = std::str::from_utf8(&self.bytes[start..self.position])
|
||
.map_err(|_| {
|
||
TranslateError::new(
|
||
TranslateErrorCode::InvalidArchive,
|
||
"invalid JSON number",
|
||
)
|
||
})?;
|
||
let value = text.parse::<f64>().map_err(|_| {
|
||
TranslateError::new(
|
||
TranslateErrorCode::InvalidArchive,
|
||
"invalid JSON number",
|
||
)
|
||
})?;
|
||
Ok(JsonValue::Number(value))
|
||
}
|
||
|
||
fn expect_literal(&mut self, literal: &str) -> Result<()> {
|
||
if self.position + literal.len() > self.bytes.len()
|
||
|| &self.bytes[self.position..self.position + literal.len()]
|
||
!= literal.as_bytes()
|
||
{
|
||
return Err(TranslateError::new(
|
||
TranslateErrorCode::InvalidArchive,
|
||
format!("JSON expected `{literal}`"),
|
||
));
|
||
}
|
||
self.position += literal.len();
|
||
Ok(())
|
||
}
|
||
}
|
||
|
||
fn utf8_sequence_length(first: u8) -> usize {
|
||
if first < 0x80 {
|
||
1
|
||
} else if first >> 5 == 0b110 {
|
||
2
|
||
} else if first >> 4 == 0b1110 {
|
||
3
|
||
} else if first >> 3 == 0b11110 {
|
||
4
|
||
} else {
|
||
1
|
||
}
|
||
}
|
||
|
||
/// Reads the current target entries for a language source from raw content.
|
||
pub fn read_language_target(
|
||
content: &str,
|
||
source: &crate::mod_translation::analyze::LanguageSource,
|
||
) -> BTreeMap<String, String> {
|
||
use crate::mod_translation::analyze::LanguageKind;
|
||
match source.kind {
|
||
LanguageKind::Json if source.is_structured_json() => {
|
||
read_json_structured(content)
|
||
}
|
||
LanguageKind::Json => read_json_flat(content),
|
||
LanguageKind::KeyValue => read_key_value(content),
|
||
LanguageKind::FreeText => {
|
||
if let Some(layout) = &source.localized_layout {
|
||
let snapshot = FreeTextSnapshot::parse(content);
|
||
read_localized_target_entries(&snapshot, layout)
|
||
} else {
|
||
let mut map = BTreeMap::new();
|
||
if content.trim().is_empty() {
|
||
map
|
||
} else {
|
||
map.insert("/".to_string(), content.to_string());
|
||
map
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
fn read_json_structured(content: &str) -> BTreeMap<String, String> {
|
||
let mut entries = BTreeMap::new();
|
||
if let Ok(root) = JsonValue::parse(content) {
|
||
flatten_json_strings(&root, "", &mut entries);
|
||
}
|
||
entries
|
||
}
|
||
|
||
fn flatten_json_strings(
|
||
value: &JsonValue,
|
||
pointer: &str,
|
||
out: &mut BTreeMap<String, String>,
|
||
) {
|
||
match value {
|
||
JsonValue::String(text) => {
|
||
out.insert(
|
||
if pointer.is_empty() { "/" } else { pointer }.to_string(),
|
||
text.clone(),
|
||
);
|
||
}
|
||
JsonValue::Object(entries) => {
|
||
for (key, value) in entries {
|
||
let escaped = key.replace('~', "~0").replace('/', "~1");
|
||
flatten_json_strings(
|
||
value,
|
||
&format!("{pointer}/{escaped}"),
|
||
out,
|
||
);
|
||
}
|
||
}
|
||
JsonValue::Array(items) => {
|
||
for (index, value) in items.iter().enumerate() {
|
||
flatten_json_strings(value, &format!("{pointer}/{index}"), out);
|
||
}
|
||
}
|
||
JsonValue::Number(_) | JsonValue::Bool(_) | JsonValue::Null => {}
|
||
}
|
||
}
|
||
|
||
pub fn read_json_flat(content: &str) -> BTreeMap<String, String> {
|
||
match JsonValue::parse(content) {
|
||
Ok(JsonValue::Object(entries)) => entries
|
||
.into_iter()
|
||
.filter_map(|(key, value)| match value {
|
||
JsonValue::String(text) => Some((key, text)),
|
||
_ => None,
|
||
})
|
||
.collect(),
|
||
_ => BTreeMap::new(),
|
||
}
|
||
}
|
||
|
||
pub fn read_key_value(content: &str) -> BTreeMap<String, String> {
|
||
let mut result = BTreeMap::new();
|
||
for raw_line in content.split("\r\n").flat_map(|part| part.split('\n')) {
|
||
let line = raw_line.trim();
|
||
if line.is_empty() || line.starts_with('#') || line.starts_with('!') {
|
||
continue;
|
||
}
|
||
let separator = find_unquoted_separator(line);
|
||
let Some(separator) = separator else { continue };
|
||
if separator < 1 {
|
||
continue;
|
||
}
|
||
let key = line[..separator].trim().to_string();
|
||
let value = line[separator + 1..].trim().to_string();
|
||
if !key.is_empty() {
|
||
result.insert(key, value);
|
||
}
|
||
}
|
||
result
|
||
}
|
||
|
||
/// Finds the first `=` or `:` that is not escaped by a backslash.
|
||
fn find_unquoted_separator(line: &str) -> Option<usize> {
|
||
let mut previous_escape = false;
|
||
for (index, character) in line.char_indices() {
|
||
if character == '\\' {
|
||
previous_escape = !previous_escape;
|
||
continue;
|
||
}
|
||
if (character == '=' || character == ':') && !previous_escape {
|
||
return Some(index);
|
||
}
|
||
previous_escape = false;
|
||
}
|
||
None
|
||
}
|
||
|
||
/// Serialises language target content for a source .
|
||
pub fn serialize_language_target(
|
||
source: &crate::mod_translation::analyze::LanguageSource,
|
||
entries: &BTreeMap<String, String>,
|
||
) -> Result<String> {
|
||
use crate::mod_translation::analyze::LanguageKind;
|
||
match source.kind {
|
||
LanguageKind::FreeText => {
|
||
Ok(serialize_localized_target(entries, source))
|
||
}
|
||
LanguageKind::Json if source.is_structured_json() => {
|
||
let template =
|
||
source.structured_template.as_deref().ok_or_else(|| {
|
||
TranslateError::new(
|
||
TranslateErrorCode::Config,
|
||
format!(
|
||
"structured template is unavailable for {}",
|
||
source.source_path
|
||
),
|
||
)
|
||
})?;
|
||
let mut root = JsonValue::parse(template)?;
|
||
for (pointer, translation) in entries {
|
||
root.set_pointer(pointer, translation.clone())?;
|
||
}
|
||
Ok(root.render_pretty())
|
||
}
|
||
LanguageKind::Json => Ok(serialize_json_flat(entries)),
|
||
LanguageKind::KeyValue => {
|
||
let mut out = String::new();
|
||
for (key, value) in entries {
|
||
out.push_str(key);
|
||
out.push('=');
|
||
out.push_str(value);
|
||
out.push('\n');
|
||
}
|
||
Ok(out)
|
||
}
|
||
}
|
||
}
|
||
|
||
pub fn serialize_json_flat(entries: &BTreeMap<String, String>) -> String {
|
||
let mut out = String::from("{\n");
|
||
let entries = entries.iter().collect::<Vec<_>>();
|
||
for (index, (key, value)) in entries.iter().enumerate() {
|
||
out.push_str(" ");
|
||
out.push_str(&json_escape(key));
|
||
out.push_str(": ");
|
||
out.push_str(&json_escape(value));
|
||
if index + 1 < entries.len() {
|
||
out.push(',');
|
||
}
|
||
out.push('\n');
|
||
}
|
||
out.push_str("}\n");
|
||
out
|
||
}
|
||
|
||
/// Merge ordering: existing target keys first, then source keys, then the
|
||
/// current batch, preserving already-written values.
|
||
pub fn ordered_language_target(
|
||
source: &crate::mod_translation::analyze::LanguageSource,
|
||
current: &BTreeMap<String, String>,
|
||
) -> BTreeMap<String, String> {
|
||
if source.kind == crate::mod_translation::analyze::LanguageKind::FreeText {
|
||
return current.clone();
|
||
}
|
||
let mut keys: Vec<String> = Vec::new();
|
||
let mut seen = std::collections::HashSet::new();
|
||
for key in source
|
||
.existing_target
|
||
.keys()
|
||
.chain(source.entries.keys())
|
||
.chain(current.keys())
|
||
{
|
||
if seen.insert(key.clone()) {
|
||
keys.push(key.clone());
|
||
}
|
||
}
|
||
keys.retain(|key| current.contains_key(key));
|
||
keys.into_iter()
|
||
.filter_map(|key| current.get(&key).cloned().map(|value| (key, value)))
|
||
.collect()
|
||
}
|
||
|
||
fn read_localized_target_entries(
|
||
snapshot: &FreeTextSnapshot,
|
||
layout: &crate::mod_translation::analyze::LocalizedLayout,
|
||
) -> BTreeMap<String, String> {
|
||
let mut result = BTreeMap::new();
|
||
for (index, line) in layout.source_lines.iter().enumerate() {
|
||
if !line.trim().is_empty()
|
||
&& let Some(translated) = snapshot.lines.get(index)
|
||
&& !translated.trim().is_empty()
|
||
{
|
||
result.insert(localized_line_key(index), translated.clone());
|
||
}
|
||
}
|
||
result
|
||
}
|
||
|
||
pub fn serialize_localized_target(
|
||
entries: &BTreeMap<String, String>,
|
||
source: &crate::mod_translation::analyze::LanguageSource,
|
||
) -> String {
|
||
let Some(layout) = &source.localized_layout else {
|
||
return entries.get("/").cloned().unwrap_or_default();
|
||
};
|
||
let base = if let Some(existing) = &layout.existing_target_lines {
|
||
existing.clone()
|
||
} else {
|
||
vec![String::new(); layout.source_lines.len()]
|
||
};
|
||
let mut lines = base;
|
||
let length = layout.source_lines.len().max(lines.len());
|
||
lines.resize(length, String::new());
|
||
for (key, value) in entries {
|
||
if let Some(index) = localized_line_index(key)
|
||
&& index < layout.source_lines.len()
|
||
{
|
||
lines[index] = value.clone();
|
||
}
|
||
}
|
||
let snapshot = FreeTextSnapshot {
|
||
bom: layout.bom,
|
||
eol: layout.eol.clone(),
|
||
trailing_newline: layout.trailing_newline,
|
||
lines,
|
||
};
|
||
snapshot.render()
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
|
||
#[test]
|
||
fn ordered_json_round_trips_keep_key_order() {
|
||
let content =
|
||
"{\n \"z\": \"1\",\n \"a\": \"2\",\n \"m\": \"3\"\n}\n";
|
||
let root = JsonValue::parse(content).unwrap();
|
||
let rendered = root.render_pretty();
|
||
let z = rendered.find("\"z\"").unwrap();
|
||
let a = rendered.find("\"a\"").unwrap();
|
||
let m = rendered.find("\"m\"").unwrap();
|
||
assert!(z < a && a < m, "key order must be preserved: {rendered}");
|
||
}
|
||
|
||
#[test]
|
||
fn pointers_set_nested_values() {
|
||
let content = r#"{"a":{"b":[{"c":"old"}]}}"#;
|
||
let mut root = JsonValue::parse(content).unwrap();
|
||
root.set_pointer("/a/b/0/c", "new".to_string()).unwrap();
|
||
assert_eq!(root.render_pretty().trim(), "{\n \"a\": {\n \"b\": [\n {\n \"c\": \"new\"\n }\n ]\n }\n}".trim());
|
||
}
|
||
|
||
#[test]
|
||
fn flat_language_key_is_not_accepted_as_a_json_pointer() {
|
||
let mut root = JsonValue::parse(r#"{"demo.hello":"Hello"}"#).unwrap();
|
||
let error = root
|
||
.set_pointer("demo.hello", "你好".to_string())
|
||
.unwrap_err();
|
||
assert_eq!(error.code, TranslateErrorCode::Config);
|
||
assert_eq!(
|
||
root.render_pretty().trim(),
|
||
"{\n \"demo.hello\": \"Hello\"\n}"
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn structured_language_serialization_round_trips_pointer_values() {
|
||
let source = crate::mod_translation::analyze::LanguageSource {
|
||
kind: crate::mod_translation::analyze::LanguageKind::Json,
|
||
namespace: "demo".to_string(),
|
||
source_path: "assets/demo/en_us/menu.json".to_string(),
|
||
target_path: "assets/demo/zh_cn/menu.json".to_string(),
|
||
entries: BTreeMap::from([(
|
||
"/menu/title".to_string(),
|
||
"Hello".to_string(),
|
||
)]),
|
||
existing_target: BTreeMap::new(),
|
||
structured_template: Some(
|
||
r#"{"menu":{"title":"Hello","width":10}}"#.to_string(),
|
||
),
|
||
localized_layout: None,
|
||
};
|
||
let translated =
|
||
BTreeMap::from([("/menu/title".to_string(), "你好".to_string())]);
|
||
let serialized =
|
||
serialize_language_target(&source, &translated).unwrap();
|
||
let reread = read_language_target(&serialized, &source);
|
||
assert_eq!(reread.get("/menu/title").map(String::as_str), Some("你好"));
|
||
assert!(serialized.contains("\"width\": 10"));
|
||
}
|
||
|
||
#[test]
|
||
fn key_value_parser_skips_comments_and_escaped_separators() {
|
||
let content = "a=1\n# comment\nb:two\nc\\=x=3\n! bang\n";
|
||
let map = read_key_value(content);
|
||
assert_eq!(map.get("a").map(String::as_str), Some("1"));
|
||
assert_eq!(map.get("b").map(String::as_str), Some("two"));
|
||
assert_eq!(map.get("c\\=x").map(String::as_str), Some("3"));
|
||
assert!(!map.contains_key("comment"));
|
||
}
|
||
|
||
#[test]
|
||
fn free_text_snapshot_preserves_bom_eol_and_trailing_newline() {
|
||
let content = "\u{feff}line1\r\nline2\r\n";
|
||
let snapshot = FreeTextSnapshot::parse(content);
|
||
assert!(snapshot.bom);
|
||
assert_eq!(snapshot.eol, "\r\n");
|
||
assert!(snapshot.trailing_newline);
|
||
assert_eq!(snapshot.lines, vec!["line1", "line2"]);
|
||
assert_eq!(snapshot.render(), content);
|
||
}
|
||
|
||
#[test]
|
||
fn local_line_keys_round_trip() {
|
||
assert_eq!(localized_line_key(0), "/lines/000000");
|
||
assert_eq!(localized_line_key(12), "/lines/000012");
|
||
assert_eq!(localized_line_index("/lines/000042"), Some(42));
|
||
assert_eq!(localized_line_index("/other"), None);
|
||
}
|
||
}
|