public void It_Renders_Null_As_Empty()
{
// Arrange
var result = ValueCaster.RenderAsString((ILiquidValue)null);
Assert.Equal("", result);
}
public void Render(IncludeTag includeTag,
ITemplateContext templateContext)
{
if (templateContext.FileSystem == null)
{
AddRenderingErrorToResult(new LiquidError {
Message = " ERROR: FileSystem is not defined"
});
return;
}
String virtualFileName = null;
LiquidExpressionEvaluator.Eval(includeTag.VirtualFileExpression, templateContext)
.WhenError(AddRenderingErrorToResult)
.WhenSuccess(result => { virtualFileName = ValueCaster.RenderAsString(result); });
if (virtualFileName == null)
{
return;
}
//virtualFileName = ValueCaster.RenderAsString(virtualFilenameVar.SuccessResult.Value);
String snippet = templateContext.FileSystem.Include(templateContext, virtualFileName);
templateContext.SymbolTableStack.DefineLocalRegistry(LOCALREGISTRY_FILE_KEY, virtualFileName);
RenderSnippet(includeTag, templateContext, snippet, virtualFileName);
}
public void It_Renders_Null_As_Empty()
{
// Arrange
var result = ValueCaster.RenderAsString((ILiquidValue)null);
Assert.That(result, Is.EqualTo(""));
}
public override LiquidExpressionResult ApplyTo(ITemplateContext ctx, ILiquidValue liquidExpression)
{
var strArray = ValueCaster.RenderAsString(liquidExpression).Split();
// TODO: add ability to toggle lower-case on/off
return(LiquidExpressionResult.Success(StringUtils.Eval(liquidExpression, x => Slug.Create(true, strArray))));
}
/// <summary>
/// Side effect: state is managed in the _counters dictionary.
/// </summary>
/// <returns></returns>
private String GetNextCycleText(String groupName, CycleTag cycleTag)
{
int currentIndex;
// Create a like dictionary key entry to keep track of this declaration. THis takes the variable
// names (not the eval-ed variables) or literals and concatenates them together.
var key = "cycle_" + groupName + "_" + String.Join("|", cycleTag.CycleList.Select(x => x.Data.Expression.ToString()));
while (true)
{
currentIndex = _counters.GetOrAdd(key, 0);
var newindex = (currentIndex + 1) % cycleTag.Length;
// fails if updated concurrently by someone else.
if (_counters.TryUpdate(key, newindex, currentIndex))
{
break;
}
}
String result = "";
var currentElement = cycleTag.ElementAt(currentIndex);
LiquidExpressionEvaluator.Eval(currentElement, _templateContext)
.WhenSuccess(x => result = ValueCaster.RenderAsString(LiquidExpressionEvaluator.Eval(currentElement, _templateContext).SuccessResult.Value))
.WhenError(err => result = FormatErrors(new List <LiquidError> {
err
}));
return(result);
}
private string RenderMacro(MacroBlockTag macroBlockTag, IEnumerable <Option <ILiquidValue> > args)
{
var macroRenderer = new MacroRenderer();
var expressionConstant = (ILiquidValue)macroRenderer.Render(this, macroBlockTag, _templateContext, args.ToList());
return(ValueCaster.RenderAsString(expressionConstant));
}
public static LiquidString Eval(ILiquidValue liquidExpression, Func <String, String> f)
{
String before = ValueCaster.RenderAsString(liquidExpression);
if (String.IsNullOrWhiteSpace(before))
{
return(LiquidString.Create(""));
}
return(LiquidString.Create(f(before)));
}
public override LiquidExpressionResult ApplyTo(ITemplateContext ctx, ILiquidValue liquidExpression)
{
String before = ValueCaster.RenderAsString(liquidExpression);
if (String.IsNullOrWhiteSpace(before))
{
return(LiquidExpressionResult.Success(LiquidString.Create("")));
}
var nospaces = before.TrimStart();
String trimmed = before.Substring(0, before.Length - nospaces.Length);
return(LiquidExpressionResult.Success(LiquidString.Create(trimmed + char.ToUpper(nospaces[0]) + nospaces.Substring(1))));
}
private String AsString(ITemplateContext ctx, Option <ILiquidValue> x, string field)
{
if (!x.HasValue)
{
return("");
}
var liquidExpressionResult = FieldAccessor.TryField(ctx, x.Value, field);
if (liquidExpressionResult.IsError || !liquidExpressionResult.SuccessResult.HasValue)
{
return("");
}
return(ValueCaster.RenderAsString(liquidExpressionResult.SuccessResult.Value));
}
public override LiquidExpressionResult ApplyTo(ITemplateContext ctx, LiquidNumeric liquidNumeric)
{
String numericString = ValueCaster.RenderAsString((ILiquidValue)liquidNumeric);
if (_single == null && _plural == null)
{
return(LiquidExpressionResult.Success(LiquidString.Create(numericString)));
}
if (_plural == null)
{
_plural = LiquidString.Create("");
}
//var str = LiquidString.Create(numericString+" ");
return(LiquidExpressionResult.Success(liquidNumeric.DecimalValue == 1 ? _single : _plural));
}
public void Visit(CycleTag cycleTag)
{
if (cycleTag.GroupNameExpressionTree == null)
{
AppendTextToCurrentAccumulator(GetNextCycleText(groupName: null, cycleTag: cycleTag));
}
else
{
// figure out the group name if any, otherwise use null.
LiquidExpressionEvaluator.Eval(cycleTag.GroupNameExpressionTree, _templateContext)
.WhenSuccess(
x =>
AppendTextToCurrentAccumulator(
GetNextCycleText(
groupName: x.HasValue ? ValueCaster.RenderAsString(x.Value) : null,
cycleTag: cycleTag)))
.WhenError(err => {
RegisterRenderingError(err);
//RenderError(err);
});
}
}
public LiquidString Render(ITemplateContext templateContext, IList <Option <ILiquidValue> > args)
{
var argsAsString = String.Join(", ", args.Select(x => x.Value.LiquidTypeName + ":" + ValueCaster.RenderAsString(x)));
return(LiquidString.Create("I heard " + argsAsString));
}
public override LiquidExpressionResult ApplyTo(ITemplateContext ctx, LiquidHash liquidLiquidHash)
{
String propertyNameString = ValueCaster.RenderAsString((ILiquidValue)_selector);
return(LiquidExpressionResult.Success(liquidLiquidHash.ValueAt(propertyNameString)));
}
private LiquidExpressionResult Contains(LiquidString liquidString, ILiquidValue liquidValue)
{
String s = ValueCaster.RenderAsString(liquidValue);
return(LiquidExpressionResult.Success(liquidString.StringVal.Contains(s) ? new LiquidBoolean(true) : new LiquidBoolean(false)));
}
public String Render(ILiquidValue result)
{
return(ValueCaster.RenderAsString(result));
}
