@Override public boolean apply(Object input, Map<String, Object> args, PebbleTemplate self, EvaluationContext context, int lineNumber) throws PebbleException { if (input == null) { throw new PebbleException(null, "Can not pass null value to \"even\" test.", lineNumber, self.getName()); } if (input instanceof Integer) { return ((Integer) input) % 2 == 0; } else { return ((Long) input) % 2 == 0; } } }
private Object mergeAsArray(Object arg1, Object arg2, int lineNumber, PebbleTemplate self) throws PebbleException { Class<?> arg1Class = arg1.getClass().getComponentType(); Class<?> arg2Class = arg2.getClass().getComponentType(); if (!arg1Class.equals(arg2Class)) { throw new PebbleException(null, "Currently, only Arrays of the same component class can be merged. Arg1: " + arg1Class .getName() + ", Arg2: " + arg2Class.getName(), lineNumber, self.getName()); } Object output = Array.newInstance(arg1Class, Array.getLength(arg1) + Array.getLength(arg2)); System.arraycopy(arg1, 0, output, 0, Array.getLength(arg1)); System.arraycopy(arg2, 0, output, Array.getLength(arg1), Array.getLength(arg2)); return output; }
@Override public Object apply(Object input, Map<String, Object> args, PebbleTemplate self, EvaluationContext context, int lineNumber) throws PebbleException { String data = input.toString(); if (args.get(ARGUMENT_NAME) == null) { throw new PebbleException(null, MessageFormat.format("The argument ''{0}'' is required.", ARGUMENT_NAME), lineNumber, self.getName()); } Map<?, ?> replacePair = (Map<?, ?>) args.get(ARGUMENT_NAME); for (Entry<?, ?> entry : replacePair.entrySet()) { data = data.replace(entry.getKey().toString(), entry.getValue().toString()); } return data; }
@Override public Object apply(Object input, Map<String, Object> args, PebbleTemplate self, EvaluationContext context, int lineNumber) throws PebbleException { if (input == null) { return null; } String delimiter = (String) args.get(ARGUMENT_NAME_DELIMITER); Number limit = (Number) args.get(ARGUMENT_NAME_LIMIT); if (delimiter == null) { throw new PebbleException(null, "missing delimiter parameter in split filter", lineNumber, self.getName()); } if (limit == null) { return ((String) input).split(delimiter); } return ((String) input).split(delimiter, limit.intValue()); }
private Object applyTemporal(final TemporalAccessor input, PebbleTemplate self, final Locale locale, int lineNumber, final String format) throws PebbleException { final DateTimeFormatter formatter = format != null ? DateTimeFormatter.ofPattern(format, locale) : DateTimeFormatter.ISO_DATE_TIME; try { return new SafeString(formatter.format(input)); } catch (DateTimeException dte) { throw new PebbleException(dte, String.format("Could not parse the string '%s' into a date.", input.toString()), lineNumber, self.getName()); } }
private Object mergeAsList(List<?> arg1, Object arg2, int lineNumber, PebbleTemplate self) throws PebbleException { List<Object> output; if (arg2 instanceof Map) { Map<?, ?> collection2 = (Map<?, ?>) arg2; output = new ArrayList<>(arg1.size() + collection2.size() + 16); output.addAll(arg1); output.addAll(collection2.entrySet()); } else if (arg2 instanceof List) { List<?> collection2 = (List<?>) arg2; output = new ArrayList<>(arg1.size() + collection2.size() + 16); output.addAll(arg1); output.addAll(collection2); } else { throw new PebbleException(null, "Currently, only Maps and Lists can be merged with a List. Arg2: " + arg2.getClass() .getName(), lineNumber, self.getName()); } return output; }
@Override public Object apply(Object input, Map<String, Object> args, PebbleTemplate self, EvaluationContext context, int lineNumber) { if (input == null) { return null; } String value = (String) input; int maxWidth = ((Long) args.get("length")).intValue(); if (maxWidth < 0) { throw new PebbleException(null, "Invalid argument to abbreviate filter; must be greater than zero", lineNumber, self.getName()); } String ellipsis = "..."; int length = value.length(); if (length < maxWidth) { return value; } if (length <= 3) { return value; } if (maxWidth <= 3) { return value.substring(0, maxWidth); } return value.substring(0, Math.max(0, maxWidth - 3)) + ellipsis; }
@Override public Object apply(Object input, Map<String, Object> args, PebbleTemplate self, EvaluationContext context, int lineNumber) throws PebbleException { if (input == null) { return null; } if (!(input instanceof Number)) { throw new PebbleException(null, "The input for the 'NumberFormat' filter has to be a number.", lineNumber, self.getName()); } Number number = (Number) input; Locale locale = context.getLocale(); if (args.get("format") != null) { Format format = new DecimalFormat((String) args.get("format"), new DecimalFormatSymbols(locale)); return format.format(number); } else { NumberFormat numberFormat = NumberFormat.getInstance(locale); return numberFormat.format(number); } }
private Object applyDate(Object dateOrString, final PebbleTemplate self, final Locale locale, int lineNumber, final String format, final String existingFormatString) throws PebbleException { Date date; DateFormat existingFormat; DateFormat intendedFormat; if (existingFormatString != null) { existingFormat = new SimpleDateFormat(existingFormatString, locale); try { date = existingFormat.parse(dateOrString.toString()); } catch (ParseException e) { throw new PebbleException(e, String.format("Could not parse the string '%s' into a date.", dateOrString.toString()), lineNumber, self.getName()); } } else { if (dateOrString instanceof Date) { date = (Date) dateOrString; } else if (dateOrString instanceof Number) { date = new Date(((Number) dateOrString).longValue()); } else { throw new IllegalArgumentException( format("Unsupported argument type: %s (value: %s)", dateOrString.getClass().getName(), dateOrString)); } } intendedFormat = new SimpleDateFormat(format, locale); return new SafeString(intendedFormat.format(date)); }
throw new PebbleException(null, "The increment of the range function must be a number " + increment, lineNumber, self.getName()); throw new PebbleException(null, "The increment of the range function must be different than 0", lineNumber, self.getName()); throw new PebbleException(null, "Arguments of range function must be of type Number or String with " + "a length of 1", lineNumber, self.getName()); throw new PebbleException(null, "The increment of the range function must be different than 0", lineNumber, self.getName()); + "length of 1", lineNumber, self.getName());
@Override public Object apply(Object input, Map<String, Object> args, PebbleTemplate self, EvaluationContext context, int lineNumber) throws PebbleException { if (input == null) { return null; } String glue = null; if (args.containsKey("separator")) { glue = (String) args.get("separator"); } if (input.getClass().isArray()) { List<Object> items = new ArrayList<>(); int length = Array.getLength(input); for (int i = 0; i < length; i++) { items.add(Array.get(input, i)); } return this.join(items, glue); } else if (input instanceof Collection) { return this.join((Collection<?>) input, glue); } else { throw new PebbleException(null, "The 'join' filter expects that the input is either a collection or an array.", lineNumber, self.getName()); } }
@Override public Object apply(Object inputObject, Map<String, Object> args, PebbleTemplate self, EvaluationContext context, int lineNumber) throws PebbleException { if (inputObject == null || inputObject instanceof SafeString) { return inputObject; } String input = StringUtils.toString(inputObject); String strategy = this.defaultStrategy; if (args.get("strategy") != null) { strategy = (String) args.get("strategy"); } if (!this.strategies.containsKey(strategy)) { throw new PebbleException(null, String.format("Unknown escaping strategy [%s]", strategy), lineNumber, self.getName()); } return new SafeString(this.strategies.get(strategy).escape(input)); }
} else if (!(argFrom instanceof Number)) { throw new PebbleException(null, "Argument fromIndex must be a number. Actual type: " + argFrom.getClass().getName(), lineNumber, self.getName()); + argTo.getClass().getName(), lineNumber, self.getName()); throw new PebbleException(null, "Slice filter can only be applied to String, List and array inputs. Actual type was: " + input.getClass().getName(), lineNumber, self.getName()); if (to > length) { throw new PebbleException(null, "toIndex must be smaller than input size: " + length, lineNumber, self.getName()); } else if (from >= to) { throw new PebbleException(null, "toIndex must be greater than fromIndex", lineNumber, self.getName());
@Override public Object apply(Object input, Map<String, Object> args, PebbleTemplate self, EvaluationContext context, int lineNumber) throws PebbleException { Object items = args.get("items"); if (input == null) { if (items == null) { throw new PebbleException(null, "The two arguments to be merged are null", lineNumber, self.getName()); } else { return items; } } else if (items == null) { return input; } // left hand side argument defines resulting type if (input instanceof Map) { return this.mergeAsMap((Map<?, ?>) input, items); } else if (input instanceof List) { return this.mergeAsList((List<?>) input, items, lineNumber, self); } else if (input.getClass().isArray()) { return this.mergeAsArray(input, items, lineNumber, self); } else { throw new PebbleException(null, "The object being filtered is not a Map/List/Array", lineNumber, self.getName()); } }
@Override public boolean apply(Object input, Map<String, Object> args, PebbleTemplate self, EvaluationContext context, int lineNumber) throws PebbleException { if (input == null) { throw new PebbleException(null, "Can not pass null value to \"even\" test.", lineNumber, self.getName()); } if (input instanceof Integer) { return ((Integer) input) % 2 == 0; } else { return ((Long) input) % 2 == 0; } } }
private Object mergeAsArray(Object arg1, Object arg2, int lineNumber, PebbleTemplate self) throws PebbleException { Class<?> arg1Class = arg1.getClass().getComponentType(); Class<?> arg2Class = arg2.getClass().getComponentType(); if (!arg1Class.equals(arg2Class)) { throw new PebbleException(null, "Currently, only Arrays of the same component class can be merged. Arg1: " + arg1Class .getName() + ", Arg2: " + arg2Class.getName(), lineNumber, self.getName()); } Object output = Array.newInstance(arg1Class, Array.getLength(arg1) + Array.getLength(arg2)); System.arraycopy(arg1, 0, output, 0, Array.getLength(arg1)); System.arraycopy(arg2, 0, output, Array.getLength(arg1), Array.getLength(arg2)); return output; }
@Override public Object apply(Object input, Map<String, Object> args, PebbleTemplate self, EvaluationContext context, int lineNumber) throws PebbleException { String data = input.toString(); if (args.get(ARGUMENT_NAME) == null) { throw new PebbleException(null, MessageFormat.format("The argument ''{0}'' is required.", ARGUMENT_NAME), lineNumber, self.getName()); } Map<?, ?> replacePair = (Map<?, ?>) args.get(ARGUMENT_NAME); for (Entry<?, ?> entry : replacePair.entrySet()) { data = data.replace(entry.getKey().toString(), entry.getValue().toString()); } return data; }
@Override public Object apply(Object input, Map<String, Object> args, PebbleTemplate self, EvaluationContext context, int lineNumber) throws PebbleException { if (input == null) { return null; } String delimiter = (String) args.get(ARGUMENT_NAME_DELIMITER); Number limit = (Number) args.get(ARGUMENT_NAME_LIMIT); if (delimiter == null) { throw new PebbleException(null, "missing delimiter parameter in split filter", lineNumber, self.getName()); } if (limit == null) { return ((String) input).split(delimiter); } return ((String) input).split(delimiter, limit.intValue()); }
private Object applyTemporal(final TemporalAccessor input, PebbleTemplate self, final Locale locale, int lineNumber, final String format) throws PebbleException { final DateTimeFormatter formatter = format != null ? DateTimeFormatter.ofPattern(format, locale) : DateTimeFormatter.ISO_DATE_TIME; try { return new SafeString(formatter.format(input)); } catch (DateTimeException dte) { throw new PebbleException(dte, String.format("Could not parse the string '%s' into a date.", input.toString()), lineNumber, self.getName()); } }