public string RunTemplate(Interfaces.ITemplateManager manager, string templateName, IDictionary <string, object> context)
{
string retStr = "";
for (int i = 0; i < 1; i++)
{
var template = manager.RenderTemplate(templateName, context);
retStr = template.ReadToEnd();
}
return(retStr);
}
public string runTemplate(Interfaces.ITemplateManager manager, string templateName, IDictionary <string, object> context)
{
Stopwatch stopwatch = new Stopwatch();
string retStr = "";
stopwatch.Start();
for (int i = 0; i < 1; i++)
{
var template = manager.RenderTemplate(templateName, context);
retStr = template.ReadToEnd();
}
using (TextWriter stream = System.IO.File.AppendText("Timers.txt"))
stream.WriteLine(Name + "," + stopwatch.ElapsedTicks);
return(retStr);
}
private void ValidateSyntaxTree(Interfaces.ITemplateManager manager)
{
var template = manager.GetTemplate(Template, new TestTyperesolver(),
new TypeResolver.ModelDescriptor(new TypeResolver.IDjangoType[]
{
new TypeResolver.CLRTypeDjangoType("Standard", typeof(EmptyClass))
}));
//the same logic responsible for retriving nodes as in NodeProvider class (DjangoDesigner).
var nodes = GetNodes(template.Nodes.ToList().ConvertAll
(node => (Interfaces.INode)node)).FindAll(node =>
(node is Interfaces.ICompletionValuesProvider) ||
(node.NodeType == Interfaces.NodeType.ParsingContext) ||
(node.ErrorMessage.Message != ""));
var actualResult = nodes.ConvertAll(
node =>
{
var valueProvider = node as Interfaces.ICompletionValuesProvider;
var values =
valueProvider == null ?
new List <string>()
: valueProvider.Values;
var contextValues = new List <string>(values);
switch (node.NodeType)
{
case Interfaces.NodeType.ParsingContext:
contextValues.InsertRange(0, (node.Context.TagClosures));
return(new DesignerData(node.Position, node.Length, contextValues.ToArray(), node.ErrorMessage.Severity, node.ErrorMessage.Message));
case Interfaces.NodeType.Reference:
return(new DesignerData(node.Position, node.Length, GetModelValues(node.Context.Model, RecursionDepth).ToArray(), node.ErrorMessage.Severity, node.ErrorMessage.Message));
default:
return(new DesignerData(node.Position, node.Length, new List <string>(values).ToArray(), node.ErrorMessage.Severity, node.ErrorMessage.Message));
}
});
for (var i = 0; i < actualResult.Count; i++)
{
Assert.AreEqual(ResultForDesigner[i].Length, actualResult[i].Length, "Invalid Length");
Assert.AreEqual(ResultForDesigner[i].Position, actualResult[i].Position, "Invalid Position");
Assert.AreEqual(ResultForDesigner[i].ErrorMessage, actualResult[i].ErrorMessage, "Invalid ErrorMessage");
Assert.AreEqual(ResultForDesigner[i].Severity, actualResult[i].Severity, "Invalid Severity");
Assert.AreEqual(ResultForDesigner[i].Values.OrderBy(x => x), actualResult[i].Values.OrderBy(x => x), "Invalid Values Array " + i);
}
Assert.AreEqual(ResultForDesigner.Count(), actualResult.Count);
}
public void Run(Interfaces.ITemplateManager manager)
{
if (ResultForDesigner != null)
{
ValidateSyntaxTree(manager);
return;
}
var context = new Dictionary <string, object>();
if (ContextValues != null)
{
for (int i = 0; i <= ContextValues.Length - 2; i += 2)
{
context.Add(ContextValues[i].ToString(), ContextValues[i + 1]);
}
}
try
{
if (resultGetter != null)
{
Result = resultGetter();
}
Assert.AreEqual(Result[0], RunTemplate(manager, Template, context), "** Invalid rendering result");
//if (Vars.Length != 0)
// Assert.AreEqual(Vars, manager.GetTemplateVariables(Template), "** Invalid variable list");
}
catch (Exception ex)
{
// Result[0] is either some object, in which case this shouldn't have happened
// or it's the type of the exception the calling code expects.
if (resultGetter != null)
{
Result = resultGetter();
}
if (Result[0] is Type)
{
Assert.AreEqual(Result[0], ex.GetType(), "Exception: " + ex.Message);
}
else
{
throw;
}
}
}
public void Setup()
{
var filters = new[]
{
//Core Filters
new Filter("add", new AddFilter()),
new Filter("get_digit", new GetDigit()),
new Filter("divisibleby", new DivisibleByFilter()),
new Filter("addslashes", new AddSlashesFilter()),
new Filter("capfirst", new CapFirstFilter()),
new Filter("escapejs", new EscapeJSFilter()),
new Filter("fix_ampersands", new FixAmpersandsFilter()),
new Filter("floatformat", new FloatFormatFilter()),
new Filter("linenumbers", new LineNumbersFilter()),
new Filter("lower", new LowerFilter()),
new Filter("upper", new UpperFilter()),
new Filter("make_list", new MakeListFilter()),
new Filter("wordcount", new WordCountFilter()),
new Filter("ljust", new LJustFilter()),
new Filter("rjust", new RJustFilter()),
new Filter("center", new CenterFilter()),
new Filter("cut", new CutFilter()),
new Filter("title", new TitleFilter()),
new Filter("removetags", new RemoveTagsFilter()),
new Filter("first", new FirstFilter()),
new Filter("last", new LastFilter()),
new Filter("length", new LengthFilter()),
new Filter("length_is", new LengthIsFilter()),
new Filter("random", new RandomFilter()),
new Filter("slice", new SliceFilter()),
new Filter("default", new DefaultFilter())
};
provider = new TemplateManagerProvider()
.WithLoader(new Loader())
.WithTag("non-nested", new TestDescriptor.SimpleNonNestedTag())
.WithTag("nested", new TestDescriptor.SimpleNestedTag())
.WithTag("url", new TestUrlTag())
.WithFilters(filters);
manager = provider.GetNewManager();
managerForDesigner = provider.WithSetting(Constants.EXCEPTION_IF_ERROR, false).GetNewManager();
}
private static string Render(string template, Lazy <TagDictionary> values, Interfaces.ITemplateManager templateManager)
{
lock (Error)
{
if (!template.Contains("{{") && !template.Contains("{%"))
{
//Use an empty tag dictionary because we don't have tags
//For some reason, this "fixes" something in files...but i have no idea what!
values = new Lazy <TagDictionary>(TagDictionary.Empty);
}
Exception exception = null;
string replacementValue;
try
{
Error.Invoked = false;
replacementValue = templateManager.RenderTemplate(StringProvider + template, values.Value).ReadToEnd();
}
catch (Exception ex)
{
exception = ex;
replacementValue = string.Empty;
Error.Invoked = true;
}
if (Error.Invoked)
{
if (string.IsNullOrWhiteSpace(replacementValue) || !replacementValue.Contains(Error.ToString()))
{
throw new ArgumentException($"Tag substitution errored on template string:\n{template}", exception);
}
var attemptedRender = replacementValue.Replace(Error.ToString(), "[ERROR OCCURRED HERE]");
throw new ArgumentException($"Tag substitution failed on template string:\n{template}\n\nAttempted rendering was:\n{attemptedRender}", exception);
}
return(replacementValue);
}
}
