com.github.jknack.handlebars.Template Java Examples

protected void applyTemplates(
      List<CapabilityDefinition> capabilities, 
      List<ServiceDefinition> services,
      List<ProtocolDefinition> protocols,
      List<TypeDefinition> types
) throws IOException {
   Map<String, List<? extends Definition>> definitions 
      = new HashMap<String, List<? extends Definition>>();
   definitions.put("capabilities", capabilities);
   definitions.put("services", services);
   definitions.put("protocols", protocols);
   definitions.put("types", types);
         
   Template template = handlebars.compile(templateName);
   OutputStreamWriter writer = new OutputStreamWriter(System.out);
   try {
      template.apply(definitions, writer);
      writer.flush();
   }
   finally {
      writer.close();
   }
}
 

private void writeFeaturePassedReport() throws IOException {
    Template template = bars.compile(FEATURE_OVERVIEW_REPORT);

    List<Feature> onlyPassed = new ArrayList<>(getProcessedFeatures());
    for (Iterator<Feature> it = onlyPassed.listIterator(); it.hasNext(); ) {

        Feature f = it.next();
        if (f.getOverallStatus().equalsIgnoreCase(Constants.FAILED)) {
            it.remove();
        }
    }

    AllFeatureReports allFeatures = new AllFeatureReports(FEATURES_PASSED_OVERVIEW, onlyPassed);
    FileUtils.writeStringToFile(new File(REPORTS_OVERVIEW_PATH + FEATURES_PASSED_HTML),
        template.apply(allFeatures));
}
 

private void writeTestsPassedReport() throws IOException {
    Template template = new Helpers(new Handlebars()).registerHelpers().compile(TEST_OVERVIEW_REPORT);

    List<TestSuiteModel> onlyPassed = new ArrayList<>(processedTestSuites);

    for (Iterator<TestSuiteModel> it = onlyPassed.listIterator(); it.hasNext(); ) {
        TestSuiteModel f = it.next();
        if (f.getOverallStatus().equalsIgnoreCase(Constants.FAILED)) {
            it.remove();
        }
    }

    AllRSpecJUnitReports allTestSuites = new AllRSpecJUnitReports("Passed test suites report", onlyPassed);
    FileUtils.writeStringToFile(new File(TEST_OVERVIEW_PATH + "testsPassed.html"),
        template.apply(allTestSuites));
}
 

private void writeTestsFailedReport() throws IOException {
    Template template = new Helpers(new Handlebars()).registerHelpers().compile(TEST_OVERVIEW_REPORT);

    List<TestSuiteModel> onlyFailed = new ArrayList<>(processedTestSuites);

    for (Iterator<TestSuiteModel> it = onlyFailed.listIterator(); it.hasNext(); ) {
        TestSuiteModel f = it.next();
        if (f.getOverallStatus().equalsIgnoreCase(Constants.PASSED)) {
            it.remove();
        }
    }

    AllRSpecJUnitReports allTestSuites = new AllRSpecJUnitReports("Failed test suites report", onlyFailed);
    FileUtils.writeStringToFile(new File(TEST_OVERVIEW_PATH + "testsFailed.html"),
        template.apply(allTestSuites));
}
 

/**
 * Compile given template.
 *
 * @param defaultTemplateDir template directory
 * @param templateName template name
 * @return Generated template
 * @throws IOException if file read went wrong
 */
public static Template compileTemplate(String defaultTemplateDir, String templateName) throws IOException {
    String templatesDirPath = System.getProperty(GeneratorConstants.TEMPLATES_DIR_PATH_KEY, defaultTemplateDir);
    ClassPathTemplateLoader cpTemplateLoader = new ClassPathTemplateLoader((templatesDirPath));
    FileTemplateLoader fileTemplateLoader = new FileTemplateLoader(templatesDirPath);
    cpTemplateLoader.setSuffix(GeneratorConstants.TEMPLATES_SUFFIX);
    fileTemplateLoader.setSuffix(GeneratorConstants.TEMPLATES_SUFFIX);

    Handlebars handlebars = new Handlebars().with(cpTemplateLoader, fileTemplateLoader);
    handlebars.setStringParams(true);
    handlebars.registerHelpers(StringHelpers.class);
    handlebars.registerHelper("equals", (object, options) -> {
        Object param0 = options.param(0, null);

        if (param0 == null) {
            throw new IllegalArgumentException("found 'null', expected 'string'");
        }
        if (object != null && object.toString().equals(param0.toString())) {
                return options.fn(options.context);
        }

        return options.inverse();
    });

    return handlebars.compile(templateName);
}
 

