private Engine SetupEngine(ResourceCollection resourceCollection, TemplatePreprocessorResource scriptResource, DocumentBuildContext context)
{
var rootPath = (RelativePath)scriptResource.ResourceName;
var engineCache = new Dictionary<string, Engine>();
var utility = new TemplateUtility(context);
_utilityObject = new
{
resolveSourceRelativePath = new Func<string, string, string>(utility.ResolveSourceRelativePath)
};
var engine = CreateDefaultEngine();
var requireAction = new Func<string, object>(
s =>
{
if (!s.StartsWith(RequireRelativePathPrefix))
{
throw new ArgumentException($"Only relative path starting with `{RequireRelativePathPrefix}` is supported in require");
}
var relativePath = (RelativePath)s.Substring(RequireRelativePathPrefix.Length);
s = relativePath.BasedOn(rootPath);
var script = resourceCollection?.GetResource(s);
if (string.IsNullOrWhiteSpace(script))
{
return null;
}
Engine cachedEngine;
if (!engineCache.TryGetValue(s, out cachedEngine))
{
cachedEngine = CreateEngine(engine, RequireFuncVariableName);
engineCache[s] = cachedEngine;
cachedEngine.Execute(script);
}
return cachedEngine.GetValue(ExportsVariableName);
});
engine.SetValue(RequireFuncVariableName, requireAction);
engineCache[rootPath] = engine;
engine.Execute(scriptResource.Content);
var value = engine.GetValue(ExportsVariableName);
if (value.IsObject())
{
var exports = value.AsObject();
GetOptionsFunc = GetFunc(GetOptionsFuncVariableName, exports);
TransformModelFunc = GetFunc(TransformFuncVariableName, exports);
}
else
{
throw new InvalidPreprocessorException("Invalid 'exports' variable definition. 'exports' MUST be an object.");
}
return engine;
}
public MustacheTemplateRenderer(ResourceCollection resourceProvider, string template)
{
if (template == null) throw new ArgumentNullException(nameof(template));
_resourceTemplateLocator = new ResourceTemplateLocator(resourceProvider);
_template = new Nustache.Core.Template();
using (var reader = new StringReader(template))
_template.Load(reader);
Dependencies = ExtractDependentFilePaths(template);
}
public TemplateJintPreprocessor(ResourceCollection resourceCollection, TemplatePreprocessorResource scriptResource, DocumentBuildContext context)
{
if (!string.IsNullOrWhiteSpace(scriptResource.Content))
{
_engine = SetupEngine(resourceCollection, scriptResource, context);
}
else
{
_engine = null;
}
}
/// <summary>
/// TemplateName can be either file or folder
/// 1. If TemplateName is file, it is considered as the default template
/// 2. If TemplateName is a folder, files inside the folder is considered as the template, each file is named after {DocumentType}.{extension}
/// </summary>
/// <param name="templateName"></param>
/// <param name="resourceProvider"></param>
public TemplateProcessor(ResourceCollection resourceProvider, DocumentBuildContext context, int maxParallelism = 0)
{
if (maxParallelism <= 0)
{
maxParallelism = Environment.ProcessorCount;
}
_resourceProvider = resourceProvider;
_templateCollection = new TemplateCollection(resourceProvider, context, maxParallelism);
Tokens = LoadTokenJson(resourceProvider) ?? new Dictionary<string, string>();
}
public static LiquidTemplateRenderer Create(ResourceCollection resourceProvider, string template)
{
if (template == null) throw new ArgumentNullException(nameof(template));
lock (_locker)
{
DotLiquid.Template.RegisterTag<Dependency>("ref");
Dependency.PopDependencies();
var liquidTemplate = DotLiquid.Template.Parse(template);
liquidTemplate.Registers.Add("file_system", new ResourceFileSystem(resourceProvider));
var dependencies = Dependency.PopDependencies();
return new LiquidTemplateRenderer(liquidTemplate, template, dependencies);
}
}
public Template(string name, DocumentBuildContext context, TemplateRendererResource templateResource, TemplatePreprocessorResource scriptResource, ResourceCollection resourceCollection, int maxParallelism)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentNullException(nameof(name));
}
Name = name;
var templateInfo = GetTemplateInfo(Name);
Extension = templateInfo.Extension;
Type = templateInfo.DocumentType;
TemplateType = templateInfo.TemplateType;
_script = scriptResource?.Content;
if (!string.IsNullOrWhiteSpace(_script))
{
ScriptName = Name + ".js";
_preprocessorPool = ResourcePool.Create(() => CreatePreprocessor(resourceCollection, scriptResource, context), maxParallelism);
try
{
using (var preprocessor = _preprocessorPool.Rent())
{
ContainsGetOptions = preprocessor.Resource.GetOptionsFunc != null;
ContainsModelTransformation = preprocessor.Resource.TransformModelFunc != null;
}
}
catch (Exception e)
{
_preprocessorPool = null;
Logger.LogWarning($"{ScriptName} is not a valid template preprocessor, ignored: {e.Message}");
}
}
if (!string.IsNullOrEmpty(templateResource?.Content) && resourceCollection != null)
{
_rendererPool = ResourcePool.Create(() => CreateRenderer(resourceCollection, templateResource), maxParallelism);
ContainsTemplateRenderer = true;
}
if (!ContainsGetOptions && !ContainsModelTransformation && !ContainsTemplateRenderer)
{
Logger.LogWarning($"Template {name} contains neither preprocessor to process model nor template to render model. Please check if the template is correctly defined. Allowed preprocessor functions are [exports.getOptions] and [exports.transform].");
}
Resources = ExtractDependentResources(Name);
}
private static IDictionary<string, string> LoadTokenJson(ResourceCollection resource)
{
var tokenJson = resource.GetResource("token.json");
if (string.IsNullOrEmpty(tokenJson))
{
// also load `global.json` for backward compatibility
// TODO: remove this
tokenJson = resource.GetResource("global.json");
if (string.IsNullOrEmpty(tokenJson))
{
return null;
}
}
return JsonUtility.FromJsonString<Dictionary<string, string>>(tokenJson);
}
public ResourceTemplateLocator(ResourceCollection resourceProvider)
{
_resourceProvider = resourceProvider;
}
public Template(string name, DocumentBuildContext context, TemplateRendererResource templateResource, TemplatePreprocessorResource scriptResource, ResourceCollection resourceCollection, int maxParallelism)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentNullException(nameof(name));
}
Name = name;
var templateInfo = GetTemplateInfo(Name);
Extension = templateInfo.Extension;
Type = templateInfo.DocumentType;
TemplateType = templateInfo.TemplateType;
_script = scriptResource?.Content;
if (!string.IsNullOrWhiteSpace(_script))
{
ScriptName = Name + ".js";
_preprocessorPool = ResourcePool.Create(() => CreatePreprocessor(resourceCollection, scriptResource, context), maxParallelism);
try
{
using (var preprocessor = _preprocessorPool.Rent())
{
ContainsGetOptions = preprocessor.Resource.GetOptionsFunc != null;
ContainsModelTransformation = preprocessor.Resource.TransformModelFunc != null;
}
}
catch (Exception e)
{
_preprocessorPool = null;
Logger.LogWarning($"{ScriptName} is not a valid template preprocessor, ignored: {e.Message}");
}
}
if (!string.IsNullOrEmpty(templateResource?.Content) && resourceCollection != null)
{
_rendererPool = ResourcePool.Create(() => CreateRenderer(resourceCollection, templateResource), maxParallelism);
ContainsTemplateRenderer = true;
}
if (!ContainsGetOptions && !ContainsModelTransformation && !ContainsTemplateRenderer)
{
Logger.LogWarning($"Template {name} contains neither preprocessor to process model nor template to render model. Please check if the template is correctly defined. Allowed preprocessor functions are [exports.getOptions] and [exports.transform].");
}
Resources = ExtractDependentResources(Name);
}
private static ITemplatePreprocessor CreatePreprocessor(ResourceCollection resourceCollection, TemplatePreprocessorResource scriptResource, DocumentBuildContext context)
{
return(new TemplateJintPreprocessor(resourceCollection, scriptResource, context));
}
private IEnumerable <string> ParseDependencies(string templateName, ResourceCollection resource, IEnumerable <string> raw)
{
return(from item in raw
from name in ParseTemplateHelper.GetResourceName(item, templateName, resource)
select name);
}
/// <summary>
/// TemplateName can be either file or folder
/// 1. If TemplateName is file, it is considered as the default template
/// 2. If TemplateName is a folder, files inside the folder is considered as the template, each file is named after {DocumentType}.{extension}
/// </summary>
/// <param name="templateName"></param>
/// <param name="resourceProvider"></param>
public TemplateProcessor(ResourceCollection resourceProvider, int maxParallelism)
{
_resourceProvider = resourceProvider;
_global = LoadGlobalJson(resourceProvider);
Templates = new TemplateCollection(resourceProvider, maxParallelism);
}
private static ITemplatePreprocessor CreatePreprocessor(ResourceCollection resourceCollection, TemplatePreprocessorResource scriptResource, DocumentBuildContext context)
{
return new TemplateJintPreprocessor(resourceCollection, scriptResource, context);
}
public ResourceFileSystem(ResourceCollection resourceProvider)
{
_resourceProvider = resourceProvider;
}
private Engine SetupEngine(ResourceCollection resourceCollection, TemplatePreprocessorResource scriptResource, DocumentBuildContext context)
{
var rootPath = (RelativePath)scriptResource.ResourceName;
var engineCache = new Dictionary <string, Engine>();
var utility = new TemplateUtility(context);
object utilityObject = new
{
resolveSourceRelativePath = new Func <string, string, string>((s1, s2) => utility.ResolveSourceRelativePath(s1, s2))
};
var engine = CreateDefaultEngine();
engine.SetValue(UtilityVariableName, utilityObject);
var requireAction = new Func <string, object>(
s =>
{
if (!s.StartsWith(RequireRelativePathPrefix))
{
throw new ArgumentException($"Only relative path starting with `{RequireRelativePathPrefix}` is supported in require");
}
var relativePath = (RelativePath)s.Substring(RequireRelativePathPrefix.Length);
s = relativePath.BasedOn(rootPath);
var script = resourceCollection?.GetResource(s);
if (string.IsNullOrWhiteSpace(script))
{
return(null);
}
Engine cachedEngine;
if (!engineCache.TryGetValue(s, out cachedEngine))
{
cachedEngine = CreateEngine(engine, RequireFuncVariableName);
engineCache[s] = cachedEngine;
cachedEngine.Execute(script);
}
return(cachedEngine.GetValue(ExportsVariableName));
});
engine.SetValue(RequireFuncVariableName, requireAction);
engineCache[rootPath] = engine;
engine.Execute(scriptResource.Content);
var value = engine.GetValue(ExportsVariableName);
if (value.IsObject())
{
var exports = value.AsObject();
GetOptionsFunc = GetFunc(GetOptionsFuncVariableName, exports);
TransformModelFunc = GetFunc(TransformFuncVariableName, exports);
}
else
{
throw new InvalidPreprocessorException("Invalid 'exports' variable definition. 'exports' MUST be an object.");
}
return(engine);
}
private static ITemplatePreprocessor CreatePreprocessor(ResourceCollection resourceCollection, TemplatePreprocessorResource scriptResource)
{
return(new TemplateJintPreprocessor(resourceCollection, scriptResource));
}
/// <summary>
/// file can start with "./" or using regex
/// </summary>
/// <param name="file"></param>
/// <returns></returns>
public static IEnumerable <string> GetResourceName(string file, string templateName, ResourceCollection resource)
{
if (string.IsNullOrWhiteSpace(file) || file == "./")
{
yield break;
}
if (file.StartsWith("./"))
{
file = file.Substring(2);
}
var regexPatternMatch = IsRegexPatternRegex.Match(file);
if (regexPatternMatch.Groups.Count > 1)
{
file = regexPatternMatch.Groups[1].Value;
var resourceKey = GetRelativeResourceKey(templateName, file);
var regex = new Regex(resourceKey, RegexOptions.IgnoreCase);
foreach (var name in resource.Names)
{
if (regex.IsMatch(name))
{
yield return(name);
}
}
}
else
{
yield return(GetRelativeResourceKey(templateName, file));
}
}
private static Dictionary <string, TemplateBundle> ReadTemplate(ResourceCollection resource, DocumentBuildContext context, int maxParallelism)
{
// type <=> list of template with different extension
var dict = new Dictionary <string, List <Template> >(StringComparer.OrdinalIgnoreCase);
if (resource == null || resource.IsEmpty)
{
return(new Dictionary <string, TemplateBundle>());
}
// Template file ends with .tmpl(Mustache) or .liquid(Liquid)
// Template file naming convention: {template file name}.{file extension}.(tmpl|liquid)
// Only files under root folder is searched
var templates = resource.GetResources(@"[^/]*\.(tmpl|liquid|js)$").ToList();
if (templates != null)
{
foreach (var group in templates.GroupBy(s => Path.GetFileNameWithoutExtension(s.Key), StringComparer.OrdinalIgnoreCase))
{
var currentTemplates =
(from i in @group
select new
{
item = i.Value,
extension = Path.GetExtension(i.Key),
name = i.Key,
} into item
where IsSupportedTemplateFile(item.extension)
select item).ToArray();
var currentScripts =
(from i in @group
select new
{
item = i.Value,
extension = Path.GetExtension(i.Key),
name = i.Key,
} into item
where IsSupportedScriptFile(item.extension)
select item).ToArray();
if (currentTemplates.Length == 0 && currentScripts.Length == 0)
{
continue;
}
// If template file does not exists, while a js script ends with .tmpl.js exists
// we consider .tmpl.js file as a standalone preprocess file
var name = group.Key;
if (currentTemplates.Length == 0)
{
if (name.EndsWith(ScriptTemplateExtension, StringComparison.OrdinalIgnoreCase))
{
name = name.Substring(0, name.Length - ScriptTemplateExtension.Length);
}
else
{
continue;
}
}
var currentTemplate = currentTemplates.FirstOrDefault();
var currentScript = currentScripts.FirstOrDefault();
if (currentTemplates.Length > 1)
{
Logger.Log(LogLevel.Warning, $"Multiple templates for type '{name}'(case insensitive) are found, the one from '{currentTemplate.item + currentTemplate.extension}' is taken.");
}
if (currentScripts.Length > 1)
{
Logger.Log(LogLevel.Warning, $"Multiple template scripts for type '{name}'(case insensitive) are found, the one from '{currentScript.item + currentScript.extension}' is taken.");
}
TemplateRendererResource templateResource =
currentTemplate == null ?
null :
new TemplateRendererResource(currentTemplate.name, currentTemplate.item, name);
TemplatePreprocessorResource templatePrepocessorResource =
currentScript == null ?
null :
new TemplatePreprocessorResource(currentScript.name, currentScript.item);
var template = new Template(name, context, templateResource, templatePrepocessorResource, resource, maxParallelism);
if (dict.TryGetValue(template.Type, out List <Template> templateList))
{
templateList.Add(template);
}
else
{
dict[template.Type] = new List <Template> {
template
};
}
}
}
return(dict.ToDictionary(s => s.Key, s => new TemplateBundle(s.Key, s.Value)));
}
public ResourceFileSystem(ResourceCollection resourceProvider)
{
_resourceProvider = resourceProvider;
}
private static ITemplateRenderer CreateRenderer(ResourceCollection resourceCollection, TemplateRendererResource templateResource)
{
if (templateResource.Type == TemplateRendererType.Liquid)
{
return LiquidTemplateRenderer.Create(resourceCollection, templateResource.Content);
}
else
{
return new MustacheTemplateRenderer(resourceCollection, templateResource.Content);
}
}
private LiquidTemplateRenderer(DotLiquid.Template liquidTemplate, string template, string templateName, ResourceCollection resource, IEnumerable <string> dependencies)
{
_template = liquidTemplate;
Raw = template;
Dependencies = ParseDependencies(templateName, resource, dependencies).ToList();
}
public TemplateCollection(ResourceCollection provider, int maxParallelism) : base(ReadTemplate(provider, maxParallelism), StringComparer.OrdinalIgnoreCase)
{
base.TryGetValue("default", out _defaultTemplate);
}
public ResourceTemplateLocator(ResourceCollection resourceProvider)
{
_resourceProvider = resourceProvider;
}
