/// <summary>
/// Generates code associated with a model object.
/// </summary>
/// <param name="type">The type of the model object.</param>
/// <param name="kind">Specifies the kind of code to generate.</param>
/// <returns>
/// The generated code.
/// </returns>
public static string GenerateForModel(
this Type type,
GenerateFor kind)
{
new { type }.AsArg().Must().NotBeNull();
var modelType = type.ToModelType();
var generatedCode = new List <string>();
if (kind.HasFlag(GenerateFor.ModelImplementationPartialClass))
{
var modelMethods = modelType.GenerateCodeForModelImplementation();
generatedCode.Add(modelMethods);
}
if (kind.HasFlag(GenerateFor.ModelImplementationTestsPartialClassWithSerialization) || kind.HasFlag(GenerateFor.ModelImplementationTestsPartialClassWithoutSerialization))
{
var tests = modelType.ExampleClosedModelType.ToModelType().GenerateCodeForTests(kind);
generatedCode.Add(tests);
}
var result = string.Join(
Environment.NewLine + "--------------------------------------------------------------------------" + Environment.NewLine,
generatedCode);
return(result);
}
/// <summary>
/// Generates code associated with a model object.
/// </summary>
/// <typeparam name="T">The type of the model object.</typeparam>
/// <param name="kind">Specifies the kind of code to generate.</param>
/// <returns>
/// The generated code.
/// </returns>
public static string GenerateForModel <T>(
GenerateFor kind)
{
var type = typeof(T);
var result = type.GenerateForModel(kind);
return(result);
}
private static string GetUsingStatementsForTestClass(
this ModelType modelType,
GenerateFor kind)
{
var statements = new List <string>
{
"System",
"System.CodeDom.Compiler",
"System.Collections.Concurrent",
"System.Collections.Generic",
"System.Collections.ObjectModel",
"System.Diagnostics.CodeAnalysis",
"System.Globalization",
"System.Linq",
"System.Reflection",
"FakeItEasy",
"OBeautifulCode.Assertion.Recipes",
"OBeautifulCode.AutoFakeItEasy",
"OBeautifulCode.CodeGen.ModelObject.Recipes",
"OBeautifulCode.Equality.Recipes",
"OBeautifulCode.Math.Recipes",
"OBeautifulCode.Reflection.Recipes",
"OBeautifulCode.Representation.System",
"OBeautifulCode.Type",
"Xunit",
};
if (kind.HasFlag(GenerateFor.ModelImplementationTestsPartialClassWithSerialization))
{
statements.AddRange(
new[]
{
"OBeautifulCode.Serialization",
"OBeautifulCode.Serialization.Recipes",
});
}
var staticStatements = new[]
{
"System.FormattableString",
};
var result = modelType.GetUsingStatements(modelType.TypeNamespace, statements, staticStatements);
return(result);
}
public static string GenerateCodeForTests(
this ModelType modelType,
GenerateFor kind)
{
var testImplementationItems = new List <string>();
if (modelType.RequiresStringRepresentation)
{
var stringFieldsCode = modelType.GenerateStringRepresentationTestFields().ReplaceCodeAnalysisSuppressionTokensInTestCode();
if (!string.IsNullOrWhiteSpace(stringFieldsCode))
{
testImplementationItems.Add(string.Empty);
testImplementationItems.Add(stringFieldsCode);
}
}
if (modelType.RequiresModel)
{
var constructorFieldsCode = modelType.GenerateConstructorTestFields().ReplaceCodeAnalysisSuppressionTokensInTestCode();
if (constructorFieldsCode != null)
{
testImplementationItems.Add(string.Empty);
testImplementationItems.Add(constructorFieldsCode);
}
}
if (modelType.RequiresDeepCloning)
{
var deepCloneWithFieldsCode = modelType.GenerateDeepCloneWithTestFields().ReplaceCodeAnalysisSuppressionTokensInTestCode();
if (!string.IsNullOrWhiteSpace(deepCloneWithFieldsCode))
{
testImplementationItems.Add(string.Empty);
testImplementationItems.Add(deepCloneWithFieldsCode);
}
}
if (modelType.RequiresEquality || modelType.RequiresHashing)
{
var equalityFieldsCode = modelType.GenerateEqualityTestFields().ReplaceCodeAnalysisSuppressionTokensInTestCode();
if (equalityFieldsCode != null)
{
testImplementationItems.Add(string.Empty);
testImplementationItems.Add(equalityFieldsCode);
}
}
if (modelType.RequiresComparability)
{
var comparableTestFields = modelType.GenerateComparableTestFields().ReplaceCodeAnalysisSuppressionTokensInTestCode();
testImplementationItems.Add(string.Empty);
testImplementationItems.Add(comparableTestFields);
}
var structuralTestMethodsCode = modelType.GenerateStructuralTestMethods().ReplaceCodeAnalysisSuppressionTokensInTestCode();
testImplementationItems.Add(string.Empty);
testImplementationItems.Add(structuralTestMethodsCode);
if (modelType.RequiresStringRepresentation)
{
var stringTestMethodsCode = modelType.GenerateStringRepresentationTestMethods().ReplaceCodeAnalysisSuppressionTokensInTestCode();
if (!string.IsNullOrWhiteSpace(stringTestMethodsCode))
{
testImplementationItems.Add(string.Empty);
testImplementationItems.Add(stringTestMethodsCode);
}
}
if (modelType.RequiresModel)
{
var constructorTestMethodsCode = modelType.GenerateConstructorTestMethods().ReplaceCodeAnalysisSuppressionTokensInTestCode();
if (constructorTestMethodsCode != null)
{
testImplementationItems.Add(string.Empty);
testImplementationItems.Add(constructorTestMethodsCode);
}
}
if (modelType.RequiresDeepCloning)
{
var cloningTestMethodsCode = modelType.GenerateCloningTestMethods().ReplaceCodeAnalysisSuppressionTokensInTestCode();
testImplementationItems.Add(string.Empty);
testImplementationItems.Add(cloningTestMethodsCode);
}
if (kind.HasFlag(GenerateFor.ModelImplementationTestsPartialClassWithSerialization) && modelType.RequiresModel)
{
var serializationTestMethodsCode = modelType.GenerateSerializationTestMethods().ReplaceCodeAnalysisSuppressionTokensInTestCode();
testImplementationItems.Add(string.Empty);
testImplementationItems.Add(serializationTestMethodsCode);
}
if (modelType.RequiresEquality)
{
var equalityTestMethodsCode = modelType.GenerateEqualityTestMethods().ReplaceCodeAnalysisSuppressionTokensInTestCode();
testImplementationItems.Add(string.Empty);
testImplementationItems.Add(equalityTestMethodsCode);
}
if (modelType.RequiresHashing)
{
var hashingTestMethodsCode = modelType.GenerateHashingTestMethods().ReplaceCodeAnalysisSuppressionTokensInTestCode();
testImplementationItems.Add(string.Empty);
testImplementationItems.Add(hashingTestMethodsCode);
}
if (modelType.RequiresComparability)
{
var comparabilityTestMethodsCode = modelType.GenerateComparabilityTestMethods().ReplaceCodeAnalysisSuppressionTokensInTestCode();
testImplementationItems.Add(string.Empty);
testImplementationItems.Add(comparabilityTestMethodsCode);
}
var testImplementationCode = testImplementationItems.Where(_ => _ != null).ToNewLineDelimited();
var codeTemplate = typeof(ModelImplementationGeneration).GetCodeTemplate(CodeTemplateKind.Test, KeyMethodKinds.Both);
var result = codeTemplate
.Replace(Tokens.UsingStatementsToken, modelType.GetUsingStatementsForTestClass(kind))
.Replace(Tokens.CodeGenAssemblyNameToken, GenerationShared.GetCodeGenAssemblyName())
.Replace(Tokens.CodeGenAssemblyVersionToken, GenerationShared.GetCodeGenAssemblyVersion())
.Replace(Tokens.ModelTypeNamespaceToken, modelType.TypeNamespace)
.Replace(Tokens.ModelTypeNameInCodeToken, modelType.TypeNameInCodeString)
.Replace(Tokens.ModelTypeNameInTestClassNameToken, modelType.TypeNameInTestClassNameString)
.Replace(Tokens.TestImplementationToken, testImplementationCode);
return(result);
}
