UnrealEngineUWP/Engine/Source/Editor/UnrealEd/Private/Commandlets/GenerateGatherArchiveCommandlet.cpp

// Copyright Epic Games, Inc. All Rights Reserved.

#include "Commandlets/GenerateGatherArchiveCommandlet.h"
#include "Internationalization/InternationalizationMetadata.h"

DEFINE_LOG_CATEGORY_STATIC(LogGenerateArchiveCommandlet, Log, All);

void ConditionTranslationMetadata(TSharedRef<FLocMetadataValue> MetadataValue)
{
	switch (MetadataValue->GetType())
	{
	case ELocMetadataType::String:
	{
		TSharedPtr<FLocMetadataValue> MetadataValuePtr = MetadataValue;
		TSharedPtr<FLocMetadataValueString> MetadataString = StaticCastSharedPtr<FLocMetadataValueString>(MetadataValuePtr);
		MetadataString->SetString(TEXT(""));
	}
	break;

	case ELocMetadataType::Array:
	{
		TArray< TSharedPtr< FLocMetadataValue > > MetadataArray = MetadataValue->AsArray();
		for (auto ArrayIter = MetadataArray.CreateIterator(); ArrayIter; ++ArrayIter)
		{
			TSharedPtr<FLocMetadataValue>& Item = *ArrayIter;
			if (Item.IsValid())
			{
				ConditionTranslationMetadata(Item.ToSharedRef());
			}
		}
	}
	break;

	case ELocMetadataType::Object:
	{
		TSharedPtr< FLocMetadataObject > MetadataObject = MetadataValue->AsObject();
		for (auto ValueIter = MetadataObject->Values.CreateConstIterator(); ValueIter; ++ValueIter)
		{
			const FString Name = (*ValueIter).Key;
			TSharedPtr< FLocMetadataValue > Value = (*ValueIter).Value;
			if (Value.IsValid())
			{
				if (Value->GetType() == ELocMetadataType::String)
				{
					MetadataObject->SetStringField(Name, TEXT(""));
				}
				else
				{
					ConditionTranslationMetadata(Value.ToSharedRef());
				}
			}
		}
	}

	default:
		break;
	}
}

void ConditionTranslation(FLocItem& LocItem)
{
	// We clear out the translation text because this should only be entered by translators
	LocItem.Text = TEXT("");

	// The translation might have metadata so we want to clear all the values of any string metadata
	if (LocItem.MetadataObj.IsValid())
	{
		ConditionTranslationMetadata(MakeShareable(new FLocMetadataValueObject(LocItem.MetadataObj)));
	}
}

void ConditionSourceMetadata(TSharedRef<FLocMetadataValue> MetadataValue)
{
	switch (MetadataValue->GetType())
	{
	case ELocMetadataType::Object:
	{
		TSharedPtr< FLocMetadataObject > MetadataObject = MetadataValue->AsObject();

		TArray< FString > NamesToBeReplaced;

		// We go through all the source metadata entries and look for any that have names prefixed with a '*'.  If we
		//  find any, we will replace them with a String type that contains an empty value
		for (auto Iter = MetadataObject->Values.CreateConstIterator(); Iter; ++Iter)
		{
			const FString& Name = (*Iter).Key;
			TSharedPtr< FLocMetadataValue > Value = (*Iter).Value;

			if (Name.StartsWith(FLocMetadataObject::COMPARISON_MODIFIER_PREFIX))
			{
				NamesToBeReplaced.Add(Name);
			}
			else
			{
				ConditionSourceMetadata(Value.ToSharedRef());
			}
		}

		for (auto Iter = NamesToBeReplaced.CreateConstIterator(); Iter; ++Iter)
		{
			MetadataObject->RemoveField(*Iter);
			MetadataObject->SetStringField(*Iter, TEXT(""));
		}
	}

	default:
		break;
	}
}

void ConditionSource(FLocItem& LocItem)
{
	if (LocItem.MetadataObj.IsValid())
	{
		ConditionSourceMetadata(MakeShareable(new FLocMetadataValueObject(LocItem.MetadataObj)));
	}
}

/**
 *	UGenerateGatherArchiveCommandlet
 */
UGenerateGatherArchiveCommandlet::UGenerateGatherArchiveCommandlet(const FObjectInitializer& ObjectInitializer)
	: Super(ObjectInitializer)
{
}

