332 lines
11 KiB
C#
332 lines
11 KiB
C#
#region Copyright & License Information
|
|
/*
|
|
* Copyright (c) The OpenRA Developers and Contributors
|
|
* This file is part of OpenRA, which is free software. It is made
|
|
* available to you under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation, either version 3 of
|
|
* the License, or (at your option) any later version. For more
|
|
* information, see COPYING.
|
|
*/
|
|
#endregion
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.Immutable;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using OpenRA.FileSystem;
|
|
using OpenRA.Mods.Common.UpdateRules;
|
|
using OpenRA.Widgets;
|
|
|
|
namespace OpenRA.Mods.Common.UtilityCommands
|
|
{
|
|
using YamlFileSet = List<(IReadWritePackage Package, string File, List<MiniYamlNodeBuilder> Nodes)>;
|
|
|
|
sealed class ExtractChromeStringsCommand : IUtilityCommand
|
|
{
|
|
string IUtilityCommand.Name { get { return "--extract-chrome-strings"; } }
|
|
|
|
bool IUtilityCommand.ValidateArguments(string[] args)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
[Desc("Extract translatable strings that are not yet localized and update chrome layout.")]
|
|
void IUtilityCommand.Run(Utility utility, string[] args)
|
|
{
|
|
// HACK: The engine code assumes that Game.modData is set.
|
|
var modData = Game.ModData = utility.ModData;
|
|
|
|
var translatableFields = modData.ObjectCreator.GetTypes()
|
|
.Where(t => t.Name.EndsWith("Widget", StringComparison.InvariantCulture) && t.IsSubclassOf(typeof(Widget)))
|
|
.ToDictionary(
|
|
t => t.Name[..^6],
|
|
t => t.GetFields().Where(f => f.HasAttribute<TranslationReferenceAttribute>()).Select(f => f.Name).ToArray())
|
|
.Where(t => t.Value.Length > 0)
|
|
.ToDictionary(t => t.Key, t => t.Value);
|
|
|
|
var chromeLayouts = modData.Manifest.ChromeLayout.GroupBy(c => c.Split('/')[0].Split('|')[0], c => c);
|
|
|
|
foreach (var layout in chromeLayouts)
|
|
{
|
|
var fluentFolder = layout.Key + "|languages";
|
|
var fluentPackage = modData.ModFiles.OpenPackage(fluentFolder);
|
|
var fluentPath = Path.Combine(fluentPackage.Name, "chrome/en.ftl");
|
|
|
|
var unsortedCandidates = new List<TranslationCandidate>();
|
|
var groupedCandidates = new Dictionary<HashSet<string>, List<TranslationCandidate>>();
|
|
|
|
var yamlSet = new YamlFileSet();
|
|
|
|
// Get all translations.
|
|
foreach (var chrome in layout)
|
|
{
|
|
modData.ModFiles.TryGetPackageContaining(chrome, out var chromePackage, out var chromeName);
|
|
var chromePath = Path.Combine(chromePackage.Name, chromeName);
|
|
|
|
var yaml = MiniYaml.FromFile(chromePath, false).ConvertAll(n => new MiniYamlNodeBuilder(n));
|
|
yamlSet.Add(((IReadWritePackage)chromePackage, chromeName, yaml));
|
|
|
|
var translationCandidates = new List<TranslationCandidate>();
|
|
foreach (var node in yaml)
|
|
{
|
|
if (node.Key != null)
|
|
{
|
|
var nodeSplit = node.Key.Split('@');
|
|
var nodeId = nodeSplit.Length > 1 ? ClearContainersAndToLower(nodeSplit[1]) : null;
|
|
FromChromeLayout(node, translatableFields, nodeId, ref translationCandidates);
|
|
}
|
|
}
|
|
|
|
if (translationCandidates.Count > 0)
|
|
{
|
|
var chromeFilename = chrome.Split('/').Last();
|
|
groupedCandidates[new HashSet<string>() { chromeFilename }] = new List<TranslationCandidate>();
|
|
for (var i = 0; i < translationCandidates.Count; i++)
|
|
{
|
|
var candidate = translationCandidates[i];
|
|
candidate.Chrome = chromeFilename;
|
|
unsortedCandidates.Add(candidate);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Join matching translations.
|
|
foreach (var candidate in unsortedCandidates)
|
|
{
|
|
HashSet<string> foundHash = null;
|
|
TranslationCandidate found = default;
|
|
foreach (var (hash, translation) in groupedCandidates)
|
|
{
|
|
foreach (var c in translation)
|
|
{
|
|
if (c.Key == candidate.Key && c.Type == candidate.Type && c.Translation == candidate.Translation)
|
|
{
|
|
foundHash = hash;
|
|
found = c;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (foundHash != null)
|
|
break;
|
|
}
|
|
|
|
if (foundHash == null)
|
|
{
|
|
var hash = groupedCandidates.Keys.First(t => t.First() == candidate.Chrome);
|
|
groupedCandidates[hash].Add(candidate);
|
|
continue;
|
|
}
|
|
|
|
var newHash = foundHash.Append(candidate.Chrome).ToHashSet();
|
|
candidate.Nodes.AddRange(found.Nodes);
|
|
groupedCandidates[foundHash].Remove(found);
|
|
|
|
var nHash = groupedCandidates.FirstOrDefault(t => t.Key.SetEquals(newHash));
|
|
if (nHash.Key != null)
|
|
groupedCandidates[nHash.Key].Add(candidate);
|
|
else
|
|
groupedCandidates[newHash] = new List<TranslationCandidate>() { candidate };
|
|
}
|
|
|
|
var startWithNewline = File.Exists(fluentPath);
|
|
|
|
// StreamWriter can't create new directories.
|
|
if (!startWithNewline)
|
|
Directory.CreateDirectory(Path.GetDirectoryName(fluentPath));
|
|
|
|
// Write to translation files.
|
|
using (var fluentWriter = new StreamWriter(fluentPath, append: true))
|
|
{
|
|
foreach (var (chromeFilename, candidates) in groupedCandidates.OrderBy(t => string.Join(',', t.Key)))
|
|
{
|
|
if (candidates.Count == 0)
|
|
continue;
|
|
|
|
if (startWithNewline)
|
|
fluentWriter.WriteLine();
|
|
else
|
|
startWithNewline = true;
|
|
|
|
fluentWriter.WriteLine("## " + string.Join(", ", chromeFilename));
|
|
|
|
// Pushing blocks of translations to string first allows for fancier formatting.
|
|
var build = "";
|
|
foreach (var grouping in candidates.GroupBy(t => t.Key))
|
|
{
|
|
if (grouping.Count() == 1)
|
|
{
|
|
var candidate = grouping.First();
|
|
var translationKey = candidate.Key;
|
|
if (candidate.Type == "text")
|
|
translationKey = $"{translationKey}";
|
|
else
|
|
translationKey = $"{translationKey}-" + candidate.Type.Replace("text", "");
|
|
|
|
build += $"{translationKey} = {candidate.Translation}\n";
|
|
foreach (var node in candidate.Nodes)
|
|
node.Value.Value = translationKey;
|
|
}
|
|
else
|
|
{
|
|
if (build.Length > 1 && build.Substring(build.Length - 2, 2) != "\n\n")
|
|
build += "\n";
|
|
|
|
var translationKey = grouping.Key;
|
|
build += $"{translationKey} =\n";
|
|
foreach (var candidate in grouping)
|
|
{
|
|
var type = candidate.Type;
|
|
if (candidate.Type != "label")
|
|
{
|
|
if (candidate.Type == "text")
|
|
type = "label";
|
|
else
|
|
type = type.Replace("text", "");
|
|
}
|
|
|
|
build += $" .{type} = {candidate.Translation}\n";
|
|
foreach (var node in candidate.Nodes)
|
|
node.Value.Value = $"{translationKey}.{type}";
|
|
}
|
|
|
|
build += "\n";
|
|
}
|
|
}
|
|
|
|
fluentWriter.WriteLine(build.Trim('\n'));
|
|
}
|
|
}
|
|
|
|
yamlSet.Save();
|
|
}
|
|
}
|
|
|
|
struct TranslationCandidate
|
|
{
|
|
public string Chrome;
|
|
public readonly string Key;
|
|
public readonly string Type;
|
|
public readonly string Translation;
|
|
public readonly List<MiniYamlNodeBuilder> Nodes;
|
|
|
|
public TranslationCandidate(string key, string type, string translation, MiniYamlNodeBuilder node)
|
|
{
|
|
Chrome = null;
|
|
Key = key;
|
|
Type = type;
|
|
Translation = translation;
|
|
Nodes = new List<MiniYamlNodeBuilder>() { node };
|
|
}
|
|
}
|
|
|
|
static string ClearContainersAndToLower(string node)
|
|
{
|
|
return node
|
|
.Replace("Background", "")
|
|
.Replace("Container", "")
|
|
.Replace("Panel", "")
|
|
.ToLowerInvariant()
|
|
.Replace("headers", "");
|
|
}
|
|
|
|
static string ClearTypesAndToLower(string node)
|
|
{
|
|
return node
|
|
.Replace("LabelForInput", "Label")
|
|
.Replace("LabelWithHighlight", "Label")
|
|
.Replace("DropdownButton", "Dropdown")
|
|
.Replace("CheckboxButton", "Checkbox")
|
|
.Replace("MenuButton", "Button")
|
|
.Replace("WorldButton", "Button")
|
|
.Replace("ProductionTypeButton", "Button")
|
|
.ToLowerInvariant();
|
|
}
|
|
|
|
static void FromChromeLayout(MiniYamlNodeBuilder node, Dictionary<string, string[]> translatables, string container, ref List<TranslationCandidate> translations)
|
|
{
|
|
var nodeSplit = node.Key.Split('@');
|
|
var nodeType = nodeSplit[0];
|
|
var nodeId = nodeSplit.Length > 1 ? ClearContainersAndToLower(nodeSplit[1]) : null;
|
|
|
|
if ((nodeType == "Background" || nodeType == "Container") && nodeId != null)
|
|
container = nodeId;
|
|
|
|
// Get translatable types.
|
|
var validChildTypes = new List<(MiniYamlNodeBuilder Node, string Type, string Value)>();
|
|
foreach (var childNode in node.Value.Nodes)
|
|
{
|
|
if (translatables.TryGetValue(nodeType, out var fieldName))
|
|
{
|
|
var childType = childNode.Key.Split('@')[0];
|
|
if (fieldName.Contains(childType)
|
|
&& !string.IsNullOrEmpty(childNode.Value.Value)
|
|
&& !UpdateUtils.IsAlreadyTranslated(childNode.Value.Value)
|
|
&& childNode.Value.Value.Any(char.IsLetterOrDigit))
|
|
{
|
|
var translationValue = childNode.Value.Value
|
|
.Replace("\\n", "\n ")
|
|
.Replace("{", "<")
|
|
.Replace("}", ">")
|
|
.Trim().Trim('\n');
|
|
|
|
validChildTypes.Add((childNode, childType.ToLowerInvariant(), translationValue));
|
|
}
|
|
}
|
|
}
|
|
|
|
// Generate translation key.
|
|
if (validChildTypes.Count > 0)
|
|
{
|
|
nodeType = ClearTypesAndToLower(nodeType);
|
|
|
|
var translationKey = nodeType;
|
|
if (!string.IsNullOrEmpty(container))
|
|
{
|
|
var containerType = string.Join('-', container.Split('_').Exclude(nodeType).Where(s => !string.IsNullOrEmpty(s)));
|
|
if (!string.IsNullOrEmpty(containerType))
|
|
translationKey = $"{translationKey}-{containerType}";
|
|
}
|
|
|
|
if (!string.IsNullOrEmpty(nodeId))
|
|
{
|
|
nodeId = string.Join('-', nodeId.Split('_')
|
|
.Except(string.IsNullOrEmpty(container) ? new string[] { nodeType } : container.Split('_').Append(nodeType))
|
|
.Where(s => !string.IsNullOrEmpty(s)));
|
|
|
|
if (!string.IsNullOrEmpty(nodeId))
|
|
translationKey = $"{translationKey}-{nodeId}";
|
|
}
|
|
|
|
foreach (var (childNode, childType, translationValue) in validChildTypes)
|
|
translations.Add(new TranslationCandidate(translationKey, childType, translationValue.Trim().Trim('\n'), childNode));
|
|
}
|
|
|
|
// Recursive.
|
|
foreach (var childNode in node.Value.Nodes)
|
|
if (childNode.Key == "Children")
|
|
foreach (var n in childNode.Value.Nodes)
|
|
FromChromeLayout(n, translatables, container, ref translations);
|
|
}
|
|
|
|
/// <summary>This is a helper method to find untranslated strings in chrome layouts.</summary>
|
|
public static void FindUntranslatedStringFields(ModData modData)
|
|
{
|
|
var types = modData.ObjectCreator.GetTypes();
|
|
foreach (var (type, fields) in types
|
|
.Where(t => t.Name.EndsWith("Widget", StringComparison.InvariantCulture) && t.IsSubclassOf(typeof(Widget)))
|
|
.ToDictionary(
|
|
t => t.Name[..^6],
|
|
t => t
|
|
.GetFields()
|
|
.Where(f => f.Name != "Id" && f.IsPublic && f.FieldType == typeof(string) && !f.HasAttribute<TranslationReferenceAttribute>())
|
|
.Distinct()
|
|
.Select(f => f.Name)
|
|
.ToList()))
|
|
if (fields.Count > 0)
|
|
Console.WriteLine($"{type}Widget:\n {string.Join("\n ", fields)}");
|
|
}
|
|
}
|
|
}
|