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);
}
