private void AddBoundAttributes(INamedTypeSymbol type, TagHelperDescriptorBuilder builder)
{
var accessibleProperties = GetAccessibleProperties(type);
foreach (var property in accessibleProperties)
{
if (ShouldSkipDescriptorCreation(property))
{
continue;
}
builder.BindAttribute(attributeBuilder =>
{
ConfigureBoundAttribute(attributeBuilder, property, type);
});
}
}
public void GetLanguageKind_TagHelperElementOwnsName()
{
// Arrange
var descriptor = TagHelperDescriptorBuilder.Create("TestTagHelper", "TestAssembly");
descriptor.TagMatchingRule(rule => rule.TagName = "test");
descriptor.SetTypeName("TestTagHelper");
var text = $"@addTagHelper *, TestAssembly{Environment.NewLine}<test>@Name</test>";
var(classifiedSpans, tagHelperSpans) = GetClassifiedSpans(text, new[] { descriptor.Build() });
// Act
var languageKind = RazorLanguageEndpoint.GetLanguageKind(classifiedSpans, tagHelperSpans, 32 + Environment.NewLine.Length);
// Assert
Assert.Equal(RazorLanguageKind.Html, languageKind);
}
public void ViewComponentTagHelperPass_Execute_CreatesViewComponentTagHelper()
{
// Arrange
var codeDocument = CreateDocument(@"
@addTagHelper TestTagHelper, TestAssembly
<tagcloud foo=""17"">");
var tagHelpers = new[]
{
TagHelperDescriptorBuilder.Create(ViewComponentTagHelperConventions.Kind, "TestTagHelper", "TestAssembly")
.TypeName("__Generated__TagCloudViewComponentTagHelper")
.BoundAttributeDescriptor(attribute => attribute
.Name("Foo")
.TypeName("System.Int32")
.PropertyName("Foo"))
.TagMatchingRuleDescriptor(rule => rule.RequireTagName("tagcloud"))
.AddMetadata(ViewComponentTagHelperMetadata.Name, "TagCloud")
.Build()
};
var engine = CreateEngine(tagHelpers);
var pass = new ViewComponentTagHelperPass()
{
Engine = engine,
};
var irDocument = CreateIRDocument(engine, codeDocument);
var vcthFullName = "AspNetCore.test.__Generated__TagCloudViewComponentTagHelper";
// Act
pass.Execute(codeDocument, irDocument);
// Assert
var tagHelper = FindTagHelperNode(irDocument);
Assert.Equal(vcthFullName, Assert.IsType <DefaultTagHelperCreateIntermediateNode>(tagHelper.Children[1]).TypeName);
Assert.Equal("Foo", Assert.IsType <DefaultTagHelperPropertyIntermediateNode>(tagHelper.Children[2]).PropertyName);
var @class = FindClassNode(irDocument);
Assert.Equal(4, @class.Children.Count);
Assert.IsType <ViewComponentTagHelperIntermediateNode>(@class.Children.Last());
}
public void CreateDescriptor_UnderstandsVariousParameterTypes()
{
// Arrange
var testCompilation = TestCompilation.Create(_assembly);
var viewComponent = testCompilation.GetTypeByMetadataName(typeof(VariousParameterViewComponent).FullName);
var factory = new ViewComponentTagHelperDescriptorFactory(testCompilation);
var expectedDescriptor = TagHelperDescriptorBuilder.Create(
ViewComponentTagHelperConventions.Kind,
"__Generated__VariousParameterViewComponentTagHelper",
typeof(VariousParameterViewComponent).GetTypeInfo().Assembly.GetName().Name)
.TypeName("__Generated__VariousParameterViewComponentTagHelper")
.DisplayName("VariousParameterViewComponentTagHelper")
.TagMatchingRuleDescriptor(rule =>
rule
.RequireTagName("vc:various-parameter")
.RequireAttributeDescriptor(attribute => attribute.Name("test-enum"))
.RequireAttributeDescriptor(attribute => attribute.Name("test-string")))
.BoundAttributeDescriptor(attribute =>
attribute
.Name("test-enum")
.PropertyName("testEnum")
.TypeName(typeof(VariousParameterViewComponent).FullName + "." + nameof(VariousParameterViewComponent.TestEnum))
.AsEnum()
.DisplayName(typeof(VariousParameterViewComponent).FullName + "." + nameof(VariousParameterViewComponent.TestEnum) + " VariousParameterViewComponentTagHelper.testEnum"))
.BoundAttributeDescriptor(attribute =>
attribute
.Name("test-string")
.PropertyName("testString")
.TypeName(typeof(string).FullName)
.DisplayName("string VariousParameterViewComponentTagHelper.testString"))
.BoundAttributeDescriptor(attribute =>
attribute
.Name("baz")
.PropertyName("baz")
.TypeName(typeof(int).FullName)
.DisplayName("int VariousParameterViewComponentTagHelper.baz"))
.AddMetadata(ViewComponentTagHelperMetadata.Name, "VariousParameter")
.Build();
// Act
var descriptor = factory.CreateDescriptor(viewComponent);
// Assert
Assert.Equal(expectedDescriptor, descriptor, TagHelperDescriptorComparer.Default);
}
public ProjectStateTest()
{
TagHelperResolver = new TestTagHelperResolver();
HostServices = TestServices.Create(
new IWorkspaceService[]
{
new TestProjectSnapshotProjectEngineFactory(),
},
new ILanguageService[]
{
TagHelperResolver,
});
HostProject = new HostProject("c:\\MyProject\\Test.csproj", FallbackRazorConfiguration.MVC_2_0);
HostProjectWithConfigurationChange = new HostProject("c:\\MyProject\\Test.csproj", FallbackRazorConfiguration.MVC_1_0);
Workspace = TestWorkspace.Create(HostServices);
var projectId = ProjectId.CreateNewId("Test");
var solution = Workspace.CurrentSolution.AddProject(ProjectInfo.Create(
projectId,
VersionStamp.Default,
"Test",
"Test",
LanguageNames.CSharp,
"c:\\MyProject\\Test.csproj"));
WorkspaceProject = solution.GetProject(projectId);
SomeTagHelpers = new List <TagHelperDescriptor>();
SomeTagHelpers.Add(TagHelperDescriptorBuilder.Create("Test1", "TestAssembly").Build());
Documents = new HostDocument[]
{
new HostDocument("c:\\MyProject\\File.cshtml", "File.cshtml"),
new HostDocument("c:\\MyProject\\Index.cshtml", "Index.cshtml"),
// linked file
new HostDocument("c:\\SomeOtherProject\\Index.cshtml", "Pages\\Index.cshtml"),
};
Text = SourceText.From("Hello, world!");
TextLoader = () => Task.FromResult(TextAndVersion.Create(Text, VersionStamp.Create()));
}
public void ModelExpressionPass_ModelExpressionProperty_SimpleExpression()
{
// Arrange
// Using \r\n here because we verify line mappings
var codeDocument = CreateDocument(
"@addTagHelper TestTagHelper, TestAssembly\r\n<p foo=\"Bar\">");
var tagHelpers = new[]
{
TagHelperDescriptorBuilder.Create("TestTagHelper", "TestAssembly")
.BoundAttributeDescriptor(attribute =>
attribute
.Name("Foo")
.TypeName("Microsoft.AspNetCore.Mvc.ViewFeatures.ModelExpression"))
.TagMatchingRuleDescriptor(rule =>
rule.RequireTagName("p"))
.Build()
};
var engine = CreateEngine(tagHelpers);
var pass = new ModelExpressionPass()
{
Engine = engine,
};
var irDocument = CreateIRDocument(engine, codeDocument);
// Act
pass.Execute(codeDocument, irDocument);
// Assert
var tagHelper = FindTagHelperNode(irDocument);
var setProperty = tagHelper.Children.OfType <TagHelperPropertyIntermediateNode>().Single();
var expression = Assert.IsType <CSharpExpressionIntermediateNode>(Assert.Single(setProperty.Children));
Assert.Equal("ModelExpressionProvider.CreateModelExpression(ViewData, __model => __model.Bar)", GetCSharpContent(expression));
var originalNode = Assert.IsAssignableFrom <IntermediateToken>(expression.Children[2]);
Assert.Equal(TokenKind.CSharp, originalNode.Kind);
Assert.Equal("Bar", originalNode.Content);
Assert.Equal(new SourceSpan("test.cshtml", 51, 1, 8, 3), originalNode.Source.Value);
}
public void GetTagHelperBinding_DoesNotAllowOptOutCharacterPrefix()
{
// Arrange
var documentDescriptors = new[]
{
TagHelperDescriptorBuilder.Create("TestType", "TestAssembly")
.TagMatchingRuleDescriptor(rule => rule.RequireTagName("*"))
.Build()
};
var documentContext = TagHelperDocumentContext.Create(string.Empty, documentDescriptors);
var service = new DefaultTagHelperFactsService();
// Act
var binding = service.GetTagHelperBinding(documentContext, "!a", Enumerable.Empty <KeyValuePair <string, string> >(), parentTag: null, parentIsTagHelper: false);
// Assert
Assert.Null(binding);
}
private void CreateContextParameter(TagHelperDescriptorBuilder builder, string childContentName)
{
builder.BindAttribute(b =>
{
b.Name = ComponentMetadata.ChildContent.ParameterAttributeName;
b.TypeName = typeof(string).FullName;
b.Metadata.Add(ComponentMetadata.Component.ChildContentParameterNameKey, bool.TrueString);
if (childContentName == null)
{
b.Documentation = ComponentResources.ChildContentParameterName_TopLevelDocumentation;
}
else
{
b.Documentation = string.Format(ComponentResources.ChildContentParameterName_Documentation, childContentName);
}
});
}
public void GetTagHelpersGivenParent_AllowsRootParentTag()
{
// Arrange
var documentDescriptors = new[]
{
TagHelperDescriptorBuilder.Create("TestType", "TestAssembly")
.TagMatchingRuleDescriptor(rule => rule.RequireTagName("div"))
.Build()
};
var documentContext = TagHelperDocumentContext.Create(string.Empty, documentDescriptors);
var service = new DefaultTagHelperFactsServiceInternal();
// Act
var descriptors = service.GetTagHelpersGivenParent(documentContext, parentTag: null /* root */);
// Assert
Assert.Equal(documentDescriptors, descriptors, TagHelperDescriptorComparer.CaseSensitive);
}
public void GetTagHelpersGivenParent_AllowsUnspecifiedParentTagHelpers()
{
// Arrange
var documentDescriptors = new[]
{
TagHelperDescriptorBuilder.Create("TestType", "TestAssembly")
.TagMatchingRuleDescriptor(rule => rule.RequireTagName("div"))
.Build()
};
var documentContext = TagHelperDocumentContext.Create(string.Empty, documentDescriptors);
var service = new DefaultTagHelperFactsService();
// Act
var descriptors = service.GetTagHelpersGivenParent(documentContext, "p");
// Assert
Assert.Equal(documentDescriptors, descriptors, TagHelperDescriptorComparer.Default);
}
public void GetTagHelpersGivenTag_RequiresTagName()
{
// Arrange
var documentDescriptors = new[]
{
TagHelperDescriptorBuilder.Create("TestType", "TestAssembly")
.TagMatchingRuleDescriptor(rule => rule.RequireTagName("strong"))
.Build()
};
var documentContext = TagHelperDocumentContext.Create(string.Empty, documentDescriptors);
var service = new DefaultTagHelperFactsService();
// Act
var descriptors = service.GetTagHelpersGivenTag(documentContext, "strong", "p");
// Assert
Assert.Equal(documentDescriptors, descriptors, TagHelperDescriptorComparer.CaseSensitive);
}
public void GetTagHelpersGivenTag_DoesNotAllowOptOutCharacterPrefix()
{
// Arrange
var documentDescriptors = new[]
{
TagHelperDescriptorBuilder.Create("TestType", "TestAssembly")
.TagMatchingRuleDescriptor(rule => rule.RequireTagName("*"))
.Build()
};
var documentContext = TagHelperDocumentContext.Create(string.Empty, documentDescriptors);
var service = new DefaultTagHelperFactsService();
// Act
var descriptors = service.GetTagHelpersGivenTag(documentContext, "!strong", parentTag: null);
// Assert
Assert.Empty(descriptors);
}
private static RazorCodeActionContext CreateRazorCodeActionContext(
CodeActionParams request,
SourceLocation location,
string filePath,
string text,
SourceSpan componentSourceSpan,
bool supportsFileCreation = true,
bool supportsCodeActionResolve = true)
{
var shortComponent = TagHelperDescriptorBuilder.Create(ComponentMetadata.Component.TagHelperKind, "Fully.Qualified.Component", "TestAssembly");
shortComponent.TagMatchingRule(rule => rule.TagName = "Component");
var fullyQualifiedComponent = TagHelperDescriptorBuilder.Create(ComponentMetadata.Component.TagHelperKind, "Fully.Qualified.Component", "TestAssembly");
fullyQualifiedComponent.TagMatchingRule(rule => rule.TagName = "Fully.Qualified.Component");
var tagHelpers = new[] { shortComponent.Build(), fullyQualifiedComponent.Build() };
var sourceDocument = TestRazorSourceDocument.Create(text, filePath: filePath, relativePath: filePath);
var projectEngine = RazorProjectEngine.Create(builder =>
{
builder.AddTagHelpers(tagHelpers);
builder.AddDirective(InjectDirective.Directive);
});
var codeDocument = projectEngine.ProcessDesignTime(sourceDocument, FileKinds.Component, Array.Empty <RazorSourceDocument>(), tagHelpers);
var cSharpDocument = codeDocument.GetCSharpDocument();
var diagnosticDescriptor = new RazorDiagnosticDescriptor("RZ10012", () => "", RazorDiagnosticSeverity.Error);
var diagnostic = RazorDiagnostic.Create(diagnosticDescriptor, componentSourceSpan);
var cSharpDocumentWithDiagnostic = RazorCSharpDocument.Create(cSharpDocument.GeneratedCode, cSharpDocument.Options, new[] { diagnostic });
codeDocument.SetCSharpDocument(cSharpDocumentWithDiagnostic);
var documentSnapshot = Mock.Of <DocumentSnapshot>(document =>
document.GetGeneratedOutputAsync() == Task.FromResult(codeDocument) &&
document.GetTextAsync() == Task.FromResult(codeDocument.GetSourceText()) &&
document.Project.TagHelpers == tagHelpers, MockBehavior.Strict);
var sourceText = SourceText.From(text);
var context = new RazorCodeActionContext(request, documentSnapshot, codeDocument, location, sourceText, supportsFileCreation, supportsCodeActionResolve: supportsCodeActionResolve);
return(context);
}
public void GetBinding_ReturnsNullForUnprefixedTags(string tagName)
{
// Arrange
var divDescriptor = TagHelperDescriptorBuilder.Create("foo1", "SomeAssembly")
.TagMatchingRuleDescriptor(rule => rule.RequireTagName(tagName))
.Build();
var descriptors = new[] { divDescriptor };
var tagHelperBinder = new TagHelperBinder("th:", descriptors);
// Act
var bindingResult = tagHelperBinder.GetBinding(
tagName: "div",
attributes: Array.Empty <KeyValuePair <string, string> >(),
parentTagName: "p",
parentIsTagHelper: false);
// Assert
Assert.Null(bindingResult);
}
public void GetBinding_ReturnsNullBindingResultPrefixAsTagName()
{
// Arrange
var catchAllDescriptor = TagHelperDescriptorBuilder.Create("foo1", "SomeAssembly")
.TagMatchingRuleDescriptor(rule => rule.RequireTagName(TagHelperMatchingConventions.ElementCatchAllName))
.Build();
var descriptors = new[] { catchAllDescriptor };
var tagHelperBinder = new TagHelperBinder("th", descriptors);
// Act
var bindingResult = tagHelperBinder.GetBinding(
tagName: "th",
attributes: Array.Empty <KeyValuePair <string, string> >(),
parentTagName: "p",
parentIsTagHelper: false);
// Assert
Assert.Null(bindingResult);
}
public DefaultVisualStudioDocumentTrackerTest()
{
RazorCoreContentType = Mock.Of <IContentType>(c => c.IsOfType(RazorLanguage.ContentType) && c.IsOfType(RazorConstants.LegacyContentType), MockBehavior.Strict);
TextBuffer = Mock.Of <ITextBuffer>(b => b.ContentType == RazorCoreContentType, MockBehavior.Strict);
FilePath = TestProjectData.SomeProjectFile1.FilePath;
ProjectPath = TestProjectData.SomeProject.FilePath;
RootNamespace = TestProjectData.SomeProject.RootNamespace;
ImportDocumentManager = new Mock <ImportDocumentManager>(MockBehavior.Strict).Object;
Mock.Get(ImportDocumentManager).Setup(m => m.OnSubscribed(It.IsAny <VisualStudioDocumentTracker>())).Verifiable();
Mock.Get(ImportDocumentManager).Setup(m => m.OnUnsubscribed(It.IsAny <VisualStudioDocumentTracker>())).Verifiable();
var projectSnapshotManagerDispatcher = new Mock <ProjectSnapshotManagerDispatcher>(MockBehavior.Strict);
projectSnapshotManagerDispatcher.Setup(d => d.AssertDispatcherThread(It.IsAny <string>())).Verifiable();
WorkspaceEditorSettings = new DefaultWorkspaceEditorSettings(projectSnapshotManagerDispatcher.Object, Mock.Of <EditorSettingsManager>(MockBehavior.Strict));
SomeTagHelpers = new List <TagHelperDescriptor>()
{
TagHelperDescriptorBuilder.Create("test", "test").Build(),
};
ProjectManager = new TestProjectSnapshotManager(Dispatcher, Workspace)
{
AllowNotifyListeners = true
};
HostProject = new HostProject(ProjectPath, FallbackRazorConfiguration.MVC_2_1, RootNamespace);
UpdatedHostProject = new HostProject(ProjectPath, FallbackRazorConfiguration.MVC_2_0, RootNamespace);
OtherHostProject = new HostProject(TestProjectData.AnotherProject.FilePath, FallbackRazorConfiguration.MVC_2_0, TestProjectData.AnotherProject.RootNamespace);
DocumentTracker = new DefaultVisualStudioDocumentTracker(
Dispatcher,
JoinableTaskFactory.Context,
FilePath,
ProjectPath,
ProjectManager,
WorkspaceEditorSettings,
Workspace,
TextBuffer,
ImportDocumentManager);
}
public DocumentStateTest()
{
TagHelperResolver = new TestTagHelperResolver();
HostProject = new HostProject(TestProjectData.SomeProject.FilePath, FallbackRazorConfiguration.MVC_2_0, TestProjectData.SomeProject.RootNamespace);
HostProjectWithConfigurationChange = new HostProject(TestProjectData.SomeProject.FilePath, FallbackRazorConfiguration.MVC_1_0, TestProjectData.SomeProject.RootNamespace);
ProjectWorkspaceState = new ProjectWorkspaceState(new[]
{
TagHelperDescriptorBuilder.Create("TestTagHelper", "TestAssembly").Build(),
});
SomeTagHelpers = new List <TagHelperDescriptor>();
SomeTagHelpers.Add(TagHelperDescriptorBuilder.Create("Test1", "TestAssembly").Build());
HostDocument = TestProjectData.SomeProjectFile1;
Text = SourceText.From("Hello, world!");
TextLoader = () => Task.FromResult(TextAndVersion.Create(Text, VersionStamp.Create()));
}
private static RazorSyntaxTree GetSyntaxTree(string source)
{
var taghelper = TagHelperDescriptorBuilder.Create("TestTagHelper", "TestAssembly")
.TagMatchingRuleDescriptor(rule => rule.RequireTagName("taghelper"))
.TypeName("TestTagHelper")
.Build();
var engine = RazorEngine.CreateDesignTime(builder =>
{
builder.AddTagHelpers(taghelper);
});
var sourceDocument = RazorSourceDocument.Create(source, "test.cshtml");
var addTagHelperImport = RazorSourceDocument.Create("@addTagHelper *, TestAssembly", "import.cshtml");
var codeDocument = RazorCodeDocument.Create(sourceDocument, new[] { addTagHelperImport });
engine.Process(codeDocument);
return(codeDocument.GetSyntaxTree());
}
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);
});
}
}
public SerializationTest()
{
var languageVersion = RazorLanguageVersion.Experimental;
var extensions = new RazorExtension[]
{
new SerializedRazorExtension("TestExtension"),
};
Configuration = RazorConfiguration.Create(languageVersion, "Custom", extensions);
ProjectWorkspaceState = new ProjectWorkspaceState(new[]
{
TagHelperDescriptorBuilder.Create("Test", "TestAssembly").Build(),
},
LanguageVersion.LatestMajor);
var converterCollection = new JsonConverterCollection();
converterCollection.RegisterRazorConverters();
Converters = converterCollection.ToArray();
}
private void AddAllowedChildren(INamedTypeSymbol type, TagHelperDescriptorBuilder builder)
{
var restrictChildrenAttribute = type.GetAttributes().Where(a => SymbolEqualityComparer.Default.Equals(a.AttributeClass, _restrictChildrenAttributeSymbol)).FirstOrDefault();
if (restrictChildrenAttribute == null)
{
return;
}
builder.AllowChildTag(childTagBuilder => childTagBuilder.Name = (string)restrictChildrenAttribute.ConstructorArguments[0].Value);
if (restrictChildrenAttribute.ConstructorArguments.Length == 2)
{
foreach (var value in restrictChildrenAttribute.ConstructorArguments[1].Values)
{
builder.AllowChildTag(childTagBuilder => childTagBuilder.Name = (string)value.Value);
}
}
}
private static TagHelperDescriptor CreateTagHelperDescriptor(
string kind,
string tagName,
string typeName,
string assemblyName,
IEnumerable <Action <BoundAttributeDescriptorBuilder> > attributes = null,
IEnumerable <Action <TagMatchingRuleDescriptorBuilder> > ruleBuilders = null,
Action <TagHelperDescriptorBuilder> configureAction = null)
{
var builder = TagHelperDescriptorBuilder.Create(kind, typeName, assemblyName);
builder.SetTypeName(typeName);
if (attributes != null)
{
foreach (var attributeBuilder in attributes)
{
builder.BoundAttributeDescriptor(attributeBuilder);
}
}
if (ruleBuilders != null)
{
foreach (var ruleBuilder in ruleBuilders)
{
builder.TagMatchingRuleDescriptor(innerRuleBuilder => {
innerRuleBuilder.RequireTagName(tagName);
ruleBuilder(innerRuleBuilder);
});
}
}
else
{
builder.TagMatchingRuleDescriptor(ruleBuilder => ruleBuilder.RequireTagName(tagName));
}
configureAction?.Invoke(builder);
var descriptor = builder.Build();
return(descriptor);
}
public void GetElementCompletions_CapturesAllAllowedChildTagsFromParentTagHelpers_AllTagHelpers()
{
// Arrange
var documentDescriptors = new[]
{
TagHelperDescriptorBuilder.Create("BoldParentCatchAll", "TestAssembly")
.TagMatchingRuleDescriptor(rule => rule.RequireTagName("*"))
.AllowChildTag("strong")
.AllowChildTag("div")
.AllowChildTag("b")
.Build(),
TagHelperDescriptorBuilder.Create("BoldParent", "TestAssembly")
.TagMatchingRuleDescriptor(rule => rule.RequireTagName("div"))
.AllowChildTag("b")
.AllowChildTag("bold")
.Build(),
};
var expectedCompletions = ElementCompletionResult.Create(new Dictionary <string, HashSet <TagHelperDescriptor> >()
{
["strong"] = new HashSet <TagHelperDescriptor> {
documentDescriptors[0]
},
["b"] = new HashSet <TagHelperDescriptor> {
documentDescriptors[0]
},
["bold"] = new HashSet <TagHelperDescriptor> {
documentDescriptors[0]
},
["div"] = new HashSet <TagHelperDescriptor> {
documentDescriptors[0], documentDescriptors[1]
},
});
var completionContext = BuildElementCompletionContext(documentDescriptors, Enumerable.Empty <string>(), containingTagName: "div");
var service = CreateTagHelperCompletionFactsService();
// Act
var completions = service.GetElementCompletions(completionContext);
// Assert
AssertCompletionsAreEquivalent(expectedCompletions, completions);
}
private static IEnumerable <TagHelperDescriptor> CreateRazorComponentTagHelperDescriptors(string assemblyName, string namespaceName, string tagName)
{
var fullyQualifiedName = $"{namespaceName}.{tagName}";
var builder = TagHelperDescriptorBuilder.Create(ComponentMetadata.Component.TagHelperKind, fullyQualifiedName, assemblyName);
builder.TagMatchingRule(rule => rule.TagName = tagName);
builder.SetTypeName(fullyQualifiedName);
builder.SetTypeNameIdentifier(tagName);
builder.SetTypeNamespace(namespaceName);
yield return(builder.Build());
var fullyQualifiedBuilder = TagHelperDescriptorBuilder.Create(ComponentMetadata.Component.TagHelperKind, fullyQualifiedName, assemblyName);
fullyQualifiedBuilder.TagMatchingRule(rule => rule.TagName = fullyQualifiedName);
fullyQualifiedBuilder.SetTypeName(fullyQualifiedName);
fullyQualifiedBuilder.SetTypeNameIdentifier(tagName);
fullyQualifiedBuilder.SetTypeNamespace(namespaceName);
fullyQualifiedBuilder.AddMetadata(ComponentMetadata.Component.NameMatchKey, ComponentMetadata.Component.FullyQualifiedNameMatch);
yield return(fullyQualifiedBuilder.Build());
}
public DefaultProjectSnapshotTest()
{
TagHelperResolver = new TestTagHelperResolver();
HostProject = new HostProject(TestProjectData.SomeProject.FilePath, FallbackRazorConfiguration.MVC_2_0, TestProjectData.SomeProject.RootNamespace);
ProjectWorkspaceState = new ProjectWorkspaceState(new[]
{
TagHelperDescriptorBuilder.Create("TestTagHelper", "TestAssembly").Build(),
},
default);
Documents = new HostDocument[]
{
TestProjectData.SomeProjectFile1,
TestProjectData.SomeProjectFile2,
// linked file
TestProjectData.AnotherProjectNestedFile3,
};
}
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);
});
}
}
private TagHelperDescriptor CreateChildContentDescriptor(BlazorSymbols symbols, TagHelperDescriptor component, BoundAttributeDescriptor attribute)
{
var typeName = component.GetTypeName() + "." + attribute.Name;
var assemblyName = component.AssemblyName;
var builder = TagHelperDescriptorBuilder.Create(BlazorMetadata.ChildContent.TagHelperKind, typeName, assemblyName);
builder.SetTypeName(typeName);
// This opts out this 'component' tag helper for any processing that's specific to the default
// Razor ITagHelper runtime.
builder.Metadata[TagHelperMetadata.Runtime.Name] = BlazorMetadata.ChildContent.RuntimeName;
// Opt out of processing as a component. We'll process this specially as part of the component's body.
builder.Metadata[BlazorMetadata.SpecialKindKey] = BlazorMetadata.ChildContent.TagHelperKind;
var xml = attribute.Documentation;
if (!string.IsNullOrEmpty(xml))
{
builder.Documentation = xml;
}
// Child content matches the property name, but only as a direct child of the component.
builder.TagMatchingRule(r =>
{
r.TagName = attribute.Name;
r.ParentTag = component.TagMatchingRules.First().TagName;
});
if (attribute.IsParameterizedChildContentProperty())
{
// For child content attributes with a parameter, synthesize an attribute that allows you to name
// the parameter.
CreateContextParameter(builder, attribute.Name);
}
var descriptor = builder.Build();
return(descriptor);
}
private void EnsureMatchings()
{
if (_matchings != null)
{
return;
}
lock (this)
{
if (_matchings == null)
{
var feature = new TagHelperFeature();
_partManager.PopulateFeature(feature);
var matchings = new List <LiquidTagHelperMatching>();
foreach (var tagHelper in feature.TagHelpers)
{
var matching = _allMatchings.GetOrAdd(tagHelper.AsType(), type =>
{
var descriptorBuilder = TagHelperDescriptorBuilder.Create(
type.FullName, type.Assembly.GetName().Name);
descriptorBuilder.SetTypeName(type.FullName);
AddTagMatchingRules(type, descriptorBuilder);
var descriptor = descriptorBuilder.Build();
return(new LiquidTagHelperMatching(
descriptor.Name,
descriptor.AssemblyName,
descriptor.TagMatchingRules
));
});
matchings.Add(matching);
}
_matchings = matchings;
}
}
}
private static void ReadAllowedChildTag(JsonReader reader, TagHelperDescriptorBuilder builder)
{
if (!reader.Read())
{
return;
}
if (reader.TokenType != JsonToken.StartObject)
{
return;
}
builder.AllowChildTag(childTag =>
{
reader.ReadProperties(propertyName =>
{
switch (propertyName)
{
case nameof(AllowedChildTagDescriptor.Name):
if (reader.Read())
{
var name = (string)reader.Value;
childTag.Name = name;
}
break;
case nameof(AllowedChildTagDescriptor.DisplayName):
if (reader.Read())
{
var displayName = (string)reader.Value;
childTag.DisplayName = displayName;
}
break;
case nameof(AllowedChildTagDescriptor.Diagnostics):
ReadDiagnostics(reader, childTag.Diagnostics);
break;
}
});
});
}
private static RazorCodeDocument GetCodeDocument(string source)
{
var taghelper = TagHelperDescriptorBuilder.Create("TestTagHelper", "TestAssembly")
.BoundAttributeDescriptor(attr => attr.Name("show").TypeName("System.Boolean"))
.BoundAttributeDescriptor(attr => attr.Name("id").TypeName("System.Int32"))
.TagMatchingRuleDescriptor(rule => rule.RequireTagName("taghelper"))
.TypeName("TestTagHelper")
.Build();
var engine = RazorEngine.CreateDesignTime(builder =>
{
builder.AddTagHelpers(taghelper);
});
var sourceDocument = RazorSourceDocument.Create(source, "test.cshtml");
var addTagHelperImport = RazorSourceDocument.Create("@addTagHelper *, TestAssembly", "import.cshtml");
var codeDocument = RazorCodeDocument.Create(sourceDocument, new[] { addTagHelperImport });
engine.Process(codeDocument);
return(codeDocument);
}
