pax_global_header 0000666 0000000 0000000 00000000064 12477734511 0014525 g ustar 00root root 0000000 0000000 52 comment=627668d1f52d93313747b7353815d996cfca80a3
jinjava-jinjava-2.0.0/ 0000775 0000000 0000000 00000000000 12477734511 0014566 5 ustar 00root root 0000000 0000000 jinjava-jinjava-2.0.0/.gitignore 0000664 0000000 0000000 00000000175 12477734511 0016561 0 ustar 00root root 0000000 0000000 # Eclipse
.classpath
.project
.settings/
.factorypath
# Intellij
.idea/
*.iml
*.iws
# Mac
.DS_Store
# Maven
log/
target/
jinjava-jinjava-2.0.0/.gitmodules 0000664 0000000 0000000 00000000314 12477734511 0016741 0 ustar 00root root 0000000 0000000 [submodule "benchmark/liquid"]
path = benchmark/liquid
url = https://github.com/Shopify/liquid.git
[submodule "benchmark/jinja2"]
path = benchmark/jinja2
url = https://github.com/mitsuhiko/jinja2.git
jinjava-jinjava-2.0.0/.travis.yml 0000664 0000000 0000000 00000000133 12477734511 0016674 0 ustar 00root root 0000000 0000000 language: java
jdk:
- oraclejdk8
install: mvn install -DskipTests=false -Dgpg.skip=true
jinjava-jinjava-2.0.0/CHANGES.md 0000664 0000000 0000000 00000006745 12477734511 0016174 0 ustar 00root root 0000000 0000000 # Jinjava Releases #
### Version 2.0.0 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.hubspot.jinjava%22%20AND%20v%3A%222.0.0%22)) ###
* 2.0.x requires JDK 8, as it contains some critical fixes to date formatting for certain languages (i.e. Finnish months)
* The 2.0.x release has some significant refactorings in the parsing code:
** nests the .parse package under the existing .tree package
** consolidating the token scanner logic, updating the node tree parser
* future updates will be able to detect more specific template syntax errors than was previously possible.
* NodeList has been removed in favor of the native JDK LinkedList implementation
### Version 1.0.9 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.hubspot.jinjava%22%20AND%20v%3A%221.0.9%22)) ###
* changed how validation of object properties happens; previously, jinjava would add TemplateErrors for unknown properties at the context root (i.e. 'foo') and when the property existed but the value was null (i.e. 'foo.bar == null'). the new logic will only add an error when the property isn't found on the given base object.
* creating richer exception hierarchy for more detailed and specific error messaging
* the simple Jinjava.render(String, Map) method will now return a container exception containing all errors encountered during rendering, instead of simply the first one
### Version 1.0.8 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.hubspot.jinjava%22%20AND%20v%3A%221.0.8%22)) ###
* fixed issue with multiple includes of the same file in a template
### Version 1.0.7 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.hubspot.jinjava%22%20AND%20v%3A%221.0.7%22)) ###
* added logic to avoid include/import cycles in include and import tags
### Version 1.0.6 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.hubspot.jinjava%22%20AND%20v%3A%221.0.6%22)) ###
* fixed issue in strftimeformatter with format strings ending in literals
* updated expression resolver to return blank strings rather than false for exception cases
### Version 1.0.5 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.hubspot.jinjava%22%20AND%20v%3A%221.0.5%22)) ###
* fixed issue in sort filter when using nested attribute
### Version 1.0.4 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.hubspot.jinjava%22%20AND%20v%3A%221.0.4%22)) ###
* Fix issue where HelperStringTokenizer could return a null last value
* Added ```unless``` tag, for inverse-if functionality
* Implemented ```from``` tag for importing specific named variables from another context
### Version 1.0.3 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.hubspot.jinjava%22%20AND%20v%3A%221.0.3%22)) ###
* Adding python methods dict.update() and date.isoformat() to analogous types
### Version 1.0.2 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.hubspot.jinjava%22%20AND%20v%3A%221.0.2%22)) ###
* Fix issue with closure scope lookups within macro functions
### Version 1.0.1 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.hubspot.jinjava%22%20AND%20v%3A%221.0.1%22)) ###
* Properly implement call tag syntax
* Fix issue with declaring a list as a default method parameter value
* Adding string split built-in filter
### Version 1.0.0 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.hubspot.jinjava%22%20AND%20v%3A%221.0.0%22)) ###
* Initial Public Release
jinjava-jinjava-2.0.0/CONTRIBUTING.md 0000664 0000000 0000000 00000002164 12477734511 0017022 0 ustar 00root root 0000000 0000000 # Contributing to Jinjava
If you would like to contribute code you can do so through GitHub by forking the repository and sending a pull request.
When submitting code, please make every effort to follow existing conventions and style in order to keep the code as readable as possible.
## License
By contributing your code, you agree to license your contribution under the terms of the APLv2: https://github.com/HubSpot/jinjava/blob/master/LICENSE
All files are released with the Apache 2.0 license.
If you are adding a new file it should have a header like this:
```
/**
* 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.
*/
```
jinjava-jinjava-2.0.0/LICENSE 0000664 0000000 0000000 00000026075 12477734511 0015605 0 ustar 00root root 0000000 0000000 Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "{}"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright {yyyy} {name of copyright owner}
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.
jinjava-jinjava-2.0.0/README.md 0000664 0000000 0000000 00000005312 12477734511 0016046 0 ustar 00root root 0000000 0000000 jinjava [](https://travis-ci.org/HubSpot/jinjava) [](https://maven-badges.herokuapp.com/maven-central/com.hubspot.jinjava/jinjava)
=======
Java-based template engine based on django template syntax, adapted to render jinja templates (at least the subset of jinja in use in HubSpot content). Currently used in production to render thousands of websites with hundreds of millions of page views per month on the [HubSpot COS](http://www.hubspot.com/products/sites).
*Note*: Requires Java >= 8. Originally forked from [jangod](https://code.google.com/p/jangod/).
Get it:
-------
```xml
com.hubspot.jinjavajinjava2.0.0-SNAPSHOT
```
Example usage:
--------------
my-template.html:
```html
*
* @author jstehler
*
*/
public class Jinjava {
private ExpressionFactory expressionFactory;
private ResourceLocator resourceLocator;
private Context globalContext;
private JinjavaConfig globalConfig;
/**
* Create a new Jinjava processor instance with the default global config
*/
public Jinjava() {
this(new JinjavaConfig());
}
/**
* Create a new jinjava processor instance with the specified global config
*
* @param globalConfig used for all render operations performed by this processor instance
*/
public Jinjava(JinjavaConfig globalConfig) {
this.globalConfig = globalConfig;
this.globalContext = new Context();
Properties expConfig = new Properties();
expConfig.setProperty(TreeBuilder.class.getName(), ExtendedSyntaxBuilder.class.getName());
TypeConverter converter = new TruthyTypeConverter();
this.expressionFactory = new ExpressionFactoryImpl(expConfig, converter);
this.resourceLocator = new CascadingResourceLocator(new ClasspathResourceLocator(), new FileLocator());
}
/**
* Set the object responsible for locating templates referenced in other templates
* @param resourceLocator the locator to use for loading all templates
*/
public void setResourceLocator(ResourceLocator resourceLocator) {
this.resourceLocator = resourceLocator;
}
/**
* @return The EL factory used to process expressions in templates by this instance.
*/
public ExpressionFactory getExpressionFactory() {
return expressionFactory;
}
/**
* @return The global config used as a base for all render operations performed by this instance.
*/
public JinjavaConfig getGlobalConfig() {
return globalConfig;
}
/**
* The global render context includes such things as the base set of tags, filters, exp tests and functions,
* used as a base by all render operations performed by this instance
*
* @return the global render context
*/
public Context getGlobalContext() {
return globalContext;
}
public ResourceLocator getResourceLocator() {
return resourceLocator;
}
/**
* Render the given template using the given context bindings.
*
* @param template jinja source template
* @param bindings map of objects to put into scope for this rendering action
* @return the rendered template
* @throws InterpretException if any syntax errors were encountered during rendering
*/
public String render(String template, Map bindings) {
RenderResult result = renderForResult(template, bindings);
Collection fatalErrors = Collections2.filter(result.getErrors(), new Predicate() {
@Override
public boolean apply(TemplateError input) {
return input.getSeverity() == ErrorType.FATAL;
}
});
if(!fatalErrors.isEmpty()) {
throw new FatalTemplateErrorsException(template, fatalErrors);
}
return result.getOutput();
}
/**
* Render the given template using the given context bindings. This method returns some
* metadata about the render process, including any errors which may have been encountered
* such as unknown variables or syntax errors.
*
* This method will not throw any exceptions; it is up to the caller to inspect the renderResult.errors
* collection if necessary / desired.
*
* @param template jinja source template
* @param bindings map of objects to put into scope for this rendering action
* @return result object containing rendered output, render context, and any encountered errors
*/
public RenderResult renderForResult(String template, Map bindings) {
return renderForResult(template, bindings, globalConfig);
}
/**
* Render the given template using the given context bindings. This method returns some
* metadata about the render process, including any errors which may have been encountered
* such as unknown variables or syntax errors.
*
* This method will not throw any exceptions; it is up to the caller to inspect the renderResult.errors
* collection if necessary / desired.
*
* @param template jinja source template
* @param bindings map of objects to put into scope for this rendering action
* @param renderConfig used to override specific config values for this render operation
* @return result object containing rendered output, render context, and any encountered errors
*/
public RenderResult renderForResult(String template, Map bindings, JinjavaConfig renderConfig) {
Context context = new Context(globalContext, bindings);
JinjavaInterpreter parentInterpreter = JinjavaInterpreter.getCurrent();
if(parentInterpreter != null) {
renderConfig = parentInterpreter.getConfig();
}
JinjavaInterpreter interpreter = new JinjavaInterpreter(this, context, renderConfig);
JinjavaInterpreter.pushCurrent(interpreter);
try {
String result = interpreter.render(template);
return new RenderResult(result, interpreter.getContext(), interpreter.getErrors());
}
catch(InterpretException e) {
return new RenderResult(TemplateError.fromSyntaxError(e), interpreter.getContext(), interpreter.getErrors());
}
catch(Exception e) {
return new RenderResult(TemplateError.fromException(e), interpreter.getContext(), interpreter.getErrors());
}
finally {
JinjavaInterpreter.popCurrent();
}
}
}
jinjava-jinjava-2.0.0/src/main/java/com/hubspot/jinjava/JinjavaConfig.java 0000664 0000000 0000000 00000003204 12477734511 0026460 0 ustar 00root root 0000000 0000000 /**********************************************************************
Copyright (c) 2014 HubSpot Inc.
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 com.hubspot.jinjava;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.time.ZoneId;
import java.time.ZoneOffset;
import java.util.Locale;
public class JinjavaConfig {
private final Charset charset;
private final Locale locale;
private final ZoneId timeZone;
private final int maxRenderDepth;
public JinjavaConfig() {
charset = StandardCharsets.UTF_8;
locale = Locale.ENGLISH;
timeZone = ZoneOffset.UTC;
maxRenderDepth = 10;
}
public JinjavaConfig(Charset charset, Locale locale, ZoneId timeZone, int maxRenderDepth) {
this.charset = charset;
this.locale = locale;
this.timeZone = timeZone;
this.maxRenderDepth = maxRenderDepth;
}
public Charset getCharset() {
return charset;
}
public Locale getLocale() {
return locale;
}
public ZoneId getTimeZone() {
return timeZone;
}
public int getMaxRenderDepth() {
return maxRenderDepth;
}
} jinjava-jinjava-2.0.0/src/main/java/com/hubspot/jinjava/el/ 0000775 0000000 0000000 00000000000 12477734511 0023506 5 ustar 00root root 0000000 0000000 jinjava-jinjava-2.0.0/src/main/java/com/hubspot/jinjava/el/ExpressionResolver.java 0000664 0000000 0000000 00000005451 12477734511 0030237 0 ustar 00root root 0000000 0000000 package com.hubspot.jinjava.el;
import java.util.Objects;
import javax.el.ELContext;
import javax.el.ELException;
import javax.el.ExpressionFactory;
import javax.el.PropertyNotFoundException;
import javax.el.ValueExpression;
import org.apache.commons.lang3.StringUtils;
import com.hubspot.jinjava.interpret.InterpretException;
import com.hubspot.jinjava.interpret.JinjavaInterpreter;
import com.hubspot.jinjava.interpret.TemplateError;
import com.hubspot.jinjava.interpret.TemplateSyntaxException;
import com.hubspot.jinjava.interpret.TemplateError.ErrorReason;
import com.hubspot.jinjava.interpret.TemplateError.ErrorType;
import com.hubspot.jinjava.util.JinjavaPropertyNotResolvedException;
import de.odysseus.el.tree.TreeBuilderException;
public class ExpressionResolver {
private JinjavaInterpreter interpreter;
private ExpressionFactory expressionFactory;
private ELContext elContext;
public ExpressionResolver(JinjavaInterpreter interpreter, ELContext elContext) {
this.interpreter = interpreter;
this.expressionFactory = interpreter.getExpressionFactory();
this.elContext = elContext;
}
public Object resolve(String expr, int lineNumber) {
interpreter.setLineNumber(lineNumber);
CharSequence cleanExpr = Objects.toString(expr, "").trim();
if (StringUtils.isBlank(cleanExpr)) {
return "";
}
try {
ValueExpression valueExp = expressionFactory.createValueExpression(
elContext, new StringBuilder("#{").append(cleanExpr).append('}')
.toString(), Object.class);
return valueExp.getValue(elContext);
} catch (PropertyNotFoundException e) {
interpreter.addError(new TemplateError(ErrorType.WARNING, ErrorReason.UNKNOWN, e.getMessage(), "", lineNumber, e));
} catch (JinjavaPropertyNotResolvedException e) {
interpreter.addError(TemplateError.fromUnknownProperty(e.getBase(), e.getProperty(), lineNumber));
} catch (TreeBuilderException e) {
interpreter.addError(TemplateError.fromException(new TemplateSyntaxException(expr,
"Error parsing '" + expr + "': " + StringUtils.substringAfter(e.getMessage(), "': "), lineNumber, e)));
} catch (ELException e) {
if(e.getCause() instanceof JinjavaPropertyNotResolvedException) {
JinjavaPropertyNotResolvedException jpe = (JinjavaPropertyNotResolvedException) e.getCause();
interpreter.addError(TemplateError.fromUnknownProperty(jpe.getBase(), jpe.getProperty(), lineNumber));
}
else {
interpreter.addError(TemplateError.fromException(new TemplateSyntaxException(expr, e.getMessage(), lineNumber, e)));
}
} catch (Exception e) {
interpreter.addError(TemplateError.fromException(new InterpretException(
String.format("Error resolving expression: [%s]", expr), e, lineNumber)));
}
return "";
}
}
jinjava-jinjava-2.0.0/src/main/java/com/hubspot/jinjava/el/ExtendedSyntaxBuilder.java 0000664 0000000 0000000 00000001660 12477734511 0030632 0 ustar 00root root 0000000 0000000 package com.hubspot.jinjava.el;
import com.hubspot.jinjava.el.ext.ExtendedParser;
import de.odysseus.el.tree.impl.Builder;
import de.odysseus.el.tree.impl.Parser;
/**
* Syntax extensions for the expression language library
*
* - pipe '|' postfix unary operator for applying filters to expressions
* - positive '+' prefix unary operator for absolute value of numeric
* - 'is' postfix operator for creating a boolean expression with an expression test function
* - named function args support (still requires precise order, but accepts syntax of fn(foo=bar, a=b)
*
*/
public class ExtendedSyntaxBuilder extends Builder {
private static final long serialVersionUID = 1L;
public ExtendedSyntaxBuilder() {
super();
}
public ExtendedSyntaxBuilder(Feature...features) {
super(features);
}
@Override
protected Parser createParser(String expression) {
return new ExtendedParser(this, expression);
}
}
jinjava-jinjava-2.0.0/src/main/java/com/hubspot/jinjava/el/JinjavaELContext.java 0000664 0000000 0000000 00000001470 12477734511 0027523 0 ustar 00root root 0000000 0000000 package com.hubspot.jinjava.el;
import java.lang.reflect.Method;
import javax.el.ELResolver;
import javax.el.FunctionMapper;
import de.odysseus.el.util.SimpleContext;
public class JinjavaELContext extends SimpleContext {
private MacroFunctionMapper functionMapper;
public JinjavaELContext() {
super();
}
public JinjavaELContext(ELResolver resolver) {
super(resolver);
}
@Override
public FunctionMapper getFunctionMapper() {
if(functionMapper == null) {
functionMapper = new MacroFunctionMapper();
}
return functionMapper;
}
@Override
public void setFunction(String prefix, String localName, Method method) {
if(functionMapper == null) {
functionMapper = new MacroFunctionMapper();
}
functionMapper.setFunction(prefix, localName, method);
}
}
jinjava-jinjava-2.0.0/src/main/java/com/hubspot/jinjava/el/JinjavaInterpreterResolver.java 0000664 0000000 0000000 00000013111 12477734511 0031676 0 ustar 00root root 0000000 0000000 package com.hubspot.jinjava.el;
import static com.hubspot.jinjava.util.Logging.ENGINE_LOG;
import java.time.Instant;
import java.time.ZoneOffset;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;
import java.util.Date;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Objects;
import javax.el.ELContext;
import org.apache.commons.lang3.LocaleUtils;
import org.apache.commons.lang3.StringUtils;
import com.google.common.collect.Lists;
import com.hubspot.jinjava.el.ext.AbstractCallableMethod;
import com.hubspot.jinjava.el.ext.ExtendedParser;
import com.hubspot.jinjava.interpret.JinjavaInterpreter;
import com.hubspot.jinjava.interpret.TemplateError;
import com.hubspot.jinjava.objects.PyWrapper;
import com.hubspot.jinjava.objects.collections.PyList;
import com.hubspot.jinjava.objects.collections.PyMap;
import com.hubspot.jinjava.objects.date.FormattedDate;
import com.hubspot.jinjava.objects.date.PyishDate;
import com.hubspot.jinjava.objects.date.StrftimeFormatter;
import com.hubspot.jinjava.util.JinjavaPropertyNotResolvedException;
import com.hubspot.jinjava.util.VariableChain;
import de.odysseus.el.util.SimpleResolver;
public class JinjavaInterpreterResolver extends SimpleResolver {
private JinjavaInterpreter interpreter;
public JinjavaInterpreterResolver(JinjavaInterpreter interpreter) {
this.interpreter = interpreter;
}
@Override
public Object invoke(ELContext context, Object base, Object method,
Class[] paramTypes, Object[] params) {
Object methodProperty = getValue(context, base, method, false);
if(methodProperty != null && methodProperty instanceof AbstractCallableMethod) {
context.setPropertyResolved(true);
return ((AbstractCallableMethod) methodProperty).evaluate(params);
}
// TODO map named params to special arg in fn to invoke
return super.invoke(context, base, method, paramTypes, params);
}
@Override
public Object getValue(ELContext context, Object base, Object prop) {
return getValue(context, base, prop, true);
}
private Object getValue(ELContext context, Object base, Object prop, boolean errOnUnknownProp) {
String property = Objects.toString(prop, "");
Object value = null;
if(ExtendedParser.INTERPRETER.equals(prop)) {
value = interpreter;
}
else if(property.startsWith(ExtendedParser.FILTER_PREFIX)) {
value = interpreter.getContext().getFilter(StringUtils.substringAfter(property, ExtendedParser.FILTER_PREFIX));
}
else if(property.startsWith(ExtendedParser.EXPTEST_PREFIX)) {
value = interpreter.getContext().getExpTest(StringUtils.substringAfter(property, ExtendedParser.EXPTEST_PREFIX));
}
else {
if(base == null) {
value = interpreter.retraceVariable((String) prop, interpreter.getLineNumber());
}
else {
try {
value = new VariableChain(Lists.newArrayList(property), base).resolve();
}
catch(JinjavaPropertyNotResolvedException e) {
if(errOnUnknownProp) {
interpreter.addError(TemplateError.fromUnknownProperty(base, property, interpreter.getLineNumber()));
}
}
}
}
context.setPropertyResolved(true);
return wrap(interpreter, value);
}
@SuppressWarnings("unchecked")
public static Object wrap(JinjavaInterpreter interpreter, Object value) {
if(value == null) {
return null;
}
if(value instanceof PyWrapper) {
return value;
}
if(List.class.isAssignableFrom(value.getClass())) {
return new PyList((List
Java-based template engine based on django template syntax, adapted to render jinja templates (at least the subset of jinja in use in HubSpot content). Currently used in production to render thousands of websites with hundreds of millions of page views per month on the [HubSpot COS](http://www.hubspot.com/products/sites).
*Note*: Requires Java >= 8. Originally forked from [jangod](https://code.google.com/p/jangod/).
Get it:
-------
```xml