private static void WriteCatalog(POCatalog catalog, string outputFile, DateTime versionDate)
{
if (File.Exists(outputFile))
{
File.Delete(outputFile);
}
var generator = new POGenerator(new POGeneratorSettings());
using var outStream = File.Open(outputFile, FileMode.OpenOrCreate);
using var writer = new StreamWriter(outStream, Encoding.UTF8);
// We only store the date when generating
catalog.Headers["PO-Revision-Date"] = string.Format("{0:yyyy-MM-dd 12:00-0400}", versionDate);
generator.Generate(writer, catalog);
}
public void GenerateFull()
{
var generator = new POGenerator();
string result;
using (var ms = new MemoryStream())
{
generator.Generate(ms, s_catalog);
result = Encoding.UTF8.GetString(ms.ToArray());
}
// Encoding.GetString keeps BOM
var expected = new StreamReader(new MemoryStream(Resources.SamplePO)).ReadToEnd()
.Replace("# should be skipped\r\n", "")
.Replace("# should be skipped too\r\n", "");
Assert.Equal(expected, result);
}
public IActionResult Export()
{
byte[] archiveFile;
var generator = new POGenerator();
using (var archiveStream = new MemoryStream())
{
using (var archive = new ZipArchive(archiveStream, ZipArchiveMode.Create, true))
{
foreach (var textCatalog in localizationProvider.TextCatalogs)
{
var entries = Enumerable.AsEnumerable <IPOEntry>(textCatalog.Value);
var contextIds = entries.Select(i => i.Key.ContextId).Distinct();
foreach (var contextId in contextIds)
{
var filteredCatalog = new POCatalog(entries.Where(entry => entry.Key.ContextId == contextId))
{
Encoding = textCatalog.Value.Encoding,
PluralFormCount = textCatalog.Value.PluralFormCount,
PluralFormSelector = textCatalog.Value.PluralFormSelector,
Language = textCatalog.Value.Language,
Headers = new Dictionary <string, string>
{
{ "X-Generator", "BlazorBoilerplate" },
}
};
var zipEntry = archive.CreateEntry($"{contextId}-{textCatalog.Key}.po");
using var entryStream = zipEntry.Open();
generator.Generate(entryStream, filteredCatalog);
}
}
}
archiveFile = archiveStream.ToArray();
}
return(File(archiveFile, MediaTypeNames.Application.Zip, "PO.zip"));
}
public static void ExportAll(string directory)
{
var languageSources = Resources.FindObjectsOfTypeAll <I2.Loc.LanguageSourceAsset>();
var gen = new POGenerator();
foreach (var source in languageSources)
{
var fullName = source.name;
var shortName = fullName.Replace("Languages", "");
POCatalog catalog = null;
if (shortName == "Dialogue" || shortName == "ButtonsImages")
{
continue;
}
int engIndex = source.mSource.GetLanguageIndex("English");
catalog = LanguageSourceToCatalog(source, engIndex);
var catalogPath = Path.Combine(directory, shortName + ".pot");
using (var file = File.Create(catalogPath))
using (var writer = new StreamWriter(file))
{
gen.Generate(writer, catalog);
}
}
// Manually generate dialogue catalog for additional infos
// Actor, conversant, conversation context
var db = Resources.FindObjectsOfTypeAll <DialogueDatabase>()[0];
var dialogueCatalog = GetDialogueCatalog(db);
var dialogueCatalogPath = Path.Combine(directory, "Dialogue.pot");
using (var file = File.Create(dialogueCatalogPath))
using (var writer = new StreamWriter(file))
{
gen.Generate(writer, dialogueCatalog);
}
}
public void GenerateSkipComments()
{
var generator = new POGenerator(new POGeneratorSettings {
SkipComments = true
});
string result;
using (var ms = new MemoryStream())
{
generator.Generate(ms, s_catalog);
result = Encoding.UTF8.GetString(ms.ToArray());
}
// Encoding.GetString keeps BOM
var expected = new StreamReader(new MemoryStream(Resources.SamplePO)).ReadToEnd();
expected = Regex.Replace(expected, @"(^|\r\n)(#[^\r]*\r\n)+", "$1");
Assert.Equal(expected, result);
}
/// <inheritdoc />
public override void Transform(Stream inputStream, Stream outputStream)
{
var parser = new POParser(new POParserSettings());
var result = parser.Parse(inputStream);
if (result.Success)
{
var inputCatalog = result.Catalog;
var outputCatalog = ProcessCatalog(inputCatalog);
var generator = new POGenerator(new POGeneratorSettings());
generator.Generate(outputStream, outputCatalog);
}
else
{
var diagnosticMessages = GetDiagnosticMessages(result.Diagnostics);
throw new POFileFormatException(diagnosticMessages);
}
}
/// <summary>
/// Creates a PO (translation) file from a set of translation keys for a specific encoding and language
/// Returns true if created succesfully and false otherwise
/// </summary>
/// <param name="fileEncoding">File encoding</param>
/// <param name="htmlTextTranslations">Translations dictionary</param>
/// <param name="language">Language used for the translations</param>
/// <param name="outputFileName">Output file name</param>
/// <returns>Returns true if created succesfully and false otherwise</returns>
public bool Create(Encoding fileEncoding, IOrderedDictionary <string, string> htmlTextTranslations, string language, string outputFileName)
{
var catalog = _catalog.CreateCatalog(fileEncoding, htmlTextTranslations, language);
var generator = new POGenerator(new POGeneratorSettings()
{
IgnoreEncoding = true
});
var stringBuilder = new StringBuilder();
var outputPath = $"{_fileWrapper.AssemblyPath()}\\output\\{outputFileName}\\";
var directoyCreateResult = _directoryWrapper.Create(outputPath);
if (directoyCreateResult != null)
{
return(false);
}
try
{
generator.Generate(stringBuilder, catalog);
}
catch (Exception ex)
{
_logger.LogError(ex, $"Failed to create PO file {outputFileName}' with language '{language}'");
return(false);
}
var fullFilePath = $"{outputPath}\\{outputFileName}_{language}.{GetTextFileTypes.PO}";
var fileCreateResult = _fileWrapper.Create(fileEncoding, stringBuilder, fullFilePath);
if (fileCreateResult != null)
{
return(false);
}
return(true);
}
public override async Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding)
{
var translationResult = (TranslationResult)context.Object;
var poCatalog = new POCatalog();
poCatalog.Language = translationResult.Language;
poCatalog.Encoding = "UTF-8";
translationResult.Entries.ForEach(entry =>
{
var poKey = new POKey(entry.Key, contextId: entry.Collection);
var poEntry = new POSingularEntry(poKey);
poEntry.Translation = entry.Value;
poCatalog.Add(poEntry);
});
var poGenerator = new POGenerator();
var memoryStream = new MemoryStream();
poGenerator.Generate(memoryStream, poCatalog, Encoding.UTF8);
memoryStream.Position = 0;
await memoryStream.CopyToAsync(context.HttpContext.Response.Body);
}
public IActionResult Export()
{
byte[] archiveFile;
var generator = new POGenerator();
using (var archiveStream = new MemoryStream())
{
using (var archive = new ZipArchive(archiveStream, ZipArchiveMode.Create, true))
{
foreach (var textCatalog in localizationProvider.TextCatalogs)
{
var zipEntry = archive.CreateEntry($"{textCatalog.Key}.po");
using var entryStream = zipEntry.Open();
generator.Generate(entryStream, textCatalog.Value);
}
}
archiveFile = archiveStream.ToArray();
}
return(File(archiveFile, MediaTypeNames.Application.Zip, "PO.zip"));
}
public async Task Visit(DataStructure dataStructure)
{
await Task.CompletedTask;
var language = Thread.CurrentThread.CurrentCulture.Name;
var projectName = dataStructure.Project.Name;
var projectPath = dataStructure.ProjectDirectory;
var localizerEntries = dataStructure.LocalizerEntries;
var POFilePath = Path.Combine(projectPath, "Localization", language + ".po");
POCatalog catalog = null;
if (File.Exists(POFilePath))
{
using var sr = new StreamReader(POFilePath, Encoding.UTF8);
var parser = new POParser(POParserSettings.Default);
var result = parser.Parse(sr);
if (result.Success)
{
catalog = result.Catalog;
foreach (var r in catalog)
{
r.Comments.Clear();
}
}
else
{
var diagnostics = result.Diagnostics;
// examine diagnostics, display an error, etc...
foreach (var diagnostic in diagnostics)
{
if (diagnostic.Severity.Equals(Karambolo.PO.DiagnosticSeverity.Error))
{
Console.WriteLine($"Error has occurred while Parse the PO file: {POFilePath}");
}
}
}
}
if (catalog == null)
{
catalog = new POCatalog
{
Encoding = Encoding.UTF8.BodyName,
PluralFormCount = 1,
PluralFormSelector = "0",
Language = language
};
var assembly = typeof(IVisitor).Assembly;
catalog.Headers = new Dictionary <string, string>
{
{ "PO-Revision-Date", DateTime.UtcNow.ToString() },
{ "Project-Id-Version", projectName },
{ "X-Crowdin-Generator", $"Generated by {assembly.GetName().Name} {assembly.GetCustomAttribute<AssemblyInformationalVersionAttribute>().InformationalVersion}" },
};
}
HashSet <POKey> sets = new HashSet <POKey>();
foreach (var entry in localizerEntries)
{
var key = new POKey(entry.Id, null, entry.ContextId);
sets.Add(key);
if (catalog.TryGetValue(key, out var POEntry))
{
if (!POEntry.Comments.OfType <POExtractedComment>().Any(c => c.Text.Equals(entry.SourceCode)))
{
POEntry.Comments.Add(new POExtractedComment {
Text = entry.SourceCode
});
}
var referenceComment = POEntry.Comments.OfType <POReferenceComment>().FirstOrDefault();
if (referenceComment == null)
{
POEntry.Comments.Add(new POReferenceComment {
References = new List <POSourceReference>()
{
POSourceReference.Parse(entry.SourceReference)
}
});
}
else
{
var sourceReference = POSourceReference.Parse(entry.SourceReference);
if (!referenceComment.References.Any(r => r.FilePath.Equals(sourceReference.FilePath) && r.Line.Equals(sourceReference.Line)))
{
referenceComment.References.Add(sourceReference);
}
}
}
else
{
POEntry = new POSingularEntry(key)
{
Comments = new List <POComment>()
{
new POReferenceComment {
References = new List <POSourceReference>()
{
POSourceReference.Parse(entry.SourceReference)
}
},
new POExtractedComment {
Text = entry.SourceCode
},
}
};
catalog.Add(POEntry);
}
}
var keys = catalog.Keys.ToList();
keys.Where(k => !sets.Contains(k)).ToList().ForEach(k => catalog.Remove(k));
if (catalog.Headers.ContainsKey("PO-Revision-Date"))
{
catalog.Headers["PO-Revision-Date"] = DateTime.UtcNow.ToString();
}
var generator = new POGenerator(POGeneratorSettings.Default);
using var sw = new StreamWriter(POFilePath, false, Encoding.UTF8);
generator.Generate(sw, catalog);
}