@Override
public void processView(ViewEngineContext context) throws ViewEngineException {
    handlebars.with(new ServletContextTemplateLoader(servletContext, getViewFolder(context)));

    Map<String, Object> model = new HashMap<>(context.getModels().asMap());
    model.put("request", context.getRequest(HttpServletRequest.class));

    Charset charset = resolveCharsetAndSetContentType(context);

    try (Writer writer = new OutputStreamWriter(context.getOutputStream(), charset);

        InputStream resourceAsStream = servletContext.getResourceAsStream(resolveView(context));
        InputStreamReader in = new InputStreamReader(resourceAsStream, "UTF-8");
        BufferedReader bufferedReader = new BufferedReader(in);) {

        String viewContent = bufferedReader.lines().collect(Collectors.joining());

        Template template = handlebars.compileInline(viewContent);
        template.apply(model, writer);

    } catch (IOException e) {
        throw new ViewEngineException(e);
    }
}
 

File generate(List<Project> projects,
		List<ConfigurationProperty> configurationProperties) {
	PathMatchingResourcePatternResolver resourceLoader = new PathMatchingResourcePatternResolver();
	try {
		Resource[] resources = resourceLoader
				.getResources("templates/spring-cloud/*.hbs");
		List<TemplateProject> templateProjects = templateProjects(projects);
		for (Resource resource : resources) {
			File templateFile = resource.getFile();
			File outputFile = new File(outputFolder, renameTemplate(templateFile));
			Template template = template(templateFile.getName().replace(".hbs", ""));
			Map<String, Object> map = new HashMap<>();
			map.put("projects", projects);
			map.put("springCloudProjects", templateProjects);
			map.put("properties", configurationProperties);
			String applied = template.apply(map);
			Files.write(outputFile.toPath(), applied.getBytes());
			info("Successfully rendered [" + outputFile.getAbsolutePath() + "]");
		}
	}
	catch (IOException e) {
		throw new IllegalStateException(e);
	}
	return outputFolder;
}
 

private void generateHtmlReport(Template templateTestClassReport, TestModel tm) throws IOException {
    for (ClassModel cm : tm.getClasses()) {

        File file = new File(classesSummaryPath + tm.getName() + cm.getName() + ".html");
        if (!file.exists()) {
            file.getParentFile().mkdirs();
            file.createNewFile();
        }
        OutputStream os =
            new FileOutputStream(file);

        PrintWriter rw = new PrintWriter(os);
        rw.print(templateTestClassReport.apply(cm));
        rw.close();
        os.close();
    }
}
 

@Override
public Object eval(String script, ScriptContext context) throws ScriptException {
    final Resource resource = (Resource) context.getBindings(ScriptContext.ENGINE_SCOPE).get(SlingBindings.RESOURCE);
    final PrintWriter out = (PrintWriter) context.getBindings(ScriptContext.ENGINE_SCOPE).get(SlingBindings.OUT);

    try {
        final Handlebars handlebars = setupHandlebars();
        final Template template = handlebars.compileInline(script);
        out.println(template.apply(getData(resource)));
    } catch(IOException ioe) {
        final ScriptException up = new ScriptException("IOException in eval");
        up.initCause(ioe);
        throw up;
    }
    return null;
}
 

