private string Serialize(ViewBufferTextWriterContent buffer)
{
using (var sw = new StringWriter())
{
buffer.WriteTo(sw, HtmlEncoder.Default);
return(sw.ToString());
}
}
public void ShouldWriteObject()
{
var buffer = new ViewBufferTextWriterContent();
buffer.Write((object)"abcd");
var result = Serialize(buffer);
Assert.Equal("abcd", result);
}
public void ShouldWriteBuffer()
{
var buffer = new ViewBufferTextWriterContent();
buffer.Write("abcd".ToCharArray());
var result = Serialize(buffer);
Assert.Equal("abcd", result);
}
public void ShouldWriteChar()
{
var buffer = new ViewBufferTextWriterContent();
buffer.Write('a');
var result = Serialize(buffer);
Assert.Equal("a", result);
}
public void ShouldWriteString()
{
var buffer = new ViewBufferTextWriterContent();
buffer.Write("<div>");
var result = Serialize(buffer);
Assert.Equal("<div>", result);
}
public static async ValueTask <Completion> WriteToAsync(List <FilterArgument> argumentsList, IReadOnlyList <Statement> statements, TextWriter writer, TextEncoder encoder, TemplateContext context)
{
var services = ((LiquidTemplateContext)context).Services;
var layoutAccessor = services.GetRequiredService <ILayoutAccessor>();
string position = null;
string name = null;
for (var i = 0; i < argumentsList.Count; i++)
{
var argument = argumentsList[i];
// check common case
if (String.IsNullOrEmpty(argument.Name) && argument.Expression is LiteralExpression literalExpression)
{
name = literalExpression.Value.ToStringValue();
continue;
}
switch (argument.Name)
{
case "position":
position = (await argument.Expression.EvaluateAsync(context)).ToStringValue();
break;
case null:
case "name":
case "":
name ??= (await argument.Expression.EvaluateAsync(context)).ToStringValue();
break;
}
}
if (statements != null && statements.Count > 0)
{
var content = new ViewBufferTextWriterContent();
var completion = await statements.RenderStatementsAsync(content, encoder, context);
if (completion != Completion.Normal)
{
return(completion);
}
var layout = await layoutAccessor.GetLayoutAsync();
var zone = layout.Zones[name];
if (zone is Shape shape)
{
await shape.AddAsync(content, position);
}
}
return(Completion.Normal);
}
public void ShouldWriteMultipleFragments()
{
var buffer = new ViewBufferTextWriterContent();
buffer.Write("ab");
buffer.Write("cd");
var result = Serialize(buffer);
Assert.Equal("abcd", result);
}
public void ShouldWriteMultipleBufferFragmentPages()
{
var buffer = new ViewBufferTextWriterContent();
var capacity = StringBuilderPool.GetInstance().Builder.Capacity;
buffer.Write(new String('x', capacity - 1).ToCharArray());
buffer.Write(new String('x', 11).ToCharArray(), 1, 3);
var result = Serialize(buffer);
Assert.Equal(capacity + 2, result.Length);
}
public void ShouldWriteMultipleStringPages()
{
var buffer = new ViewBufferTextWriterContent();
var capacity = StringBuilderPool.GetInstance().Builder.Capacity;
var page = new String('x', capacity);
buffer.Write(page);
buffer.Write(page);
var result = Serialize(buffer);
Assert.Equal(page + page, result);
}
private ShapeBinding BuildShapeBinding(string shapeType, Template template)
{
return(new ShapeBinding()
{
BindingName = shapeType,
BindingSource = shapeType,
BindingAsync = async displayContext =>
{
var content = new ViewBufferTextWriterContent();
await _liquidTemplateManager.RenderAsync(template.Content, content, _htmlEncoder, displayContext.Value);
return content;
}
});
}
public async Task <IHtmlContent> RenderHtmlContentAsync(string source, TextEncoder encoder, object model = null, IEnumerable <KeyValuePair <string, FluidValue> > properties = null)
{
if (String.IsNullOrWhiteSpace(source))
{
return(HtmlString.Empty);
}
var result = GetCachedTemplate(source);
var context = new LiquidTemplateContext(_serviceProvider, _templateOptions);
if (properties != null)
{
foreach (var property in properties)
{
context.SetValue(property.Key, property.Value);
}
}
var htmlContentWriter = new ViewBufferTextWriterContent();
await result.RenderAsync(htmlContentWriter, encoder, context, model);
return(htmlContentWriter);
}
public static async ValueTask <Completion> WriteToAsync(string identifier, List <FilterArgument> arguments, IReadOnlyList <Statement> statements, TextWriter writer, TextEncoder encoder, TemplateContext context)
{
var services = ((LiquidTemplateContext)context).Services;
var viewContextAccessor = services.GetRequiredService <ViewContextAccessor>();
var viewContext = viewContextAccessor.ViewContext;
// If no identifier is set, use the first argument as the name of the tag helper
// e.g., {% helper "input", for: "Text", class: "form-control" %}
identifier ??= (await arguments[0].Expression.EvaluateAsync(context)).ToStringValue();
// These mapping will assign an argument name to the first element in the filter arguments,
// such that the tag helper can be matched based on the expected attribute names.
if (DefaultArgumentsMapping.TryGetValue(identifier, out var mapping))
{
arguments = new List <FilterArgument>(arguments);
arguments[0] = new FilterArgument(mapping, arguments[0].Expression);
}
var filterArguments = new FilterArguments();
foreach (var argument in arguments)
{
filterArguments.Add(argument.Name, await argument.Expression.EvaluateAsync(context));
}
var factory = services.GetRequiredService <LiquidTagHelperFactory>();
var activator = factory.GetActivator(identifier, filterArguments.Names);
if (activator == LiquidTagHelperActivator.None)
{
return(Completion.Normal);
}
var tagHelper = factory.CreateTagHelper(activator, viewContext,
filterArguments, out var contextAttributes, out var outputAttributes);
ViewBufferTextWriterContent content = null;
if (statements != null && statements.Count > 0)
{
content = new ViewBufferTextWriterContent();
var completion = await statements.RenderStatementsAsync(content, encoder, context);
if (completion != Completion.Normal)
{
return(completion);
}
}
Interlocked.CompareExchange(ref _uniqueId, long.MaxValue, 0);
var id = Interlocked.Increment(ref _uniqueId);
var tagHelperContext = new TagHelperContext(contextAttributes, new Dictionary <object, object>(), id.ToString());
TagHelperOutput tagHelperOutput = null;
if (content != null)
{
tagHelperOutput = new TagHelperOutput(
identifier,
outputAttributes, (_, e) => Task.FromResult(new DefaultTagHelperContent().AppendHtml(content))
);
}
else
{
tagHelperOutput = new TagHelperOutput(
identifier,
outputAttributes, (_, e) => Task.FromResult <TagHelperContent>(new DefaultTagHelperContent())
);
}
await tagHelper.ProcessAsync(tagHelperContext, tagHelperOutput);
return(Completion.Normal);
}
public override async ValueTask <Completion> WriteToAsync(TextWriter writer, TextEncoder encoder, TemplateContext context)
{
if (!context.AmbientValues.TryGetValue("Services", out var servicesValue))
{
throw new ArgumentException("Services missing while invoking 'helper'");
}
var services = servicesValue as IServiceProvider;
var viewContextAccessor = services.GetRequiredService <ViewContextAccessor>();
var viewContext = viewContextAccessor.ViewContext;
var arguments = (FilterArguments)(await _arguments.EvaluateAsync(context)).ToObjectValue();
var helper = _helper ?? arguments["helper_name"].Or(arguments.At(0)).ToStringValue();
var factory = services.GetRequiredService <LiquidTagHelperFactory>();
// Each tag is a singleton, as views are
if (_activator == null)
{
lock (this)
{
if (_activator == null)
{
_activator = factory.GetActivator(helper, arguments.Names);
}
}
}
if (_activator == LiquidTagHelperActivator.None)
{
return(Completion.Normal);
}
var tagHelper = factory.CreateTagHelper(_activator, viewContext,
arguments, out var contextAttributes, out var outputAttributes);
ViewBufferTextWriterContent content = null;
if (Statements != null && Statements.Count > 0)
{
content = new ViewBufferTextWriterContent();
var completion = Completion.Break;
for (var index = 0; index < Statements.Count; index++)
{
completion = await Statements[index].WriteToAsync(content, encoder, context);
if (completion != Completion.Normal)
{
return(completion);
}
}
}
var tagHelperContext = new TagHelperContext(contextAttributes, new Dictionary <object, object>(), Guid.NewGuid().ToString("N"));
TagHelperOutput tagHelperOutput = null;
if (content != null)
{
tagHelperOutput = new TagHelperOutput(
helper,
outputAttributes, (_, e) => Task.FromResult(new DefaultTagHelperContent().AppendHtml(content))
);
tagHelperOutput.Content.AppendHtml(content);
}
else
{
tagHelperOutput = new TagHelperOutput(
helper,
outputAttributes, (_, e) => Task.FromResult <TagHelperContent>(new DefaultTagHelperContent())
);
}
await tagHelper.ProcessAsync(tagHelperContext, tagHelperOutput);
tagHelperOutput.WriteTo(writer, (HtmlEncoder)encoder);
return(Completion.Normal);
}
public static async ValueTask <Completion> WriteToAsync(
List <FilterArgument> argumentsList,
IReadOnlyList <Statement> statements,
TextWriter writer,
TextEncoder encoder,
TemplateContext context)
{
var services = ((LiquidTemplateContext)context).Services;
var layoutAccessor = services.GetRequiredService <ILayoutAccessor>();
var logger = services.GetRequiredService <ILogger <ZoneTag> >();
string position = null;
string name = null;
for (var i = 0; i < argumentsList.Count; i++)
{
var argument = argumentsList[i];
// check common case
if (String.IsNullOrEmpty(argument.Name) && argument.Expression is LiteralExpression literalExpression)
{
name = literalExpression.Value.ToStringValue();
continue;
}
switch (argument.Name)
{
case "position":
position = (await argument.Expression.EvaluateAsync(context)).ToStringValue();
break;
case null:
case "name":
case "":
name ??= (await argument.Expression.EvaluateAsync(context)).ToStringValue();
break;
}
}
if (statements != null && statements.Count > 0)
{
var content = new ViewBufferTextWriterContent();
var completion = await statements.RenderStatementsAsync(content, encoder, context);
if (completion != Completion.Normal)
{
return(completion);
}
var layout = await layoutAccessor.GetLayoutAsync();
var zone = layout.Zones[name];
if (zone is Shape shape)
{
await shape.AddAsync(content, position);
}
else
{
logger.LogWarning(
"Unable to add shape to the zone using the {{% zone %}} Liquid tag because the zone's type " +
"is \"{ActualType}\" instead of the expected {ExpectedType}",
zone.GetType().FullName,
nameof(Shape));
}
}
return(Completion.Normal);
}
