Java Handlebars类代码示例

import com.github.jknack.handlebars.Handlebars; //导入依赖的package包/类
private static Builder compileHandlebarsAndApply(final Handlebars handlebars,
                                                 final String templateName,
                                                 final Map<String, Object> model,
                                                 final Function<String, Builder> method) {
    Preconditions.checkArgument(StringUtils.hasText(templateName), "Template name not specified");

    final Context context = Context.newBuilder(model).combine(model).build();
    try {
        return method.apply(handlebars.compile(templateName).apply(context));
    } catch (IOException e) {
        throw new RuntimeException("Could not render template", e);

    } finally {
        context.destroy();
    }
}
 

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

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

import com.github.jknack.handlebars.Handlebars; //导入依赖的package包/类
@Override
public CharSequence apply(final String path, final Options options)
        throws IOException {
    notEmpty(path, "found: '%s', expected 'template path'", path);
    String wrapperName = options.hash("wrapper", "anonymous");
    final JsWrapper wrapper = JsWrapper.wrapper(wrapperName);
    notNull(wrapper, "found '%s', expected: '%s'",
            wrapperName, StringUtils.join(JsWrapper.values(), ", ").toLowerCase());

    Handlebars handlebars = options.handlebars;
    String name = path;
    if (name.startsWith("/")) {
        name = name.substring(1);
    }
    if (wrapper == JsWrapper.AMD) {
        name += handlebars.getLoader().getSuffix();
    }
    Template template = handlebars.compile(path);
    String precompiled = template.toJavaScript();
    return new Handlebars.SafeString(wrapper.wrap(name, precompiled));
}
 

import com.github.jknack.handlebars.Handlebars; //导入依赖的package包/类
@Override
public CharSequence applyWithCurrentTemplate(final String path, final Options options) {
    notEmpty(path, "found: '%s', expected 'template path'", path);
    String wrapperName = options.hash("wrapper", "anonymous");
    final JsWrapper wrapper = JsWrapper.wrapper(wrapperName);
    notNull(wrapper, "found '%s', expected: '%s'",
            wrapperName, StringUtils.join(JsWrapper.values(), ", ").toLowerCase());

    Handlebars handlebars = options.handlebars;
    String name = StringUtils.substringBeforeLast(path,".");
    if (name.startsWith("/")) {
        name = name.substring(1);
    }
    if (wrapper == JsWrapper.AMD) {
        name += handlebars.getLoader().getSuffix();
    }
    Template template = options.fn;
    String precompiled = template.toJavaScript();
    return new Handlebars.SafeString(wrapper.wrap(name, precompiled));
}
 

import com.github.jknack.handlebars.Handlebars; //导入依赖的package包/类
public CharSequence radioGroup(Object obj, String field, String values, Options options) {
	StringBuilder radios = new StringBuilder();
	String labelClass = options.hash("labelClass");

	String tmpl = "<label class=\"%s\"><input type=\"radio\" name=\"%s\" value=\"%s\"%s>%s</label>";

	for(String value : values.split(",")) {
		try {
			String checked = "";
			if(BeanUtils.getSimpleProperty(obj, field).equalsIgnoreCase(value)) {
				checked = " checked";
			}
			radios.append(String.format(tmpl, labelClass, field, value, checked, WordUtils.capitalize(value)));
		} catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
			log.warn("Could not find property {} on object {}", field, obj);
		}
	}

	return new Handlebars.SafeString(radios);
}
 

import com.github.jknack.handlebars.Handlebars; //导入依赖的package包/类
private CharSequence link(Image image, String type, Options options) {
	boolean modal = options.hash("lightbox", true);
	String figureClass = options.hash("figure-class");
	String imgTag = String.format("<img src=\"%s\" title=\"%s\"/>",
			imageUrl(image, type),
			image.getTitle() == null ? "" : image.getTitle());

	if(figureClass != null) {
		imgTag = String.format("<figure class=\"%s\">%s</figure>", figureClass, imgTag);
	}

	if(modal) {
		imgTag = String.format("<a href=\"%s\" title=\"%s\">%s</a>",
				imageUrl(image, "fullsize"), generateCaption(image), imgTag);
	}

	return new Handlebars.SafeString(imgTag);
}
 

