Java Template.apply方法代码示例

import com.github.jknack.handlebars.Template; //导入方法依赖的package包/类
String compileWith(Handlebars handlebars) {
  try {
    Template compiledFragment = handlebars.compileInline(unwrappedContent);
    LOGGER.trace("Applying context [{}] to fragment [{}]", fragment.context(),
        StringUtils
            .abbreviate(fragment.content().replaceAll("[\n\r\t]", ""),
                MAX_FRAGMENT_CONTENT_LOG_LENGTH));
    return compiledFragment.apply(
        Context.newBuilder(fragment.context())
            .push(JsonObjectValueResolver.INSTANCE)
            .build());
  } catch (IOException e) {
    LOGGER.error("Could not process fragment [{}]", fragment.content(), e);
    throw new IllegalStateException("Handlebars fragment can not be evaluated correctly.");
  }
}
 

import com.github.jknack.handlebars.Template; //导入方法依赖的package包/类
@Override
public void processView(ViewEngineContext context) throws ViewEngineException {
    Models models = context.getModels();

    try (PrintWriter writer = context.getResponse().getWriter();
        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(models, writer);
    } catch (IOException e) {
        throw new ViewEngineException(e);
    }
}
 

import com.github.jknack.handlebars.Template; //导入方法依赖的package包/类
private String render(final boolean isInline, final String source, final Object data, final String languageCode) {
	try {
		final Template template = isInline ? handlebars.compileInline(source) : handlebars.compile(source);

		final Context context = Context.newBuilder(data).combine(LANGUAGE_PROPERTY, languageCode)
				.resolver(
						ScalaJsonValueResolver.INSTANCE,
						JsonNodeValueResolver.INSTANCE, 
						MapValueResolver.INSTANCE, 
						FieldValueResolver.INSTANCE)
				.build();

		return template.apply(context);

	} catch (Exception e) {
		throw new RuntimeException(e);
	}
}
 

import com.github.jknack.handlebars.Template; //导入方法依赖的package包/类
public String getQuery(String id, Map<String, Object> procedureParameters) {
    Handlebars handlebars = new Handlebars();
    Map<String, Object> parameters = new LinkedHashMap<String, Object>() {};
    try {
        String query = this.getQueries().get(id.toLowerCase());
        Template template = handlebars.compileInline(query);
        for (String key : procedureParameters.keySet()) {
            // TODO: review the search condition
            Boolean escape = (id == "search" || id == "suggestions")? true: false;
            String queryCondition = createQueryCondition(procedureParameters.get(key), escape);
            parameters.put(key, new Handlebars.SafeString(queryCondition));
        }
        LOGGER.info("getQuery; parameters: " + parameters);
        query = template.apply(parameters);
        LOGGER.info("getQuery; Query: " + query);
        return query;
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    }
}
 

import com.github.jknack.handlebars.Template; //导入方法依赖的package包/类
private void ensureReleaseBranch(AdvancedSCMManager amm, String targetBranch) throws AdvancedSCMException, ReleaseBranchInvalidException{
    String releaseFileContent = null;
    if (releaseFileContentTemplate != null && !releaseFileContentTemplate.isEmpty()
            && releaseFilePath != null && !releaseFilePath.isEmpty()) {
        Handlebars handlebars = new Handlebars();
        Context templateContext = Context.newContext(null);
        templateContext.data("release", amm.getReleaseBranch(targetBranch).getReleaseName());
        Template mustacheTemplate;
        try {
            mustacheTemplate = handlebars.compileInline(releaseFileContentTemplate);
            releaseFileContent = mustacheTemplate.apply(templateContext);
        } catch (IOException e) {
            throw new AdvancedSCMException("Error rendering release file content template");
        }
    }
    amm.ensureReleaseBranch(
            targetBranch, releaseFilePath, releaseFileContent,
            "[Jenkins Integration Merge] " + targetBranch + " release", commitUsername);
}
 