@Override
public void processView(ViewEngineContext context) throws ViewEngineException {

    Map<String, Object> model = new HashMap<>(context.getModels().asMap());
    model.put("request", context.getRequest(HttpServletRequest.class));
    
    Charset charset = resolveCharsetAndSetContentType(context);

    try (Writer writer = new OutputStreamWriter(context.getOutputStream(), charset);
         
        InputStream resourceAsStream = servletContext.getResourceAsStream(resolveView(context));
        InputStreamReader in = new InputStreamReader(resourceAsStream, "UTF-8");
        BufferedReader bufferedReader = new BufferedReader(in);) {

        String viewContent = bufferedReader.lines().collect(Collectors.joining());

        Template template = handlebars.compileInline(viewContent);
        template.apply(model, writer);
        
    } catch (IOException e) {
        throw new ViewEngineException(e);
    }
}
 

protected void applyTemplates(List<CapabilityDefinition> capabilities,
      List<ServiceDefinition> services,
      List<ProtocolDefinition> protocols) throws IOException {
   Map<String, List<? extends Definition>> definitions
      = new HashMap<String, List<? extends Definition>>();
   definitions.put("capabilities", capabilities);
   definitions.put("services", services);
   definitions.put("protocols", protocols);

   Template template = handlebars.compile(templateName);
   OutputStreamWriter writer = new OutputStreamWriter(System.out);
   try {
      template.apply(definitions, writer);
      writer.flush();
   }
   finally {
      writer.close();
   }
}
 

private String getBannersFooter(Handlebars handlebars, Map<String, Object> context) {
    try {
        Template template = handlebars.compile("templates/banner_footer");

        context.put("bannerJSON", getActiveBannersJSON());

        return template.apply(context);
    } catch (IOException e) {
        log.warn("IOException while getting banners footer", e);
        return "";
    }
}
 

@Override
public String getFooter() {
    StringBuilder result = new StringBuilder();

    I18n i18n = getI18n(this.getClass().getClassLoader(), "org.sakaiproject.pasystem.impl.i18n.pasystem");
    Handlebars handlebars = loadHandleBars(i18n);

    Session session = SessionManager.getCurrentSession();

    Map<String, Object> context = new HashMap<String, Object>();

    try {
        Template template = handlebars.compile("templates/shared_footer");

        context.put("portalCDNQuery", PortalUtils.getCDNQuery());
        context.put("sakai_csrf_token", session.getAttribute("sakai.csrf.token"));

        result.append(template.apply(context));
    } catch (IOException e) {
        log.warn("IOException while getting footer", e);
        return "";
    }

    result.append(getBannersFooter(handlebars, context));
    result.append(getPopupsFooter(handlebars, context));
    result.append(getTimezoneCheckFooter(handlebars, context));

    return result.toString();
}
 

private Helper<String> getMultipleLinesHelper() {
    return (context, options) -> {
        Options.Buffer buffer = options.buffer();
        String[] lines = context.split("\n");
        Context parent = options.context;
        Template fn = options.fn;
        for (String line : lines) {
            buffer.append(options.apply(fn, parent.combine("@line", line)));
        }
        return buffer;
    };
}
 

private String getPopupsFooter(Handlebars handlebars, Map<String, Object> context) {
    Session session = SessionManager.getCurrentSession();
    User currentUser = UserDirectoryService.getCurrentUser();

    if (currentUser == null || currentUser.getId() == null || "".equals(currentUser.getId())) {
        return "";
    }

    try {
        if (session.getAttribute(POPUP_SCREEN_SHOWN) == null) {
            Popup popup = new PopupForUser(currentUser).getPopup();
            if (popup.isActiveNow()) {
                context.put("popupTemplate", popup.getTemplate());
                context.put("popupUuid", popup.getUuid());
                context.put("popup", true);

                if (currentUser.getId() != null) {
                    // Delivered!
                    session.setAttribute(POPUP_SCREEN_SHOWN, "true");
                }
            }
        }


        Template template = handlebars.compile("templates/popup_footer");
        return template.apply(context);
    } catch (IOException | MissingUuidException e) {
        log.warn("IOException while getting popups footer", e);
        return "";
    }
}
 

