999 lines
46 KiB
C#
999 lines
46 KiB
C#
#region Disclaimer / License
|
|
// Copyright (C) 2015, The Duplicati Team
|
|
// http://www.duplicati.com, info@duplicati.com
|
|
//
|
|
// This library is free software; you can redistribute it and/or
|
|
// modify it under the terms of the GNU Lesser General Public
|
|
// License as published by the Free Software Foundation; either
|
|
// version 2.1 of the License, or (at your option) any later version.
|
|
//
|
|
// This library is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
// Lesser General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public
|
|
// License along with this library; if not, write to the Free Software
|
|
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
//
|
|
#endregion
|
|
using System;
|
|
using System.Windows.Forms;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Xml.Linq;
|
|
using System.IO;
|
|
using System.Net;
|
|
|
|
namespace LocalizationTool
|
|
{
|
|
static class Program
|
|
{
|
|
/// <summary>
|
|
/// The main entry point for the application.
|
|
/// </summary>
|
|
[STAThread]
|
|
static void Main(string[] args)
|
|
{
|
|
if (args.Length == 0)
|
|
{
|
|
PrintUsage();
|
|
return;
|
|
}
|
|
|
|
//All relative paths are to the app dir
|
|
System.IO.Directory.SetCurrentDirectory(Application.StartupPath);
|
|
|
|
string loc = args.Length >= 2 ? args[1] : null;
|
|
|
|
switch (args[0].ToLower())
|
|
{
|
|
case "clean":
|
|
case "cleanup":
|
|
Clean(loc);
|
|
break;
|
|
case "build":
|
|
Compile(loc);
|
|
break;
|
|
case "update":
|
|
Update(loc);
|
|
break;
|
|
case "create":
|
|
if (args.Length != 2)
|
|
{
|
|
Console.WriteLine("missing locale identifier");
|
|
PrintUsage();
|
|
return;
|
|
}
|
|
Create(loc);
|
|
break;
|
|
case "report":
|
|
Report(loc);
|
|
break;
|
|
case "export":
|
|
Export(loc);
|
|
break;
|
|
case "exportdiff":
|
|
if (args.Length != 3)
|
|
{
|
|
Console.WriteLine("missing locale identifier or input CSV file");
|
|
PrintUsage();
|
|
return;
|
|
}
|
|
|
|
ExportDiff(loc, args[2]);
|
|
break;
|
|
case "import":
|
|
if (args.Length != 3)
|
|
{
|
|
Console.WriteLine("missing locale identifier or input CSV file");
|
|
PrintUsage();
|
|
return;
|
|
}
|
|
Import(loc, args[2]);
|
|
break;
|
|
case "guiupdate":
|
|
Application.EnableVisualStyles();
|
|
Application.DoEvents();
|
|
|
|
Report(loc);
|
|
new UpdateGUI(System.IO.Path.Combine(Application.StartupPath, "report." + loc + ".xml")).ShowDialog();
|
|
break;
|
|
case "webpull":
|
|
WebPull(loc, false);
|
|
break;
|
|
case "webupdate":
|
|
WebPull(loc, true);
|
|
break;
|
|
default:
|
|
PrintUsage();
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
private static void PrintUsage()
|
|
{
|
|
Console.WriteLine("Usage: ");
|
|
|
|
Console.WriteLine("LocalizationTool.exe CLEAN [locale identifier]");
|
|
Console.WriteLine("LocalizationTool.exe BUILD [locale identifier]");
|
|
Console.WriteLine("LocalizationTool.exe UPDATE [locale identifier]");
|
|
Console.WriteLine("LocalizationTool.exe REPORT [locale identifier]");
|
|
Console.WriteLine("LocalizationTool.exe CREATE <locale indentifier>");
|
|
Console.WriteLine("LocalizationTool.exe GUIUPDATE <locale identifier>");
|
|
Console.WriteLine("LocalizationTool.exe EXPORT [locale identifier]");
|
|
Console.WriteLine("LocalizationTool.exe IMPORT <locale identifier> <input CSV file>");
|
|
Console.WriteLine("LocalizationTool.exe EXPORTDIFF <locale identifier> <input CSV file>");
|
|
Console.WriteLine("LocalizationTool.exe WEBPULL [locale identifier]");
|
|
Console.WriteLine("LocalizationTool.exe WEBUPDATE [locale identifier]");
|
|
}
|
|
|
|
private struct CSVEntry
|
|
{
|
|
public string Filename;
|
|
public string Fieldkey;
|
|
public string Origvalue;
|
|
public string Value;
|
|
public string Status;
|
|
|
|
public string[] extraFields;
|
|
|
|
public CSVEntry(List<string> fields)
|
|
{
|
|
Filename = fields[0];
|
|
Fieldkey = fields[1];
|
|
Status = fields[2];
|
|
Origvalue = fields[3];
|
|
Value = fields[4];
|
|
|
|
if (fields.Count > 5)
|
|
{
|
|
extraFields = new string[fields.Count - 5];
|
|
fields.CopyTo(5, extraFields, 0, extraFields.Length);
|
|
}
|
|
else
|
|
extraFields = null;
|
|
}
|
|
}
|
|
|
|
private static bool IsValidCulture(string c)
|
|
{
|
|
try
|
|
{
|
|
System.Globalization.CultureInfo.GetCultureInfo(c);
|
|
return true;
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Downloads updated CSV files from the web and generates diff files, and optionally updates the local CSV files
|
|
/// </summary>
|
|
/// <param name="loc">The culture to use</param>
|
|
/// <param name="update">True if the elements should be updated as well</param>
|
|
private static void WebPull(string loc, bool update)
|
|
{
|
|
var locs =
|
|
from n in Directory.GetFiles(Application.StartupPath, "report.*.url")
|
|
where IsValidCulture(Path.GetFileNameWithoutExtension(n).Substring("report.".Length))
|
|
select Path.GetFileNameWithoutExtension(n).Substring("report.".Length);
|
|
|
|
if (!string.IsNullOrEmpty(loc))
|
|
{
|
|
locs = locs.Where(c => string.Equals(c, loc, StringComparison.CurrentCultureIgnoreCase));
|
|
if (locs.Count() == 0)
|
|
{
|
|
Console.WriteLine("No URL file found for culture {0}", loc);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (locs.Count() == 0)
|
|
{
|
|
Console.WriteLine("No culture.url files found");
|
|
return;
|
|
}
|
|
|
|
foreach (var culture in locs)
|
|
{
|
|
var url = string.Format("report.{0}.url", culture);
|
|
var file = string.Format("report.{0}.new.csv", culture);
|
|
|
|
if (File.Exists(file))
|
|
File.Delete(file);
|
|
Console.Write("Downloading updated CSV for {0} ... ", culture);
|
|
try { new WebClient().DownloadFile(File.ReadAllText(url).Trim(), file); }
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Failed!");
|
|
Console.WriteLine(" -> {0}", ex.Message);
|
|
continue;
|
|
}
|
|
Console.WriteLine("Done!");
|
|
|
|
if (update)
|
|
{
|
|
Console.Write("Updating local files for {0} .", culture);
|
|
ExportDiff(culture, file);
|
|
Console.Write(".");
|
|
Import(culture, file);
|
|
Console.Write(".");
|
|
Export(culture);
|
|
Console.WriteLine(" Done!");
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Imports a CSV file into a dictionary format,
|
|
/// Outer key is filename, inner key is fieldname, inner value is translated text
|
|
/// </summary>
|
|
/// <param name="file">The CSV file to read from</param>
|
|
/// <param name="loc">The current culture string</param>
|
|
/// <returns>Dictionary where outer key is filename, inner key is fieldname, inner value is translated text</returns>
|
|
private static Dictionary<string, Dictionary<string, CSVEntry>> ImportCSV(string file, string loc, Func<CSVEntry, bool> filter)
|
|
{
|
|
Dictionary<string, Dictionary<string, CSVEntry>> values = new Dictionary<string, Dictionary<string, CSVEntry>>();
|
|
|
|
using (CSVReader r = new CSVReader(file))
|
|
{
|
|
List<string> fields = null;
|
|
while ((fields = r.AdvanceLine()) != null)
|
|
if (fields.Count >= 5)
|
|
{
|
|
CSVEntry e = new CSVEntry(fields);
|
|
e.Filename = System.IO.Path.Combine(System.IO.Path.Combine(Application.StartupPath, loc), e.Filename);
|
|
|
|
if (filter != null && filter(e))
|
|
continue;
|
|
|
|
if (!values.ContainsKey(e.Filename))
|
|
values.Add(e.Filename, new Dictionary<string, CSVEntry>());
|
|
|
|
Dictionary<string, CSVEntry> l = values[e.Filename];
|
|
l[e.Fieldkey] = e;
|
|
}
|
|
}
|
|
|
|
return values;
|
|
}
|
|
|
|
private static void Import(string loc, string p)
|
|
{
|
|
//Outer key is filename, inner key is fieldname, inner value is translated text
|
|
Dictionary<string, Dictionary<string, CSVEntry>> values = ImportCSV(p, loc, e => e.Value.Trim().Length == 0 || e.Value == e.Origvalue);
|
|
|
|
if (Duplicati.Library.Utility.Utility.IsClientLinux)
|
|
{
|
|
Dictionary<string, Dictionary<string, CSVEntry>> remap = new Dictionary<string, Dictionary<string, CSVEntry>>();
|
|
foreach(string key in values.Keys)
|
|
remap[key.Replace("\\", System.IO.Path.DirectorySeparatorChar.ToString ())] = values[key];
|
|
|
|
values = remap;
|
|
}
|
|
|
|
string folder = System.IO.Path.Combine(Application.StartupPath, loc);
|
|
if (!System.IO.Directory.Exists(folder))
|
|
Create(loc);
|
|
else
|
|
Update(loc);
|
|
|
|
XNamespace xmlns = "";
|
|
foreach (ResXFileInfo inf in GetResXList(loc))
|
|
{
|
|
if (System.IO.File.Exists(inf.TargetFile) && values.ContainsKey(inf.TargetFile))
|
|
{
|
|
XDocument targetDoc = XDocument.Load(inf.TargetFile);
|
|
XNode insertTarget = targetDoc.Element("root").LastNode;
|
|
var targetVals = targetDoc.Element("root").Elements("data").ToSafeDictionary(c => c.Attribute("name").Value, inf.TargetFile);
|
|
var sourceVals = values[inf.TargetFile];
|
|
values.Remove(inf.TargetFile);
|
|
|
|
bool updated = false;
|
|
foreach (var item in sourceVals)
|
|
if (targetVals.ContainsKey(item.Key))
|
|
{
|
|
if (targetVals[item.Key].Element("value").Value.Replace("\r\n", "\n") != item.Value.Value.Replace("\r\n", "\n"))
|
|
{
|
|
updated = true;
|
|
targetVals[item.Key].Element("value").Value = item.Value.Value;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
updated = true;
|
|
insertTarget.AddAfterSelf(new XElement("data",
|
|
new XAttribute("name", item.Key),
|
|
new XAttribute(xmlns + "space", "preserve"),
|
|
new XElement("value", item.Value.Value)
|
|
));
|
|
}
|
|
|
|
if (updated)
|
|
targetDoc.Save(inf.TargetFile);
|
|
}
|
|
}
|
|
|
|
if (values.Count != 0)
|
|
Console.WriteLine("The following files were translated but did not exist: " + string.Join(Environment.NewLine, values.Keys.ToArray()));
|
|
}
|
|
|
|
|
|
public static IEnumerable<string> GetLocaleFolders(string locid)
|
|
{
|
|
if (string.IsNullOrEmpty(locid))
|
|
return System.IO.Directory.GetDirectories(Application.StartupPath).Where(c =>
|
|
{
|
|
try
|
|
{
|
|
System.Globalization.CultureInfo.GetCultureInfo(System.IO.Path.GetFileName(c));
|
|
return true;
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}).Select(c => System.IO.Path.GetFileName(c));
|
|
else
|
|
return new string[] { locid };
|
|
}
|
|
|
|
private static void Export(string cultures)
|
|
{
|
|
Update(cultures);
|
|
Report(cultures);
|
|
|
|
foreach (string culture in GetLocaleFolders(cultures))
|
|
{
|
|
XDocument doc = XDocument.Load(System.IO.Path.Combine(Application.StartupPath, "report." + culture + ".xml"));
|
|
string outfile = System.IO.Path.Combine(Application.StartupPath, "report." + culture + ".csv");
|
|
|
|
Dictionary<string, Dictionary<string, CSVEntry>> elems = new Dictionary<string, Dictionary<string, CSVEntry>>();
|
|
foreach (var file in doc.Element("root").Elements("file"))
|
|
{
|
|
string filename = file.Attribute("filename").Value.Substring(Duplicati.Library.Utility.Utility.AppendDirSeparator(Application.StartupPath).Length);
|
|
filename = filename.Substring(culture.Length + 1);
|
|
|
|
Dictionary<string, CSVEntry> e = new Dictionary<string, CSVEntry>();
|
|
elems[filename] = e;
|
|
|
|
foreach (var item in file.Element("updated").Elements("item"))
|
|
{
|
|
CSVEntry c = new CSVEntry();
|
|
c.Filename = filename;
|
|
c.Fieldkey = item.Attribute("name").Value;
|
|
c.Status = item.Parent.Name.LocalName;
|
|
c.Origvalue = item.Element("original").Value;
|
|
c.Value = item.Element("translated").Value;
|
|
e.Add(c.Fieldkey, c);
|
|
|
|
}
|
|
|
|
foreach (var item in file.Element("missing").Elements("item"))
|
|
{
|
|
CSVEntry c = new CSVEntry();
|
|
c.Filename = filename;
|
|
c.Fieldkey = item.Attribute("name").Value;
|
|
c.Status = item.Parent.Name.LocalName;
|
|
c.Origvalue = item.Value;
|
|
c.Value = "";
|
|
e.Add(c.Fieldkey, c);
|
|
}
|
|
|
|
foreach (var item in file.Element("not-updated").Elements("item"))
|
|
{
|
|
CSVEntry c = new CSVEntry();
|
|
c.Filename = filename;
|
|
c.Fieldkey = item.Attribute("name").Value;
|
|
c.Status = item.Parent.Name.LocalName;
|
|
c.Origvalue = item.Value;
|
|
c.Value = "";
|
|
e.Add(c.Fieldkey, c);
|
|
}
|
|
|
|
foreach (var item in file.Element("unused").Elements("item"))
|
|
{
|
|
CSVEntry c = new CSVEntry();
|
|
c.Filename = filename;
|
|
c.Fieldkey = item.Attribute("name").Value;
|
|
c.Status = item.Parent.Name.LocalName;
|
|
c.Origvalue = "";
|
|
c.Value = item.Value;
|
|
e.Add(c.Fieldkey, c);
|
|
}
|
|
|
|
}
|
|
|
|
WriteCSVFile(outfile, culture, elems, null);
|
|
}
|
|
}
|
|
|
|
private static void ExportDiff(string culture, string inputfile)
|
|
{
|
|
inputfile = System.IO.Path.GetFullPath(inputfile);
|
|
|
|
string currentFile = System.IO.Path.Combine(Application.StartupPath, "report." + culture + ".csv");
|
|
string diffFile = System.IO.Path.Combine(Application.StartupPath, "report." + culture + ".diff.csv");
|
|
|
|
if (currentFile.Equals(inputfile, Duplicati.Library.Utility.Utility.ClientFilenameStringComparision))
|
|
throw new Exception("Input file will be overwritten, please use another file");
|
|
|
|
Export(culture);
|
|
|
|
|
|
//Outer key is filename, inner key is fieldname, inner value is translated text
|
|
Dictionary<string, Dictionary<string, CSVEntry>> inputValues = ImportCSV(inputfile, culture, null);
|
|
Dictionary<string, Dictionary<string, CSVEntry>> currentValues = ImportCSV(currentFile, culture, null);
|
|
|
|
Dictionary<string, Dictionary<string, CSVEntry>> added = new Dictionary<string, Dictionary<string, CSVEntry>>();
|
|
Dictionary<string, Dictionary<string, CSVEntry>> removed = new Dictionary<string, Dictionary<string, CSVEntry>>();
|
|
|
|
foreach (var f in currentValues)
|
|
{
|
|
Dictionary<string, CSVEntry> other;
|
|
inputValues.TryGetValue(f.Key, out other);
|
|
|
|
if (other == null)
|
|
{
|
|
added.Add(f.Key, f.Value);
|
|
}
|
|
else
|
|
{
|
|
Dictionary<string, CSVEntry> a = new Dictionary<string,CSVEntry>();
|
|
|
|
foreach (KeyValuePair<string, CSVEntry> s in f.Value)
|
|
{
|
|
if (other.ContainsKey(s.Key))
|
|
other.Remove(s.Key);
|
|
else
|
|
a.Add(s.Key, s.Value);
|
|
}
|
|
|
|
if (a.Count > 0)
|
|
added.Add(f.Key, a);
|
|
|
|
if (other.Count > 0)
|
|
removed.Add(f.Key, other);
|
|
}
|
|
}
|
|
|
|
Dictionary<string, Dictionary<string, string>> overrides = new Dictionary<string, Dictionary<string, string>>();
|
|
Dictionary<string, Dictionary<string, CSVEntry>> diffElems = new Dictionary<string, Dictionary<string, CSVEntry>>();
|
|
|
|
foreach (KeyValuePair<string, Dictionary<string, CSVEntry>> f in added)
|
|
foreach (KeyValuePair<string, CSVEntry> s in f.Value)
|
|
if (s.Value.Origvalue == s.Value.Value || s.Value.Value.Trim().Length == 0)
|
|
{
|
|
if (!overrides.ContainsKey(f.Key))
|
|
overrides.Add(f.Key, new Dictionary<string, string>());
|
|
if (!diffElems.ContainsKey(f.Key))
|
|
diffElems.Add(f.Key, new Dictionary<string, CSVEntry>());
|
|
overrides[f.Key].Add(s.Key, "not-updated");
|
|
diffElems[f.Key].Add(s.Key, s.Value);
|
|
}
|
|
|
|
foreach (KeyValuePair<string, Dictionary<string, CSVEntry>> f in removed)
|
|
foreach (KeyValuePair<string, CSVEntry> s in f.Value)
|
|
{
|
|
if (!overrides.ContainsKey(f.Key))
|
|
overrides.Add(f.Key, new Dictionary<string, string>());
|
|
if (!diffElems.ContainsKey(f.Key))
|
|
diffElems.Add(f.Key, new Dictionary<string, CSVEntry>());
|
|
overrides[f.Key].Add(s.Key, "unused");
|
|
diffElems[f.Key].Add(s.Key, s.Value);
|
|
}
|
|
|
|
WriteCSVFile(diffFile, culture, diffElems, overrides);
|
|
|
|
//Re-read the file
|
|
inputValues = ImportCSV(inputfile, culture, null);
|
|
|
|
//Add the new entries
|
|
foreach (KeyValuePair<string, Dictionary<string, CSVEntry>> f in added)
|
|
{
|
|
if (!inputValues.ContainsKey(f.Key))
|
|
inputValues.Add(f.Key, new Dictionary<string, CSVEntry>());
|
|
|
|
Dictionary<string, CSVEntry> o = inputValues[f.Key];
|
|
|
|
foreach (KeyValuePair<string, CSVEntry> s in f.Value)
|
|
o.Add(s.Key, s.Value);
|
|
|
|
}
|
|
|
|
foreach (KeyValuePair<string, Dictionary<string, CSVEntry>> f in currentValues)
|
|
{
|
|
Dictionary<string, CSVEntry> o = inputValues[f.Key];
|
|
foreach (KeyValuePair<string, CSVEntry> s in f.Value)
|
|
{
|
|
CSVEntry c = o[s.Key];
|
|
if (s.Value.Status == "unused")
|
|
c.Status = "unused";
|
|
else if (c.Origvalue == c.Value)
|
|
c.Status = "not-updated";
|
|
else if (string.IsNullOrEmpty(c.Value) || c.Value.Trim().Length == 0)
|
|
c.Status = "missing";
|
|
else
|
|
c.Status = "updated";
|
|
|
|
o[s.Key] = c;
|
|
}
|
|
}
|
|
|
|
//Update the removed entries
|
|
foreach (KeyValuePair<string, Dictionary<string, CSVEntry>> f in removed)
|
|
{
|
|
Dictionary<string, CSVEntry> o = inputValues[f.Key];
|
|
foreach (KeyValuePair<string, CSVEntry> s in f.Value)
|
|
{
|
|
CSVEntry c = o[s.Key];
|
|
c.Status = "unused";
|
|
o[s.Key] = c;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//Write the output file
|
|
diffFile = System.IO.Path.Combine(Application.StartupPath, "report." + culture + ".updated.csv");
|
|
WriteCSVFile(diffFile, culture, inputValues, null);
|
|
}
|
|
|
|
private static void WriteCSVFile(string filename, string culture, Dictionary<string, Dictionary<string, CSVEntry>> entries, Dictionary<string, Dictionary<string, string>> status_overrides)
|
|
{
|
|
if (status_overrides == null)
|
|
status_overrides = new Dictionary<string, Dictionary<string, string>>();
|
|
|
|
List<KeyValuePair<string, KeyValuePair<string, CSVEntry>>> sortlist = new List<KeyValuePair<string, KeyValuePair<string, CSVEntry>>>();
|
|
foreach (KeyValuePair<string, Dictionary<string, CSVEntry>> f in entries)
|
|
foreach (KeyValuePair<string, CSVEntry> s in f.Value)
|
|
sortlist.Add(new KeyValuePair<string, KeyValuePair<string, CSVEntry>>(f.Key, s));
|
|
|
|
var sortedlist = sortlist.OrderBy(x => x.Key + System.IO.Path.PathSeparator + x.Value.Key);
|
|
|
|
using (System.IO.StreamWriter sw = new System.IO.StreamWriter(filename, false, new System.Text.UTF8Encoding(false)))
|
|
{
|
|
string filenameprefix = System.IO.Path.Combine(Application.StartupPath, culture);
|
|
int pfl = filenameprefix.Length + 1;
|
|
|
|
foreach (KeyValuePair<string, KeyValuePair<string, CSVEntry>> f in sortedlist)
|
|
{
|
|
string status = f.Value.Value.Status;
|
|
if (status_overrides.ContainsKey(f.Key) && status_overrides[f.Key].ContainsKey(f.Value.Key))
|
|
status = status_overrides[f.Key][f.Value.Key];
|
|
|
|
string path = f.Key;
|
|
if (f.Key.StartsWith(filenameprefix, Duplicati.Library.Utility.Utility.ClientFilenameStringComparision))
|
|
path = f.Key.Substring(Math.Min(pfl, f.Key.Length));
|
|
|
|
if (Duplicati.Library.Utility.Utility.IsClientLinux)
|
|
path = path.Replace(System.IO.Path.DirectorySeparatorChar.ToString(), "\\");
|
|
|
|
WriteCSVLine(sw, path, f.Value.Key, status, f.Value.Value.Origvalue, f.Value.Value.Value, f.Value.Value.extraFields);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static string CSV_SEPARATOR = ",";
|
|
|
|
private static void WriteCSVLine(System.IO.StreamWriter sw, string filename, string key, string status, string originalText, string translatedText, string[] extraFields)
|
|
{
|
|
sw.Write(EscapeCSVString(filename));
|
|
sw.Write(CSV_SEPARATOR);
|
|
sw.Write(EscapeCSVString(key));
|
|
sw.Write(CSV_SEPARATOR);
|
|
sw.Write(EscapeCSVString(status));
|
|
sw.Write(CSV_SEPARATOR);
|
|
sw.Write(EscapeCSVString(originalText));
|
|
sw.Write(CSV_SEPARATOR);
|
|
sw.Write(EscapeCSVString(translatedText));
|
|
|
|
if (extraFields != null && extraFields.Length > 0)
|
|
foreach (string s in extraFields)
|
|
{
|
|
sw.Write(CSV_SEPARATOR);
|
|
sw.Write(EscapeCSVString(s));
|
|
}
|
|
|
|
sw.Write("\r\n");
|
|
}
|
|
|
|
private static string EscapeCSVString(string value)
|
|
{
|
|
//.Replace("\\", "\\\\").Replace("\r\n", "\\n").Replace("\r", "\\n").Replace("\n", "\\n").Replace("\t", "\\t")
|
|
return "\"" + value.Replace("\"", "\"\"") + "\"";
|
|
}
|
|
|
|
private static void Report(string cultures)
|
|
{
|
|
foreach (string culture in GetLocaleFolders(cultures))
|
|
{
|
|
Dictionary<string, string> ignores = new Dictionary<string, string>();
|
|
string ignorefile = System.IO.Path.Combine(Application.StartupPath, "ignore." + culture + ".xml");
|
|
if (System.IO.File.Exists(ignorefile))
|
|
ignores = XDocument.Load(ignorefile).Element("root").Elements("ignore").Select(c => c.Value).ToSafeDictionary(c => c.ToLower().Trim(), ignorefile);
|
|
|
|
//Make sure we ignore empty strings
|
|
ignores[""] = "";
|
|
|
|
//Ignore common leftover values
|
|
for (int i = 1; i < 20; i++)
|
|
{
|
|
string _i = i.ToString();
|
|
ignores["textbox" + _i] = "";
|
|
ignores["combobox" + _i] = "";
|
|
ignores["checkbox" + _i] = "";
|
|
ignores["label" + _i] = "";
|
|
ignores["radiobutton" + _i] = "";
|
|
ignores["button" + _i] = "";
|
|
ignores["toolstrip" + _i] = "";
|
|
ignores["toolstripbutton" + _i] = "";
|
|
ignores["statusstrip" + _i] = "";
|
|
}
|
|
|
|
|
|
XDocument report = new XDocument(
|
|
new XElement("root")
|
|
);
|
|
XElement reportRoot = report.Element("root");
|
|
|
|
IEnumerable<ResXFileInfo> files = GetResXList(culture);
|
|
var missingFiles = files.Where(c => !System.IO.File.Exists(c.TargetFile));
|
|
var existingFiles = files.Where(c => System.IO.File.Exists(c.TargetFile));
|
|
|
|
var extraFiles = from x in Duplicati.Library.Utility.Utility.EnumerateFiles(System.IO.Path.Combine(Application.StartupPath, culture))
|
|
where
|
|
x.EndsWith("." + culture + ".resx")
|
|
&&
|
|
!files.Select(c => c.TargetFile).Contains(x)
|
|
select x;
|
|
|
|
reportRoot.Add(
|
|
new XElement("files",
|
|
new XElement("missing",
|
|
from x in missingFiles
|
|
select new XElement("file", x.TargetFile)
|
|
),
|
|
new XElement("unused",
|
|
from x in extraFiles
|
|
select new XElement("file", x)
|
|
)
|
|
)
|
|
);
|
|
|
|
foreach(ResXFileInfo inf in existingFiles)
|
|
{
|
|
IEnumerable<XElement> sourceElements = XDocument.Load(inf.SourceFile).Element("root").Elements("data");
|
|
IEnumerable<XElement> targetElements = XDocument.Load(inf.TargetFile).Element("root").Elements("data");
|
|
|
|
if (inf.IsForm)
|
|
{
|
|
//Look only for strings
|
|
Func<XElement, bool> filter =
|
|
c =>
|
|
!c.Attribute("name").Value.StartsWith(">>")
|
|
&&
|
|
c.Attribute("mimetype") == null
|
|
&&
|
|
(
|
|
c.Attribute("type") == null
|
|
||
|
|
c.Attribute("type").Value == "System.String, mscorlib"
|
|
||
|
|
c.Attribute("type").Value == "System.String"
|
|
);
|
|
|
|
sourceElements = sourceElements.Where(filter);
|
|
targetElements = targetElements.Where(filter);
|
|
}
|
|
|
|
//Filter the source and target before proceeding
|
|
sourceElements = sourceElements.Where(c => !ignores.ContainsKey(c.Element("value").Value.Trim().ToLower()) && !c.Element("value").Value.Trim().ToLower().StartsWith("..\\resources\\") && !c.Element("value").Value.Trim().ToLower().StartsWith("../resources/"));
|
|
targetElements = targetElements.Where(c => !ignores.ContainsKey(c.Element("value").Value.Trim().ToLower()) && !c.Element("value").Value.Trim().ToLower().StartsWith("..\\resources\\") && !c.Element("value").Value.Trim().ToLower().StartsWith("../resources/"));
|
|
|
|
var sourceVals = sourceElements.ToSafeDictionary(c => c.Attribute("name").Value, inf.SourceFile);
|
|
var targetVals = targetElements.ToSafeDictionary(c => c.Attribute("name").Value, inf.TargetFile);
|
|
|
|
var missing = sourceVals.Where(c => !targetVals.ContainsKey(c.Key)).ToList();
|
|
var unused = targetVals.Where(c => !sourceVals.ContainsKey(c.Key)).ToList();
|
|
var notUpdated = sourceVals.Where(c =>
|
|
targetVals.ContainsKey(c.Key)
|
|
&&
|
|
targetVals[c.Key].Element("value").Value == c.Value.Element("value").Value).ToList();
|
|
|
|
var updated = sourceVals.Where(c =>
|
|
!missing.Contains(c)
|
|
&&
|
|
!unused.Contains(c)
|
|
&&
|
|
!notUpdated.Contains(c)
|
|
&&
|
|
targetVals.ContainsKey(c.Key)
|
|
);
|
|
|
|
var yy = sourceVals.Values.Where(x => x.Value.Contains("System.Draw")).Concat(targetVals.Values.Where(x => x.Value.Contains("System.Draw")));
|
|
if (yy.Count() != 0)
|
|
{
|
|
}
|
|
|
|
reportRoot.Add(
|
|
new XElement("file",
|
|
new XAttribute("filename", inf.TargetFile),
|
|
new XElement("missing",
|
|
from x in missing
|
|
select new XElement("item",
|
|
new XAttribute("name", x.Key),
|
|
x.Value.Element("value").Value
|
|
)
|
|
),
|
|
new XElement("unused",
|
|
from x in unused
|
|
select new XElement("item",
|
|
new XAttribute("name", x.Key),
|
|
x.Value.Element("value").Value
|
|
)
|
|
),
|
|
new XElement("not-updated",
|
|
from x in notUpdated
|
|
select new XElement("item",
|
|
new XAttribute("name", x.Key),
|
|
x.Value.Element("value").Value
|
|
)
|
|
),
|
|
new XElement("updated",
|
|
from x in updated
|
|
select new XElement("item",
|
|
new XAttribute("name", x.Key),
|
|
new XElement("original",
|
|
x.Value.Element("value").Value
|
|
),
|
|
new XElement("translated",
|
|
targetVals[x.Key].Element("value").Value
|
|
)
|
|
)
|
|
)
|
|
)
|
|
);
|
|
}
|
|
|
|
report.Save(System.IO.Path.Combine(Application.StartupPath, "report." + culture + ".xml"));
|
|
}
|
|
}
|
|
|
|
private static void Create(string culture)
|
|
{
|
|
System.Globalization.CultureInfo ci = System.Globalization.CultureInfo.GetCultureInfo(culture); //Validate
|
|
string folder = System.IO.Path.Combine(Application.StartupPath, culture);
|
|
if (!System.IO.Directory.Exists(folder))
|
|
System.IO.Directory.CreateDirectory(folder);
|
|
Update(culture);
|
|
}
|
|
|
|
public class ResXFileInfo
|
|
{
|
|
public string SourceFile { get; set; }
|
|
public string TargetFile { get; set; }
|
|
public string NetrualTargetFile { get; set; }
|
|
public bool IsForm { get; set; }
|
|
}
|
|
|
|
public static IEnumerable<ResXFileInfo> GetResXList(string culture)
|
|
{
|
|
List<ResXFileInfo> res = new List<ResXFileInfo>();
|
|
foreach (XElement conf in XDocument.Load(System.IO.Path.Combine(Application.StartupPath, "configuration.xml")).Element("root").Elements("configuration"))
|
|
{
|
|
string sourcefolder = conf.Element("sourcefolder").Value;
|
|
if (Duplicati.Library.Utility.Utility.IsClientLinux)
|
|
sourcefolder = sourcefolder.Replace("\\", System.IO.Path.DirectorySeparatorChar.ToString());
|
|
|
|
string outputfolder = System.IO.Path.GetFullPath(Duplicati.Library.Utility.Utility.AppendDirSeparator(System.IO.Path.Combine(Application.StartupPath, culture)));
|
|
sourcefolder = Duplicati.Library.Utility.Utility.AppendDirSeparator(System.IO.Path.GetFullPath(sourcefolder));
|
|
|
|
foreach (XElement fn in conf.Elements("assembly"))
|
|
{
|
|
string subfolder = fn.Attribute("folder").Value;
|
|
if (Duplicati.Library.Utility.Utility.IsClientLinux)
|
|
subfolder = subfolder.Replace("\\", System.IO.Path.DirectorySeparatorChar.ToString());
|
|
|
|
foreach (string s in Duplicati.Library.Utility.Utility.EnumerateFiles(System.IO.Path.Combine(sourcefolder, subfolder)))
|
|
{
|
|
if (s.ToLower().StartsWith(Application.StartupPath.ToLower()))
|
|
continue;
|
|
|
|
if (s.EndsWith(".resx"))
|
|
{
|
|
string targetNameNeutral = System.IO.Path.Combine(outputfolder, s.Substring(sourcefolder.Length));
|
|
|
|
if (!System.IO.Directory.Exists(System.IO.Path.GetDirectoryName(targetNameNeutral)))
|
|
System.IO.Directory.CreateDirectory(System.IO.Path.GetDirectoryName(targetNameNeutral));
|
|
|
|
string targetFilename = targetNameNeutral.Substring(0, targetNameNeutral.Length - "resx".Length) + culture + ".resx";
|
|
if (res.Where(x => x.TargetFile == targetFilename).FirstOrDefault() == null)
|
|
res.Add(new ResXFileInfo()
|
|
{
|
|
SourceFile = s,
|
|
IsForm = System.IO.File.Exists(System.IO.Path.ChangeExtension(s, ".cs")),
|
|
NetrualTargetFile = targetNameNeutral,
|
|
TargetFile = targetFilename
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
private static void Update(string cultures)
|
|
{
|
|
foreach (string culture in GetLocaleFolders(cultures))
|
|
{
|
|
foreach (ResXFileInfo inf in GetResXList(culture))
|
|
{
|
|
if (inf.IsForm)
|
|
System.IO.File.Copy(inf.SourceFile, inf.NetrualTargetFile, true); //Copy the updated resx
|
|
|
|
if (System.IO.File.Exists(inf.TargetFile))
|
|
{
|
|
//Merge, forms are auto-merged, in that they depend on the neutral .resx file
|
|
if (!inf.IsForm)
|
|
{
|
|
XDocument targetDoc = XDocument.Load(inf.TargetFile);
|
|
XNode insertTarget = targetDoc.Element("root").LastNode;
|
|
|
|
var sourceVals = XDocument.Load(inf.SourceFile).Element("root").Elements("data").ToSafeDictionary(c => c.Attribute("name").Value, inf.SourceFile);
|
|
var targetVals = targetDoc.Element("root").Elements("data").ToSafeDictionary(c => c.Attribute("name").Value, inf.TargetFile);
|
|
|
|
bool updated = false;
|
|
foreach (var item in sourceVals)
|
|
if (!targetVals.ContainsKey(item.Key))
|
|
{
|
|
updated = true;
|
|
insertTarget.AddAfterSelf(new XElement(item.Value));
|
|
}
|
|
|
|
if (updated)
|
|
targetDoc.Save(inf.TargetFile);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (inf.IsForm)
|
|
using (System.IO.StreamWriter sw = new System.IO.StreamWriter(inf.TargetFile))
|
|
sw.Write(Properties.Resources.Empty_resx);
|
|
else
|
|
{
|
|
if (Duplicati.Library.Utility.Utility.IsClientLinux)
|
|
{
|
|
var doc = XDocument.Load(inf.SourceFile);
|
|
var entries = from x in doc.Element("root").Elements("data")
|
|
where
|
|
x.Attribute("type") != null
|
|
&&
|
|
x.Attribute("type").Value == "System.Resources.ResXFileRef, System.Windows.Forms"
|
|
select x;
|
|
|
|
foreach(var e in entries)
|
|
{
|
|
string name = e.Element("value").Value;
|
|
int ixpos = name.IndexOf(";");
|
|
string path = name.Substring(0, ixpos);
|
|
path = path.Replace ("\\", System.IO.Path.DirectorySeparatorChar.ToString());
|
|
e.Element("value").Value = path + name.Substring(ixpos);
|
|
}
|
|
|
|
doc.Save(inf.TargetFile);
|
|
|
|
} else {
|
|
System.IO.File.Copy(inf.SourceFile, inf.TargetFile);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
foreach (var item in from y in
|
|
(from x in XDocument.Load(inf.SourceFile).Element("root").Elements("data")
|
|
where
|
|
x.Attribute("type") != null
|
|
&&
|
|
x.Attribute("type").Value == "System.Resources.ResXFileRef, System.Windows.Forms"
|
|
select x)
|
|
let relname = y.Element("value").Value.Substring(0, y.Element("value").Value.IndexOf(";"))
|
|
let sourceRes = System.IO.Path.GetFullPath(System.IO.Path.Combine(System.IO.Path.GetDirectoryName(inf.SourceFile), relname)).Replace("\\", System.IO.Path.DirectorySeparatorChar.ToString())
|
|
let targetRes = System.IO.Path.GetFullPath(System.IO.Path.Combine(System.IO.Path.GetDirectoryName(inf.TargetFile), relname)).Replace("\\", System.IO.Path.DirectorySeparatorChar.ToString())
|
|
|
|
select new { sourceRes, targetRes }
|
|
)
|
|
{
|
|
if (!System.IO.Directory.Exists(System.IO.Path.GetDirectoryName(item.targetRes)))
|
|
System.IO.Directory.CreateDirectory(System.IO.Path.GetDirectoryName(item.targetRes));
|
|
|
|
if (!System.IO.File.Exists(item.targetRes))
|
|
{
|
|
if (Duplicati.Library.Utility.Utility.IsClientLinux && !System.IO.File.Exists(item.sourceRes))
|
|
{
|
|
string basefolder = System.IO.Path.GetDirectoryName(item.sourceRes);
|
|
string sourcefile = System.IO.Directory.GetFiles (basefolder).FirstOrDefault (x => item.sourceRes.Equals(x, StringComparison.InvariantCultureIgnoreCase));
|
|
if (sourcefile == null)
|
|
Console.WriteLine ("Source file not found: " + item.sourceRes);
|
|
else
|
|
System.IO.File.Copy (sourcefile, item.targetRes);
|
|
|
|
} else {
|
|
System.IO.File.Copy(item.sourceRes, item.targetRes);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
string batchfilename = System.IO.Path.Combine(System.IO.Path.Combine(Application.StartupPath, culture), "gui update.bat");
|
|
System.IO.File.WriteAllText(batchfilename, Properties.Resources.Batchjob_bat, System.Text.Encoding.Default);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
private static void Clean(string cultureReq)
|
|
{
|
|
string root = Duplicati.Library.Utility.Utility.AppendDirSeparator(Application.StartupPath);
|
|
if (!string.IsNullOrEmpty(cultureReq))
|
|
root = System.IO.Path.Combine(root, cultureReq);
|
|
|
|
foreach (string s in Duplicati.Library.Utility.Utility.EnumerateFiles(Application.StartupPath))
|
|
if (System.IO.Path.GetDirectoryName(s) != Application.StartupPath && (System.IO.Path.GetExtension(s) == ".resources" || System.IO.Path.GetExtension(s) == ".dll"))
|
|
System.IO.File.Delete(s);
|
|
else if (System.IO.Path.GetExtension(s) == ".resx")
|
|
{
|
|
//Remove the extra files required for resgen.exe
|
|
string culture = s.Substring(root.Length);
|
|
culture = culture.Substring(0, culture.IndexOf(System.IO.Path.DirectorySeparatorChar));
|
|
if (!s.ToLower().EndsWith("." + culture.ToLower() + ".resx") && System.IO.File.Exists(s.Substring(0, s.Length - "resx".Length) + culture + ".resx"))
|
|
System.IO.File.Delete(s);
|
|
}
|
|
|
|
}
|
|
|
|
private static void Compile(string cultureReq)
|
|
{
|
|
XDocument doc = XDocument.Load(System.IO.Path.Combine(Application.StartupPath, "configuration.xml"));
|
|
|
|
foreach (XElement conf in doc.Element("root").Elements("configuration"))
|
|
{
|
|
string keyfile = conf.Element("keyfile") == null ? null : conf.Element("keyfile").Value;
|
|
string versionassembly = conf.Element("versionassembly").Value;
|
|
string outputfolder = conf.Element("outputfolder").Value;
|
|
string productname = conf.Element("productname").Value;
|
|
string fxVer = conf.Element("frameworkVersion") == null ? "4.0" : conf.Element("frameworkVersion").Value;
|
|
|
|
Console.WriteLine("Compiling for framework: " + fxVer);
|
|
|
|
foreach (XElement n in conf.Elements("assembly"))
|
|
{
|
|
string assemblyName = n.Attribute("name").Value;
|
|
string folder = n.Attribute("folder").Value;
|
|
string @namespace = n.Attribute("namespace") == null ? assemblyName : n.Attribute("namespace").Value;
|
|
|
|
foreach (string culture in GetLocaleFolders(cultureReq))
|
|
{
|
|
List<string> excludes = (from x in n.Elements("exclude")
|
|
let fullpath = System.IO.Path.Combine(System.IO.Path.Combine(Application.StartupPath, culture), x.Value)
|
|
select fullpath).ToList();
|
|
|
|
string outfolder = System.IO.Path.GetFullPath(System.IO.Path.Combine(outputfolder, culture));
|
|
if (!System.IO.Directory.Exists(outfolder))
|
|
System.IO.Directory.CreateDirectory(outfolder);
|
|
|
|
ResXCompiler.CompileResxFiles(System.IO.Path.Combine(System.IO.Path.Combine(Application.StartupPath, culture), folder), excludes, @namespace, System.IO.Path.Combine(outfolder, assemblyName + ".resources.dll"), System.IO.Path.GetFullPath(versionassembly), keyfile, culture, productname, fxVer);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} |