private void ConfigureBoundAttribute(
BoundAttributeDescriptorBuilder builder,
IPropertySymbol property,
INamedTypeSymbol containingType)
{
var attributeNameAttribute = property
.GetAttributes()
.Where(a => SymbolEqualityComparer.Default.Equals(a.AttributeClass, _htmlAttributeNameAttributeSymbol))
.FirstOrDefault();
bool hasExplicitName;
string attributeName;
if (attributeNameAttribute == null ||
attributeNameAttribute.ConstructorArguments.Length == 0 ||
string.IsNullOrEmpty((string)attributeNameAttribute.ConstructorArguments[0].Value))
{
hasExplicitName = false;
attributeName = HtmlConventions.ToHtmlCase(property.Name);
}
else
{
hasExplicitName = true;
attributeName = (string)attributeNameAttribute.ConstructorArguments[0].Value;
}
var hasPublicSetter = property.SetMethod != null && property.SetMethod.DeclaredAccessibility == Accessibility.Public;
var typeName = GetFullName(property.Type);
builder.TypeName = typeName;
builder.SetPropertyName(property.Name);
if (hasPublicSetter)
{
builder.Name = attributeName;
if (property.Type.TypeKind == TypeKind.Enum)
{
builder.IsEnum = true;
}
if (IncludeDocumentation)
{
var xml = property.GetDocumentationCommentXml();
if (!string.IsNullOrEmpty(xml))
{
builder.Documentation = xml;
}
}
}
else if (hasExplicitName && !IsPotentialDictionaryProperty(property))
{
// Specified HtmlAttributeNameAttribute.Name though property has no public setter.
var diagnostic = RazorDiagnosticFactory.CreateTagHelper_InvalidAttributeNameNullOrEmpty(GetFullName(containingType), property.Name);
builder.Diagnostics.Add(diagnostic);
}
ConfigureDictionaryBoundAttribute(builder, property, containingType, attributeNameAttribute, attributeName, hasPublicSetter);
}
private HashSet <RazorDiagnostic> Validate()
{
HashSet <RazorDiagnostic> diagnostics = null;
if (string.IsNullOrWhiteSpace(Name))
{
var diagnostic = RazorDiagnosticFactory.CreateTagHelper_InvalidBoundAttributeParameterNullOrWhitespace(_parent.Name);
diagnostics ??= new();
diagnostics.Add(diagnostic);
}
else
{
foreach (var character in Name)
{
if (char.IsWhiteSpace(character) || HtmlConventions.IsInvalidNonWhitespaceHtmlCharacters(character))
{
var diagnostic = RazorDiagnosticFactory.CreateTagHelper_InvalidBoundAttributeParameterName(
_parent.Name,
Name,
character);
diagnostics ??= new();
diagnostics.Add(diagnostic);
}
}
}
return(diagnostics);
}
private HashSet <RazorDiagnostic> Validate()
{
HashSet <RazorDiagnostic> diagnostics = null;
if (string.IsNullOrWhiteSpace(Name))
{
var diagnostic = RazorDiagnosticFactory.CreateTagHelper_InvalidRestrictedChildNullOrWhitespace(_parent.GetDisplayName());
diagnostics ??= new();
diagnostics.Add(diagnostic);
}
else if (Name != TagHelperMatchingConventions.ElementCatchAllName)
{
foreach (var character in Name)
{
if (char.IsWhiteSpace(character) || HtmlConventions.IsInvalidNonWhitespaceHtmlCharacters(character))
{
var diagnostic = RazorDiagnosticFactory.CreateTagHelper_InvalidRestrictedChild(_parent.GetDisplayName(), Name, character);
diagnostics ??= new();
diagnostics.Add(diagnostic);
}
}
}
return(diagnostics);
}
public void ToHtmlCase_ReturnsExpectedConversions(string input, string expectedOutput)
{
// Arrange, Act
var output = HtmlConventions.ToHtmlCase(input);
// Assert
Assert.Equal(output, expectedOutput);
}
private HashSet <RazorDiagnostic> Validate()
{
HashSet <RazorDiagnostic> diagnostics = null;
if (string.IsNullOrWhiteSpace(TagName))
{
var diagnostic = RazorDiagnosticFactory.CreateTagHelper_InvalidTargetedTagNameNullOrWhitespace();
diagnostics ??= new();
diagnostics.Add(diagnostic);
}
else if (TagName != TagHelperMatchingConventions.ElementCatchAllName)
{
foreach (var character in TagName)
{
if (char.IsWhiteSpace(character) || HtmlConventions.IsInvalidNonWhitespaceHtmlCharacters(character))
{
var diagnostic = RazorDiagnosticFactory.CreateTagHelper_InvalidTargetedTagName(TagName, character);
diagnostics ??= new();
diagnostics.Add(diagnostic);
}
}
}
if (ParentTag != null)
{
if (string.IsNullOrWhiteSpace(ParentTag))
{
var diagnostic = RazorDiagnosticFactory.CreateTagHelper_InvalidTargetedParentTagNameNullOrWhitespace();
diagnostics ??= new();
diagnostics.Add(diagnostic);
}
else
{
foreach (var character in ParentTag)
{
if (char.IsWhiteSpace(character) || HtmlConventions.IsInvalidNonWhitespaceHtmlCharacters(character))
{
var diagnostic = RazorDiagnosticFactory.CreateTagHelper_InvalidTargetedParentTagName(ParentTag, character);
diagnostics ??= new();
diagnostics.Add(diagnostic);
}
}
}
}
return(diagnostics);
}
private void AddTagMatchingRules(INamedTypeSymbol type, TagHelperDescriptorBuilder descriptorBuilder)
{
var targetElementAttributes = type
.GetAttributes()
.Where(attribute => SymbolEqualityComparer.Default.Equals(attribute.AttributeClass, _htmlTargetElementAttributeSymbol));
// If there isn't an attribute specifying the tag name derive it from the name
if (!targetElementAttributes.Any())
{
var name = type.Name;
if (name.EndsWith(TagHelperNameEnding, StringComparison.OrdinalIgnoreCase))
{
name = name.Substring(0, name.Length - TagHelperNameEnding.Length);
}
descriptorBuilder.TagMatchingRule(ruleBuilder =>
{
var htmlCasedName = HtmlConventions.ToHtmlCase(name);
ruleBuilder.TagName = htmlCasedName;
});
return;
}
foreach (var targetElementAttribute in targetElementAttributes)
{
descriptorBuilder.TagMatchingRule(ruleBuilder =>
{
var tagName = HtmlTargetElementAttribute_Tag(targetElementAttribute);
ruleBuilder.TagName = tagName;
var parentTag = HtmlTargetElementAttribute_ParentTag(targetElementAttribute);
ruleBuilder.ParentTag = parentTag;
var tagStructure = HtmlTargetElementAttribute_TagStructure(targetElementAttribute);
ruleBuilder.TagStructure = tagStructure;
var requiredAttributeString = HtmlTargetElementAttribute_Attributes(targetElementAttribute);
RequiredAttributeParser.AddRequiredAttributes(requiredAttributeString, ruleBuilder);
});
}
}
private HashSet <RazorDiagnostic> Validate()
{
HashSet <RazorDiagnostic> diagnostics = null;
if (string.IsNullOrWhiteSpace(Name))
{
var diagnostic = RazorDiagnosticFactory.CreateTagHelper_InvalidTargetedAttributeNameNullOrWhitespace();
diagnostics ??= new();
diagnostics.Add(diagnostic);
}
else
{
var name = new StringSegment(Name);
var isDirectiveAttribute = this.IsDirectiveAttribute();
if (isDirectiveAttribute && name.StartsWith("@", StringComparison.Ordinal))
{
name = name.Subsegment(1);
}
else if (isDirectiveAttribute)
{
var diagnostic = RazorDiagnosticFactory.CreateTagHelper_InvalidRequiredDirectiveAttributeName(GetDisplayName(), Name);
diagnostics ??= new();
diagnostics.Add(diagnostic);
}
for (var i = 0; i < name.Length; i++)
{
var character = name[i];
if (char.IsWhiteSpace(character) || HtmlConventions.IsInvalidNonWhitespaceHtmlCharacters(character))
{
var diagnostic = RazorDiagnosticFactory.CreateTagHelper_InvalidTargetedAttributeName(Name, character);
diagnostics ??= new();
diagnostics.Add(diagnostic);
}
}
}
return(diagnostics);
}
private static void AddTagMatchingRules(Type type, TagHelperDescriptorBuilder descriptorBuilder)
{
var targetElementAttributes = type.GetCustomAttributes <HtmlTargetElementAttribute>();
// If there isn't an attribute specifying the tag name derive it from the name
if (!targetElementAttributes.Any())
{
var name = type.Name;
if (name.EndsWith("TagHelper", StringComparison.OrdinalIgnoreCase))
{
name = name.Substring(0, name.Length - "TagHelper".Length);
}
descriptorBuilder.TagMatchingRule(ruleBuilder =>
{
var htmlCasedName = HtmlConventions.ToHtmlCase(name);
ruleBuilder.TagName = htmlCasedName;
});
return;
}
foreach (var targetElementAttribute in targetElementAttributes)
{
descriptorBuilder.TagMatchingRule(ruleBuilder =>
{
var tagName = targetElementAttribute.Tag;
ruleBuilder.TagName = tagName;
var parentTag = targetElementAttribute.ParentTag;
ruleBuilder.ParentTag = parentTag;
var tagStructure = targetElementAttribute.TagStructure;
ruleBuilder.TagStructure = (Microsoft.AspNetCore.Razor.Language.TagStructure)tagStructure;
var requiredAttributeString = targetElementAttribute.Attributes;
RequiredAttributeParser.AddRequiredAttributes(requiredAttributeString, ruleBuilder);
});
}
}
public virtual TagHelperDescriptor CreateDescriptor(INamedTypeSymbol type)
{
var assemblyName = type.ContainingAssembly.Name;
var shortName = GetShortName(type);
var tagName = $"vc:{HtmlConventions.ToHtmlCase(shortName)}";
var typeName = $"__Generated__{shortName}ViewComponentTagHelper";
var displayName = shortName + "ViewComponentTagHelper";
var descriptorBuilder = TagHelperDescriptorBuilder.Create(ViewComponentTagHelperConventions.Kind, typeName, assemblyName);
descriptorBuilder.SetTypeName(typeName);
descriptorBuilder.DisplayName = displayName;
if (TryFindInvokeMethod(type, out var method, out var diagnostic))
{
var methodParameters = method.Parameters;
descriptorBuilder.TagMatchingRule(ruleBuilder =>
{
ruleBuilder.TagName = tagName;
AddRequiredAttributes(methodParameters, ruleBuilder);
});
AddBoundAttributes(methodParameters, displayName, descriptorBuilder);
}
public ArrayConvProfile()
{
HtmlConventions.Add(new TestConvention1());
}
private HashSet <RazorDiagnostic> Validate()
{
// data-* attributes are explicitly not implemented by user agents and are not intended for use on
// the server; therefore it's invalid for TagHelpers to bind to them.
const string DataDashPrefix = "data-";
var isDirectiveAttribute = this.IsDirectiveAttribute();
HashSet <RazorDiagnostic> diagnostics = null;
if (string.IsNullOrWhiteSpace(Name))
{
if (IndexerAttributeNamePrefix == null)
{
var diagnostic = RazorDiagnosticFactory.CreateTagHelper_InvalidBoundAttributeNullOrWhitespace(
_parent.GetDisplayName(),
GetDisplayName());
diagnostics ??= new();
diagnostics.Add(diagnostic);
}
}
else
{
if (Name.StartsWith(DataDashPrefix, StringComparison.OrdinalIgnoreCase))
{
var diagnostic = RazorDiagnosticFactory.CreateTagHelper_InvalidBoundAttributeNameStartsWith(
_parent.GetDisplayName(),
GetDisplayName(),
Name);
diagnostics ??= new();
diagnostics.Add(diagnostic);
}
StringSegment name = Name;
if (isDirectiveAttribute && name.StartsWith("@", StringComparison.Ordinal))
{
name = name.Subsegment(1);
}
else if (isDirectiveAttribute)
{
var diagnostic = RazorDiagnosticFactory.CreateTagHelper_InvalidBoundDirectiveAttributeName(
_parent.GetDisplayName(),
GetDisplayName(),
Name);
diagnostics ??= new();
diagnostics.Add(diagnostic);
}
for (var i = 0; i < name.Length; i++)
{
var character = name[i];
if (char.IsWhiteSpace(character) || HtmlConventions.IsInvalidNonWhitespaceHtmlCharacters(character))
{
var diagnostic = RazorDiagnosticFactory.CreateTagHelper_InvalidBoundAttributeName(
_parent.GetDisplayName(),
GetDisplayName(),
name.Value,
character);
diagnostics ??= new();
diagnostics.Add(diagnostic);
}
}
}
if (IndexerAttributeNamePrefix != null)
{
if (IndexerAttributeNamePrefix.StartsWith(DataDashPrefix, StringComparison.OrdinalIgnoreCase))
{
var diagnostic = RazorDiagnosticFactory.CreateTagHelper_InvalidBoundAttributePrefixStartsWith(
_parent.GetDisplayName(),
GetDisplayName(),
IndexerAttributeNamePrefix);
diagnostics ??= new();
diagnostics.Add(diagnostic);
}
else if (IndexerAttributeNamePrefix.Length > 0 && string.IsNullOrWhiteSpace(IndexerAttributeNamePrefix))
{
var diagnostic = RazorDiagnosticFactory.CreateTagHelper_InvalidBoundAttributeNullOrWhitespace(
_parent.GetDisplayName(),
GetDisplayName());
diagnostics ??= new();
diagnostics.Add(diagnostic);
}
else
{
StringSegment indexerPrefix = IndexerAttributeNamePrefix;
if (isDirectiveAttribute && indexerPrefix.StartsWith("@", StringComparison.Ordinal))
{
indexerPrefix = indexerPrefix.Subsegment(1);
}
else if (isDirectiveAttribute)
{
var diagnostic = RazorDiagnosticFactory.CreateTagHelper_InvalidBoundDirectiveAttributePrefix(
_parent.GetDisplayName(),
GetDisplayName(),
indexerPrefix.Value);
diagnostics ??= new();
diagnostics.Add(diagnostic);
}
for (var i = 0; i < indexerPrefix.Length; i++)
{
var character = indexerPrefix[i];
if (char.IsWhiteSpace(character) || HtmlConventions.IsInvalidNonWhitespaceHtmlCharacters(character))
{
var diagnostic = RazorDiagnosticFactory.CreateTagHelper_InvalidBoundAttributePrefix(
_parent.GetDisplayName(),
GetDisplayName(),
indexerPrefix.Value,
character);
diagnostics ??= new();
diagnostics.Add(diagnostic);
}
}
}
}
return(diagnostics);
}
public ProfileTest2()
{
HtmlConventions.Add(new TestConvention2());
}
