public void CompilesAndReturnsRuntimeGeneratedTemplateClass() { const string TemplateCode = @"class RuntimeGeneratedTemplateClass { }"; var compiler = new TemplateCompiler(); Type result = compiler.CompileTemplate(TemplateCode); Assert.IsNotNull(result, "Result type is null"); }
public void SimpleBlockTemplateCompilesCorrectly() { var source = FileHelper.GetTemplateSource("simple-block.html"); var compiler = new TemplateCompiler(source); var minifier = new MinifierCompiler <TemplateCompiler>(compiler); var result = minifier.Compile().ToString(); Assert.AreEqual(result, "function(n){var t=\"\",i;for(t+=\"<ul>\",i=0;i<n.users.length;i++)t+=\"<li>\"+n.users[i].name,t+=\"<\\/li>\";return t+\"<\\/ul>\"}"); }
public static void TemplateCompiler_Compile_CollectionQuery_Empty() { var values = new Values(); var template = RawUriTemplate.Parse("?f={Collection[]}"); Func <Values, string> compiled = TemplateCompiler.Compile <Values>(template); string result = compiled(values); Assert.Equal("", result); }
public static void TemplateCompiler_Compile_DefaultQuery() { var values = new Values(); var template = RawUriTemplate.Parse("?f={NullableField=Default}"); Func <Values, string> compiled = TemplateCompiler.Compile <Values>(template); string result = compiled(values); Assert.Equal("?f=Default", result); }
public static void TemplateCompiler_Compile_Formattable_Default() { var values = new Values(); var template = RawUriTemplate.Parse("?f={Formattable=Value}"); Func <Values, string> compiled = TemplateCompiler.Compile <Values>(template); string result = compiled(values); Assert.Equal("?f=Value", result); }
public void SimpleTemplateCompilesCorrectly() { var source = FileHelper.GetTemplateSource("simple.html"); var compiler = new TemplateCompiler(source); var minifier = new MinifierCompiler <TemplateCompiler>(compiler); var result = minifier.Compile().ToString(); Assert.AreEqual(result, "function(n){var t=\"\";return t+=\"<div>\"+n.test,t+\"<\\/div>\"}"); }
/** Compile a template */ public virtual CompiledTemplate Compile(string srcName, string name, List <FormalArgument> args, string template, IToken templateToken) // for error location { //System.out.println("TemplateGroup.Compile: "+enclosingTemplateName); TemplateCompiler c = new TemplateCompiler(this); return(c.Compile(srcName, name, args, template, templateToken)); }
public void TestAnonIncludeArgMismatch3() { ITemplateErrorListener errors = new ErrorBuffer(); string template = "<a:{x|foo},{bar}>"; CompiledTemplate code = new TemplateCompiler(new TemplateGroup() { ErrorManager = new ErrorManager(errors) }).Compile(template); string expected = "1:11: anonymous template has 0 arg(s) but mapped across 1 value(s)" + newline; Assert.AreEqual(expected, errors.ToString()); }
/// <inheritdoc /> public ICompilerResult Compile(string name, string content, Action <CompileContext> action = null) { if (string.IsNullOrEmpty(content)) { throw new ArgumentNullException(nameof(content)); } if (string.IsNullOrEmpty(name)) { name = content.GetHashCode().ToString(); } return(Options.CompilerResults[name] = TemplateCompiler.Compile(name, content, Options, action)); }
public void ShouldUseCustomModuleName() { var options = new TemplateCompilerOptions { ModuleName = "myapp", WorkingDir = "/fixtures" }; var compiler = new TemplateCompiler(options); var result = compiler.Compile(new VirtualFile[] {_template1}); Assert.Equal(File.ReadAllText("../../../expected/compiled2.js"), result); }
public void ShouldUseCustomModuleName() { var options = new TemplateCompilerOptions { ModuleName = "myapp", WorkingDir = "/fixtures" }; var compiler = new TemplateCompiler(options); var result = compiler.Compile(new VirtualFile[] { _template1 }); Assert.Equal(File.ReadAllText("../../../expected/compiled2.js"), result); }
public static void TemplateCompiler_Compile_Query() { var values = new Values() { Field = 100 }; var template = RawUriTemplate.Parse("?f={Field}"); Func <Values, string> compiled = TemplateCompiler.Compile <Values>(template); string result = compiled(values); Assert.Equal("?f=100", result); }
public void TestList() { string template = "<[a,b]>"; CompiledTemplate code = new TemplateCompiler(new TemplateGroup()).Compile(template); string asmExpected = "list, load_attr 0, add, load_attr 1, add, write"; string asmResult = code.GetInstructions(); Assert.AreEqual(asmExpected, asmResult); string stringsExpected = "[a, b]"; string stringsResult = code.strings.ToListString(); Assert.AreEqual(stringsExpected, stringsResult); }
public static void TemplateCompiler_Compile_EnumQuery_Flags_Named() { var values = new Values() { Flags = FlagsEnum.First | FlagsEnum.Second }; var template = RawUriTemplate.Parse("?f={Flags.First=first}&s={Flags.Second=baz}"); Func <Values, string> compiled = TemplateCompiler.Compile <Values>(template); string result = compiled(values); Assert.Equal("?f=first&s=baz", result); }
public static void TemplateCompiler_Compile_NotFormattable() { var values = new Values() { NotFormattable = new NotFormattable() }; var template = RawUriTemplate.Parse("?f={NotFormattable}"); Func <Values, string> compiled = TemplateCompiler.Compile <Values>(template); string result = compiled(values); Assert.Equal("?f=Foo%21", result); }
public static void TemplateCompiler_Compile_EnumQuery_Nullable_Named() { var values = new Values() { NormalNullable = NormalEnum.First }; var template = RawUriTemplate.Parse("?f={NormalNullable.First=foo}&s={NormalNullable.Second=bar}"); Func <Values, string> compiled = TemplateCompiler.Compile <Values>(template); string result = compiled(values); Assert.Equal("?f=foo", result); }
public static void TemplateCompiler_Compile_EnumQuery_Named() { var values = new Values() { Normal = NormalEnum.Second }; var template = RawUriTemplate.Parse("?f={Normal.First}&s={Normal.Second=second}&t={Normal.Second}"); Func <Values, string> compiled = TemplateCompiler.Compile <Values>(template); string result = compiled(values); Assert.Equal("?s=second&t", result); }
public static void TemplateCompiler_Compile_NullablePath() { var values = new Values() { NullableField = 100 }; var template = RawUriTemplate.Parse("/test/{NullableField:x}"); Func <Values, string> compiled = TemplateCompiler.Compile <Values>(template); string result = compiled(values); Assert.Equal("/test/64", result); }
public void TestSuperIncludeWithNamedArgs() { string template = "<super.foo(x=a,y={b})>"; CompiledTemplate code = new TemplateCompiler(new TemplateGroup()).Compile(template); string asmExpected = "args, load_attr 0, store_arg 1, new 2 0, store_arg 3, super_new_box_args 4, write"; string asmResult = code.GetInstructions(); Assert.AreEqual(asmExpected, asmResult); string stringsExpected = "[a, x, _sub1, y, foo]"; string stringsResult = code.strings.ToListString(); Assert.AreEqual(stringsExpected, stringsResult); }
public void TestSuperIncludeWithArgs() { string template = "<super.foo(a,{b})>"; CompiledTemplate code = new TemplateCompiler(new TemplateGroup()).Compile(template); string asmExpected = "load_attr 0, new 1 0, super_new 2 2, write"; string asmResult = code.GetInstructions(); Assert.AreEqual(asmExpected, asmResult); string stringsExpected = "[a, _sub1, foo]"; string stringsResult = code.strings.ToListString(); Assert.AreEqual(stringsExpected, stringsResult); }
public void TestAnonZipMap() { string template = "<a,b:{x,y | <x><y>}>"; CompiledTemplate code = new TemplateCompiler(new TemplateGroup()).Compile(template); string asmExpected = "load_attr 0, load_attr 1, null, null, new 2 2, zip_map 2, write"; string asmResult = code.GetInstructions(); Assert.AreEqual(asmExpected, asmResult); string stringsExpected = "[a, b, _sub1]"; string stringsResult = code.strings.ToListString(); Assert.AreEqual(stringsExpected, stringsResult); }
public void TestIf() { string template = "go: <if(name)>hi, foo<endif>"; CompiledTemplate code = new TemplateCompiler(new TemplateGroup()).Compile(template); string asmExpected = "write_str 0, load_attr 1, brf 12, write_str 2"; string asmResult = code.GetInstructions(); Assert.AreEqual(asmExpected, asmResult); string stringsExpected = "[go: , name, hi, foo]"; string stringsResult = code.strings.ToListString(); Assert.AreEqual(stringsExpected, stringsResult); }
public void TestRotMapArg() { string template = "<name:bold(x),italics()>"; CompiledTemplate code = new TemplateCompiler(new TemplateGroup()).Compile(template); string asmExpected = "load_attr 0, null, load_attr 1, new 2 2, null, new 3 1, rot_map 2, write"; string asmResult = code.GetInstructions(); Assert.AreEqual(asmExpected, asmResult); string stringsExpected = "[name, x, bold, italics]"; string stringsResult = code.strings.ToListString(); Assert.AreEqual(stringsExpected, stringsResult); }
public void TestIndirectMapArg() { string template = "<name:(t)(x)>"; CompiledTemplate code = new TemplateCompiler(new TemplateGroup()).Compile(template); string asmExpected = "load_attr 0, load_attr 1, tostr, null, load_attr 2, new_ind 2, map, write"; string asmResult = code.GetInstructions(); Assert.AreEqual(asmExpected, asmResult); string stringsExpected = "[name, t, x]"; string stringsResult = code.strings.ToListString(); Assert.AreEqual(stringsExpected, stringsResult); }
public void TestIndirectIncludeWitArgs() { string template = "hi <(foo)(a,b)>"; CompiledTemplate code = new TemplateCompiler(new TemplateGroup()).Compile(template); string asmExpected = "write_str 0, load_attr 1, tostr, load_attr 2, load_attr 3, new_ind 2, write"; string asmResult = code.GetInstructions(); Assert.AreEqual(asmExpected, asmResult); string stringsExpected = "[hi , foo, a, b]"; string stringsResult = code.strings.ToListString(); Assert.AreEqual(stringsExpected, stringsResult); }
public void TestInclude() { string template = "hi <foo()>"; CompiledTemplate code = new TemplateCompiler(new TemplateGroup()).Compile(template); string asmExpected = "write_str 0, new 1 0, write"; string asmResult = code.GetInstructions(); Assert.AreEqual(asmExpected, asmResult); string stringsExpected = "[hi , foo]"; string stringsResult = code.strings.ToListString(); Assert.AreEqual(stringsExpected, stringsResult); }
public void TestAnonMap() { string template = "<name:{n | <n>}>"; CompiledTemplate code = new TemplateCompiler(new TemplateGroup()).Compile(template); string asmExpected = "load_attr 0, null, new 1 1, map, write"; string asmResult = code.GetInstructions(); Assert.AreEqual(asmExpected, asmResult); string stringsExpected = "[name, _sub1]"; string stringsResult = code.strings.ToListString(); Assert.AreEqual(stringsExpected, stringsResult); }
public void TestZipMapArg() { string template = "<names,phones:bold(x)>"; CompiledTemplate code = new TemplateCompiler(new TemplateGroup()).Compile(template); string asmExpected = "load_attr 0, load_attr 1, null, null, load_attr 2, new 3 3, zip_map 2, write"; string asmResult = code.GetInstructions(); Assert.AreEqual(asmExpected, asmResult); string stringsExpected = "[names, phones, x, bold]"; string stringsResult = code.strings.ToListString(); Assert.AreEqual(stringsExpected, stringsResult); }
public void TestOptionAsTemplate() { string template = "hi <name; separator={, }>"; CompiledTemplate code = new TemplateCompiler(new TemplateGroup()).Compile(template); string asmExpected = "write_str 0, load_attr 1, options, new 2 0, store_option 3, write_opt"; string asmResult = code.GetInstructions(); Assert.AreEqual(asmExpected, asmResult); string stringsExpected = "[hi , name, _sub1]"; string stringsResult = code.strings.ToListString(); Assert.AreEqual(stringsExpected, stringsResult); }
public void TestProp() { string template = "hi <a.b>"; CompiledTemplate code = new TemplateCompiler(new TemplateGroup()).Compile(template); string asmExpected = "write_str 0, load_attr 1, load_prop 2, write"; string asmResult = code.GetInstructions(); Assert.AreEqual(asmExpected, asmResult); string stringsExpected = "[hi , a, b]"; string stringsResult = code.strings.ToListString(); Assert.AreEqual(stringsExpected, stringsResult); }
public void TestRepeatedMap() { string template = "<name:bold():italics()>"; CompiledTemplate code = new TemplateCompiler(new TemplateGroup()).Compile(template); string asmExpected = "load_attr 0, null, new 1 1, map, null, new 2 1, map, write"; string asmResult = code.GetInstructions(); Assert.AreEqual(asmExpected, asmResult); string stringsExpected = "[name, bold, italics]"; string stringsResult = code.strings.ToListString(); Assert.AreEqual(stringsExpected, stringsResult); }
public void TestAnonIncludeArgs() { string template = "<({ a, b | <a><b>})>"; CompiledTemplate code = new TemplateCompiler(new TemplateGroup()).Compile(template); string asmExpected = "new 0 0, tostr, write"; string asmResult = code.GetInstructions(); Assert.AreEqual(asmExpected, asmResult); string stringsExpected = "[_sub1]"; string stringsResult = code.strings.ToListString(); Assert.AreEqual(stringsExpected, stringsResult); }
public void ShouldCombineMultipleFiles() { var options = new TemplateCompilerOptions { Prefix = "/templates", ModuleName = "myapp", WorkingDir = "/fixtures" }; var compiler = new TemplateCompiler(options); var result = compiler.Compile(new VirtualFile[] { _template1, _template2 }); Assert.Equal(File.ReadAllText("../../../expected/compiled4.js"), result); }
private void Compile() { var options = new TemplateCompilerOptions { OutputPath = OutputFile, Prefix = Prefix, ModuleName = ModuleName, WorkingDir = WorkingDir, Standalone = Standalone, LowercaseTemplateName = LowercaseTemplateName }; var compiler = new TemplateCompiler(options); var files = SourceFiles.Select(f => new FileInfoVirtualFile(f.ItemSpec, new FileInfo(f.ItemSpec))).ToArray(); compiler.CompileToFile(files); Log.LogMessage("Compiled {0} templates to {1}", SourceFiles.Length, OutputFile); }
public override BundleResponse GenerateBundleResponse(BundleContext context) { if (context == null) throw new ArgumentNullException("context"); if (!BundleTable.EnableOptimizations) { return new BundleResponse(string.Empty, new List<BundleFile>()); } var bundleFiles = EnumerateFiles(context); var ignoredFiles = context.BundleCollection.IgnoreList.FilterIgnoredFiles(context, bundleFiles); var files = Orderer.OrderFiles(context, ignoredFiles).ToList(); if (string.IsNullOrWhiteSpace(_options.WorkingDir)) { _options.WorkingDir = "/"; } var compiler = new TemplateCompiler(_options); var virtualFiles = files.Select(f => f.VirtualFile).ToArray(); var result = compiler.Compile(virtualFiles); return ApplyTransforms(context, result, files); }
static void showErrors(TemplateCompiler compiler, IConfigSectionNode configRoot) { ConsoleUtils.Warning("Compilation finished with errors"); Console.WriteLine(); ConsoleUtils.Info("Compile unit errors:"); foreach(var erru in compiler.CompileUnitsWithErrors) { ConsoleUtils.Error(string.Format("Unit '{0}'. Type '{1}' Text: '{2}'", erru.TemplateSource.GetName(16), erru.CompilationException.GetType().Name, erru.CompilationException.Message)); } Console.WriteLine(); ConsoleUtils.Info(string.Format("{0} Code compilation errors:", compiler.LanguageName)); foreach(var cerr in compiler.CodeCompilerErrors) { ConsoleUtils.Error( cerr.ToString() ); } }
/// <summary> /// Creates a template with reading from a file. /// </summary> /// <param name="templateFile">Template file.</param> /// <param name="encoding">Encoding used to read /// file content, if NULL the system default encoding /// is used.</param> /// <param name="compilerVersion">Indicates the compiler version to use. /// Such as "v3.5" or "v2.0".</param> /// <exception cref="ArgumentNullException"> /// If <paramref name="templateFile"/> is null or empty. /// </exception> public AtTemplate(string templateFile, Encoding encoding, string compilerVersion) { if (string.IsNullOrEmpty(templateFile)) { throw new ArgumentNullException("templateFile"); } if (string.IsNullOrEmpty(compilerVersion)) { this.compiler = new TemplateCompiler(); } else { this.compiler = new TemplateCompiler(compilerVersion); } this.parser.TemplateFile = Path.GetFullPath(templateFile); this.encoding = (encoding == null ? Encoding.Default : encoding); }
/// <summary> /// Creates a template with specified text. /// </summary> /// <param name="text">Template text.</param> /// <param name="compilerVersion">Indicates the compiler version to use. /// Such as "v3.5" or "v2.0".</param> /// <exception cref="ArgumentNullException"> /// If <paramref name="text"/> is null or empty. /// </exception> public AtTemplate(string text, string compilerVersion) { if (text == null) { throw new ArgumentNullException("templateText"); } if (string.IsNullOrEmpty(compilerVersion)) { this.compiler = new TemplateCompiler(); } else { this.compiler = new TemplateCompiler(compilerVersion); } for (int i = 0; i < text.Length; i++) { char c = text[i]; if (c == '\n') { this.parser.LineEnding = "\n"; break; } else if (c == '\r') { if (i + 1 < text.Length && text[i + 1] == '\n') { this.parser.LineEnding = "\r\n"; } else { this.parser.LineEnding = "\r"; } break; } } this.parser.Reader = new StringReader(text); }
public void ShouldLowercaseTemplateName() { var options = new TemplateCompilerOptions { ModuleName = "", WorkingDir = "/fixtures", LowercaseTemplateName = true }; var template = new TestVirtualFile("/fixtures/TEMPLATE1.html", "test"); var compiler = new TemplateCompiler(options); var result = compiler.Compile(new VirtualFile[] {template}); Assert.Equal(File.ReadAllText("../../../expected/compiled1.js"), result); }
static void showOptions(TemplateCompiler compiler) { const string NONE = "<none>"; Console.WriteLine(); ConsoleUtils.Info("Compiler type: "+compiler.GetType().FullName); ConsoleUtils.Info("Assembly file: "+compiler.AssemblyFileName ?? NONE); ConsoleUtils.Info("Base template type name: "+compiler.BaseTypeName ?? NONE); ConsoleUtils.Info("Compile code: "+compiler.CompileCode ?? NONE); ConsoleUtils.Info("Language name: "+compiler.LanguageName ?? NONE); ConsoleUtils.Info("Namespace: "+compiler.Namespace ?? NONE); foreach(var asm in compiler.ReferencedAssemblies) ConsoleUtils.Info("Referenced assembly: "+asm); ConsoleUtils.Info("Ref assembly search path: "+compiler.ReferencedAssembliesSearchPath ?? NONE ); }
static void writeToDiskCompiledSourceFiles(TemplateCompiler compiler, IConfigSectionNode configRoot) { var ext = configRoot["ext"].AttrByIndex(0).ValueAsString(compiler.LanguageSourceFileExtension); foreach(var cu in compiler) { if (cu.CompilationException!=null) continue; var fs = cu.TemplateSource as FileTemplateStringContentSource; if (fs==null) continue; File.WriteAllText(fs.FileName + ext , cu.CompiledSource); } }
public void ShouldRenderStandaloneModule() { var options = new TemplateCompilerOptions { ModuleName = "", WorkingDir = "/fixtures", Standalone = true }; var compiler = new TemplateCompiler(options); var result = compiler.Compile(new VirtualFile[] {_template1}); Assert.Equal(File.ReadAllText("../../../expected/compiled5.js"), result); }