import com.github.jknack.handlebars.Handlebars; //导入依赖的package包/类
Context apply(String s, Map<String, String> args, boolean isBatch, Handle dbiHandle, Map<String, String> parameters, NameList names) throws IOException {
	
	ObjectReader mapper = new ObjectMapper().readerFor(Object.class);

       HashMap<String, Object> parsedArgs = new HashMap<>();
       for (Map.Entry<String, String> a : args.entrySet()) {
           try {
               parsedArgs.put(a.getKey(), mapper.readValue(a.getValue()));
           } catch (Exception e) {
               parsedArgs.put(a.getKey(), a.getValue());
           }
       }

       Handlebars handlebars = new Handlebars().with(EscapingStrategy.NOOP);
       this.parameters = parameters;
       StringHelper.register(handlebars);
       StringHelpers.register(handlebars);
       FilterHelper.register(handlebars);
       ConditionalHelper.register(handlebars);
       new ParameterHelper(parameters, names).registerHelper(handlebars);
       eh = new EachHelper(parameters, names, isBatch, dbiHandle).registerHelper(handlebars);
       template = handlebars.compileInline(s);
       sql = template.apply(parsedArgs);
       
       return this;     		
}
 

import com.github.jknack.handlebars.Handlebars; //导入依赖的package包/类
protected String apply(String s, Object context) throws IOException {
       Handlebars handlebars = new Handlebars().with(EscapingStrategy.NOOP);
       StringHelper.register(handlebars);
       StringHelpers.register(handlebars);
       FilterHelper.register(handlebars);
       ConditionalHelper.register(handlebars);
       parameters = new LinkedHashMap<String, String>();
       names = new NameList() {
       	int i = 0;
   	    protected String next() {
   	    	return "p"+(i++);
   	    }       	
       };
       new ParameterHelper(parameters, names).registerHelper(handlebars);
   	return handlebars.compileInline(s).apply(
   		(context!=null && context instanceof TestUtils.MapBuilder)?
			((TestUtils.MapBuilder)context).build() : context);
}
 

import com.github.jknack.handlebars.Handlebars; //导入依赖的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.Handlebars; //导入依赖的package包/类
@Override
public CharSequence apply(String fragmentName, Options options) throws IOException {
    if ((fragmentName == null) || fragmentName.isEmpty()) {
        throw new IllegalArgumentException("Fragment name cannot be null or empty.");
    }

    Lookup lookup = options.data(HbsRenderable.DATA_KEY_LOOKUP);
    RequestLookup requestLookup = options.data(HbsRenderable.DATA_KEY_REQUEST_LOOKUP);
    Optional<Fragment> fragment = lookup.getFragmentIn(requestLookup.tracker().getCurrentComponentName(),
                                                       fragmentName);
    if (!fragment.isPresent()) {
        throw new IllegalArgumentException(
                "Fragment '" + fragmentName + "' does not exists in component '" +
                        requestLookup.tracker().getCurrentComponentName() + "' or in its dependencies.");
    }

    Model model = new ContextModel(options.context, options.hash);
    API api = options.data(HbsRenderable.DATA_KEY_API);
    String content = fragment.get().render(model, lookup, requestLookup, api);
    return new Handlebars.SafeString(content);
}
 

import com.github.jknack.handlebars.Handlebars; //导入依赖的package包/类
static Handlebars create(final List<TemplateLoader> templateLoaders, final I18nResolver i18NResolver, final I18nIdentifierFactory i18nIdentifierFactory) {
    if (templateLoaders.isEmpty()) {
        throw new SunriseConfigurationException("Could not initialize Handlebars due to missing template loaders configuration", CONFIG_TEMPLATE_LOADERS);
    }
    logger.info("Provide Handlebars: template loaders [{}]]",
            templateLoaders.stream().map(TemplateLoader::getPrefix).collect(joining(", ")));
    final TemplateLoader[] loaders = templateLoaders.toArray(new TemplateLoader[templateLoaders.size()]);
    final Handlebars handlebars = new Handlebars()
            .with(loaders)
            .with(new HighConcurrencyTemplateCache())
            .infiniteLoops(true);
    handlebars.registerHelper("i18n", new HandlebarsI18nHelper(i18NResolver, i18nIdentifierFactory));
    handlebars.registerHelper("cms", new HandlebarsCmsHelper());
    handlebars.registerHelper("json", new HandlebarsJsonHelper<>());
    return handlebars;
}
 

import com.github.jknack.handlebars.Handlebars; //导入依赖的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.Handlebars; //导入依赖的package包/类
public static void main(String[] args) throws Exception {
	App app = App.configure(conf -> {
		conf.set(Config.RENDERER_REPOSITORY, new HandleBarsRepo());
		return conf;
	});

	// see. https://github.com/jknack/handlebars.java
	Handlebars engine = new Handlebars();
	Template t = engine.compileInline("Hello {{this}}!");

	// use handlebars simply
	app.get("/bars",
			(req, res) -> res.render("john", Renderer.of(t::apply)));

	// read template from templates/say/hello.html
	app.get("/hello",
			(req, res) -> res.render(new User("peter"), "say/hello"));
	
	app.listen().addShutdownHook();
}