int32 UGenerateGatherArchiveCommandlet::Main( const FString& Params )
{
	// Parse command line - we're interested in the param vals
	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(LogGenerateArchiveCommandlet, 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(LogGenerateArchiveCommandlet, Error, TEXT("No config section specified."));
		return -1;
	}

	// Get manifest name.
	FString ManifestName;
	if( !GetStringFromConfig( *SectionName, TEXT("ManifestName"), ManifestName, GatherTextConfigPath ) )
	{
		UE_LOG( LogGenerateArchiveCommandlet, Error, TEXT("No manifest name specified.") );
		return -1;
	}

	// Get archive name.
	FString ArchiveName;
	if (!(GetStringFromConfig(*SectionName, TEXT("ArchiveName"), ArchiveName, GatherTextConfigPath)))
	{
		UE_LOG(LogGenerateArchiveCommandlet, Error, TEXT("No archive name specified."));
		return -1;
	}

	// Get native culture.
	FString NativeCulture;
	if (!GetStringFromConfig(*SectionName, TEXT("NativeCulture"), NativeCulture, GatherTextConfigPath))
	{
		UE_LOG(LogGenerateArchiveCommandlet, Error, TEXT("No native culture specified."));
		return -1;
	}

	// Get cultures to generate.
	TArray<FString> CulturesToGenerate;
	GetStringArrayFromConfig(*SectionName, TEXT("CulturesToGenerate"), CulturesToGenerate, GatherTextConfigPath);
	
	if( CulturesToGenerate.Num() == 0 )
	{
		UE_LOG(LogGenerateArchiveCommandlet, Error, TEXT("No cultures specified for generation."));
		return -1;
	}

	// Get destination path.
	FString DestinationPath;
	if( !GetPathFromConfig( *SectionName, TEXT("DestinationPath"), DestinationPath, GatherTextConfigPath ) )
	{
		UE_LOG( LogGenerateArchiveCommandlet, Error, TEXT("No destination path specified.") );
		return -1;
	}

	// Load the manifest and all archives
	FLocTextHelper LocTextHelper(DestinationPath, ManifestName, ArchiveName, NativeCulture, CulturesToGenerate, GatherManifestHelper->GetLocFileNotifies(), GatherManifestHelper->GetPlatformSplitMode());
	{
		FText LoadError;
		if (!LocTextHelper.LoadAll(ELocTextHelperLoadFlags::LoadOrCreate, &LoadError))
		{
			UE_LOG(LogGenerateArchiveCommandlet, Error, TEXT("%s"), *LoadError.ToString());
			return -1;
		}
	}

	// We need to make sure the native culture is processed first
	if (CulturesToGenerate.RemoveSingle(NativeCulture) > 0)
	{
		CulturesToGenerate.Insert(NativeCulture, 0);
	}

	for (const FString& CultureName : CulturesToGenerate)
	{
		// Add any missing manifest entries to the archive for this culture
		const bool bIsNativeCulture = CultureName == NativeCulture;
		LocTextHelper.EnumerateSourceTexts([&LocTextHelper, &CultureName, &NativeCulture, &bIsNativeCulture](TSharedRef<FManifestEntry> InManifestEntry) -> bool
		{
			for (const FManifestContext& Context : InManifestEntry->Contexts)
			{
				if (!Context.bIsOptional)
				{
					TSharedPtr<FArchiveEntry> ArchiveEntry = LocTextHelper.FindTranslation(CultureName, InManifestEntry->Namespace, Context.Key, Context.KeyMetadataObj);
					if (ArchiveEntry.IsValid())
					{
						// We only update existing entries for the native culture, as this lets us preserve stale translations in foreign archives so we can decide later whether we actually want to use them
						if (bIsNativeCulture && !ArchiveEntry->Source.IsExactMatch(InManifestEntry->Source))
						{
							LocTextHelper.UpdateTranslation(CultureName, InManifestEntry->Namespace, Context.Key, Context.KeyMetadataObj, InManifestEntry->Source, InManifestEntry->Source);
						}
					}
					else
					{
						// Get the source we should use for the new entry
						FLocItem ArchiveSource = InManifestEntry->Source;
						if (!bIsNativeCulture)
						{
							TSharedPtr<FArchiveEntry> NativeArchiveEntry = LocTextHelper.FindTranslation(NativeCulture, InManifestEntry->Namespace, Context.Key, Context.KeyMetadataObj);
							if (NativeArchiveEntry.IsValid() && !NativeArchiveEntry->Source.IsExactMatch(NativeArchiveEntry->Translation))
							{
								ArchiveSource = NativeArchiveEntry->Source;
							}
						}

						// We want to process the source before adding it to the archive
						ConditionSource(ArchiveSource);

						FLocItem ArchiveTranslation = ArchiveSource;
						if (!bIsNativeCulture)
						{
							// We want to process the translation before adding it to the archive
							// We skip this for native entries so that the source text is also added as the translation
							ConditionTranslation(ArchiveTranslation);
						}

						LocTextHelper.AddTranslation(CultureName, InManifestEntry->Namespace, Context.Key, Context.KeyMetadataObj, ArchiveSource, ArchiveTranslation, Context.bIsOptional);
					}
				}
			}

			return true; // continue enumeration
		}, true);

		// Trim any dead entries out of the archive
		LocTextHelper.TrimArchive(CultureName);

		// Save the new archive
		{
			FText SaveError;
			if (!LocTextHelper.SaveArchive(CultureName, &SaveError))
			{
				UE_LOG(LogGenerateArchiveCommandlet, Error, TEXT("%s"), *SaveError.ToString());
				return -1;
			}
		}
	}
	
	return 0;
}