/// <summary> /// Creates a new instance of the StringTemplateViewEngine /// </summary> /// <param name="viewPath">The physical path to the root views directory</param> public StringTemplateViewEngine(string viewPath) { Group = new TemplateGroupDirectory(viewPath, '$', '$') { Listener = new Log4NetTemplateErrorListener() }; }
public virtual void LoadPrecRuleTemplates() { string templateGroupFile = Path.Combine("Tool", "Templates", "LeftRecursiveRules.stg"); recRuleTemplates = new TemplateGroupFile( Path.Combine( Path.GetDirectoryName(typeof(AntlrTool).GetTypeInfo().Assembly.Location), templateGroupFile), Encoding.UTF8); if (!recRuleTemplates.IsDefined("recRule")) { tool.errMgr.ToolError(ErrorType.MISSING_CODE_GEN_TEMPLATES, "LeftRecursiveRules"); } // use codegen to get correct language templates; that's it though CodeGenerator gen = new CodeGenerator(tool, null, language); TemplateGroup templates = gen.GetTemplates(); if (templates == null) { // this class will still operate using Java templates templates = new CodeGenerator(tool, null, "Java").GetTemplates(); Debug.Assert(templates != null); } codegenTemplates = templates; }
public LexerATNFactory(LexerGrammar g) : base(g) { // use codegen to get correct language templates for lexer commands string language = g.GetOptionString("language"); CodeGenerator gen = new CodeGenerator(g.tool, null, language); AbstractTarget target = gen.GetTarget(); codegenTemplates = target != null ? target.GetTemplates() : null; }
public virtual TemplateGroup GetTemplates() { if (templates == null) { templates = LoadTemplates(); } return templates; }
public static string ToListString(this IList list) { TemplateGroup group = new TemplateGroup(); group.DefineTemplate("listTemplate", "[<list:{x|<x>}; separator=\", \">]", new string[] { "list" }); group.RegisterRenderer(typeof(IList), new CollectionRenderer()); Template st = group.GetInstanceOf("listTemplate"); st.Add("list", list); return st.Render(); }
public void TestMissingDictionaryValue2() { TemplateGroup group = new TemplateGroup(); group.DefineTemplate("test", "<if(m.foo)>[<m.foo>]<endif>", new string[] { "m" }); Template t = group.GetInstanceOf("test"); t.Add("m", new Dictionary<string, string>()); string expecting = ""; string result = t.Render(); Assert.AreEqual(expecting, result); }
public void TestEmptyListGetsNoOutput() { TemplateGroup group = new TemplateGroup(); group.DefineTemplate("test", "begin\n" + "<users:{u | name: <u>}; separator=\", \">\n" + "end\n", new string[] { "users" }); Template t = group.GetInstanceOf("test"); t.Add("users", new List<string>()); string expecting = "begin" + newline + "end"; string result = t.Render(); Assert.AreEqual(expecting, result); }
public void TestAttrSeparator() { TemplateGroup group = new TemplateGroup(); group.DefineTemplate("test", "hi <name; separator=sep>!", new string[] { "name", "sep" }); Template st = group.GetInstanceOf("test"); st.Add("sep", ", "); st.Add("name", "Ter"); st.Add("name", "Tom"); st.Add("name", "Sumana"); string expected = "hi Ter, Tom, Sumana!"; string result = st.Render(); Assert.AreEqual(expected, result); }
public void TestIllegalOption() { ErrorBuffer errors = new ErrorBuffer(); TemplateGroup group = new TemplateGroup(); group.Listener = errors; group.DefineTemplate("test", "<name; bad=\"ugly\">", new string[] { "name" }); Template st = group.GetInstanceOf("test"); st.Add("name", "Ter"); string expected = "Ter"; string result = st.Render(); Assert.AreEqual(expected, result); expected = "[test 1:7: no such option: bad]"; Assert.AreEqual(expected, errors.Errors.ToListString()); }
public void TestDoubleListApplyWithNullValueAndNullOption() { // first apply sends [Template, null, Template] to second apply, which puts [] around // the value. This verifies that null not blank comes out of first apply // since we don't get [null]. TemplateGroup group = new TemplateGroup(); group.DefineTemplate("test", "<name:{n | <n>}:{n | [<n>]}; null=\"n/a\">", new string[] { "name" }); Template st = group.GetInstanceOf("test"); st.Add("name", "Ter"); st.Add("name", null); st.Add("name", "Sumana"); string expected = "[Ter]n/a[Sumana]"; string result = st.Render(); Assert.AreEqual(expected, result); }
public void TestIndirectMap() { TemplateGroup group = new TemplateGroup(); group.DefineTemplate("a", "[<x>]", new string[] { "x" }); group.DefineTemplate("test", "hi <names:(templateName)()>!", new string[] { "names", "templateName" }); Template st = group.GetInstanceOf("test"); st.Add("names", "Ter"); st.Add("names", "Tom"); st.Add("names", "Sumana"); st.Add("templateName", "a"); string expected = "hi [Ter][Tom][Sumana]!"; string result = st.Render(); Assert.AreEqual(expected, result); }
public void TestParallelMap() { TemplateGroup group = new TemplateGroup('$', '$'); group.DefineTemplate("test", "hi $names,phones:{n,p | $n$:$p$;}$", new string[] { "names", "phones" }); Template st = group.GetInstanceOf("test"); st.Add("names", "Ter"); st.Add("names", "Tom"); st.Add("names", "Sumana"); st.Add("phones", "x5001"); st.Add("phones", "x5002"); st.Add("phones", "x5003"); string expected = "hi Ter:x5001;Tom:x5002;Sumana:x5003;"; string result = st.Render(); Assert.AreEqual(expected, result); }
public void TestEmptyExpr2() { string template = "hi <> "; TemplateGroup group = new TemplateGroup(); ErrorBuffer errors = new ErrorBuffer(); group.Listener = errors; try { group.DefineTemplate("test", template); } catch (TemplateException) { } string result = errors.ToString(); string expected = "test 1:3: doesn't look like an expression" + newline; Assert.AreEqual(expected, result); }
public static string ReplacePropertyTokensInGroups(IEnumerable collection, string groupTemplate) { StringBuilder resultBuilder = new StringBuilder(); foreach (var listItem in collection) { //We need new template for every collection item so that sub collection items like registrants are cleaned up TemplateGroup eventGroup = new TemplateGroup(TextTemplateUtils.DefaultTokenStartDelimiter, TextTemplateUtils.DefaultTokenEndDelimiter); eventGroup.RegisterRenderer(typeof(string), new StringRenderer()); Template eventTemplate = new Template(eventGroup, groupTemplate); AddPropertiesToTemplate(listItem, eventTemplate); resultBuilder.Append(eventTemplate.Render(CultureInfo.InvariantCulture)); } return resultBuilder.ToString(); }
protected TemplateGroup GetTemplateGroup(List<string> templateNames) { if (tg == null) { // combile the header and all .st files and load everything into a TemplateGroup tg = new TemplateGroup(); foreach (var templateName in templateNames) { tg.ImportTemplates(GetTemplateGroupFromResource(templateName)); } foreach (var type in attributeRenderers.Keys) { var renderer = attributeRenderers[type]; tg.RegisterRenderer(type, renderer); } } return tg; }
public void TestEvalSTIteratingSubtemplateInSTFromAnotherGroup() { ErrorBuffer errors = new ErrorBuffer(); TemplateGroup innerGroup = new TemplateGroup(); innerGroup.Listener = errors; innerGroup.DefineTemplate("test", "<m:samegroup()>", new string[] { "m" }); innerGroup.DefineTemplate("samegroup", "hi ", new string[] { "x" }); Template st = innerGroup.GetInstanceOf("test"); st.Add("m", new int[] { 1, 2, 3 }); TemplateGroup outerGroup = new TemplateGroup(); outerGroup.DefineTemplate("errorMessage", "<x>", new string[] { "x" }); Template outerST = outerGroup.GetInstanceOf("errorMessage"); outerST.Add("x", st); string expected = "hi hi hi "; string result = outerST.Render(); Assert.AreEqual(errors.Errors.Count, 0); // ignores no such prop errors Assert.AreEqual(expected, result); }
public void TestEvalSTFromAnotherGroup() { ErrorBuffer errors = new ErrorBuffer(); TemplateGroup innerGroup = new TemplateGroup(); innerGroup.Listener = errors; innerGroup.DefineTemplate("bob", "inner"); Template st = innerGroup.GetInstanceOf("bob"); TemplateGroup outerGroup = new TemplateGroup(); outerGroup.Listener = errors; outerGroup.DefineTemplate("errorMessage", "<x>", new string[] { "x" }); outerGroup.DefineTemplate("bob", "outer"); // should not be visible to test() in innerGroup Template outerST = outerGroup.GetInstanceOf("errorMessage"); outerST.Add("x", st); string expected = "inner"; string result = outerST.Render(); Assert.AreEqual(errors.Errors.Count, 0); // ignores no such prop errors Assert.AreEqual(expected, result); }
public void TestIndirectTemplateIncludeViaTemplate() { TemplateGroup group = new TemplateGroup(); group.DefineTemplate("foo", "bar"); group.DefineTemplate("tname", "foo"); string template = "<(tname())()>"; group.DefineTemplate("test", template, new string[] { "name" }); Template st = group.GetInstanceOf("test"); string expected = "bar"; string result = st.Render(); Assert.AreEqual(expected, result); }
public void TestSeparatorWithNullFirstValueAndNullOption() { TemplateGroup group = new TemplateGroup(); group.DefineTemplate("test", "hi <name; null=\"n/a\", separator=\", \">!", new string[] { "name" }); Template st = group.GetInstanceOf("test"); st.Add("name", null); st.Add("name", "Tom"); st.Add("name", "Sumana"); string expected = "hi n/a, Tom, Sumana!"; string result = st.Render(); Assert.AreEqual(expected, result); }
public void TestIndirectTemplateIncludeWithArgs() { TemplateGroup group = new TemplateGroup(); group.DefineTemplate("foo", "<x><y>", new string[] { "x", "y" }); string template = "<(name)({1},{2})>"; group.DefineTemplate("test", template, new string[] { "name" }); Template st = group.GetInstanceOf("test"); st.Add("name", "foo"); string expected = "12"; string result = st.Render(); Assert.AreEqual(expected, result); }
public void TestParallelMapThenMap() { TemplateGroup group = new TemplateGroup(); group.DefineTemplate("bold", "[<x>]", new string[] { "x" }); group.DefineTemplate("test", "hi <names,phones:{n,p | <n>:<p>;}:bold()>", new string[] { "names", "phones" }); Template st = group.GetInstanceOf("test"); st.Add("names", "Ter"); st.Add("names", "Tom"); st.Add("names", "Sumana"); st.Add("phones", "x5001"); st.Add("phones", "x5002"); string expected = "hi [Ter:x5001;][Tom:x5002;][Sumana:;]"; string result = st.Render(); Assert.AreEqual(expected, result); }
public void TestPropConvertsToString() { ErrorBufferAllErrors errors = new ErrorBufferAllErrors(); TemplateGroup group = new TemplateGroup(); group.Listener = errors; string template = "<u.(name)>"; Template st = new Template(group, template); st.Add("u", new User(1, "parrt")); st.Add("name", 100); string expected = ""; string result = st.Render(); Assert.AreEqual(expected, result); TemplateRuntimeMessage msg = (TemplateRuntimeMessage)errors.Errors[0]; TemplateNoSuchPropertyException e = (TemplateNoSuchPropertyException)msg.Cause; Assert.AreEqual("Antlr4.Test.StringTemplate.BaseTest+User.100", e.PropertyName); }
public void TestParallelMapWith3Versus2Elements() { TemplateGroup group = new TemplateGroup(); group.DefineTemplate("test", "hi <names,phones:{n,p | <n>:<p>;}>", new string[] { "names", "phones" }); Template st = group.GetInstanceOf("test"); st.Add("names", "Ter"); st.Add("names", "Tom"); st.Add("names", "Sumana"); st.Add("phones", "x5001"); st.Add("phones", "x5002"); string expected = "hi Ter:x5001;Tom:x5002;Sumana:;"; string result = st.Render(); Assert.AreEqual(expected, result); }
public void TestWeirdChar2() { string template = "\n<\\\n"; TemplateGroup group = new TemplateGroup(); ErrorBuffer errors = new ErrorBuffer(); group.Listener = errors; try { group.DefineTemplate("test", template); } catch (TemplateException) { } string result = errors.ToString(); string expected = "test 1:2: invalid escaped char: '<EOF>'" + newline + "test 1:2: expecting '>', found '<EOF>'" + newline; Assert.AreEqual(expected, result); }
public void TestRoundRobinMap() { TemplateGroup group = new TemplateGroup(); group.DefineTemplate("a", "[<x>]", new string[] { "x" }); group.DefineTemplate("b", "(<x>)", new string[] { "x" }); group.DefineTemplate("test", "hi <name:a(),b()>!", new string[] { "name" }); Template st = group.GetInstanceOf("test"); st.Add("name", "Ter"); st.Add("name", "Tom"); st.Add("name", "Sumana"); string expected = "hi [Ter](Tom)[Sumana]!"; string result = st.Render(); Assert.AreEqual(expected, result); }
public void TestWeirdChar() { string template = " <*>"; TemplateGroup group = new TemplateGroup(); ErrorBuffer errors = new ErrorBuffer(); group.Listener = errors; try { group.DefineTemplate("test", template); } catch (TemplateException) { } string result = errors.ToString(); string expected = "test 1:4: invalid character '*'" + newline + "test 1:0: this doesn't look like a template: \" <*>\"" + newline; Assert.AreEqual(expected, result); }
public void TestUnterminatedExpr() { string template = "hi <t()$"; TemplateGroup group = new TemplateGroup(); ErrorBuffer errors = new ErrorBuffer(); group.Listener = errors; try { group.DefineTemplate("test", template); } catch (TemplateException) { } string result = errors.ToString(); string expected = "test 1:7: invalid character '$'" + newline + "test 1:7: invalid character '<EOF>'" + newline + "test 1:7: premature EOF" + newline; Assert.AreEqual(expected, result); }
public void TestNullValueAndNullOption() { TemplateGroup group = new TemplateGroup(); group.DefineTemplate("test", "<name; null=\"n/a\">", new string[] { "name" }); Template st = group.GetInstanceOf("test"); st.Add("name", null); string expected = "n/a"; string result = st.Render(); Assert.AreEqual(expected, result); }
public void TestOptionDoesntApplyToNestedTemplate() { TemplateGroup group = new TemplateGroup(); group.DefineTemplate("foo", "<zippo>"); group.DefineTemplate("test", "<foo(); null=\"n/a\">", new string[] { "zippo" }); Template st = group.GetInstanceOf("test"); st.Add("zippo", null); string expected = ""; string result = st.Render(); Assert.AreEqual(expected, result); }
public void TestSeparatorWithSpaces() { TemplateGroup group = new TemplateGroup(); group.DefineTemplate("test", "hi <name; separator= \", \">!", new string[] { "name" }); Template st = group.GetInstanceOf("test"); Console.WriteLine(st.impl.Ast.ToStringTree()); st.Add("name", "Ter"); st.Add("name", "Tom"); st.Add("name", "Sumana"); string expected = "hi Ter, Tom, Sumana!"; string result = st.Render(); Assert.AreEqual(expected, result); }