public void should_load_default_templates_from_template_directory( ITemplateLoader templateLoader, DirectoryInfo root, ICraneContext context, IFileManager fileManager, IEnumerable <ITemplate> result) { "Given I have a project root folder" ._(() => { context = ServiceLocator.Resolve <ICraneContext>(); fileManager = ServiceLocator.Resolve <IFileManager>(); context.ProjectRootDirectory = new DirectoryInfo(fileManager.GetTemporaryDirectory()); }); "And a template loader" ._(() => templateLoader = ServiceLocator.Resolve <ITemplateLoader>()); "When I call load" ._(() => result = templateLoader.Load()); "It should load the default source template" ._( () => result.Any( item => item.Name.Equals(CraneConfiguration.DefaultSourceProviderName) && item.TemplateType == TemplateType.Source)); "It should load the default build template" ._( () => result.Any( item => item.Name.Equals(CraneConfiguration.DefaultBuildProviderName) && item.TemplateType == TemplateType.Build)); }
public static void LoadTemplates() { foreach (var clazz in ClassLoaderUtils.GetClassesForPackage()) { ITemplateLoader templateLoader = (ITemplateLoader)Activator.CreateInstance(clazz); templateLoader.Load(); } }
public string Load(TemplateContext context, SourceSpan callerSpan, string templatePath) { return(_baseFileSystem.Load(context, callerSpan, templatePath)); }
public TemplateResolver(IConfiguration configuration, ITemplateLoader loader) { _configuration = configuration; Templates = loader.Load(); }
public object Invoke(TemplateContext context, ScriptNode callerContext, ScriptArray arguments, ScriptBlockStatement blockStatement) { if (arguments.Count == 0) { throw new ScriptRuntimeException(callerContext.Span, string.Format(RS.BadFunctionInvokeArgEmpty, "include")); } string templateName = context.ToString(callerContext.Span, arguments[0]); // If template name is empty, throw an exception if (string.IsNullOrEmpty(templateName)) { // In a liquid template context, we let an include to continue without failing if (context is LiquidTemplateContext) { return(null); } throw new ScriptRuntimeException(callerContext.Span, RS.IncludeNameRequired); } ITemplateLoader templateLoader = context.TemplateLoader; if (templateLoader == null) { throw new ScriptRuntimeException(callerContext.Span, string.Format(RS.NoTemplateLoader, "include")); } string templatePath; try { templatePath = templateLoader.GetPath(context, callerContext.Span, templateName); } catch (Exception ex) when(!(ex is ScriptRuntimeException)) { throw new ScriptRuntimeException(callerContext.Span, string.Format(RS.IncludeResolvePathError, templateName), ex); } // If template name is empty, throw an exception if (templatePath == null) { throw new ScriptRuntimeException(callerContext.Span, string.Format(RS.IncludePathNullError, templateName)); } // Compute a new parameters for the include ScriptArray newParameters = new ScriptArray(arguments.Count - 1); for (int i = 1; i < arguments.Count; i++) { newParameters[i] = arguments[i]; } context.SetValue(ScriptVariable.Arguments, newParameters, true); Template template; if (!context.CachedTemplates.TryGetValue(templatePath, out template)) { string templateText; try { templateText = templateLoader.Load(context, callerContext.Span, templatePath); } catch (Exception ex) when(!(ex is ScriptRuntimeException)) { throw new ScriptRuntimeException(callerContext.Span, string.Format(RS.IncludeLoadError, templateName, templatePath), ex); } if (templateText == null) { throw new ScriptRuntimeException(callerContext.Span, string.Format(RS.IncludeContentEmpty, templateName, templatePath)); } // Clone parser options ParserOptions parserOptions = context.TemplateLoaderParserOptions; LexerOptions lexerOptions = context.TemplateLoaderLexerOptions; template = Template.Parse(templateText, templatePath, parserOptions, lexerOptions); // If the template has any errors, throw an exception if (template.HasErrors) { throw new ScriptParserRuntimeException(callerContext.Span, string.Format(RS.IncludeParseError, templateName, templatePath), template.Messages); } context.CachedTemplates.Add(templatePath, template); } // Make sure that we cannot recursively include a template context.PushOutput(); object result = null; try { context.EnterRecursive(callerContext); result = template.Render(context); context.ExitRecursive(callerContext); } finally { context.PopOutput(); } return(result); }