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);
}
public void ToHtmlCase_ReturnsExpectedConversions(string input, string expectedOutput)
{
// Arrange, Act
var output = HtmlConventions.ToHtmlCase(input);
// Assert
Assert.Equal(output, expectedOutput);
}
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 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);
}
