Localization

[adamsitnik]

• make LocalizationResources internal and static
• tests
• merge translation contributions (Translate to Spanish #1979, Set russian language #1381)
• move SDK translations here

I've not configured OneLocBuild as we may move the code to dotnet/runtime where it's already configured for the whole repo.

To move the existing translations from SDK repo to here I've wrote a console app that took care of mapping the translations by ID, by original English text (some IDs has changed but text remained the same).

The app is ugly but it does what it's needed:

Details

using System.Text;
using System.Transactions;
using System.Xml;
using System.Xml.Linq;

namespace CopyTranslations
{
    internal class Program
    {
        static void Main(string[] args)
        {
            DirectoryInfo sdkFolder = new DirectoryInfo(args[0]);
            DirectoryInfo sclFolder = new DirectoryInfo(args[1]);

            foreach (FileInfo sourceFile in sdkFolder.GetFiles("*.xlf"))
            {
                string extension = sourceFile.Name.Substring(sourceFile.Name.IndexOf('.'));
                string destinationFilePath = Path.Combine(sclFolder.FullName, $"Resources{extension}");

                using FileStream src = sourceFile.OpenRead();
                using XmlReader srcXml = XmlReader.Create(src);

                XmlDocument sourceDocument = new ();
                sourceDocument.Load(srcXml);

                XmlNode srcBodyNode = sourceDocument.ChildNodes[1]!.ChildNodes[0]!.ChildNodes[0]!;
                Dictionary<string, string> idToTarget = new ();
                Dictionary<string, string> sourceToTarget = new ();

                foreach (XmlNode node in srcBodyNode.ChildNodes)
                {
                    if (GetSource(node) != GetTarget(node)) // some has no translations
                    {
                        idToTarget.Add(GetId(node), GetTarget(node));
                        sourceToTarget.TryAdd(Normalize(GetSource(node)), GetTarget(node));
                    }
                }

                XmlDocument destinationDocument = new ();
                destinationDocument.Load(destinationFilePath);

                XmlNode dstBodyNode = destinationDocument.ChildNodes[1]!.ChildNodes[0]!.ChildNodes[0]!;

                foreach (XmlElement destinationElement in dstBodyNode.ChildNodes)
                {
                    string id = GetId(destinationElement);
                    string source = GetSource(destinationElement);

                    if (idToTarget.TryGetValue(id, out string? translation) // same IDs
                        || sourceToTarget.TryGetValue(Normalize(source), out translation)) // same English text
                    {
                        if (source.Contains("'{0}'") && translation.Contains("„{0}”"))
                        {
                            translation = translation.Replace("„{0}”", "'{0}'");
                        }
                        else if (source.Contains("'{0}'") && translation.Contains("\"{0}\""))
                        {
                            translation = translation.Replace("\"{0}\"", "'{0}'");
                        }
                        else if (source.Contains("'{0}'") && !translation.Contains("'{0}'"))
                        {
                            translation = translation.Replace("{0}", "'{0}'");
                        }

                        if (source.EndsWith('.') && !translation.EndsWith('.'))
                        {
                            translation += ".";
                        }

                        translation = translation.Replace(" :", ":");

                        destinationElement.ChildNodes[1]!.InnerText = translation;
                        destinationElement.ChildNodes[1]!.Attributes!["state"]!.InnerText = "translated";
                    }
                }

                destinationDocument.Save(destinationFilePath);
            }

            static string GetId(XmlNode node) => node.Attributes!["id"]!.InnerText;

            static string GetSource(XmlNode node) => node.ChildNodes[0]!.InnerText!;

            static string GetTarget(XmlNode node) => node.ChildNodes[1]!.InnerText!;

            static string Normalize(string formatString)
            {
                StringBuilder buffer = new(formatString);
                for (int i = 0; i < 4; i++)
                {
                    buffer.Replace("'{" + i + "}'", "{" + i + "}");
                }

                buffer.Replace(".", "");
                buffer.Replace(",", "");

                return buffer.ToString();
            }
        }
    }
}

[adamsitnik]

I am including these types and the resources here so the tests can call the internal APIs to verify error messages.

[adamsitnik]

I've added this type to a different project than System.CommandLine.Tests to ensure that it does not use the resources included in that project.

[adamsitnik]

@KalleOlaviNiemitalo I've removed all the unused methods and resources, thank you for the feedback!

I was also curious if it's not a bug that we don't use them. It turned out that we are now just using different methods for the same purposes:

command-line-api/src/System.CommandLine/LocalizationResources.cs

Line 55 in b8a9761

internal static string RequiredArgumentMissing(SymbolResult symbolResult) =>

command-line-api/src/System.CommandLine/LocalizationResources.cs

Line 19 in b8a9761

internal static string ExpectsOneArgument(OptionResult optionResult)

[KalleOlaviNiemitalo]

Huh. I wonder if the unused resources were preserved for API compatibility only.