/*
* Copyright 2013 Martin Kouba
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.trimou.handlebars;
import java.util.Set;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.trimou.engine.MustacheTagType;
import org.trimou.exception.MustacheException;
import org.trimou.exception.MustacheProblem;
import org.trimou.util.Arrays;
import org.trimou.util.Checker;
/**
*
* @author Martin Kouba
* @since 1.5
*/
public final class HelperValidator {
private static final Logger LOGGER = LoggerFactory
.getLogger(HelperValidator.class);
private HelperValidator() {
}
/**
*
* @param helperClazz
* @param definition
* @param paramSize
* @throws MustacheException
* If the helper expects more params
*/
public static void checkParams(Class<? extends Helper> helperClazz,
HelperDefinition definition, int paramSize) {
Checker.checkArgumentNotNull(definition);
Checker.checkArgument(paramSize >= 0,
"Helper may only require zero or more params");
int size = definition.getParameters().size();
if (size < paramSize) {
throw newValidationException(String.format(
"Insufficient number of parameters - expected: %s, current: %s",
paramSize, size), helperClazz, definition);
}
if (size > paramSize) {
LOGGER.trace(
"{} superfluous parameters detected [helper: {}, template: {}, line: {}]",
size - paramSize, helperClazz.getName(),
definition.getTagInfo().getTemplateName(),
definition.getTagInfo().getLine());
}
}
/**
*
* @param helperClazz
* @param definition
* @param allowedTypes
* @throws MustacheException
* If the helper tag type does not match any one of the
* specified types
*/
public static void checkType(Class<? extends Helper> helperClazz,
HelperDefinition definition, MustacheTagType... allowedTypes) {
Checker.checkArgumentsNotNull(definition, allowedTypes);
if (!Arrays.contains(allowedTypes, definition.getTagInfo().getType())) {
throw newValidationException("Unsupported tag type", helperClazz,
definition);
}
}
/**
*
* @param helperClazz
* @param definition
* @param hashSize
* @throws MustacheException
* If the helper expects more hash entries
*/
public static void checkHash(Class<? extends Helper> helperClazz,
HelperDefinition definition, int hashSize) {
Checker.checkArgumentNotNull(definition);
Checker.checkArgument(hashSize >= 0,
"Helper may only require zero or more hash entries");
int size = definition.getHash().size();
if (size < hashSize) {
throw newValidationException(String.format(
"Insufficient number of hash entries - expected: %s, current: %s",
hashSize, size), helperClazz, definition);
}
if (size > hashSize) {
LOGGER.trace(
"{} superfluous hash entries detected [helper: {}, template: {}, line: {}]",
size - hashSize, helperClazz.getName(),
definition.getTagInfo().getTemplateName(),
definition.getTagInfo().getLine());
}
}
/**
*
* @param definition
* @param hashSize
* @see #checkHash(Class, HelperDefinition, int)
*/
public static void checkHash(HelperDefinition definition,
BasicHelper helper) {
// Number of required hash entries
checkHash(helper.getClass(), definition,
helper.numberOfRequiredHashEntries());
if (!helper.getRequiredHashKeys().isEmpty()) {
// Check required hash keys
for (String key : helper.getRequiredHashKeys()) {
if (!definition.getHash().containsKey(key)) {
throw newValidationException(String
.format("Required hash key %s not found", key),
helper.getClass(), definition);
}
}
}
if (definition.getHash().isEmpty()
|| BasicHelper.ANY_HASH_KEY_SUPPORTED
.equals(helper.getSupportedHashKeys())) {
return;
}
// Log a warning message if an unsupported hash key is found
Set<String> supportedHashKeys = helper.getSupportedHashKeys();
for (String key : definition.getHash().keySet()) {
if (!supportedHashKeys.contains(key)) {
LOGGER.info(
"Unsupported hash key detected [key: {}, helper: {}, template: {}, line: {}]",
key, helper.getClass().getName(),
definition.getTagInfo().getTemplateName(),
definition.getTagInfo().getLine());
}
}
}
public static MustacheException newValidationException(String msg,
Class<? extends Helper> helperClazz, HelperDefinition definition) {
return new MustacheException(
MustacheProblem.COMPILE_HELPER_VALIDATION_FAILURE,
msg + " [helper: %s, template: %s, line: %s]",
helperClazz.getName(),
definition.getTagInfo().getTemplateName(),
definition.getTagInfo().getLine());
}
}