private String getTimezoneCheckFooter(Handlebars handlebars, Map<String, Object> context) {
    if (ServerConfigurationService.getBoolean("pasystem.timezone-check", true)) {

        try {
            Template template = handlebars.compile("templates/timezone_footer");

            return template.apply(context);
        } catch (IOException e) {
            log.warn("Timezone footer failed", e);
            return "";
        }
    } else {
        return "";
    }
}
 

@Override
public String render(final String templateName, final TemplateContext templateContext) {
    final Template template = compileTemplate(templateName);
    final Context context = contextFactory.create(handlebars, templateName, templateContext);
    try {
        LOGGER.debug("Rendering template " + templateName);
        return template.apply(context);
    } catch (IOException e) {
        throw new TemplateRenderException("Context could not be applied to template " + templateName, e);
    }
}
 

private void writeTestCaseSummaryReport() throws IOException {
    Template template = new Helpers(new Handlebars()).registerHelpers().compile(TEST_SUMMARY_REPORT);
    for (TestSuiteModel ts : processedTestSuites) {
        String content = template.apply(ts);
        FileUtils.writeStringToFile(new File(TEST_SUMMARY_PATH + ts.getUniqueID() + ".html"),
            content);
    }
}
 

/**
 * Constructs a handlebars template engine
 *
 * @param resourceRoot the resource root
 */
public HandlebarsTemplateEngine(String resourceRoot) {
    TemplateLoader templateLoader = new ClassPathTemplateLoader();
    templateLoader.setPrefix(resourceRoot);
    templateLoader.setSuffix(null);

    handlebars = new Handlebars(templateLoader);

    // Set Guava cache.
    Cache<TemplateSource, Template> cache = CacheBuilder.newBuilder().expireAfterWrite(10, TimeUnit.MINUTES)
            .maximumSize(1000).build();

    handlebars = handlebars.with(new GuavaTemplateCache(cache));
}
 

/**
 * Get/Parse a template source.
 *
 * @param source The template source.
 * @param parser The parser.
 * @return A Handlebars template.
 * @throws IOException If we can't read input.
 */
private Template cacheGet(final TemplateSource source, final Parser parser) throws IOException {
    Pair<TemplateSource, Template> entry = cache.get(source);
    if (entry == null) {
        log.debug("Loading: {}", source);
        entry = Pair.of(source, parser.parse(source));
        cache.put(source, entry);
    } else {
        log.debug("Found in cache: {}", source);
    }
    return entry.getValue();
}
 

