protected StringTemplateGroup GetTemplateManager(Controller controller) { if ((controller.AreaName == null) || (controller.AreaName.Trim().Length == 0)) { return(templateGroup); } StringTemplateGroup group = (StringTemplateGroup)area2templateManager[controller.AreaName]; if (group == null) { group = new BasicStringTemplateGroup( ConfigConstants.STGROUP_NAME_PREFIX + "_area_" + controller.AreaName, (StringTemplateLoader)null, config.TemplateLexerType); group.SuperGroup = templateGroup; if (config.TemplateWriterTypeName != null) { group.SetTemplateWriterType(config.TemplateWriterType); } IEnumerator renderersEnumerator = config.GetAttributeRenderersForArea(controller.AreaName); while (renderersEnumerator.MoveNext()) { RendererInfo rendererInfo = (RendererInfo)renderersEnumerator.Current; group.RegisterAttributeRenderer(rendererInfo.AttributeType, rendererInfo.GetRendererInstance()); } area2templateManager[controller.AreaName] = group; } return(group); }
/// <summary> /// Retrieves the ST layout template for the specified controller. /// </summary> protected StringTemplate GetLayoutTemplate(Controller controller) { string layoutName = controller.LayoutName; string templateName = string.Format("{0}/{1}", ConfigConstants.LAYOUTS_DIR, layoutName.Replace('\\', '/')); StringTemplateGroup templateManager = GetTemplateManager(controller); StringTemplate st = templateManager.GetInstanceOf(templateName); return(st); }
public void SetUp() { group = new StringTemplateGroup(new System.IO.StringReader(gString)); /* // warm up the on-the-fly compiler for (int i=1; i<=2*N; i++) { testBaselineLiteral(); testSingleLocalAttributeReference(); testApplyTemplateToList(); } */ }
/// <summary> /// Retrieves the ST template for specified controller and template name. /// </summary> protected StringTemplate GetViewTemplate(Controller controller, string viewName) { StringTemplate st = null; StringTemplateGroup templateManager = GetTemplateManager(controller); if (viewName.IndexOfAny(ConfigConstants.PATH_SEPARATOR_CHARS) == -1) { // try locations in order bool controllerHasArea = ((controller.AreaName != null) && (controller.AreaName.Trim().Length > 0)); string templateName; // <area>/<controller>/<view> if (controllerHasArea) { templateName = string.Format("{0}/{1}/{2}", controller.AreaName, controller.Name, viewName); st = templateManager.GetInstanceOf(templateName); } if (st == null) { // <area>/shared/<view> if (controllerHasArea) { templateName = string.Format("{0}/{1}/{2}", controller.AreaName, ConfigConstants.SHARED_DIR, viewName); st = templateManager.GetInstanceOf(templateName); } if (st == null) { // <controller>/<view> templateName = string.Format("{0}/{1}", controller.Name, viewName); st = templateManager.GetInstanceOf(templateName); if (st == null) { // shared/<view> templateName = string.Format("{0}/{1}", ConfigConstants.SHARED_DIR, viewName); st = templateManager.GetInstanceOf(templateName); } } } } if (st == null) { st = templateManager.GetInstanceOf(viewName.Replace('\\', '/')); } if (st == null) { throw new Castle.MonoRail.Framework.RailsException("Could not find the view: " + viewName); } return(st); }
public static void Main(string[] args) { StringTemplateGroup group = new StringTemplateGroup("dummy"); StringTemplate bold = group.DefineTemplate("bold", "<b>$attr$</b>"); StringTemplate banner = group.DefineTemplate("banner", "the banner"); StringTemplate st = new StringTemplate(group, "<html>\n" + "$banner(a=b)$" + "<p><b>$name$:$email$</b>" + "$if(member)$<i>$fontTag$member</font></i>$endif$"); st.SetAttribute("name", "Terence"); st.SetAttribute("name", "Tom"); st.SetAttribute("email", "*****@*****.**"); st.SetAttribute("templateAttr", bold); StringTemplateTreeView frame = new StringTemplateTreeView("StringTemplateTreeView Example", st); Application.Run(frame); }
public void Initialize() { config = STViewEngineConfiguration.GetConfig(ConfigConstants.ELEMENT_stview_sectionname); StringTemplateGroup componentGroup = new ViewComponentStringTemplateGroup( ConfigConstants.STGROUP_NAME_PREFIX + "_components", config.TemplateLexerType); StringTemplateGroup helpersSTGroup = new BasicStringTemplateGroup( ConfigConstants.STGROUP_NAME_PREFIX + "_helpersST", new EmbeddedResourceTemplateLoader(this.GetType().Assembly, ConfigConstants.HELPER_RESOURCE_NAMESPACE, false), config.TemplateLexerType); helpersSTGroup.SuperGroup = componentGroup; templateGroup = new BasicStringTemplateGroup( ConfigConstants.STGROUP_NAME_PREFIX, new FileSystemTemplateLoader(ViewSourceLoader.ViewRootDir, false), config.TemplateLexerType); templateGroup.SuperGroup = helpersSTGroup; if (config.TemplateWriterTypeName != null) { componentGroup.SetTemplateWriterType(config.TemplateWriterType); helpersSTGroup.SetTemplateWriterType(config.TemplateWriterType); templateGroup.SetTemplateWriterType(config.TemplateWriterType); } IEnumerator globalRenderersEnumerator = config.GetGlobalAttributeRenderers(); while (globalRenderersEnumerator.MoveNext()) { RendererInfo renderInfo = (RendererInfo)globalRenderersEnumerator.Current; componentGroup.RegisterAttributeRenderer(renderInfo.AttributeType, renderInfo.GetRendererInstance()); helpersSTGroup.RegisterAttributeRenderer(renderInfo.AttributeType, renderInfo.GetRendererInstance()); templateGroup.RegisterAttributeRenderer(renderInfo.AttributeType, renderInfo.GetRendererInstance()); } }
public static void Main(string[] args) { // choose a skin or site "look" to present string skin = "blue"; // allow overrides for language and skin from arguments on command line string language = null; if ( args.Length > 0 ) { language = args[0]; } if ( args.Length > 1) { if ( "blue".Equals(args[1]) || "red".Equals(args[1]) ) skin = args[1]; } TryToSetRequestedLocale(language); // load strings from a properties files like en.strings ResourceManager resMgr = new ResourceManager("ST.Examples.i18n.Content.Strings", typeof(ResourceWrapper).Assembly); ResourceWrapper strings = new ResourceWrapper(resMgr); // get a template group rooted at appropriate skin string absoluteSkinRootDirectoryName = Path.Combine(new DirectoryInfo(AppDomain.CurrentDomain.BaseDirectory).Parent.FullName, skin); StringTemplateGroup templates = new StringTemplateGroup("test", absoluteSkinRootDirectoryName); // generate some pages; every page gets strings table to pull strings from StringTemplate page1ST = templates.GetInstanceOf("page1"); page1ST.SetAttribute("strings", strings); StringTemplate page2ST = templates.GetInstanceOf("page2"); page2ST.SetAttribute("strings", strings); // render to text Console.Out.WriteLine(page1ST); Console.Out.WriteLine(page2ST); }
public virtual void TestMultipleRefsToIEnumeratorGivesEmptyOutput() { string templates = "" + "group TestIEnum ;" + NL + "Action(Arg) ::=<<" + NL + "Ref 1: " + NL + " $Arg:{X=$it$ # }$" + NL + "Ref 2: " + NL + " $Arg:{X=$it$ # }$" + NL + ">>" ; StringTemplateGroup group = new StringTemplateGroup( new StringReader(templates), typeof(DefaultTemplateLexer)); StringTemplate actionST = group.GetInstanceOf("Action"); int[] myIntArray = new int[5] { 1, 2, 3, 4, 5 }; actionST.SetAttribute("Arg", myIntArray.GetEnumerator()); string expected = "" + "Ref 1: " + NL + " X=1 # X=2 # X=3 # X=4 # X=5 # " + NL + "Ref 2: " + NL + " X=1 # X=2 # X=3 # X=4 # X=5 # " + NL ; string actual = actionST.ToString(); Assert.AreEqual(expected, actual, "IEnumerators have side-effects. Can't just Reset() and reuse because it may be \"deliberately positioned\"."); }
public virtual void testEmbeddedMultiLineIF() { StringTemplateGroup group = new StringTemplateGroup("test"); StringTemplate main = new StringTemplate(group, "$sub$"); StringTemplate sub = new StringTemplate( group, "" + "begin" + NL + "$if(foo)$" + NL + "$foo$" + NL + "$else$" + NL + "blort" + NL + "$endif$" + NL ); sub.SetAttribute("foo", "stuff"); main.SetAttribute("sub", sub); string expecting = "begin" + NL + "stuff"; Assert.AreEqual(expecting, main.ToString()); main = new StringTemplate(group, "$sub$"); sub = sub.GetInstanceOf(); main.SetAttribute("sub", sub); expecting = "begin" + NL + "blort"; Assert.AreEqual(expecting, main.ToString()); }
public void testImplicitRegionRedefError() { // cannot define an implicitly-defined template more than once string templates = "" + "group test;" + NL + "a() ::= \"X<@r()>Y\"" + NL + "@a.r() ::= \"foo\"" + NL + "@a.r() ::= \"bar\"" + NL; IStringTemplateErrorListener errors = new ErrorBuffer(); StringTemplateGroup group = new StringTemplateGroup(new StringReader(templates), errors); StringTemplate st = group.GetInstanceOf("a"); st.ToString(); string result = errors.ToString(); string expecting = "group test line 4: redefinition of template region: @a.r"; Assert.AreEqual(expecting, result); }
public virtual void testIFTemplate() { StringTemplateGroup group = new StringTemplateGroup("dummy", ".", typeof(AngleBracketTemplateLexer)); StringTemplate t = new StringTemplate(group, "SELECT <column> FROM PERSON " + "<if(cond)>WHERE ID=<id><endif>;"); t.SetAttribute("column", "name"); t.SetAttribute("cond", "true"); t.SetAttribute("id", "231"); Assert.AreEqual(t.ToString(), "SELECT name FROM PERSON WHERE ID=231;"); }
public virtual void testIFCondWithParensDollarDelimsTemplate() { StringTemplateGroup group = new StringTemplateGroup("dummy", "."); StringTemplate t = new StringTemplate(group, "$if(map.(type))$$type$ $prop$=$map.(type)$;$endif$"); Hashtable map = new Hashtable(); map["int"] = "0"; t.SetAttribute("map", map); t.SetAttribute("prop", "x"); t.SetAttribute("type", "int"); Assert.AreEqual("int x=0;", t.ToString()); }
public virtual void testGroupSatisfiesSingleInterface() { // this also tests the group loader IStringTemplateErrorListener errors = new ErrorBuffer(); StringTemplateGroup.RegisterGroupLoader(new CommonGroupLoader(errors, TEMPDIR)); string groupIStr = "" + "interface testI;" + NL + "t();" + NL + "bold(item);" + NL + "optional duh(a,b,c);" + NL; WriteFile(TEMPDIR, "testI.sti", groupIStr); string templates = "" + "group testG implements testI;" + NL + "t() ::= <<foo>>" + NL + "bold(item) ::= <<foo>>" + NL + "duh(a,b,c) ::= <<foo>>" + NL; WriteFile(TEMPDIR, "testG.stg", templates); file1 = new StreamReader(Path.Combine(TEMPDIR, "testG.stg")); StringTemplateGroup group = new StringTemplateGroup(file1, errors); string expecting = ""; // should be no errors Assert.AreEqual(expecting, errors.ToString()); }
public virtual void testGroupExtendsSuperGroup() { // this also tests the group loader IStringTemplateErrorListener errors = new ErrorBuffer(); StringTemplateGroup.RegisterGroupLoader( new CommonGroupLoader(errors, TEMPDIR) ); string superGroup = "" + "group superG;" + NL + "bold(item) ::= <<*<item>*>>;\n" + NL; WriteFile(TEMPDIR, "superG.stg", superGroup); string templates = "" + "group testG : superG;" + NL + "main(x) ::= <<$bold(x)$>>" + NL; WriteFile(TEMPDIR, "testG.stg", templates); file1 = new StreamReader(Path.Combine(TEMPDIR, "testG.stg")); StringTemplateGroup group = new StringTemplateGroup(file1, typeof(DefaultTemplateLexer), errors); StringTemplate st = group.GetInstanceOf("main"); st.SetAttribute("x", "foo"); string expecting = "*foo*"; Assert.AreEqual(expecting, st.ToString()); }
public virtual void testFormalArgumentAssignment() { string templates = "" + "group test;" + NL + @"page() ::= <<$body(font=""Times"")$>>" + NL + @"body(font) ::= ""<font face=$font$>my body</font>""" + NL; StringTemplateGroup group = new StringTemplateGroup(new StringReader(templates), typeof(DefaultTemplateLexer)); StringTemplate t = group.GetInstanceOf("page"); string expecting = "<font face=Times>my body</font>"; Assert.AreEqual(expecting, t.ToString()); }
public virtual void testExprInParens() { // specify a template to apply to an attribute // Use a template group so we can specify the start/stop chars StringTemplateGroup group = new StringTemplateGroup("dummy", "."); StringTemplate bold = group.DefineTemplate("bold", "<b>$it$</b>"); StringTemplate duh = new StringTemplate(group, @"$(""blort: ""+(list)):bold()$"); duh.SetAttribute("list", "a"); duh.SetAttribute("list", "b"); duh.SetAttribute("list", "c"); // System.out.println(duh); string expecting = "<b>blort: abc</b>"; Assert.AreEqual(expecting, duh.ToString()); }
public virtual void TestIfTestingDoesNotAdvanceIEnumeratorPosition2() { string templates = "" + "group TestIEnum ;" + NL + "ActionWithIfTest(Arg) ::=<<" + NL + "$if( Arg )$" + NL + "$Arg:{X=$it$ # }$" + NL + "$endif$" + NL + ">>" + NL + "ActionWithoutIfTest(Arg) ::=<<" + NL + "$Arg:{X=$it$ # }$" + NL + ">>" ; StringTemplateGroup group = new StringTemplateGroup( new StringReader(templates), typeof(DefaultTemplateLexer)); StringTemplate actionWithIfTestST = group.GetInstanceOf("ActionWithIfTest"); StringTemplate actionWithoutIfTestST = group.GetInstanceOf("ActionWithoutIfTest"); int[] myIntArray = new int[5] { 1, 2, 3, 4, 5 }; actionWithIfTestST.SetAttribute("Arg", myIntArray.GetEnumerator()); actionWithoutIfTestST.SetAttribute("Arg", myIntArray.GetEnumerator()); string resultWithIfTestST = actionWithIfTestST.ToString(); string resultWithoutIfTestST = actionWithoutIfTestST.ToString(); Assert.AreEqual(resultWithIfTestST, resultWithoutIfTestST); }
public virtual void testFindTemplateInCLASSPATH_Nope_JustRelativeToAssemblyLocation() { // Look for templates in CLASSPATH as resources StringTemplateGroup mgroup = new StringTemplateGroup("method stuff", typeof(AngleBracketTemplateLexer)); StringTemplate m = mgroup.GetInstanceOf("tests/method"); // "method.st" references body() so "body.st" will be loaded too m.SetAttribute("visibility", "public"); m.SetAttribute("name", "foobar"); m.SetAttribute("returnType", "void"); m.SetAttribute("statements", "i=1;"); // body inherits these from method m.SetAttribute("statements", "x=i;"); string expecting = "public void foobar() {" + NL + "\t// start of a body" + NL + "\ti=1;" + NL + "\tx=i;" + NL + "\t// end of a body" + NL + "}"; //.Replace(Environment.NewLine, "\n") below mitigates against failure due to line-ending differences Assert.AreEqual(expecting, m.ToString().Replace(Environment.NewLine, "\n")); }
public virtual void TestFirstThenRestTwiceOnIEnumeratorResultsInNoOutputFor2ndRef() { string templates = "" + "group TestIEnum ;" + NL + "FirstThenRest(Arg) ::=<<" + NL + "Iteration 1: " + NL + "FIRST: $first(Arg):{X=$it$ # }$" + NL + "REST : $rest(Arg):{X=$it$ # }$" + NL + "-------------" + NL + "Iteration 2: " + NL + "FIRST: $first(Arg):{X=$it$ # }$" + NL + "REST : $rest(Arg):{X=$it$ # }$" + NL + "-------------" + NL + ">>" ; StringTemplateGroup group = new StringTemplateGroup( new StringReader(templates), typeof(DefaultTemplateLexer)); StringTemplate actionST = group.GetInstanceOf("FirstThenRest"); int[] myIntArray = new int[5] { 1, 2, 3, 4, 5 }; actionST.SetAttribute("Arg", myIntArray.GetEnumerator()); string expected = "" + "Iteration 1: " + NL + "FIRST: X=1 # " + NL + "REST : X=2 # X=3 # X=4 # X=5 # " + NL + "-------------" + NL + "Iteration 2: " + NL + "FIRST: X=1 # " + NL + "REST : X=2 # X=3 # X=4 # X=5 # " + NL + "-------------" + NL ; string actual = actionST.ToString(); Assert.AreEqual(expected, actual, "IEnumerators have side-effects. Can't just Reset() and reuse because it may be \"deliberately positioned\"."); }
public virtual void testFormalArgumentAssignmentInApply() { string templates = "" + "group test;" + NL + @"page(name) ::= <<$name:bold(font=""Times"")$>>" + NL + @"bold(font) ::= ""<font face=$font$><b>$it$</b></font>""" + NL; StringTemplateGroup group = new StringTemplateGroup(new StringReader(templates), typeof(DefaultTemplateLexer)); StringTemplate t = group.GetInstanceOf("page"); t.SetAttribute("name", "Ter"); string expecting = "<font face=Times><b>Ter</b></font>"; Assert.AreEqual(expecting, t.ToString()); }
public void testComplicatedInheritance() { // in super: decls invokes labels // in sub: overridden decls which calls super.decls // overridden labels // Bug: didn't see the overridden labels. In other words, // the overridden decls called super which called labels, but // didn't get the subgroup overridden labels--it calls the // one in the superclass. Ouput was "DL" not "DSL"; didn't // invoke sub's labels(). string basetemplates = "" + "group base;" + NL + "decls() ::= \"D<labels()>\"" + NL + "labels() ::= \"L\"" + NL ; StringTemplateGroup @base = new StringTemplateGroup( new StringReader(basetemplates), typeof(AngleBracketTemplateLexer)); string subtemplates = "" + "group sub;" + NL + "decls() ::= \"<super.decls()>\"" + NL + "labels() ::= \"SL\"" + NL ; StringTemplateGroup sub = new StringTemplateGroup( new StringReader(subtemplates), typeof(AngleBracketTemplateLexer)); sub.SuperGroup = @base; StringTemplate st = sub.GetInstanceOf("decls"); string expecting = "DSL"; string result = st.ToString(); Assert.AreEqual(expecting, result); }
public virtual void testGroupFileFormat() { string templates = "" + "group test;" + NL + @"t() ::= ""literal template""" + NL + @"bold(item) ::= ""<b>$item$</b>""" + NL + "duh() ::= <<" + NL + "xx" + NL + ">>" + NL; StringTemplateGroup group = new StringTemplateGroup(new StringReader(templates), typeof(DefaultTemplateLexer)); string expecting = "" + "group test;" + NL + "bold(item) ::= <<<b>$item$</b>>>" + NL + "duh() ::= <<xx>>" + NL + "t() ::= <<literal template>>" + NL; Assert.AreEqual(expecting, group.ToString()); StringTemplate a = group.GetInstanceOf("t"); expecting = "literal template"; Assert.AreEqual(expecting, a.ToString()); StringTemplate b = group.GetInstanceOf("bold"); b.SetAttribute("item", "dork"); expecting = "<b>dork</b>"; Assert.AreEqual(expecting, b.ToString()); }
public virtual void testComplicatedSeparatorExpr() { StringTemplateGroup group = new StringTemplateGroup("test"); StringTemplate bold = group.DefineTemplate("bulletSeparator", "</li>$foo$<li>"); // make separator a complicated expression with args passed to included template StringTemplate t = new StringTemplate( group, @"<ul>$name; separator=bulletSeparator(foo="" "")+"" ""$</ul>" ); t.SetAttribute("name", "Ter"); t.SetAttribute("name", "Tom"); t.SetAttribute("name", "Mel"); //System.out.println(t); string expecting = "<ul>Ter</li> <li> Tom</li> <li> Mel</ul>"; Assert.AreEqual(expecting, t.ToString()); }
public virtual void testIFBoolean() { StringTemplateGroup group = new StringTemplateGroup("dummy", "."); StringTemplate t = new StringTemplate(group, "$if(b)$x$endif$ $if(!b)$y$endif$"); t.SetAttribute("b", (object)true); Assert.AreEqual(t.ToString(), "x "); t = t.GetInstanceOf(); t.SetAttribute("b", (object)false); Assert.AreEqual(t.ToString(), " y"); }
public void testEmbeddedRegionRedefError() { // cannot define an embedded template within group string templates = "" + "group test;" + NL + "a() ::= \"X<@r>dork<@end>Y\"" + "@a.r() ::= \"foo\"" + NL; IStringTemplateErrorListener errors = new ErrorBuffer(); StringTemplateGroup group = new StringTemplateGroup(new StringReader(templates), errors); StringTemplate st = group.GetInstanceOf("a"); st.ToString(); string result = errors.ToString(); string expecting = "group test line 2: redefinition of template region: @a.r"; Assert.AreEqual(expecting, result); }
public virtual void testIFCondWithParensTemplate() { StringTemplateGroup group = new StringTemplateGroup("dummy", ".", typeof(AngleBracketTemplateLexer)); StringTemplate t = new StringTemplate(group, "<if(map.(type))><type> <prop>=<map.(type)>;<endif>"); Hashtable map = new Hashtable(); map["int"] = "0"; t.SetAttribute("map", map); t.SetAttribute("prop", "x"); t.SetAttribute("type", "int"); Assert.AreEqual("int x=0;", t.ToString()); }
public void testEmbeddedRegionRef() { string templates = "" + "group test;" + NL + "a() ::= \"X$@r$blort$@end$Y\"" + NL; StringTemplateGroup group = new StringTemplateGroup(new StringReader(templates), typeof(DefaultTemplateLexer)); StringTemplate st = group.GetInstanceOf("a"); string result = st.ToString(); string expecting = "XblortY"; Assert.AreEqual(expecting, result); }
public void testImplicitOverriddenRegionRedefError() { string templates1 = "" + "group super;" + NL + "a() ::= \"X<@r()>Y\"" + "@a.r() ::= \"foo\"" + NL; StringTemplateGroup group = new StringTemplateGroup( new StringReader(templates1)); string templates2 = "" + "group sub;" + NL + "@a.r() ::= \"foo\"" + NL + "@a.r() ::= \"bar\"" + NL; IStringTemplateErrorListener errors = new ErrorBuffer(); StringTemplateGroup subGroup = new StringTemplateGroup( new StringReader(templates2), errors, group); StringTemplate st = subGroup.GetInstanceOf("a"); string result = errors.ToString(); string expecting = "group sub line 3: redefinition of template region: @a.r"; Assert.AreEqual(expecting, result); }
public void testEmbeddedRegionRefWithNewlinesAngleBrackets() { string templates = "" + "group test;" + NL + "a() ::= \"X<@r>" + NL + "blort" + NL + "<@end>" + NL + "Y\"" + NL; StringTemplateGroup group = new StringTemplateGroup(new StringReader(templates)); StringTemplate st = group.GetInstanceOf("a"); string result = st.ToString(); string expecting = "XblortY"; Assert.AreEqual(expecting, result); }
public virtual void testLiteralStringEscapes() { StringTemplateGroup group = new StringTemplateGroup("dummy", "."); group.DefineTemplate("foo", "$x$ && $it$"); StringTemplate t = new StringTemplate(group, @"$A:foo(x=""dog\""\"""")$"); StringTemplate u = new StringTemplate(group, @"$A:foo(x=""dog\""g"")$"); StringTemplate v = new StringTemplate(group, @"$A:{$it:foo(x=""\{dog\}\"""")$ is cool}$"); t.SetAttribute("A", "ick"); u.SetAttribute("A", "ick"); v.SetAttribute("A", "ick"); string expecting = @"dog"""" && ick"; Assert.AreEqual(expecting, t.ToString()); expecting = @"dog""g && ick"; Assert.AreEqual(expecting, u.ToString()); expecting = @"{dog}"" && ick is cool"; Assert.AreEqual(expecting, v.ToString()); }
public void testEscapedTemplateDelimiters() { string templates = "" + "group test;" + NL + "t() ::= <<$\"literal\":{a|$a$\\}}$ template\n>>" + NL + "bold(item) ::= <<<b>$item$</b\\>>>" + NL + "duh() ::= <<" + NL + "xx" + NL + ">>" + NL; StringTemplateGroup group = new StringTemplateGroup(new StringReader(templates), typeof(DefaultTemplateLexer)); string expecting = "" + "group test;" + NL + "bold(item) ::= <<<b>$item$</b>>>" + NL + "duh() ::= <<xx>>" + NL + "t() ::= <<$\"literal\":{a|$a$\\}}$ template>>" + NL; Assert.AreEqual(expecting, group.ToString()); StringTemplate b = group.GetInstanceOf("bold"); b.SetAttribute("item", "dork"); expecting = "<b>dork</b>"; Assert.AreEqual(expecting, b.ToString()); StringTemplate a = group.GetInstanceOf("t"); expecting = "literal} template"; Assert.AreEqual(expecting, a.ToString()); }
public virtual void testSimpleIndentOfAttributeList() { string templates = "" + "group test;" + NL + "list(names) ::= <<" + @" $names; separator=""\n""$" + NL + ">>" + NL; IStringTemplateErrorListener errors = new ErrorBuffer(); StringTemplateGroup group = new StringTemplateGroup(new StringReader(templates), typeof(DefaultTemplateLexer), errors); StringTemplate t = group.GetInstanceOf("list"); t.SetAttribute("names", "Terence"); t.SetAttribute("names", "Jim"); t.SetAttribute("names", "Sriram"); string expecting = "" + " Terence" + NL + " Jim" + NL + " Sriram"; Assert.AreEqual(expecting, t.ToString()); }
public virtual void testExpressionAsRHSOfAssignment() { StringTemplateGroup group = new StringTemplateGroup("test"); StringTemplate hostname = group.DefineTemplate("hostname", "$machine$.jguru.com"); StringTemplate bold = group.DefineTemplate("bold", "<b>$x$</b>"); StringTemplate t = new StringTemplate(group, @"$bold(x=hostname(machine=""www""))$"); string expecting = "<b>www.jguru.com</b>"; Assert.AreEqual(expecting, t.ToString()); }