protected void RenderAll(List <object> list, Context context, IndentationTextWriter result) { list.ForEach(token => { try { if (token is IRenderable) { ((IRenderable)token).Render(context, result); } else { result.Write(token.ToString()); } } catch (Exception ex) { if (ex.InnerException is LiquidException) { ex = ex.InnerException; } result.Write(context.HandleError(ex)); } }); }
public void Render(Context context, IndentationTextWriter result) { object output = RenderInternal(context); if (output != null) { var transformer = Template.GetValueTypeTransformer(output.GetType()); if (transformer != null) { output = transformer(output); } string outputString; if (output is IEnumerable) #if NET35 { outputString = string.Join(string.Empty, ((IEnumerable)output).Cast <object>().Select(o => o.ToString()).ToArray()); } #else { outputString = string.Join(string.Empty, ((IEnumerable)output).Cast <object>()); } #endif else if (output is bool) { outputString = output.ToString().ToLower(); } else { outputString = output.ToString(); } result.Write(outputString); }
/// <summary> /// Render takes a hash with local variables. /// /// if you use the same filters over and over again consider registering them globally /// with <tt>Template.register_filter</tt> /// /// Following options can be passed: /// /// * <tt>filters</tt> : array with local filters /// * <tt>registers</tt> : hash with register variables. Those can be accessed from /// filters and tags and might be useful to integrate liquid more with its host application /// </summary> private void RenderInternal(IndentationTextWriter result, RenderParameters parameters) { if (Root == null) { return; } Context context; Hash registers; IEnumerable <Type> filters; parameters.Evaluate(this, out context, out registers, out filters); if (registers != null) { Registers.Merge(registers); } if (filters != null) { context.AddFilters(filters); } try { // Render the nodelist. Root.Render(context, result); } finally { _errors = context.Errors; } }
/// <summary> /// Primarily intended for testing. /// </summary> /// <param name="context"></param> /// <returns></returns> internal string Render(Context context) { using (var result = IndentationTextWriter.Create()) { Render(context, result); return(result.ToString()); } }
/// <summary> /// Renders the template using the specified parameters and returns a string containing the result. /// </summary> /// <param name="parameters"></param> /// <returns></returns> public string Render(RenderParameters parameters) { using (var writer = IndentationTextWriter.Create()) { Render(writer, parameters); return(writer.ToString()); } }
/// <summary> /// Renders the template into the specified Stream. /// </summary> /// <param name="stream"></param> /// <param name="parameters"></param> public void Render(Stream stream, RenderParameters parameters) { // Can't dispose this new StreamWriter, because it would close the // passed-in stream, which isn't up to us. var streamWriter = IndentationTextWriter.Create(new StreamWriter(stream)); RenderInternal(streamWriter, parameters); streamWriter.Flush(); }
public static IndentationTextWriter Create(TextWriter Writer = null, string IndentTab = null) { IndentationTextWriter Result = null; if (Writer == null) { Writer = new StringWriter(); } if (IndentTab == null) { IndentTab = " ".Replicate(AppExec.GetConfiguration <int>("FileGeneration", "IndentSize", 4)); } Result = new IndentationTextWriter(Writer, IndentTab); Result.IndentationDepth = DotLiquid.Tags.Inject.RecursionLevel; return(Result); }
public virtual void Render(Context context, IndentationTextWriter result) { }
public override void Render(Context context, IndentationTextWriter result) { RenderAll(NodeList, context, result); }
/// <summary> /// Renders the template into the specified StreamWriter. /// </summary> /// <param name="result"></param> /// <param name="parameters"></param> public void Render(IndentationTextWriter result, RenderParameters parameters) { RenderInternal(result, parameters); }