bool UGenerateGatherArchiveCommandlet::WriteArchiveToFile(TSharedRef< FJsonObject > ArchiveJSONObject, const FString& OutputDirectoryPath, const TCHAR* Culture, const FString& FileName)
{
FString FullOutPath = FPaths::ConvertRelativePathToFull(OutputDirectoryPath) / Culture / FileName;
if( !WriteJSONToTextFile(ArchiveJSONObject, FullOutPath, SourceControlInfo ) )
{
return false;
}
UE_LOG(LogGenerateArchiveCommandlet, Log, TEXT("Writing archive to %s."), *OutputDirectoryPath);
return true;
}
bool UGenerateGatherManifestCommandlet::WriteManifest( const TSharedPtr<FInternationalizationManifest>& InManifest, const FString& OutputFilePath )
{
// We can not continue if the provided manifest is not valid
if( !InManifest.IsValid() )
{
return false;
}
FJsonInternationalizationManifestSerializer ManifestSerializer;
TSharedRef<FJsonObject> JsonManifestObj = MakeShareable( new FJsonObject );
bool bSuccess = ManifestSerializer.SerializeManifest( InManifest.ToSharedRef(), JsonManifestObj );
if( bSuccess )
{
bSuccess = WriteJSONToTextFile( JsonManifestObj, OutputFilePath, SourceControlInfo );
}
return bSuccess;
}
bool UInternationalizationExportCommandlet::DoImport(const FString& SourcePath, const FString& DestinationPath, const FString& Filename)
{
// Get manifest name.
FString ManifestName;
if( !GetStringFromConfig( *SectionName, TEXT("ManifestName"), ManifestName, ConfigPath ) )
{
UE_LOG( LogInternationalizationExportCommandlet, Error, TEXT("No manifest name specified.") );
return false;
}
// Get archive name.
FString ArchiveName;
if( !( GetStringFromConfig(* SectionName, TEXT("ArchiveName"), ArchiveName, ConfigPath ) ) )
{
UE_LOG(LogInternationalizationExportCommandlet, Error, TEXT("No archive name specified."));
return false;
}
// Get culture directory setting, default to true if not specified (used to allow picking of import directory with file open dialog from Translation Editor)
bool bUseCultureDirectory = true;
if (!(GetBoolFromConfig(*SectionName, TEXT("bUseCultureDirectory"), bUseCultureDirectory, ConfigPath)))
{
bUseCultureDirectory = true;
}
// Process the desired cultures
for(int32 Culture = 0; Culture < CulturesToGenerate.Num(); Culture++)
{
// Load the Portable Object file if found
const FString CultureName = CulturesToGenerate[Culture];
FString POFilePath = "";
if (bUseCultureDirectory)
{
POFilePath = SourcePath / CultureName / Filename;
}
else
{
POFilePath = SourcePath / Filename;
}
FPortableObjectFormatDOM PortableObject;
const bool HasLoadedPOFile = LoadPOFile(POFilePath, PortableObject);
if (!HasLoadedPOFile)
{
continue;
}
if (ShouldPersistComments)
{
PreserveExtractedCommentsForPersistence(PortableObject);
}
if (PortableObject.GetProjectName() != ManifestName.Replace(TEXT(".manifest"), TEXT("")))
{
UE_LOG(LogInternationalizationExportCommandlet, Log, TEXT("The project name (%s) in the file (%s) did not match the target manifest project (%s)."), *POFilePath, *PortableObject.GetProjectName(), *ManifestName.Replace(TEXT(".manifest"), TEXT("")));
}
const FString ManifestFileName = DestinationPath / ManifestName;
TSharedPtr< FJsonObject > ManifestJsonObject = NULL;
ManifestJsonObject = ReadJSONTextFile( ManifestFileName );
FJsonInternationalizationManifestSerializer ManifestSerializer;
TSharedRef< FInternationalizationManifest > InternationalizationManifest = MakeShareable( new FInternationalizationManifest );
ManifestSerializer.DeserializeManifest( ManifestJsonObject.ToSharedRef(), InternationalizationManifest );
if( !FPaths::FileExists(ManifestFileName) )
{
UE_LOG( LogInternationalizationExportCommandlet, Error, TEXT("Failed to find manifest %s."), *ManifestFileName);
continue;
}
const FString DestinationCulturePath = DestinationPath / CultureName;
const FString ArchiveFileName = DestinationCulturePath / ArchiveName;
if( !FPaths::FileExists(ArchiveFileName) )
{
UE_LOG( LogInternationalizationExportCommandlet, Error, TEXT("Failed to find destination archive %s."), *ArchiveFileName);
continue;
}
TSharedPtr< FJsonObject > ArchiveJsonObject = NULL;
ArchiveJsonObject = ReadJSONTextFile( ArchiveFileName );
FJsonInternationalizationArchiveSerializer ArchiveSerializer;
TSharedRef< FInternationalizationArchive > InternationalizationArchive = MakeShareable( new FInternationalizationArchive );
ArchiveSerializer.DeserializeArchive( ArchiveJsonObject.ToSharedRef(), InternationalizationArchive );
bool bModifiedArchive = false;
{
for( auto EntryIter = PortableObject.GetEntriesIterator(); EntryIter; ++EntryIter )
{
auto POEntry = *EntryIter;
if( POEntry->MsgId.IsEmpty() || POEntry->MsgStr.Num() == 0 || POEntry->MsgStr[0].Trim().IsEmpty() )
{
// We ignore the header entry or entries with no translation.
continue;
}
// Some warning messages for data we don't process at the moment
if( !POEntry->MsgIdPlural.IsEmpty() || POEntry->MsgStr.Num() > 1 )
{
UE_LOG( LogInternationalizationExportCommandlet, Error, TEXT("Portable Object entry has plural form we did not process. File: %s MsgCtxt: %s MsgId: %s"), *POFilePath, *POEntry->MsgCtxt, *POEntry->MsgId );
}
FString Key;
FString Namespace;
ParsePOMsgCtxtForIdentity(POEntry->MsgCtxt, Namespace, Key);
const FString& SourceText = ConditionPoStringForArchive(POEntry->MsgId);
const FString& Translation = ConditionPoStringForArchive(POEntry->MsgStr[0]);
TSharedPtr<FLocMetadataObject> KeyMetaDataObject;
// Get key metadata from the manifest, using the namespace and key.
if (!Key.IsEmpty())
{
// Find manifest entry by namespace
for (auto ManifestEntryIterator = InternationalizationManifest->GetEntriesByContextIdIterator(); ManifestEntryIterator; ++ManifestEntryIterator)
{
const FString& ManifestEntryNamespace = ManifestEntryIterator->Key;
const TSharedRef<FManifestEntry>& ManifestEntry = ManifestEntryIterator->Value;
if (ManifestEntry->Namespace == Namespace)
{
FContext* const MatchingContext = ManifestEntry->Contexts.FindByPredicate([&](FContext& Context) -> bool
{
return Context.Key == Key;
});
if (MatchingContext)
{
KeyMetaDataObject = MatchingContext->KeyMetadataObj;
}
}
}
}
//@TODO: Take into account optional entries and entries that differ by keymetadata. Ex. Each optional entry needs a unique msgCtxt
const TSharedPtr< FArchiveEntry > FoundEntry = InternationalizationArchive->FindEntryBySource( Namespace, SourceText, KeyMetaDataObject );
if( !FoundEntry.IsValid() )
{
UE_LOG(LogInternationalizationExportCommandlet, Warning, TEXT("Could not find corresponding archive entry for PO entry. File: %s MsgCtxt: %s MsgId: %s"), *POFilePath, *POEntry->MsgCtxt, *POEntry->MsgId );
continue;
}
if( FoundEntry->Translation != Translation )
{
FoundEntry->Translation = Translation;
bModifiedArchive = true;
}
}
}
if( bModifiedArchive )
{
TSharedRef<FJsonObject> FinalArchiveJsonObj = MakeShareable( new FJsonObject );
ArchiveSerializer.SerializeArchive( InternationalizationArchive, FinalArchiveJsonObj );
if( !WriteJSONToTextFile(FinalArchiveJsonObj, ArchiveFileName, SourceControlInfo ) )
{
UE_LOG( LogInternationalizationExportCommandlet, Error, TEXT("Failed to write archive to %s."), *ArchiveFileName );
return false;
}
}
}
return true;
}
bool UInternationalizationExportCommandlet::DoImport(const FString& SourcePath, const FString& DestinationPath, const FString& Filename)
{
// Get manifest name.
FString ManifestName;
if( !GetStringFromConfig( *SectionName, TEXT("ManifestName"), ManifestName, ConfigPath ) )
{
UE_LOG( LogInternationalizationExportCommandlet, Error, TEXT("No manifest name specified.") );
return false;
}
// Get archive name.
FString ArchiveName;
if( !( GetStringFromConfig(* SectionName, TEXT("ArchiveName"), ArchiveName, ConfigPath ) ) )
{
UE_LOG(LogInternationalizationExportCommandlet, Error, TEXT("No archive name specified."));
return false;
}
// Get culture directory setting, default to true if not specified (used to allow picking of import directory with file open dialog from Translation Editor)
bool bUseCultureDirectory = true;
if (!(GetBoolFromConfig(*SectionName, TEXT("bUseCultureDirectory"), bUseCultureDirectory, ConfigPath)))
{
bUseCultureDirectory = true;
}
// Process the desired cultures
for(int32 Culture = 0; Culture < CulturesToGenerate.Num(); Culture++)
{
// Load the Portable Object file if found
const FString CultureName = CulturesToGenerate[Culture];
FString POFilePath = "";
if (bUseCultureDirectory)
{
POFilePath = SourcePath / CultureName / Filename;
}
else
{
POFilePath = SourcePath / Filename;
}
if( !FPaths::FileExists(POFilePath) )
{
UE_LOG( LogInternationalizationExportCommandlet, Warning, TEXT("Could not find file %s"), *POFilePath );
continue;
}
FString POFileContents;
if ( !FFileHelper::LoadFileToString( POFileContents, *POFilePath ) )
{
UE_LOG( LogInternationalizationExportCommandlet, Error, TEXT("Failed to load file %s."), *POFilePath);
continue;
}
FPortableObjectFormatDOM PortableObject;
if( !PortableObject.FromString( POFileContents ) )
{
UE_LOG( LogInternationalizationExportCommandlet, Error, TEXT("Failed to parse Portable Object file %s."), *POFilePath);
continue;
}
if( PortableObject.GetProjectName() != ManifestName.Replace(TEXT(".manifest"), TEXT("")) )
{
UE_LOG( LogInternationalizationExportCommandlet, Warning, TEXT("The project name (%s) in the file (%s) did not match the target manifest project (%s)."), *POFilePath, *PortableObject.GetProjectName(), *ManifestName.Replace(TEXT(".manifest"), TEXT("")));
}
const FString DestinationCulturePath = DestinationPath / CultureName;
FString ArchiveFileName = DestinationCulturePath / ArchiveName;
if( !FPaths::FileExists(ArchiveFileName) )
{
UE_LOG( LogInternationalizationExportCommandlet, Error, TEXT("Failed to find destination archive %s."), *ArchiveFileName);
continue;
}
TSharedPtr< FJsonObject > ArchiveJsonObject = NULL;
ArchiveJsonObject = ReadJSONTextFile( ArchiveFileName );
FJsonInternationalizationArchiveSerializer ArchiveSerializer;
TSharedRef< FInternationalizationArchive > InternationalizationArchive = MakeShareable( new FInternationalizationArchive );
ArchiveSerializer.DeserializeArchive( ArchiveJsonObject.ToSharedRef(), InternationalizationArchive );
bool bModifiedArchive = false;
{
for( auto EntryIter = PortableObject.GetEntriesIterator(); EntryIter; ++EntryIter )
{
auto POEntry = *EntryIter;
if( POEntry->MsgId.IsEmpty() || POEntry->MsgStr.Num() == 0 || POEntry->MsgStr[0].Trim().IsEmpty() )
{
// We ignore the header entry or entries with no translation.
continue;
}
// Some warning messages for data we don't process at the moment
if( !POEntry->MsgIdPlural.IsEmpty() || POEntry->MsgStr.Num() > 1 )
{
UE_LOG( LogInternationalizationExportCommandlet, Error, TEXT("Portable Object entry has plural form we did not process. File: %s MsgCtxt: %s MsgId: %s"), *POFilePath, *POEntry->MsgCtxt, *POEntry->MsgId );
}
const FString& Namespace = POEntry->MsgCtxt;
const FString& SourceText = ConditionPoStringForArchive(POEntry->MsgId);
const FString& Translation = ConditionPoStringForArchive(POEntry->MsgStr[0]);
//@TODO: Take into account optional entries and entries that differ by keymetadata. Ex. Each optional entry needs a unique msgCtxt
TSharedPtr< FArchiveEntry > FoundEntry = InternationalizationArchive->FindEntryBySource( Namespace, SourceText, NULL );
if( !FoundEntry.IsValid() )
{
UE_LOG(LogInternationalizationExportCommandlet, Warning, TEXT("Could not find corresponding archive entry for PO entry. File: %s MsgCtxt: %s MsgId: %s"), *POFilePath, *POEntry->MsgCtxt, *POEntry->MsgId );
continue;
}
if( FoundEntry->Translation != Translation )
{
FoundEntry->Translation = Translation;
bModifiedArchive = true;
}
}
}
if( bModifiedArchive )
{
TSharedRef<FJsonObject> FinalArchiveJsonObj = MakeShareable( new FJsonObject );
ArchiveSerializer.SerializeArchive( InternationalizationArchive, FinalArchiveJsonObj );
if( !WriteJSONToTextFile(FinalArchiveJsonObj, ArchiveFileName, SourceControlInfo ) )
{
UE_LOG( LogInternationalizationExportCommandlet, Error, TEXT("Failed to write archive to %s."), *ArchiveFileName );
return false;
}
}
}
return true;
}
int32 URepairLocalizationDataCommandlet::Main(const FString& Params)
{
FInternationalization& I18N = FInternationalization::Get();
// Parse command line.
TArray<FString> Tokens;
TArray<FString> Switches;
TMap<FString, FString> ParamVals;
UCommandlet::ParseCommandLine(*Params, Tokens, Switches, ParamVals);
//Set config file
const FString* ParamVal = ParamVals.Find(FString(TEXT("Config")));
FString GatherTextConfigPath;
if ( ParamVal )
{
GatherTextConfigPath = *ParamVal;
}
else
{
UE_LOG(LogRepairLocalizationDataCommandlet, Error, TEXT("No config specified."));
return -1;
}
//Set config section
ParamVal = ParamVals.Find(FString(TEXT("Section")));
FString SectionName;
if ( ParamVal )
{
SectionName = *ParamVal;
}
else
{
UE_LOG(LogRepairLocalizationDataCommandlet, Error, TEXT("No config section specified."));
return -1;
}
// Get destination path.
FString DestinationPath;
if( !GetPathFromConfig( *SectionName, TEXT("DestinationPath"), DestinationPath, GatherTextConfigPath ) )
{
UE_LOG( LogRepairLocalizationDataCommandlet, Error, TEXT("No destination path specified.") );
return -1;
}
// Get manifest name.
FString ManifestName;
if( !GetStringFromConfig( *SectionName, TEXT("ManifestName"), ManifestName, GatherTextConfigPath ) )
{
UE_LOG( LogRepairLocalizationDataCommandlet, Error, TEXT("No manifest name specified.") );
return -1;
}
// Get archive name.
FString ArchiveName;
if( !( GetStringFromConfig(* SectionName, TEXT("ArchiveName"), ArchiveName, GatherTextConfigPath ) ) )
{
UE_LOG(LogRepairLocalizationDataCommandlet, Error, TEXT("No archive name specified."));
return -1;
}
// Get cultures to generate.
TArray<FString> CulturesToGenerate;
GetStringArrayFromConfig(*SectionName, TEXT("CulturesToGenerate"), CulturesToGenerate, GatherTextConfigPath);
if( CulturesToGenerate.Num() == 0 )
{
UE_LOG(LogRepairLocalizationDataCommandlet, Error, TEXT("No cultures specified for generation."));
return -1;
}
for(int32 i = 0; i < CulturesToGenerate.Num(); ++i)
{
if( I18N.GetCulture( CulturesToGenerate[i] ).IsValid() )
{
UE_LOG(LogRepairLocalizationDataCommandlet, Verbose, TEXT("Specified culture is not a valid runtime culture, but may be a valid base language: %s"), *(CulturesToGenerate[i]) );
}
}
//////////////////////////////////////////////////////////////////////////
// Read the damaged manifest.
const FString ManifestFilePath = DestinationPath / ManifestName;
const TSharedPtr<FJsonObject> ManifestJsonObject = ReadJSONTextFile( ManifestFilePath );
if( !ManifestJsonObject.IsValid() )
{
UE_LOG(LogRepairLocalizationDataCommandlet, Error, TEXT("Could not read manifest file %s."), *ManifestFilePath);
return -1;
}
FJsonInternationalizationManifestSerializer ManifestSerializer;
const TSharedRef< FInternationalizationManifest > InternationalizationManifest = MakeShareable( new FInternationalizationManifest );
ManifestSerializer.DeserializeManifest( ManifestJsonObject.ToSharedRef(), InternationalizationManifest );
// Read the damaged archives.
TArray< TSharedRef<FInternationalizationArchive> > InternationalizationArchives;
TArray<FString> ArchiveCultures;
for(int32 Culture = 0; Culture < CulturesToGenerate.Num(); Culture++)
{
// Read in any existing archive for this culture.
const FString CulturePath = DestinationPath / CulturesToGenerate[Culture];
const FString ArchiveFilePath = CulturePath / ArchiveName;
if( FPaths::FileExists(ArchiveFilePath) )
{
TSharedPtr< FJsonObject > ArchiveJsonObject = ReadJSONTextFile( ArchiveFilePath );
if( !ArchiveJsonObject.IsValid() )
{
UE_LOG(LogRepairLocalizationDataCommandlet, Error, TEXT("Could not read archive file %s."), *ArchiveFilePath);
return -1;
}
FJsonInternationalizationArchiveSerializer ArchiveSerializer;
const TSharedRef< FInternationalizationArchive > InternationalizationArchive = MakeShareable( new FInternationalizationArchive );
ArchiveSerializer.DeserializeArchive( ArchiveJsonObject.ToSharedRef(), InternationalizationArchive );
InternationalizationArchives.Add(InternationalizationArchive);
ArchiveCultures.Add(CulturesToGenerate[Culture]);
}
}
// Repair.
RepairManifestAndArchives(InternationalizationManifest, InternationalizationArchives);
// Write the repaired manifests.
TSharedRef< FJsonObject > OutputManifestJsonObj = MakeShareable( new FJsonObject );
ManifestSerializer.SerializeManifest( InternationalizationManifest, OutputManifestJsonObj );
if (!WriteJSONToTextFile( OutputManifestJsonObj, DestinationPath / ManifestName, SourceControlInfo ))
{
UE_LOG( LogRepairLocalizationDataCommandlet, Error,TEXT("Failed to write manifest to %s."), *DestinationPath );
return -1;
}
// Write the repaired archives.
{
int Index = 0;
for (const TSharedRef<FInternationalizationArchive>& InternationalizationArchive : InternationalizationArchives)
{
TSharedRef< FJsonObject > OutputArchiveJsonObj = MakeShareable( new FJsonObject );
FJsonInternationalizationArchiveSerializer ArchiveSerializer;
ArchiveSerializer.SerializeArchive( InternationalizationArchive, OutputArchiveJsonObj );
int32 Culture = 0;
if (!WriteJSONToTextFile( OutputArchiveJsonObj, (DestinationPath / *ArchiveCultures[Index] / ArchiveName), SourceControlInfo ))
{
UE_LOG( LogRepairLocalizationDataCommandlet, Error,TEXT("Failed to write archive to %s."), *DestinationPath );
return -1;
}
++Index;
}
}
return 0;
}
bool UInternationalizationConditioningCommandlet::ProcessArchive( const FString& PrimaryLangExt, const FString& SourcePath, const FString& DestinationPath )
{
FString ArchiveName = TEXT("Archive.txt");
TArray<FString> LanguagesToProcess;
TArray<FString> TargetCultures;
bool bAppendToExistingArchive = true;
GetConfigString( *SectionName, TEXT("ArchiveName"), ArchiveName, GatherTextConfigPath );
GetConfigArray( *SectionName, TEXT("ProcessLanguage"), LanguagesToProcess, GatherTextConfigPath );
GetConfigArray( *SectionName, TEXT("TargetCulture"), TargetCultures, GatherTextConfigPath );
GetConfigBool( *SectionName, TEXT("bAppendToExistingArchive"), bAppendToExistingArchive, GatherTextConfigPath );
// Build info about the primary language
TArray<FString> PrimaryFilenames;
TArray<FString> PathPrimaryFilenames;
FString PrimaryLocDirectory = SourcePath / PrimaryLangExt + TEXT("/");
FString PrimaryWildcardName = PrimaryLocDirectory + TEXT("*.") + PrimaryLangExt;
// Grab the list of primary language loc files
IFileManager::Get().FindFiles(PathPrimaryFilenames, *PrimaryWildcardName, true, false);
for ( int32 FileIndex = 0; FileIndex < PathPrimaryFilenames.Num(); FileIndex++ )
{
FString* CompleteFilename = new(PrimaryFilenames) FString(PrimaryLocDirectory + PathPrimaryFilenames[FileIndex]);
}
if ( PrimaryFilenames.Num() == 0 )
{
UE_LOG(LogInternationalizationConditioningCommandlet, Warning, TEXT("No primary language(%s) loc files found!"), *PrimaryLangExt);
return false;
}
for( int32 LanguageIndex = 0; LanguageIndex < LanguagesToProcess.Num(); LanguageIndex++ )
{
FString ForeignLangExt = LanguagesToProcess[LanguageIndex];
TArray<FString> ForeignFilenames;
TArray<FString> PathForeignFilenames;
FString ForeignLocDirectory = SourcePath / ForeignLangExt + TEXT("/");
FString ForeignWildcardName = ForeignLocDirectory + TEXT("*.") + ForeignLangExt;
FString TargetSubfolder = TargetCultures.Num() > LanguageIndex ? TargetCultures[LanguageIndex] : ForeignLangExt;
// Get a list of foreign loc files
IFileManager::Get().FindFiles(PathForeignFilenames, *ForeignWildcardName, true, false);
for ( int32 FileIndex = 0; FileIndex < PathForeignFilenames.Num(); FileIndex++ )
{
FString* CompleteFilename = new(ForeignFilenames) FString(ForeignLocDirectory + PathForeignFilenames[FileIndex]);
}
if ( ForeignFilenames.Num() == 0 )
{
UE_LOG(LogInternationalizationConditioningCommandlet, Warning, TEXT("No foreign loc files found using language extension '%s'"), *ForeignLangExt);
continue;
}
ReadLocFiles(PrimaryFilenames, ForeignFilenames);
TArray<FLocalizationFileEntry> ArchiveProperties;
// FSor each file in the list,
for ( int32 i = 0; i < LocPairs.Num(); i++ )
{
FLocalizationFilePair& Pair = LocPairs[i];
Pair.CompareFiles();
Pair.GetTranslatedProperties( ArchiveProperties );
Pair.GetIdenticalProperties( ArchiveProperties );
}
TSharedRef< FInternationalizationArchive > InternationalizationArchive = MakeShareable( new FInternationalizationArchive );
FInternationalizationArchiveJsonSerializer ArchiveSerializer;
const FString DestinationArchiveFileName = DestinationPath / TargetSubfolder / ArchiveName;
// If we want to append to an existing archive, we first read it into our data structure
if( bAppendToExistingArchive )
{
FString ExistingArchiveFileName = DestinationArchiveFileName;
if( FPaths::FileExists(ExistingArchiveFileName) )
{
TSharedPtr< FJsonObject > ExistingArchiveJsonObject = ReadJSONTextFile( ExistingArchiveFileName );
if( ExistingArchiveJsonObject.IsValid() )
{
ArchiveSerializer.DeserializeArchive( ExistingArchiveJsonObject.ToSharedRef(), InternationalizationArchive );
}
}
}
for( int PropIndex = 0; PropIndex < ArchiveProperties.Num(); PropIndex++ )
{
FLocalizationFileEntry& Prop = ArchiveProperties[PropIndex];
FString NewNamespace = Prop.Namespace;
FLocItem Source( Prop.SourceText );
FLocItem Translation( Prop.TranslatedText );
if( !InternationalizationArchive->AddEntry( NewNamespace, Source, Translation, NULL, false ) )
{
TSharedPtr<FArchiveEntry> ExistingConflictEntry = InternationalizationArchive->FindEntryBySource( NewNamespace, Source, NULL );
if( !ExistingConflictEntry.IsValid() )
{
// Looks like we failed to add for a reason beyond conflicting translation, display an error and continue.
UE_LOG(LogInternationalizationConditioningCommandlet, Warning, TEXT("Failed to add entry to archive Namespace [%s]: (DEFAULT TEXT): %s (EXISTING TRANSLATION): %s"),
*NewNamespace, *Prop.SourceText, *ExistingConflictEntry->Translation.Text );
continue;
}
// If we can't add the entry, we find the existing conflicting entry and see if the translation is empty. If it is empty we will
// just overwrite the translation. If it is not empty we will display info about the conflict.
if( ExistingConflictEntry->Translation.Text.IsEmpty() )
{
ExistingConflictEntry->Translation.Text = Prop.TranslatedText;
}
else
{
UE_LOG(LogInternationalizationConditioningCommandlet, Warning, TEXT("Conflicting translation ignored in Namespace [%s]: (DEFAULT TEXT): %s (EXISTING TRANSLATION): %s (REJECTED TRANSLATION): %s"),
*NewNamespace, *Prop.SourceText, *ExistingConflictEntry->Translation.Text, *Prop.TranslatedText );
}
}
}
TSharedRef<FJsonObject> FinalArchiveJsonObj = MakeShareable( new FJsonObject );
ArchiveSerializer.SerializeArchive( InternationalizationArchive, FinalArchiveJsonObj );
WriteJSONToTextFile( FinalArchiveJsonObj, DestinationArchiveFileName, SourceControlInfo );
LocPairs.Empty();
}
return true;
}
bool UInternationalizationConditioningCommandlet::ProcessManifest( const FString& PrimaryLangExt, const FString& SourcePath, const FString& DestinationPath )
{
FString ManifestName = TEXT("Manifest.txt");
GetConfigString( *SectionName, TEXT("ManifestName"), ManifestName, GatherTextConfigPath );
// Build info about the primary language
TArray<FString> PrimaryFilenames;
TArray<FString> PathPrimaryFilenames;
FString PrimaryLocDirectory = SourcePath / PrimaryLangExt + TEXT("/");
FString PrimaryWildcardName = PrimaryLocDirectory + TEXT("*.") + PrimaryLangExt;
// Grab the list of primary language loc files
IFileManager::Get().FindFiles(PathPrimaryFilenames, *PrimaryWildcardName, true, false);
for ( int32 FileIndex = 0; FileIndex < PathPrimaryFilenames.Num(); FileIndex++ )
{
FString* CompleteFilename = new(PrimaryFilenames) FString(PrimaryLocDirectory + PathPrimaryFilenames[FileIndex]);
}
if ( PrimaryFilenames.Num() == 0 )
{
UE_LOG(LogInternationalizationConditioningCommandlet, Warning, TEXT("No primary language(%s) loc files found!"), *PrimaryLangExt);
return false;
}
// Here we cheat a bit and use the primary language as the foreign language, some inefficiency here but it will let us leverage an
// existing system to get the entries we are after
ReadLocFiles(PrimaryFilenames, PrimaryFilenames);
// Instead of extracting the translated properties, we will pull out the identical properties which will be all the entries
// in the localization files since we are comparing the primary language with itself.
TArray<FLocalizationFileEntry> IdenticalProperties;
for ( int32 i = 0; i < LocPairs.Num(); i++ )
{
FLocalizationFilePair& Pair = LocPairs[i];
Pair.CompareFiles();
Pair.GetIdenticalProperties( IdenticalProperties );
}
// First we want to see if there is an existing manifest. If so we will load it up and add our entries there
TSharedRef< FInternationalizationManifest > InternationalizationManifest = MakeShareable( new FInternationalizationManifest );
FInternationalizationManifestJsonSerializer ManifestSerializer;
FString ExistingManifestFileName = DestinationPath / ManifestName;
if( FPaths::FileExists(ExistingManifestFileName) )
{
TSharedPtr< FJsonObject > ExistingManifestJsonObject = ReadJSONTextFile( ExistingManifestFileName );
if( ExistingManifestJsonObject.IsValid() )
{
ManifestSerializer.DeserializeManifest( ExistingManifestJsonObject.ToSharedRef(), InternationalizationManifest );
}
}
// Now we add our properties to the manifest.
for( int PropIndex = 0; PropIndex < IdenticalProperties.Num(); PropIndex++ )
{
FLocalizationFileEntry& Prop = IdenticalProperties[PropIndex];
// We use the file(package) name and the namespace for the manifest namespace so we avoid potential collisions when multiple ini files have entries where the KEY and namespace are the same but the source text is different
FString NewNamespace = Prop.Namespace;
FContext PropContext;
PropContext.Key = Prop.Key;
PropContext.SourceLocation = NewNamespace;
FLocItem Source( Prop.SourceText );
bool bAddSuccessful = InternationalizationManifest->AddSource( NewNamespace, Source, PropContext );
if(!bAddSuccessful)
{
UE_LOG(LogInternationalizationConditioningCommandlet, Warning, TEXT("Could not add manifest entry %s."), *PropContext.SourceLocation );
}
}
TSharedRef<FJsonObject> FinalManifestJsonObj = MakeShareable( new FJsonObject );
ManifestSerializer.SerializeManifest( InternationalizationManifest, FinalManifestJsonObj );
FString DestinationManifestFileName = DestinationPath / ManifestName;
WriteJSONToTextFile( FinalManifestJsonObj, DestinationManifestFileName, SourceControlInfo );
LocPairs.Empty();
return true;
}