public override bool Equals(TagHelperDescriptor descriptorX, TagHelperDescriptor descriptorY)
{
if (descriptorX == descriptorY)
{
return true;
}
Assert.True(base.Equals(descriptorX, descriptorY));
// Normal comparer doesn't care about the case, required attribute order, allowed children order,
// attributes or prefixes. In tests we do.
Assert.Equal(descriptorX.TagName, descriptorY.TagName, StringComparer.Ordinal);
Assert.Equal(descriptorX.Prefix, descriptorY.Prefix, StringComparer.Ordinal);
Assert.Equal(descriptorX.RequiredAttributes, descriptorY.RequiredAttributes, StringComparer.Ordinal);
Assert.Equal(descriptorX.RequiredParent, descriptorY.RequiredParent, StringComparer.Ordinal);
if (descriptorX.AllowedChildren != descriptorY.AllowedChildren)
{
Assert.Equal(descriptorX.AllowedChildren, descriptorY.AllowedChildren, StringComparer.Ordinal);
}
Assert.Equal(
descriptorX.Attributes,
descriptorY.Attributes,
TagHelperAttributeDescriptorComparer.Default);
Assert.Equal(
descriptorX.DesignTimeDescriptor,
descriptorY.DesignTimeDescriptor,
TagHelperDesignTimeDescriptorComparer.Default);
return true;
}
private void Register(TagHelperDescriptor descriptor)
{
HashSet <TagHelperDescriptor> descriptorSet;
if (_tagHelperPrefix == null)
{
_tagHelperPrefix = descriptor.Prefix;
}
var registrationKey =
string.Equals(descriptor.TagName, ElementCatchAllTarget, StringComparison.Ordinal) ?
ElementCatchAllTarget :
descriptor.FullTagName;
// Ensure there's a HashSet to add the descriptor to.
if (!_registrations.TryGetValue(registrationKey, out descriptorSet))
{
descriptorSet = new HashSet <TagHelperDescriptor>(TagHelperDescriptorComparer.Default);
_registrations[registrationKey] = descriptorSet;
}
descriptorSet.Add(descriptor);
}
public void GetDescriptors_DuplicateDescriptorsAreNotPartOfTagHelperDescriptorPool()
{
// Arrange
var divDescriptor = new TagHelperDescriptor
{
TagName = "div",
TypeName = "foo1",
AssemblyName = "SomeAssembly",
};
var descriptors = new TagHelperDescriptor[] { divDescriptor, divDescriptor };
var provider = new TagHelperDescriptorProvider(descriptors);
// Act
var retrievedDescriptors = provider.GetDescriptors(
tagName: "div",
attributeNames: Enumerable.Empty <string>(),
parentTagName: "p");
// Assert
var descriptor = Assert.Single(retrievedDescriptors);
Assert.Same(divDescriptor, descriptor);
}
public override int GetHashCode(TagHelperDescriptor descriptor)
{
var hashCodeCombiner = HashCodeCombiner.Start();
hashCodeCombiner.Add(base.GetHashCode(descriptor));
hashCodeCombiner.Add(descriptor.TagName, StringComparer.Ordinal);
hashCodeCombiner.Add(descriptor.Prefix, StringComparer.Ordinal);
if (descriptor.DesignTimeDescriptor != null)
{
hashCodeCombiner.Add(
TagHelperDesignTimeDescriptorComparer.Default.GetHashCode(descriptor.DesignTimeDescriptor));
}
foreach (var requiredAttribute in descriptor.RequiredAttributes.OrderBy(attribute => attribute))
{
hashCodeCombiner.Add(requiredAttribute, StringComparer.Ordinal);
}
if (descriptor.AllowedChildren != null)
{
foreach (var child in descriptor.AllowedChildren.OrderBy(child => child))
{
hashCodeCombiner.Add(child, StringComparer.Ordinal);
}
}
var orderedAttributeHashCodes = descriptor.Attributes
.Select(attribute => TagHelperAttributeDescriptorComparer.Default.GetHashCode(attribute))
.OrderBy(hashcode => hashcode);
foreach (var attributeHashCode in orderedAttributeHashCodes)
{
hashCodeCombiner.Add(attributeHashCode);
}
return hashCodeCombiner.CombinedHash;
}
public void TagHelperDescriptor_WithIndexerAttributes_CanBeDeserialized()
{
// Arrange
var serializedDescriptor =
$"{{\"{ nameof(TagHelperDescriptor.Prefix) }\":\"prefix:\"," +
$"\"{ nameof(TagHelperDescriptor.TagName) }\":\"tag name\"," +
$"\"{ nameof(TagHelperDescriptor.FullTagName) }\":\"prefix:tag name\"," +
$"\"{ nameof(TagHelperDescriptor.TypeName) }\":\"type name\"," +
$"\"{ nameof(TagHelperDescriptor.AssemblyName) }\":\"assembly name\"," +
$"\"{ nameof(TagHelperDescriptor.Attributes) }\":[" +
$"{{\"{ nameof(TagHelperAttributeDescriptor.IsIndexer) }\":true," +
$"\"{ nameof(TagHelperAttributeDescriptor.IsStringProperty) }\":false," +
$"\"{ nameof(TagHelperAttributeDescriptor.Name) }\":\"attribute one\"," +
$"\"{ nameof(TagHelperAttributeDescriptor.PropertyName) }\":\"property name\"," +
$"\"{ nameof(TagHelperAttributeDescriptor.TypeName) }\":\"property type name\"," +
$"\"{ nameof(TagHelperAttributeDescriptor.DesignTimeDescriptor) }\":null}}," +
$"{{\"{ nameof(TagHelperAttributeDescriptor.IsIndexer) }\":true," +
$"\"{ nameof(TagHelperAttributeDescriptor.IsStringProperty) }\":true," +
$"\"{ nameof(TagHelperAttributeDescriptor.Name) }\":\"attribute two\"," +
$"\"{ nameof(TagHelperAttributeDescriptor.PropertyName) }\":\"property name\"," +
$"\"{ nameof(TagHelperAttributeDescriptor.TypeName) }\":\"{ typeof(string).FullName }\"," +
$"\"{ nameof(TagHelperAttributeDescriptor.DesignTimeDescriptor) }\":null}}]," +
$"\"{ nameof(TagHelperDescriptor.RequiredAttributes) }\":[]," +
$"\"{ nameof(TagHelperDescriptor.AllowedChildren) }\":null," +
$"\"{ nameof(TagHelperDescriptor.RequiredParent) }\":null," +
$"\"{nameof(TagHelperDescriptor.TagStructure)}\":1," +
$"\"{ nameof(TagHelperDescriptor.DesignTimeDescriptor) }\":null}}";
var expectedDescriptor = new TagHelperDescriptor
{
Prefix = "prefix:",
TagName = "tag name",
TypeName = "type name",
AssemblyName = "assembly name",
Attributes = new[]
{
new TagHelperAttributeDescriptor
{
Name = "attribute one",
PropertyName = "property name",
TypeName = "property type name",
IsIndexer = true
},
new TagHelperAttributeDescriptor
{
Name = "attribute two",
PropertyName = "property name",
TypeName = typeof(string).FullName,
IsIndexer = true,
IsStringProperty = true
}
},
TagStructure = TagStructure.NormalOrSelfClosing
};
// Act
var descriptor = JsonConvert.DeserializeObject <TagHelperDescriptor>(serializedDescriptor);
// Assert
Assert.NotNull(descriptor);
Assert.Equal(expectedDescriptor.Prefix, descriptor.Prefix, StringComparer.Ordinal);
Assert.Equal(expectedDescriptor.TagName, descriptor.TagName, StringComparer.Ordinal);
Assert.Equal(expectedDescriptor.FullTagName, descriptor.FullTagName, StringComparer.Ordinal);
Assert.Equal(expectedDescriptor.TypeName, descriptor.TypeName, StringComparer.Ordinal);
Assert.Equal(expectedDescriptor.AssemblyName, descriptor.AssemblyName, StringComparer.Ordinal);
Assert.Equal(expectedDescriptor.Attributes, descriptor.Attributes, TagHelperAttributeDescriptorComparer.Default);
Assert.Empty(descriptor.RequiredAttributes);
}
public void TagHelperDescriptor_WithIndexerAttributes_CanBeSerialized()
{
// Arrange
var descriptor = new TagHelperDescriptor
{
Prefix = "prefix:",
TagName = "tag name",
TypeName = "type name",
AssemblyName = "assembly name",
Attributes = new[]
{
new TagHelperAttributeDescriptor
{
Name = "attribute one",
PropertyName = "property name",
TypeName = "property type name",
IsIndexer = true
},
new TagHelperAttributeDescriptor
{
Name = "attribute two",
PropertyName = "property name",
TypeName = typeof(string).FullName,
IsIndexer = true,
IsStringProperty = true
},
},
AllowedChildren = new[] { "allowed child one", "allowed child two" },
RequiredParent = "parent name"
};
var expectedSerializedDescriptor =
$"{{\"{ nameof(TagHelperDescriptor.Prefix) }\":\"prefix:\"," +
$"\"{ nameof(TagHelperDescriptor.TagName) }\":\"tag name\"," +
$"\"{ nameof(TagHelperDescriptor.FullTagName) }\":\"prefix:tag name\"," +
$"\"{ nameof(TagHelperDescriptor.TypeName) }\":\"type name\"," +
$"\"{ nameof(TagHelperDescriptor.AssemblyName) }\":\"assembly name\"," +
$"\"{ nameof(TagHelperDescriptor.Attributes) }\":[" +
$"{{\"{ nameof(TagHelperAttributeDescriptor.IsIndexer) }\":true," +
$"\"{ nameof(TagHelperAttributeDescriptor.IsStringProperty) }\":false," +
$"\"{ nameof(TagHelperAttributeDescriptor.Name) }\":\"attribute one\"," +
$"\"{ nameof(TagHelperAttributeDescriptor.PropertyName) }\":\"property name\"," +
$"\"{ nameof(TagHelperAttributeDescriptor.TypeName) }\":\"property type name\"," +
$"\"{ nameof(TagHelperAttributeDescriptor.DesignTimeDescriptor) }\":null}}," +
$"{{\"{ nameof(TagHelperAttributeDescriptor.IsIndexer) }\":true," +
$"\"{ nameof(TagHelperAttributeDescriptor.IsStringProperty) }\":true," +
$"\"{ nameof(TagHelperAttributeDescriptor.Name) }\":\"attribute two\"," +
$"\"{ nameof(TagHelperAttributeDescriptor.PropertyName) }\":\"property name\"," +
$"\"{ nameof(TagHelperAttributeDescriptor.TypeName) }\":\"{ typeof(string).FullName }\"," +
$"\"{ nameof(TagHelperAttributeDescriptor.DesignTimeDescriptor) }\":null}}]," +
$"\"{ nameof(TagHelperDescriptor.RequiredAttributes) }\":[]," +
$"\"{ nameof(TagHelperDescriptor.AllowedChildren) }\":[\"allowed child one\",\"allowed child two\"]," +
$"\"{ nameof(TagHelperDescriptor.RequiredParent) }\":\"parent name\"," +
$"\"{ nameof(TagHelperDescriptor.TagStructure) }\":0," +
$"\"{ nameof(TagHelperDescriptor.DesignTimeDescriptor) }\":null}}";
// Act
var serializedDescriptor = JsonConvert.SerializeObject(descriptor);
// Assert
Assert.Equal(expectedSerializedDescriptor, serializedDescriptor, StringComparer.Ordinal);
}
private static bool MatchesLookupInfo(TagHelperDescriptor descriptor, LookupInfo lookupInfo)
{
if (!string.Equals(descriptor.AssemblyName, lookupInfo.AssemblyName, StringComparison.Ordinal))
{
return false;
}
if (lookupInfo.TypePattern.EndsWith("*", StringComparison.Ordinal))
{
if (lookupInfo.TypePattern.Length == 1)
{
// TypePattern is "*".
return true;
}
var lookupTypeName = lookupInfo.TypePattern.Substring(0, lookupInfo.TypePattern.Length - 1);
return descriptor.TypeName.StartsWith(lookupTypeName, StringComparison.Ordinal);
}
return string.Equals(descriptor.TypeName, lookupInfo.TypePattern, StringComparison.Ordinal);
}
private void Register(TagHelperDescriptor descriptor)
{
HashSet<TagHelperDescriptor> descriptorSet;
if (_tagHelperPrefix == null)
{
_tagHelperPrefix = descriptor.Prefix;
}
var registrationKey =
string.Equals(descriptor.TagName, ElementCatchAllTarget, StringComparison.Ordinal) ?
ElementCatchAllTarget :
descriptor.FullTagName;
// Ensure there's a HashSet to add the descriptor to.
if (!_registrations.TryGetValue(registrationKey, out descriptorSet))
{
descriptorSet = new HashSet<TagHelperDescriptor>(TagHelperDescriptorComparer.Default);
_registrations[registrationKey] = descriptorSet;
}
descriptorSet.Add(descriptor);
}
