public static string ExpandMasterPage(IResourceFileReader reader, ResourceInfo info, Regex masterRegex, Regex bodyRegex)
{
var template = info.Content;
var path = info.Path;
var masterPageResourceName = ExtractMasterPageResourceName(reader, info, masterRegex).FirstOrDefault();
template = masterRegex.Replace(template, string.Empty);
if (masterPageResourceName != null)
{
using var stream = reader.GetResourceStream(masterPageResourceName);
if (stream != null)
{
using var sr = new StreamReader(stream);
var master = sr.ReadToEnd();
if (bodyRegex.IsMatch(master))
{
return(bodyRegex.Replace(master, template));
}
else
{
Logger.LogInfo($"Master page {masterPageResourceName} does not contain {{{{!body}}}} element, content in current template {path} is ignored.");
return(master);
}
}
}
return(template);
}
public TemplatePageLoader(IResourceFileReader reader, DocumentBuildContext context, int maxParallelism)
{
_reader = reader;
_maxParallelism = maxParallelism;
_rendererLoader = new RendererLoader(reader, maxParallelism);
_preprocessorLoader = new PreprocessorLoader(reader, context, maxParallelism);
}
public TemplateJintPreprocessor(IResourceFileReader resourceCollection, ResourceInfo scriptResource, DocumentBuildContext context, string name = null)
{
if (!string.IsNullOrWhiteSpace(scriptResource.Content))
{
SetupEngine(resourceCollection, scriptResource, context);
}
ContainsGetOptions = _getOptionsFunc != null;
ContainsModelTransformation = _transformFunc != null;
Path = scriptResource.Path;
Name = name ?? System.IO.Path.GetFileNameWithoutExtension(Path);
}
public TranslationProcess(
IResourceFileReader resourceFileReader,
ILanguageSelector languageSelector,
ITranslationClient translateClient,
IResourceFileWriter resourceFileWriter,
IResourceFileTranslatorUi ui
)
{
ResourceFileReader = resourceFileReader;
LanguageSelector = languageSelector;
TranslationClient = translateClient;
ResourceFileWriter = resourceFileWriter;
Ui = ui;
}
private static IEnumerable <string> ExtractMasterPageResourceName(IResourceFileReader reader, ResourceInfo info, Regex masterRegex)
{
var template = info.Content;
var path = info.Path;
foreach (Match match in masterRegex.Matches(template))
{
var filePath = match.Groups["file"].Value;
foreach (var name in GetResourceName(filePath, path, reader))
{
yield return(name);
Logger.LogWarning($"Multiple definitions for master page found, only the first one {match.Groups[0].Value} takes effect.");
yield break;
}
}
}
private void ImportResources(string fileName, IResourceFileReader resourceFileReader)
{
var workingDirectory = Path.GetDirectoryName(fileName);
var documentName = resourceFileReader.GetDocumentName(fileName);
if (IsDocumentOpen)
{
var fileMatchesDocument = string.Equals(Document.Name, documentName, StringComparison.CurrentCultureIgnoreCase);
if (fileMatchesDocument == false)
{
var closeConfirmation = QuestionBox.Show(Strings.ResourceFileLoad_CloseConfirmation);
switch (closeConfirmation)
{
case MessageBoxResult.Yes:
// Load resources in a new document
if (CloseDocument())
{
break;
}
// User chose not to close current document -> cancel
return;
case MessageBoxResult.No:
// Load resources in opened document
break;
case MessageBoxResult.Cancel:
// Do not load resources
return;
default:
throw new InvalidOperationException();
}
}
}
var document = Document ?? CreateNewDocument(workingDirectory, documentName);
resourceFileReader.LoadResources(document, fileName);
Document = document;
IsDocumentModified = true;
}
public static LiquidTemplateRenderer Create(IResourceFileReader resourceProvider, ResourceInfo info, string name = null)
{
if (info == null)
{
throw new ArgumentNullException(nameof(info));
}
if (info.Content == null)
{
throw new ArgumentNullException(nameof(info.Content));
}
if (info.Path == null)
{
throw new ArgumentNullException(nameof(info.Path));
}
var processedTemplate = ParseTemplateHelper.ExpandMasterPage(resourceProvider, info, MasterPageRegex, MasterPageBodyRegex);
// Guarantee that each time returns a new renderer
// As Dependency is a globally shared object, allow one entry at a time
lock (_locker)
{
try
{
DotLiquid.Template.RegisterTag <Dependency>("ref");
Dependency.PopDependencies();
var liquidTemplate = DotLiquid.Template.Parse(processedTemplate);
var dependencies = Dependency.PopDependencies();
liquidTemplate.Registers.Add("file_system", new ResourceFileSystem(resourceProvider));
return(new LiquidTemplateRenderer(liquidTemplate, processedTemplate, info.Path, resourceProvider, dependencies, name));
}
catch (DotLiquid.Exceptions.SyntaxException e)
{
throw new DocfxException($"Syntax error for template {info.Path}: {e.Message}", e);
}
}
}
public MustacheTemplateRenderer(IResourceFileReader reader, ResourceInfo info, string name = null)
{
if (info == null)
{
throw new ArgumentNullException(nameof(info));
}
if (info.Content == null)
{
throw new ArgumentNullException(nameof(info.Content));
}
if (info.Path == null)
{
throw new ArgumentNullException(nameof(info.Path));
}
Path = info.Path;
Name = name ?? System.IO.Path.GetFileNameWithoutExtension(Path);
_reader = reader;
_resourceTemplateLocator = new ResourceTemplateLocator(reader);
_template = new Nustache.Core.Template();
var processedTemplate = ParseTemplateHelper.ExpandMasterPage(reader, info, MasterPageRegex, MasterPageBodyRegex);
using (var sr = new StringReader(processedTemplate))
{
try
{
_template.Load(sr);
}
catch (Nustache.Core.NustacheException e)
{
throw new DocfxException($"Error in mustache template {info.Path}: {e.Message}", e);
}
}
Dependencies = ExtractDependencyResourceNames(processedTemplate).ToList();
}
public RendererLoader(IResourceFileReader reader, int maxParallelism)
{
_reader = reader;
_maxParallelism = maxParallelism;
}
private Engine SetupEngine(IResourceFileReader resourceCollection, ResourceInfo scriptResource, DocumentBuildContext context)
{
var rootPath = (RelativePath)scriptResource.Path;
var engineCache = new Dictionary <string, Engine>();
var utility = new TemplateUtility(context);
_utilityObject = new
{
resolveSourceRelativePath = new Func <string, string, string>(utility.ResolveSourceRelativePath),
getHrefFromRoot = new Func <string, string, string>(utility.GetHrefFromRoot),
markup = new Func <string, string, string>(utility.Markup),
};
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);
}
if (!engineCache.TryGetValue(s, out Engine 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);
_transformFunc = GetFunc(TransformFuncVariableName, exports);
}
else
{
throw new InvalidPreprocessorException("Invalid 'exports' variable definition. 'exports' MUST be an object.");
}
return(engine);
}
/// <summary>
/// file can start with "./" or using regex
/// </summary>
/// <param name="file"></param>
/// <returns></returns>
public static IEnumerable <string> GetResourceName(string file, string templateName, IResourceFileReader reader)
{
if (string.IsNullOrWhiteSpace(file) || file == "./")
{
yield break;
}
if (file.StartsWith("./", StringComparison.Ordinal))
{
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 reader.Names)
{
if (regex.IsMatch(name))
{
yield return(name);
}
}
}
else
{
yield return(GetRelativeResourceKey(templateName, file));
}
}
public ResourceTemplateLocator(IResourceFileReader reader)
{
_reader = reader;
}
private IEnumerable <string> ParseDependencies(string path, IResourceFileReader reader, IEnumerable <string> raw)
{
return(from item in raw
from name in ParseTemplateHelper.GetResourceName(item, path, reader)
select name);
}
private LiquidTemplateRenderer(DotLiquid.Template liquidTemplate, string template, string path, IResourceFileReader reader, IEnumerable <string> dependencies, string name)
{
_template = liquidTemplate;
Raw = template;
Dependencies = ParseDependencies(path, reader, dependencies).ToList();
Path = path;
Name = name ?? System.IO.Path.GetFileNameWithoutExtension(Path);
}
public ResourceFileSystem(IResourceFileReader reader)
{
_reader = reader;
}
public PreprocessorLoader(IResourceFileReader reader, DocumentBuildContext context, int maxParallelism)
{
_reader = reader;
_maxParallelism = maxParallelism;
_context = context;
}
