protected virtual void InnerInit(IFixture fixture)
{
Metadatas = fixture.CreateMany <TemplateCodeGenerationMetadata>(5).ToList();
Metadatas[0].BaseTemplates.Add(Metadatas[1]);
Metadatas[0].BaseTemplates.Add(Metadatas[2]);
Metadatas[0].BaseTemplates.Add(Metadatas[3]);
Metadatas[0].BaseTemplates.Add(Metadatas[4]);
Metadata = Metadatas[0];
_init = true;
}
protected virtual bool ValidateBaseTemplatesAreKnown(TemplateCodeGenerationMetadata template)
{
var unresolvedBaseTemplates = template.TemplateInfo.BaseTemplateIds
.Where(baseId => template.BaseTemplates.All(baseTemplate => baseTemplate.Id != baseId))
.ToArray();
if (unresolvedBaseTemplates.Length == 0)
{
return(true);
}
foreach (var unresolved in unresolvedBaseTemplates)
{
_logger.MissingBaseTemplateInModel(template, unresolved);
}
return(false);
}
protected virtual bool ValidateTemplateHasNoFieldsIdenticalToTemplateName(TemplateCodeGenerationMetadata template)
{
// check for a field named the same as its template; this is bad because you cannot have a property named the same as its enclosing class
var fieldsWithSameNameAsEnclosingTemplate = template.OwnFields
.Where(field => FieldCodeNameEqualsTemplateCodeName(field, template))
.ToArray();
if (fieldsWithSameNameAsEnclosingTemplate.Length == 0)
{
return(true);
}
foreach (var childDuplicate in fieldsWithSameNameAsEnclosingTemplate)
{
_logger.FieldNamedSameAsTemplate(template, childDuplicate);
}
return(false);
}
protected virtual bool ValidateTemplateFieldNamesAreNovel(TemplateCodeGenerationMetadata template, IReadOnlyDictionary <Guid, TemplateCodeGenerationMetadata> allTemplatesIndex)
{
// look for fields with identical names in the whole current template's inheritance tree
var fieldsWithIdenticalNames = GetAllBaseTemplates(template, allTemplatesIndex)
.SelectMany(currentTemplate => currentTemplate.OwnFields)
.GroupBy(field => field.CodeName, StringComparer.OrdinalIgnoreCase)
.Where(field => field.Count() > 1)
.ToArray();
if (fieldsWithIdenticalNames.Length == 0)
{
return(true);
}
foreach (var duplicate in fieldsWithIdenticalNames)
{
_logger.DuplicateFieldNames(duplicate);
}
return(false);
}
protected override bool FieldCodeNameEqualsTemplateCodeName(TemplateFieldCodeGenerationMetadata field, TemplateCodeGenerationMetadata template)
{
if (ForceFieldNameToMatchTemplateName)
{
return(true);
}
return(base.FieldCodeNameEqualsTemplateCodeName(field, template));
}
public bool Public_ValidateBaseTemplatesAreKnown(TemplateCodeGenerationMetadata template)
{
return(ValidateBaseTemplatesAreKnown(template));
}
public bool Public_ValidateTemplateHasNoFieldsIdenticalToTemplateName(TemplateCodeGenerationMetadata template)
{
return(ValidateTemplateHasNoFieldsIdenticalToTemplateName(template));
}
public bool Public_ValidateTemplateFieldNamesAreNovel(TemplateCodeGenerationMetadata template,
IReadOnlyDictionary <Guid, TemplateCodeGenerationMetadata> allTemplatesIndex)
{
return(ValidateTemplateFieldNamesAreNovel(template, allTemplatesIndex));
}
public void ValidateTemplateFieldNamesAreNovel_WhenThereAreFieldsWithIdenticalNames_ReturnFalse([Greedy] TestableStandardArchitectureValidator sut, TemplateCodeGenerationMetadata template, IReadOnlyDictionary <Guid, TemplateCodeGenerationMetadata> allTemplatesIndex)
{
sut.Public_ValidateTemplateFieldNamesAreNovel(template, allTemplatesIndex).Should().BeFalse();
}
public void ValidateTemplateHasNoFieldsIdenticalToTemplateName_WhenItDoes_ReturnFalse([Greedy] TestableStandardArchitectureValidator sut, TemplateCodeGenerationMetadata template)
{
sut.ForceFieldNameToMatchTemplateName = true;
sut.Public_ValidateTemplateHasNoFieldsIdenticalToTemplateName(template).Should().BeFalse();
}
public void ValidateTemplateHasNoFieldsIdenticalToTemplateName_WhenItDoesnt_ReturnTrue([Greedy] TestableStandardArchitectureValidator sut, TemplateCodeGenerationMetadata template)
{
sut.Public_ValidateTemplateHasNoFieldsIdenticalToTemplateName(template).Should().BeTrue();
}
protected virtual IEnumerable <TemplateCodeGenerationMetadata> GetAllBaseTemplates(TemplateCodeGenerationMetadata template, IReadOnlyDictionary <Guid, TemplateCodeGenerationMetadata> allTemplatesIndex)
{
var parentBases = new Queue <TemplateCodeGenerationMetadata>(template.BaseTemplates);
var bases = new Dictionary <Guid, TemplateCodeGenerationMetadata>();
while (parentBases.Count > 0)
{
var currentBase = parentBases.Dequeue();
// already processed this template; skip it (e.g. a template cycle), or if it's the parent template
if (bases.ContainsKey(currentBase.Id) || currentBase.Id.Equals(template.Id))
{
continue;
}
// add grandparent base templates to processing queue
var newBases = currentBase.BaseTemplates;
foreach (var newBase in newBases)
{
parentBases.Enqueue(newBase);
}
// add parent base template to bases
bases.Add(currentBase.Id, currentBase);
}
return(bases.Values.ToList());
}
protected virtual bool FieldCodeNameEqualsTemplateCodeName(TemplateFieldCodeGenerationMetadata field, TemplateCodeGenerationMetadata template)
{
return(field.CodeName.Equals(template.CodeName));
}
public virtual void FieldNamedSameAsTemplate(TemplateCodeGenerationMetadata template, TemplateFieldCodeGenerationMetadata field)
{
_logger.Error($"{template.Path} ({template.Id})");
_logger.Error($"The field {field.Name} has the same name as its template. This is an architecture smell, please rename it.");
}
public virtual void MissingBaseTemplateInModel(TemplateCodeGenerationMetadata template, Guid missingTemplateId)
{
_logger.Warn($"{template.Path} ({template.Id})");
_logger.Warn($"Unable to resolve base template {missingTemplateId}. No fields from this template will exist.");
}