import com.github.jknack.handlebars.Template; //导入方法依赖的package包/类
@Override
protected void onRender(Node content, RenderableDefinition definition, RenderingContext renderingContext,
                        Map<String, Object> context, String templateScript) throws RenderException {

    final AppendableWriter out;
    try {
        out = renderingContext.getAppendable();
        AggregationState aggregationState = (AggregationState) context.get("state");
        Node node = aggregationState.getCurrentContentNode();
        Locale locale = aggregationState.getLocale();
        context.put("content", new ChainedContentMap(node, locale));
        Context combinedContext = Context.newBuilder(context)
                .resolver(JavaBeanValueResolver.INSTANCE, FieldValueResolver.INSTANCE, MapValueResolver.INSTANCE)
                .build();
        try {
            Template template = handlebars.compile(templateScript);
            template.apply(combinedContext, out);
        } finally {
            combinedContext.destroy();
        }
    } catch (IOException e) {
        LOGGER.error("Cannot render template", e);
    }
}
 

import com.github.jknack.handlebars.Template; //导入方法依赖的package包/类
private void prepareStatement() throws ReportException {
  try {
    Map<String, String> parameters = new HashMap<String, String>();
    Enumeration<String> paramNames = request.getParameterNames();
    while (paramNames.hasMoreElements()) {
      String key = paramNames.nextElement();
      parameters.put(key, StringEscapeUtils.escapeSql(request.getParameter(key)));
    }
    log.trace("Loading parameters from request: {}", parameters);

    Handlebars handlebars = new Handlebars();

    Template template = handlebars.compileInline(config.getQuery());

    statement = template.apply(parameters);

    log.trace("Loaded statement: {}", statement);
  } catch (IOException ioe) {
    throw new ReportException("Exception templating query", ioe);
  }
}
 

import com.github.jknack.handlebars.Template; //导入方法依赖的package包/类
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);
    }
}
 

import com.github.jknack.handlebars.Template; //导入方法依赖的package包/类
@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);
    }
}
 

import com.github.jknack.handlebars.Template; //导入方法依赖的package包/类
private void writeTemplate(Path path, Template template, Object context) {
  try (final BufferedWriter writer = Files.newBufferedWriter(path, UTF_8)) {
    template.apply(context, writer);
  } catch (Exception e) {
    throw Throwables.propagate(e);
  }
}
 

import com.github.jknack.handlebars.Template; //导入方法依赖的package包/类
private String createGlossary(final Template template, final SubDomain domain) {
    final String glossary;
    try {
        glossary = template.apply(domain);
    } catch (IOException e) {
        log.debug(e.getMessage(), e);
        throw new IllegalStateException(
            format("Glossary Template is not applicable: %s", e.getMessage())
        );
    }
    return glossary;
}
 

import com.github.jknack.handlebars.Template; //导入方法依赖的package包/类
private static void writeReport(@Nonnull String reportName, @Nonnull Map<String,Object> data, @Nonnull Path filePath) throws IOException {
  Template template = initTemplate(reportName);
  String html = template.apply(data);
  try (BufferedWriter writer = Files.newBufferedWriter(filePath, StandardCharsets.UTF_8)) {
    writer.write(html);
  }
}
 

import com.github.jknack.handlebars.Template; //导入方法依赖的package包/类
private void saveMeshUiConfig() {
	File parentFolder = new File(CONFIG_FOLDERNAME);
	if (!parentFolder.exists() && !parentFolder.mkdirs()) {
		throw error(INTERNAL_SERVER_ERROR, "Could not create configuration folder {" + parentFolder.getAbsolutePath() + "}");
	}
	File outputFile = new File(parentFolder, CONF_FILE);
	if (!outputFile.exists()) {
		InputStream ins = getClass().getResourceAsStream("/meshui-templates/mesh-ui-config.hbs");
		if (ins == null) {
			throw error(INTERNAL_SERVER_ERROR, "Could not find mesh-ui config template within classpath.");
		}
		try {
			Handlebars handlebars = new Handlebars();
			Template template = handlebars.compileInline(IOUtils.toString(ins));

			Map<String, Object> model = new HashMap<>();
			int httpPort = Mesh.mesh().getOptions().getHttpServerOptions().getPort();
			model.put("mesh_http_port", httpPort);

			// Prepare render context
			Context context = Context.newBuilder(model).resolver(MapValueResolver.INSTANCE).build();
			FileWriter writer = new FileWriter(outputFile);
			template.apply(context, writer);
			writer.close();
		} catch (Exception e) {
			log.error("Could not save configuration file {" + outputFile.getAbsolutePath() + "}");
		}
	}
}
 

import com.github.jknack.handlebars.Template; //导入方法依赖的package包/类
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);
    }
}
 

import com.github.jknack.handlebars.Template; //导入方法依赖的package包/类
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);
    }
}