private String render(Template template, Object data) {
    try {
        // Can't currently get the jackson module working not sure why.
        Map<String, Object> jsonMap = Json.serializer().mapFromJson(Json.serializer().toString(data));
        if (log.isDebugEnabled()) {
            log.debug("rendering template " + template.filename() + "\n" + Json.serializer().toPrettyString(jsonMap));
        }
        return template.apply(jsonMap);
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}
 

@Test
public void testUnsupportedContext_unknownType() throws Exception {

	Context ctx = Context.newContext( new Object());
	Handlebars handlebars = Mockito.mock( Handlebars.class );
	Template tpl = Mockito.mock(  Template.class  );
	Options opts = new Options(
			handlebars, "helper", TagType.SECTION, ctx, tpl, tpl,
			new Object[ 0 ],
			new HashMap<String,Object>( 0 ));

	AllHelper helper = new AllHelper();
	Assert.assertEquals( "", helper.apply( null, opts ));
}
 

private void writeFeatureSummaryReports() throws IOException {
    Template template = bars.compile(FEATURE_SUMMARY_REPORT);
    for (Feature feature : getProcessedFeatures()) {
        String generatedFeatureHtmlContent = template.apply(feature);
        // generatedFeatureSummaryReports.put(feature.getUniqueID(), generatedFeatureHtmlContent);
        FileUtils.writeStringToFile(new File(REPORTS_SUMMARY_PATH + feature.getUniqueID() + ".html"),
            generatedFeatureHtmlContent);
    }
}
 

private String generateConfigWithParameters(String sourceTemplate, FileSystemType fileSystemType, Map<String, Object> templateObject) throws IOException {
    String defaultPath = fileSystemType.getDefaultPath();
    Template defaultPathTemplate = handlebars.compileInline(defaultPath, HandlebarTemplate.DEFAULT_PREFIX.key(), HandlebarTemplate.DEFAULT_POSTFIX.key());
    templateObject.put("defaultPath", defaultPathTemplate.apply(templateObject));
    Template template = handlebars.compileInline(sourceTemplate, HandlebarTemplate.DEFAULT_PREFIX.key(), HandlebarTemplate.DEFAULT_POSTFIX.key());
    return template.apply(templateObject);
}
 

private void writeTestsPassedReport() throws IOException {
    Template template = new Helpers(new Handlebars()).registerHelpers().compile(TEST_OVERVIEW_REPORT);

    List<TestSuiteModel> onlyPassed = new ArrayList<>(getProcessedTestSuites());
    for (Iterator<TestSuiteModel> it = onlyPassed.listIterator(); it.hasNext(); ) {
        TestSuiteModel f = it.next();
        if (f.getOverallStatus().equalsIgnoreCase(Constants.FAILED)) {
            it.remove();
        }
    }

    AllJUnitReports allTestSuites = new AllJUnitReports("Passed test suites report", onlyPassed);
    FileUtils.writeStringToFile(new File(TEST_OVERVIEW_PATH + "testsPassed.html"),
        template.apply(allTestSuites));
}
 

private void writeTestCaseSummaryReport() throws IOException {
    Template template = new Helpers(new Handlebars()).registerHelpers().compile(TEST_SUMMARY_REPORT);
    for (TestSuiteModel ts : processedTestSuites) {
        String content = template.apply(ts);
        FileUtils.writeStringToFile(new File(TEST_SUMMARY_PATH + ts.getUniqueID() + ".html"),
            content);
    }
}
 

@Override
public void render(Map<String, Object> context, String templateFile, Handler<AsyncResult<Buffer>> handler) {
  try {
    String src = adjustLocation(templateFile);
    TemplateHolder<Template> template = getTemplate(src);

    if (template == null) {
      // either it's not cache or cache is disabled
      int idx = src.lastIndexOf('/');
      String prefix = "";
      String basename = src;
      if (idx != -1) {
        prefix = src.substring(0, idx);
        basename = src.substring(idx + 1);
      }
      synchronized (this) {
        loader.setPrefix(prefix);
        template = new TemplateHolder<>(handlebars.compile(basename), prefix);
      }
      putTemplate(src, template);
    }

    Context engineContext = Context.newBuilder(context).resolver(getResolvers()).build();
    handler.handle(Future.succeededFuture(Buffer.buffer(template.template().apply(engineContext))));
  } catch (Exception ex) {
    handler.handle(Future.failedFuture(ex));
  }
}
 

private void writeTestsByNameOverview() throws IOException {
    Template template = new Helpers(new Handlebars()).registerHelpers().compile(testNameOverviewReport);
    AllTestNgReports allTestNgReports =
        new AllTestNgReports("Tests by name overview report", processedTestNgReports);
    FileUtils.writeStringToFile(new File(testOverviewPath + "testsByNameOverview.html"),
        template.apply(allTestNgReports));
}
 

private void writeTestsByClassOverview() throws IOException {
    Template template = new Helpers(new Handlebars()).registerHelpers().compile(testOverviewReport);
    AllTestNgReports allTestNgReports =
        new AllTestNgReports("Tests by class overview report", processedTestNgReports);
    FileUtils.writeStringToFile(new File(testOverviewPath + TESTS_BY_CLASS_OVERVIEW),
        template.apply(allTestNgReports));
}
 

@Override
public String render(ModelAndView modelAndView) {
    String viewName = modelAndView.getViewName();
    try {
        Template template = handlebars.compile(viewName);
        return template.apply(modelAndView.getModel());
    } catch (IOException e) {
        throw new RuntimeIOException(e);
    }
}