public static void unrealtypedetails_has_the_correct_field_details_list_name_upon_creation() { var capitalisedName = "CapitalisedName"; var fieldDefinitionRaw = GenerateFieldDefinition("test", "1", new TypeReferenceRaw { sourceReference = new SourceReferenceRaw { line = "1", column = "1" }, builtInType = "float" }); var typeDefinition = GenerateTypeDefinition("TestType", "improbable.codegen.TestType", null, null, new FieldDefinitionRaw[] { fieldDefinitionRaw }); var packageDetails = GeneratePackageDetails(); var fieldDetails = new List <UnrealFieldDetails>(); fieldDetails.Add(new UnrealFieldDetails(fieldDefinitionRaw, new UnrealBuiltInTypeReference(fieldDefinitionRaw.singularType))); var typeDetails = new UnrealTypeDetails(typeDefinition, capitalisedName, fieldDetails, packageDetails); Assert.That(typeDetails.FieldDetailsList.Count() == 1, "The wrong number of field details were created during the creation of an unreal type details object"); Assert.That(typeDetails.FieldDetailsList.FirstOrDefault((fieldDetail) => { return(fieldDetail.CapitalisedName == "Test" && fieldDetail.LowercaseName == "test" && fieldDetail.TypeReference.UnrealType == "float"); }) != null, "The generated field detail for the unreal type detail did not contain the correct data"); }
private List <UnrealTypeDetails> ProcessTypes(ICollection <SchemaFileRaw> schemaFiles) { var allTypeDefinitions = schemaFiles.SelectMany(schemaFile => schemaFile.typeDefinitions); qualifiedNameToTypeDefinition = allTypeDefinitions.ToDictionary(typeDefinition => typeDefinition.qualifiedName, typeDefinition => typeDefinition); var unrealTypes = new List <UnrealTypeDetails>(); foreach (var schemaFile in schemaFiles) { var packageDetails = unrealPackageDetails[schemaFile.canonicalName]; foreach (var typeDefinition in schemaFile.typeDefinitions) { var capitalisedTypeName = resolvedTypeToCapitalisedNames[typeDefinition]; var unrealType = new UnrealTypeDetails(typeDefinition, capitalisedTypeName, new List <UnrealFieldDetails>(), packageDetails); unrealTypes.Add(unrealType); typeDefinitionToUnrealType.Add(typeDefinition, unrealType); } } ProcessFieldDetails(schemaFiles); return(unrealTypes); }
public static void run_executes_the_expected_file_operations_when_running_an_unrealtypejob() { var mockFileSystem = GenerateMockFileSystem(); mockFileSystem.GetFileInfoMock = (path) => { var file = new MockFileWrapper(path, Path.GetDirectoryName(path), new DateTime(1, 1, 1)); file.ExistsMock = () => { return(false); }; return(file); }; mockFileSystem.GetFilesInDirectoryMock = (path, searchpattern, recursive) => { return(new List <IFile>()); }; var unrealPackageDetails = new UnrealPackageDetails("improbable.codegen.TestComponent", TestSchemaPath, "improbable.codegen"); var unrealTypeDetails = new UnrealTypeDetails(GenerateTypeDefinition("TestType", "improbable.codegen.TestType"), "TestType", new List <UnrealFieldDetails>(), unrealPackageDetails); var typeJob = new UnrealTypeJob(unrealTypeDetails, new HashSet <string>(), new HashSet <string>(), new HashSet <string>(), Path.Combine("OutputDir", "test"), mockFileSystem); var jobRunner = new JobRunner(mockFileSystem); jobRunner.Run(new List <ICodegenJob>() { typeJob }, new List <string>() { OutputDirectory }); Assert.That(mockFileSystem.DirectoryExistsCallCount == 2); Assert.That(mockFileSystem.WriteToFileCallCount == 2); Assert.That(mockFileSystem.WrittenFiles.Count == 2); Assert.That(mockFileSystem.WrittenFiles.Contains(Path.Combine(OutputDirectory, "TestType.h"))); Assert.That(mockFileSystem.WrittenFiles.Contains(Path.Combine(OutputDirectory, "TestType.cpp"))); }
public static void unrealcommanddetails_has_the_correct_unreal_command_delegate_name_upon_creation() { var capitalisedName = "CapitalisedName"; var qualifiedOwnerName = "improbable.codegen.Test"; var captialisedOwnerName = "improbable.codegen.OwnerComponent"; var commandDefinition = GenerateCommandDefinition("Test", new TypeReferenceRaw { sourceReference = new SourceReferenceRaw { line = "1", column = "1" }, builtInType = null, userType = "DamageResponse" }, new TypeReferenceRaw { sourceReference = new SourceReferenceRaw { line = "1", column = "1" }, builtInType = null, userType = "DamageRequest" }); var packageDetails = GeneratePackageDetails(); var fieldDefinitionFloat = ModelTypeFactory.GenerateFieldDefinition("test", "1", new TypeReferenceRaw { sourceReference = new SourceReferenceRaw { line = "1", column = "1" }, builtInType = "float" }); var fieldDefinitionInt32 = ModelTypeFactory.GenerateFieldDefinition("test", "1", new TypeReferenceRaw { sourceReference = new SourceReferenceRaw { line = "1", column = "1" }, builtInType = "int32" }); var userTypeDefinition = ModelTypeFactory.GenerateTypeDefinition("TestType", "improbable.codegen.TestType", null, null, new FieldDefinitionRaw[] { fieldDefinitionFloat, fieldDefinitionInt32 }); var unrealFieldDetails = new List <UnrealFieldDetails>(); unrealFieldDetails.Add(new UnrealFieldDetails(fieldDefinitionFloat, new UnrealBuiltInTypeReference(fieldDefinitionFloat.singularType))); unrealFieldDetails.Add(new UnrealFieldDetails(fieldDefinitionInt32, new UnrealBuiltInTypeReference(fieldDefinitionInt32.singularType))); var unrealTypeDetails = new UnrealTypeDetails(userTypeDefinition, "TestType", unrealFieldDetails, null); var requestTypeReference = new UnrealUserTypeReference(unrealTypeDetails); var responseTypeReference = new UnrealUserTypeReference(unrealTypeDetails); var commandDetails = new UnrealCommandDetails(commandDefinition, capitalisedName, qualifiedOwnerName, captialisedOwnerName, requestTypeReference, responseTypeReference, packageDetails); Assert.That(commandDetails.UnrealCommandDelegateName == string.Format("F{0}Command", capitalisedName), "the field UnrealCommandDelegateName did not have the expected value upon creation"); }
public static void unrealtypedetails_has_the_correct_capitalised_qualified_name_upon_creation() { var capitalisedName = "CapitalisedName"; var typeDefinition = GenerateTypeDefinition("TestType", "improbable.codegen.TestType"); var packageDetails = GeneratePackageDetails(); var typeDetails = new UnrealTypeDetails(typeDefinition, capitalisedName, new List <UnrealFieldDetails>(), packageDetails); Assert.That(typeDetails.CapitalisedQualifiedName == Formatting.QualifiedNameToCapitalisedCamelCase(typeDefinition.qualifiedName), "the field CapitalisedQualifiedName did not have the expected value upon creation"); }
public static void unrealtypedetails_has_the_correct_underlying_capitalised_name_upon_creation() { var capitalisedName = "CapitalisedName"; var typeDefinition = GenerateTypeDefinition("TestType", "improbable.codegen.TestType"); var packageDetails = GeneratePackageDetails(); var typeDetails = new UnrealTypeDetails(typeDefinition, capitalisedName, new List <UnrealFieldDetails>(), packageDetails); Assert.That(typeDetails.UnderlyingCapitalisedName == "TestType", "the field UnderlyingCapitalisedName did not have the expected value upon creation"); }
public static void unrealusertypereference_is_initiated_as_expected_when_passed_an_user_type_reference() { var fieldDefinitionFloat = ModelTypeFactory.GenerateFieldDefinition("test", "1", new TypeReferenceRaw { sourceReference = new SourceReferenceRaw { line = "1", column = "1" }, builtInType = "float" }); var fieldDefinitionInt32 = ModelTypeFactory.GenerateFieldDefinition("test", "1", new TypeReferenceRaw { sourceReference = new SourceReferenceRaw { line = "1", column = "1" }, builtInType = "int32" }); var userTypeDefinition = ModelTypeFactory.GenerateTypeDefinition("TestType", "improbable.codegen.TestType", null, null, new FieldDefinitionRaw[] { fieldDefinitionFloat, fieldDefinitionInt32 }); var unrealFieldDetails = new List <UnrealFieldDetails>(); unrealFieldDetails.Add(new UnrealFieldDetails(fieldDefinitionFloat, new UnrealBuiltInTypeReference(fieldDefinitionFloat.singularType))); unrealFieldDetails.Add(new UnrealFieldDetails(fieldDefinitionInt32, new UnrealBuiltInTypeReference(fieldDefinitionInt32.singularType))); var unrealTypeDetails = new UnrealTypeDetails(userTypeDefinition, "TestType", unrealFieldDetails, null); var unrealUserTypeReference = new UnrealUserTypeReference(unrealTypeDetails); Assert.That(unrealUserTypeReference.UnderlyingCapitalisedName == "ImprobableCodegenTestType"); Assert.That(unrealUserTypeReference.RequiredIncludes.Count == 1); Assert.That(unrealUserTypeReference.RequiredIncludes.Contains("\"TestType.h\"")); Assert.That(unrealUserTypeReference.UnderlyingQualifiedName == "improbable::codegen::TestType"); Assert.That(unrealUserTypeReference.UnrealType == "UTestType*"); Assert.That(unrealUserTypeReference.AssignUnderlyingValueToUnrealMemberVariable("TestField", "val") == "if (TestField == nullptr) { TestField = NewObject<UTestType>(this); } TestField->Init(val)"); Assert.That(unrealUserTypeReference.ConvertUnderlyingValueToUnrealLocalVariable("val") == "NewObject<UTestType>()->Init(val)"); Assert.That(unrealUserTypeReference.ConvertUnderlyingValueToUnrealMemberVariable("val") == "NewObject<UTestType>(this)->Init(val)"); Assert.That(unrealUserTypeReference.ConvertUnrealValueToSnapshotValue("val") == "val->GetUnderlying()"); Assert.That(unrealUserTypeReference.ConvertUnrealValueToUnderlyingValue("val") == "val->GetUnderlying()"); Assert.That(unrealUserTypeReference.DefaultInitialisationString == "improbable::codegen::TestType(0, 0)"); Assert.That(unrealUserTypeReference.SnapshotType == "improbable::codegen::TestType"); }
public static void run_does_not_clean_output_folders_of_jobs_if_the_output_folder_contains_the_files_to_be_generated() { var mockFileSystem = GenerateMockFileSystem(); mockFileSystem.GetFilesInDirectoryMock = (path, searchpatter, recursive) => { return(new List <IFile>() { new MockFileWrapper(Path.Combine(path, "TestType.h"), path, new DateTime(1, 1, 1)), new MockFileWrapper(Path.Combine(path, "TestType.cpp"), path, new DateTime(1, 1, 1)) }); }; mockFileSystem.GetFileInfoMock = (path) => { var fileMock = new MockFileWrapper(path, Path.GetDirectoryName(path), new DateTime(1, 1, 1)); fileMock.ExistsMock = () => { return(true); }; return(fileMock); }; var unrealPackageDetails = new UnrealPackageDetails("improbable.codegen.TestComponent", TestSchemaPath, "improbable.codegen"); var cleanUnrealTypeDetails = new UnrealTypeDetails(GenerateTypeDefinition("TestType", "improbable.codegen.TestType"), "TestType", new List <UnrealFieldDetails>(), unrealPackageDetails); var cleanTypeJob = new UnrealTypeJob(cleanUnrealTypeDetails, new HashSet <string>(), new HashSet <string>(), new HashSet <string>(), OutputDirectory, mockFileSystem); var jobRunner = new JobRunner(mockFileSystem); jobRunner.Run(new List <ICodegenJob>() { cleanTypeJob }, new List <string>() { OutputDirectory }); //This validates that the output folder was not deleted Assert.That(mockFileSystem.DeleteDirectoryCallCount == 0); Assert.That(mockFileSystem.GetFilesInDirectoryCallCount == 1); //This validates that no codegen jobs were run as they were expected to not be dirty. Assert.That(mockFileSystem.WriteToFileCallCount == 0); Assert.That(mockFileSystem.DirectoryExistsCallCount == 0); Assert.That(mockFileSystem.DirectoryExistsCallCount == 0); Assert.That(mockFileSystem.WriteToFileCallCount == 0); Assert.That(cleanTypeJob.IsDirty() == false); }
public static void unreallisttypereference_is_initiated_as_expected_when_passed_a_list_type_reference_with_an_user_type_as_contained_type() { var userTypeDefinition = GenerateTypeDefinition(); var unrealTypeDetails = new UnrealTypeDetails(userTypeDefinition, "TestType", new List <UnrealFieldDetails>(), null); var containedTypeReference = new UnrealUserTypeReference(unrealTypeDetails); var unrealListTypeReference = new UnrealListTypeReference(containedTypeReference); Assert.That(unrealListTypeReference.UnderlyingCapitalisedName == "ImprobableCodegenTestType"); Assert.That(unrealListTypeReference.RequiredIncludes.Count == 2); Assert.That(unrealListTypeReference.RequiredIncludes.Contains("\"TestType.h\"")); Assert.That(unrealListTypeReference.RequiredIncludes.Contains("\"ImprobableCodegenTestTypeList.h\"")); Assert.That(unrealListTypeReference.UnderlyingQualifiedName == "improbable::codegen::TestType"); Assert.That(unrealListTypeReference.UnrealType == "UImprobableCodegenTestTypeList*"); Assert.That(unrealListTypeReference.AssignUnderlyingValueToUnrealMemberVariable("TestField", "val") == "if (TestField == nullptr) { TestField = NewObject<UImprobableCodegenTestTypeList>(this); } TestField->Init(val)"); Assert.That(unrealListTypeReference.ConvertUnderlyingValueToUnrealLocalVariable("val") == "NewObject<UImprobableCodegenTestTypeList>()->Init(val)"); Assert.That(unrealListTypeReference.ConvertUnderlyingValueToUnrealMemberVariable("val") == "NewObject<UImprobableCodegenTestTypeList>(this)->Init(val)"); Assert.That(unrealListTypeReference.ConvertUnrealValueToUnderlyingValue("val") == "val->GetUnderlying()"); }
public UnrealUserTypeReference(UnrealTypeDetails unrealType) { ReferenceType = ReferenceType.UserType; UnderlyingQualifiedName = unrealType.UnderlyingQualifiedName; UnderlyingCapitalisedName = Formatting.CppQualifiedNameToCapitalisedCamelCase(UnderlyingQualifiedName); UnrealType = string.Format("U{0}*", unrealType.CapitalisedName); CapitalisedName = string.Format("{0}", unrealType.CapitalisedName); RequiredIncludes = new List <string>(); RequiredIncludes.Add(string.Format("\"{0}.h\"", unrealType.CapitalisedName)); ConvertUnderlyingValueToUnrealMemberVariable = (cppValue) => { // Set owning object as new uobject's outer. return(string.Format("NewObject<U{0}>(this)->Init({1})", unrealType.CapitalisedName, cppValue)); }; AssignUnderlyingValueToUnrealMemberVariable = (capitalizedName, cppValue) => { return(string.Format(@"if ({0} == nullptr) {{ {0} = NewObject<U{1}>(this); }} {0}->Init({2})", capitalizedName, unrealType.CapitalisedName, cppValue)); }; CheckInequality = (capitalizedName, compName) => { return(string.Format("{0} && ({0}->GetUnderlying() != {1})", capitalizedName, compName)); }; ConvertUnderlyingValueToUnrealLocalVariable = (cppValue) => { // Set static instance package as the uobject's outer. return(string.Format("NewObject<U{0}>()->Init({1})", unrealType.CapitalisedName, cppValue)); }; ConvertUnrealValueToSnapshotValue = (VarName) => { return(string.Format("{0}->GetUnderlying()", VarName)); }; ConvertUnrealValueToUnderlyingValue = (unrealValue) => { return(string.Format("{0}->GetUnderlying()", unrealValue)); }; ArgumentName = UnrealType; SnapshotType = unrealType.UnderlyingQualifiedName; UClassName = string.Format("U{0}", unrealType.CapitalisedName); TypeDetails = unrealType; DefaultValue = "nullptr"; }
public UnrealTypeJob(UnrealTypeDetails unrealType, HashSet <string> generatedMaps, HashSet <string> generatedOptions, HashSet <string> generatedLists, string outputDirectory, IFileSystem fileSystem) : base(outputDirectory, fileSystem) { InputFiles = new List <string>() { unrealType.UnderlyingPackageDetails.SourceSchema }; OutputFiles = new List <string>(); var headerGenerator = new UnrealTypeHeaderGenerator(unrealType); var typeHeaderFileName = unrealType.CapitalisedName + headerSuffix; OutputFiles.Add(typeHeaderFileName); Content.Add(typeHeaderFileName, headerGenerator.TransformText()); var implementationGenerator = new UnrealTypeImplementationGenerator(unrealType); var typeImplFileName = unrealType.CapitalisedName + cppSuffix; OutputFiles.Add(typeImplFileName); Content.Add(typeImplFileName, implementationGenerator.TransformText()); foreach (var fieldDefinition in unrealType.FieldDetailsList) { if (fieldDefinition.IsMap()) { var mapTypeReference = fieldDefinition.TypeReference as UnrealMapTypeReference; var filename = string.Format("{0}To{1}Map", mapTypeReference.KeyType.UnderlyingCapitalisedName, mapTypeReference.ValueType.UnderlyingCapitalisedName); if (generatedMaps.Contains(filename)) { continue; } generatedMaps.Add(filename); var mapHeaderGenerator = new UnrealMapHeaderGenerator(mapTypeReference); var mapHeaderFileName = filename + headerSuffix; OutputFiles.Add(mapHeaderFileName); Content.Add(mapHeaderFileName, mapHeaderGenerator.TransformText()); var mapImplementationGenerator = new UnrealMapImplementationGenerator(mapTypeReference); var mapImplFileName = filename + cppSuffix; OutputFiles.Add(mapImplFileName); Content.Add(mapImplFileName, mapImplementationGenerator.TransformText()); } if (fieldDefinition.IsOption()) { var optionTypeReference = fieldDefinition.TypeReference as UnrealOptionTypeReference; var filename = string.Format("{0}Option", fieldDefinition.TypeReference.UnderlyingCapitalisedName); if (generatedOptions.Contains(filename)) { continue; } generatedOptions.Add(filename); var optionHeaderGenerator = new UnrealOptionHeaderGenerator(optionTypeReference); var optionHeaderFileName = filename + headerSuffix; OutputFiles.Add(optionHeaderFileName); Content.Add(optionHeaderFileName, optionHeaderGenerator.TransformText()); var optionImplementationGenerator = new UnrealOptionImplementationGenerator(optionTypeReference); var optionImplFileName = filename + cppSuffix; OutputFiles.Add(optionImplFileName); Content.Add(optionImplFileName, optionImplementationGenerator.TransformText()); } if (fieldDefinition.IsList()) { var listTypeReference = fieldDefinition.TypeReference as UnrealListTypeReference; var filename = string.Format("{0}List", fieldDefinition.TypeReference.UnderlyingCapitalisedName); if (generatedLists.Contains(filename)) { continue; } generatedLists.Add(filename); var listHeaderGenerator = new UnrealListHeaderGenerator(listTypeReference); var listHeaderFileName = filename + headerSuffix; OutputFiles.Add(listHeaderFileName); Content.Add(listHeaderFileName, listHeaderGenerator.TransformText()); var listImplementationGenerator = new UnrealListImplementationGenerator(listTypeReference); var listImplFileName = filename + cppSuffix; OutputFiles.Add(listImplFileName); Content.Add(listImplFileName, listImplementationGenerator.TransformText()); } } }
public UnrealTypeHeaderGenerator(UnrealTypeDetails unrealType) { this.unrealType = unrealType; }
public void run_does_clean_if_files_are_present_in_output_folder_that_should_not_be_there() { var mockFileSystem = GenerateMockFileSystem(); mockFileSystem.GetFilesInDirectoryMock = (path, searchpatter, recursive) => { return(new List <IFile>() { new MockFileWrapper(Path.Combine(path, "TestType.h"), path, new DateTime(1, 1, 1)), new MockFileWrapper(Path.Combine(path, "TestType.cpp"), path, new DateTime(1, 1, 1)), new MockFileWrapper(Path.Combine(path, "Invalid.cpp"), path, new DateTime(1, 1, 1)), }); }; mockFileSystem.DeleteDirectoryMock = (path) => { }; mockFileSystem.GetFileInfoMock = (path) => { var fileMock = new MockFileWrapper(path, Path.GetDirectoryName(path), new DateTime(1, 1, 1)); bool fileExists = false; var fileName = Path.GetFileName(path); if (fileName == "TestType.h" || fileName == "TestType.cpp" || fileName == "Invalid.cpp") { fileExists = true; } fileMock.ExistsMock = () => { return(fileExists); }; return(fileMock); }; var unrealPackageDetails = new UnrealPackageDetails("improbable.codegen.TestComponent", TestSchemaPath, "improbable.codegen"); var cleanUnrealTypeDetails = new UnrealTypeDetails(GenerateTypeDefinition("TestType", "improbable.codegen.TestType"), "TestType", new List <UnrealFieldDetails>(), unrealPackageDetails); var cleanTypeJob = new UnrealTypeJob(cleanUnrealTypeDetails, new HashSet <string>(), new HashSet <string>(), new HashSet <string>(), OutputDirectory, mockFileSystem); var dirtyUnrealTypeDetails = new UnrealTypeDetails(GenerateTypeDefinition("DirtyTestType", "improbable.codegen.DirtyTestType"), "DirtyTestType", new List <UnrealFieldDetails>(), unrealPackageDetails); var dirtyTypeJob = new UnrealTypeJob(dirtyUnrealTypeDetails, new HashSet <string>(), new HashSet <string>(), new HashSet <string>(), OutputDirectory, mockFileSystem); var jobRunner = new JobRunner(mockFileSystem); jobRunner.Run(new List <ICodegenJob>() { cleanTypeJob, dirtyTypeJob }, new List <string>() { OutputDirectory }); //Validate that the folder check was correct Assert.That(mockFileSystem.DeleteDirectoryCallCount == 1); Assert.That(mockFileSystem.GetFilesInDirectoryCallCount == 1); //Validate that the correct jobs were run and expected files were written Assert.That(mockFileSystem.GetFileInfoCallCount == 4); Assert.That(mockFileSystem.DirectoryExistsCallCount == 4); Assert.That(mockFileSystem.WriteToFileCallCount == 4); Assert.That(mockFileSystem.WrittenFiles.Count == 4); Assert.That(mockFileSystem.WrittenFiles.Contains(Path.Combine(OutputDirectory, "TestType.h"))); Assert.That(mockFileSystem.WrittenFiles.Contains(Path.Combine(OutputDirectory, "TestType.cpp"))); Assert.That(mockFileSystem.WrittenFiles.Contains(Path.Combine(OutputDirectory, "DirtyTestType.h"))); Assert.That(mockFileSystem.WrittenFiles.Contains(Path.Combine(OutputDirectory, "DirtyTestType.cpp"))); Assert.That(cleanTypeJob.IsDirty()); Assert.That(dirtyTypeJob.IsDirty()); }
public UnrealTypeImplementationGenerator(UnrealTypeDetails unrealType) { this.unrealType = unrealType; }