helper = new HelperStringTokenizer(tagNode.getHelpers()).allTokens();
if (helper.isEmpty()) {
throw new InterpretException("Tag 'block' expects an identifier", tagNode.getLineNumber());
}
String blockName = WhitespaceUtils.unquote(helper.get(0));
interpreter.addBlock(blockName, tagNode.getChildren());
return JinjavaInterpreter.BLOCK_STUB_START + blockName + JinjavaInterpreter.BLOCK_STUB_END;
}
@Override
public String getEndTagName() {
return ENDTAGNAME;
}
@Override
public String getName() {
return TAGNAME;
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/lib/tag/CallTag.java 0000664 0000000 0000000 00000004653 12511767770 0026614 0 ustar 00root root 0000000 0000000 package com.hubspot.jinjava.lib.tag;
import java.util.LinkedHashMap;
import com.hubspot.jinjava.interpret.JinjavaInterpreter;
import com.hubspot.jinjava.lib.fn.MacroFunction;
import com.hubspot.jinjava.tree.TagNode;
/**
* In some cases it can be useful to pass a macro to another macro. For this purpose you can use the
* special call block. The following example shows a macro that takes advantage of the call
* functionality and how it can be used:
*
*
* {% macro render_dialog(title, class='dialog') -%}
* <div class="{{ class }}">
* <h2>{{ title }}</h2>
* <div class="contents">
* {{ caller() }}
* </div>
* </div>
* {%- endmacro %}
*
* {% call render_dialog('Hello World') %}
* This is a simple dialog rendered by using a macro and
* a call block.
* {% endcall %}
*
*
* It’s also possible to pass arguments back to the call block. This makes it useful as replacement
* for loops. Generally speaking a call block works exactly like an macro, just that it doesn’t have a name.
*
* Here an example of how a call block can be used with arguments:
*
*
* {% macro dump_users(users) -%}
* <ul>
* {%- for user in users %}
* <li><p>{{ user.username|e }}</p>{{ caller(user) }}</li>
* {%- endfor %}
* </ul>
* {%- endmacro %}
*
* {% call(user) dump_users(list_of_user) %}
* <dl>
* <dl>Realname</dl>
* <dd>{{ user.realname|e }}</dd>
* <dl>Description</dl>
* <dd>{{ user.description }}</dd>
* </dl>
* {% endcall %}
*
*
* @author jstehler
*
*/
public class CallTag implements Tag {
@Override
public String getName() {
return "call";
}
@Override
public String getEndTagName() {
return "endcall";
}
@Override
public String interpret(TagNode tagNode, JinjavaInterpreter interpreter) {
String macroExpr = "{{" + tagNode.getHelpers().trim() + "}}";
interpreter.enterScope();
try {
LinkedHashMap args = new LinkedHashMap<>();
MacroFunction caller = new MacroFunction(tagNode.getChildren(), "caller", args, false, false, true, interpreter.getContext());
interpreter.getContext().addGlobalMacro(caller);
return interpreter.render(macroExpr);
}
finally {
interpreter.leaveScope();
}
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/lib/tag/CycleTag.java 0000664 0000000 0000000 00000005727 12511767770 0027003 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.lib.tag;
import java.util.List;
import com.hubspot.jinjava.interpret.InterpretException;
import com.hubspot.jinjava.interpret.JinjavaInterpreter;
import com.hubspot.jinjava.tree.TagNode;
import com.hubspot.jinjava.util.HelperStringTokenizer;
/**
* {% cycle a,b,c %} {% cycle a,'b',c as d %} {% cycle d %}
*
* @author anysome
*
*/
public class CycleTag implements Tag {
private static final String LOOP_INDEX = "loop.index0";
private static final String TAGNAME = "cycle";
@SuppressWarnings("unchecked")
@Override
public String interpret(TagNode tagNode, JinjavaInterpreter interpreter) {
List values;
String var = null;
HelperStringTokenizer tk = new HelperStringTokenizer(tagNode.getHelpers());
List helper = tk.allTokens();
if (helper.size() == 1) {
HelperStringTokenizer items = new HelperStringTokenizer(helper.get(0));
items.splitComma(true);
values = items.allTokens();
Integer forindex = (Integer) interpreter.retraceVariable(LOOP_INDEX, tagNode.getLineNumber());
if (forindex == null) {
forindex = 0;
}
if (values.size() == 1) {
var = values.get(0);
values = (List) interpreter.retraceVariable(var, tagNode.getLineNumber());
if (values == null) {
return interpreter.resolveString(var, tagNode.getLineNumber());
}
} else {
for (int i = 0; i < values.size(); i++) {
values.set(i, interpreter.resolveString(values.get(i), tagNode.getLineNumber()));
}
}
return values.get(forindex % values.size());
} else if (helper.size() == 3) {
HelperStringTokenizer items = new HelperStringTokenizer(helper.get(0));
items.splitComma(true);
values = items.allTokens();
for (int i = 0; i < values.size(); i++) {
values.set(i, interpreter.resolveString(values.get(i), tagNode.getLineNumber()));
}
var = helper.get(2);
interpreter.getContext().put(var, values);
return "";
} else {
throw new InterpretException("Tag 'cycle' expects 1 or 3 helper(s) >>> " + helper.size(), tagNode.getLineNumber());
}
}
@Override
public String getEndTagName() {
return null;
}
@Override
public String getName() {
return TAGNAME;
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/lib/tag/ElseIfTag.java 0000664 0000000 0000000 00000001047 12511767770 0027102 0 ustar 00root root 0000000 0000000 package com.hubspot.jinjava.lib.tag;
import com.hubspot.jinjava.doc.annotations.JinjavaDoc;
import com.hubspot.jinjava.interpret.JinjavaInterpreter;
import com.hubspot.jinjava.tree.TagNode;
@JinjavaDoc(value="", hidden=true)
public class ElseIfTag implements Tag {
static final String ELSEIF = "elif";
@Override
public String interpret(TagNode tagNode, JinjavaInterpreter interpreter) {
return "";
}
@Override
public String getEndTagName() {
return null;
}
@Override
public String getName() {
return ELSEIF;
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/lib/tag/ElseTag.java 0000664 0000000 0000000 00000002333 12511767770 0026622 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.lib.tag;
import com.hubspot.jinjava.doc.annotations.JinjavaDoc;
import com.hubspot.jinjava.interpret.JinjavaInterpreter;
import com.hubspot.jinjava.tree.TagNode;
@JinjavaDoc(value="", hidden=true)
public class ElseTag implements Tag {
static final String ELSE = "else";
@Override
public String interpret(TagNode tagNode, JinjavaInterpreter interpreter) {
return "";
}
@Override
public String getEndTagName() {
return null;
}
@Override
public String getName() {
return ELSE;
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/lib/tag/EndTag.java 0000664 0000000 0000000 00000001177 12511767770 0026445 0 ustar 00root root 0000000 0000000 package com.hubspot.jinjava.lib.tag;
import com.hubspot.jinjava.doc.annotations.JinjavaDoc;
import com.hubspot.jinjava.interpret.JinjavaInterpreter;
import com.hubspot.jinjava.tree.TagNode;
@JinjavaDoc(value="", hidden=true)
public final class EndTag implements Tag {
private final String endTagName;
public EndTag(Tag tag) {
this.endTagName = tag.getEndTagName();
}
@Override
public String getName() {
return endTagName;
}
@Override
public String interpret(TagNode tagNode, JinjavaInterpreter interpreter) {
return "";
}
@Override
public String getEndTagName() {
return endTagName;
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/lib/tag/ExtendsTag.java 0000664 0000000 0000000 00000003745 12511767770 0027354 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.lib.tag;
import java.io.IOException;
import com.hubspot.jinjava.interpret.InterpretException;
import com.hubspot.jinjava.interpret.JinjavaInterpreter;
import com.hubspot.jinjava.tree.Node;
import com.hubspot.jinjava.tree.TagNode;
import com.hubspot.jinjava.util.HelperStringTokenizer;
/**
* {% extends "base.html" %} {% extends var_fileName %}
*/
public class ExtendsTag implements Tag {
private static final String TAGNAME = "extends";
@Override
public String interpret(TagNode tagNode, JinjavaInterpreter interpreter) {
HelperStringTokenizer tokenizer = new HelperStringTokenizer(tagNode.getHelpers());
if (!tokenizer.hasNext()) {
throw new InterpretException("Tag 'extends' expects template path", tagNode.getLineNumber());
}
String templateFile = interpreter.resolveString(tokenizer.next(), tagNode.getLineNumber());
try {
String template = interpreter.getResource(templateFile);
Node node = interpreter.parse(template);
interpreter.addExtendParentRoot(node);
return "";
} catch (IOException e) {
throw new InterpretException(e.getMessage(), e, tagNode.getLineNumber());
}
}
@Override
public String getEndTagName() {
return null;
}
@Override
public String getName() {
return TAGNAME;
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/lib/tag/ForTag.java 0000664 0000000 0000000 00000010652 12511767770 0026463 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.lib.tag;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import org.apache.commons.lang3.StringUtils;
import com.google.common.collect.Lists;
import com.hubspot.jinjava.doc.annotations.JinjavaDoc;
import com.hubspot.jinjava.interpret.InterpretException;
import com.hubspot.jinjava.interpret.JinjavaInterpreter;
import com.hubspot.jinjava.tree.Node;
import com.hubspot.jinjava.tree.TagNode;
import com.hubspot.jinjava.util.ForLoop;
import com.hubspot.jinjava.util.HelperStringTokenizer;
import com.hubspot.jinjava.util.ObjectIterator;
/**
* {% for a in b|f1:d,c %}
*
* {% for key, value in my_dict %}
*
* @author anysome
*
*/
@JinjavaDoc(value="outputs the inner content for each item in the given iterable")
public class ForTag implements Tag {
private static final String LOOP = "loop";
private static final String TAGNAME = "for";
private static final String ENDTAGNAME = "endfor";
@SuppressWarnings("unchecked")
@Override
public String interpret(TagNode tagNode, JinjavaInterpreter interpreter) {
List helper = new HelperStringTokenizer(tagNode.getHelpers()).splitComma(true).allTokens();
List loopVars = Lists.newArrayList();
int inPos = 0;
while(inPos < helper.size()) {
String val = helper.get(inPos);
if("in".equals(val)) {
break;
}
else {
loopVars.add(val);
inPos++;
}
}
if(inPos >= helper.size()) {
throw new InterpretException("Tag 'for' expects valid 'in' clause, got: " + tagNode.getHelpers(), tagNode.getLineNumber());
}
String loopExpr = StringUtils.join(helper.subList(inPos + 1, helper.size()), ",");
Object collection = interpreter.resolveELExpression(loopExpr, tagNode.getLineNumber());
ForLoop loop = ObjectIterator.getLoop(collection);
interpreter.enterScope();
try {
interpreter.getContext().put(LOOP, loop);
StringBuilder buff = new StringBuilder();
while (loop.hasNext()) {
Object val = loop.next();
// set item variables
if(loopVars.size() == 1) {
interpreter.getContext().put(loopVars.get(0), val);
}
else {
for(String loopVar : loopVars) {
if(Map.Entry.class.isAssignableFrom(val.getClass())) {
Map.Entry entry = (Entry) val;
Object entryVal = null;
if("key".equals(loopVar)) {
entryVal = entry.getKey();
}
else if("value".equals(loopVar)) {
entryVal = entry.getValue();
}
interpreter.getContext().put(loopVar, entryVal);
}
else {
try {
PropertyDescriptor[] valProps = Introspector.getBeanInfo(val.getClass()).getPropertyDescriptors();
for(PropertyDescriptor valProp : valProps) {
if(loopVar.equals(valProp.getName())) {
interpreter.getContext().put(loopVar, valProp.getReadMethod().invoke(val));
break;
}
}
} catch (Exception e) {
throw new InterpretException(e.getMessage(), e, tagNode.getLineNumber());
}
}
}
}
for (Node node : tagNode.getChildren()) {
buff.append(node.render(interpreter));
}
}
return buff.toString();
}
finally {
interpreter.leaveScope();
}
}
@Override
public String getEndTagName() {
return ENDTAGNAME;
}
@Override
public String getName() {
return TAGNAME;
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/lib/tag/FromTag.java 0000664 0000000 0000000 00000006571 12511767770 0026645 0 ustar 00root root 0000000 0000000 package com.hubspot.jinjava.lib.tag;
import java.io.IOException;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import com.google.common.collect.Iterators;
import com.google.common.collect.PeekingIterator;
import com.hubspot.jinjava.doc.annotations.JinjavaDoc;
import com.hubspot.jinjava.interpret.InterpretException;
import com.hubspot.jinjava.interpret.JinjavaInterpreter;
import com.hubspot.jinjava.lib.fn.MacroFunction;
import com.hubspot.jinjava.tree.Node;
import com.hubspot.jinjava.tree.TagNode;
import com.hubspot.jinjava.util.HelperStringTokenizer;
/**
* Alternatively you can import names from the template into the current namespace:
*
* {% from 'forms.html' import input as input_field, textarea %}
*
* Username
* {{ input_field('username') }}
* Password
* {{ input_field('password', type='password') }}
*
*
* {{ textarea('comment') }}
*
*
* @author jstehler
*/
@JinjavaDoc(
value="Alternatively you can import names from the template into the current namespace:\n\n" +
"{% from 'forms.html' import input as input_field, textarea %}\n" +
"\n" +
"Username \n" +
"{{ input_field('username') }} \n" +
"Password \n" +
"{{ input_field('password', type='password') }} \n" +
" \n" +
"\n" +
"{{ textarea('comment') }}\n" +
"
")
public class FromTag implements Tag {
@Override
public String getName() {
return "from";
}
@Override
public String interpret(TagNode tagNode, JinjavaInterpreter interpreter) {
List helper = new HelperStringTokenizer(tagNode.getHelpers()).splitComma(true).allTokens();
if (helper.size() < 3 || !helper.get(1).equals("import")) {
throw new InterpretException("Tag 'from' expects import list: " + helper, tagNode.getLineNumber());
}
String templateFile = interpreter.resolveString(helper.get(0), tagNode.getLineNumber());
Map imports = new LinkedHashMap<>();
PeekingIterator args = Iterators.peekingIterator(helper.subList(2, helper.size()).iterator());
while(args.hasNext()) {
String fromName = args.next();
String importName = fromName;
if(args.hasNext() && args.peek() != null && args.peek().equals("as")) {
args.next();
importName = args.next();
}
imports.put(fromName, importName);
}
try {
String template = interpreter.getResource(templateFile);
Node node = interpreter.parse(template);
JinjavaInterpreter child = new JinjavaInterpreter(interpreter);
child.render(node);
for(Map.Entry importMapping : imports.entrySet()) {
Object val = child.getContext().getGlobalMacro(importMapping.getKey());
if(val != null) {
interpreter.getContext().addGlobalMacro((MacroFunction) val);
}
else {
val = child.getContext().get(importMapping.getKey());
if(val != null) {
interpreter.getContext().put(importMapping.getValue(), val);
}
}
}
return "";
} catch (IOException e) {
throw new InterpretException(e.getMessage(), e, tagNode.getLineNumber());
}
}
@Override
public String getEndTagName() {
return null;
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/lib/tag/IfTag.java 0000664 0000000 0000000 00000006111 12511767770 0026266 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.lib.tag;
import java.util.Iterator;
import org.apache.commons.lang3.StringUtils;
import com.hubspot.jinjava.doc.annotations.JinjavaDoc;
import com.hubspot.jinjava.interpret.InterpretException;
import com.hubspot.jinjava.interpret.JinjavaInterpreter;
import com.hubspot.jinjava.tree.Node;
import com.hubspot.jinjava.tree.TagNode;
import com.hubspot.jinjava.util.ObjectTruthValue;
@JinjavaDoc("Outputs inner content if expression evaluates to true, otherwise evaluates any elif blocks, finally outputting content of any else block present")
public class IfTag implements Tag {
private static final String TAGNAME = "if";
private static final String ENDTAGNAME = "endif";
@Override
public String interpret(TagNode tagNode, JinjavaInterpreter interpreter) {
if(StringUtils.isBlank(tagNode.getHelpers())) {
throw new InterpretException("Tag 'if' expects expression", tagNode.getLineNumber());
}
Iterator nodeIterator = tagNode.getChildren().iterator();
TagNode nextIfElseTagNode = (TagNode) tagNode;
while(nextIfElseTagNode != null && !evaluateIfElseTagNode(nextIfElseTagNode, interpreter)) {
nextIfElseTagNode = findNextIfElseTagNode(nodeIterator);
}
StringBuilder sb = new StringBuilder();
if(nextIfElseTagNode != null) {
while(nodeIterator.hasNext()) {
Node n = nodeIterator.next();
if(n.getName().equals(ElseIfTag.ELSEIF) || n.getName().equals(ElseTag.ELSE)) {
break;
}
sb.append(n.render(interpreter));
}
}
return sb.toString();
}
private TagNode findNextIfElseTagNode(Iterator nodeIterator) {
while(nodeIterator.hasNext()) {
Node node = nodeIterator.next();
if(TagNode.class.isAssignableFrom(node.getClass())) {
TagNode tag = (TagNode) node;
if(tag.getName().equals(ElseIfTag.ELSEIF) || tag.getName().equals(ElseTag.ELSE)) {
return tag;
}
}
}
return null;
}
protected boolean evaluateIfElseTagNode(TagNode tagNode, JinjavaInterpreter interpreter) {
if(tagNode.getName().equals(ElseTag.ELSE)) {
return true;
}
return ObjectTruthValue.evaluate(interpreter.resolveELExpression(tagNode.getHelpers(), tagNode.getLineNumber()));
}
@Override
public String getEndTagName() {
return ENDTAGNAME;
}
@Override
public String getName() {
return TAGNAME;
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/lib/tag/IfchangedTag.java 0000664 0000000 0000000 00000004343 12511767770 0027605 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.lib.tag;
import org.apache.commons.lang3.StringUtils;
import com.hubspot.jinjava.interpret.InterpretException;
import com.hubspot.jinjava.interpret.JinjavaInterpreter;
import com.hubspot.jinjava.tree.Node;
import com.hubspot.jinjava.tree.TagNode;
/**
* {% ifchange var %}
*
* @author anysome
*
*/
public class IfchangedTag implements Tag {
private static final String LASTKEY = "'IF\"CHG";
private static final String TAGNAME = "ifchanged";
private static final String ENDTAGNAME = "endif";
@Override
public String interpret(TagNode tagNode, JinjavaInterpreter interpreter) {
if (StringUtils.isBlank(tagNode.getHelpers())) {
throw new InterpretException("Tag 'ifchanged' expects 1 helper >>> 0", tagNode.getLineNumber());
}
boolean isChanged = true;
String var = tagNode.getHelpers().trim();
Object older = interpreter.getContext().get(LASTKEY + var);
Object test = interpreter.retraceVariable(var, tagNode.getLineNumber());
if (older == null) {
if (test == null) {
isChanged = false;
}
} else if (older.equals(test)) {
isChanged = false;
}
interpreter.getContext().put(LASTKEY + var, test);
if (isChanged) {
StringBuilder sb = new StringBuilder();
for (Node node : tagNode.getChildren()) {
sb.append(node.render(interpreter));
}
return sb.toString();
}
return "";
}
@Override
public String getEndTagName() {
return ENDTAGNAME;
}
@Override
public String getName() {
return TAGNAME;
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/lib/tag/ImportTag.java 0000664 0000000 0000000 00000007711 12511767770 0027211 0 ustar 00root root 0000000 0000000 package com.hubspot.jinjava.lib.tag;
import static com.hubspot.jinjava.util.Logging.ENGINE_LOG;
import java.io.IOException;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.commons.lang3.StringUtils;
import com.hubspot.jinjava.doc.annotations.JinjavaDoc;
import com.hubspot.jinjava.interpret.Context;
import com.hubspot.jinjava.interpret.InterpretException;
import com.hubspot.jinjava.interpret.JinjavaInterpreter;
import com.hubspot.jinjava.lib.fn.MacroFunction;
import com.hubspot.jinjava.tree.Node;
import com.hubspot.jinjava.tree.TagNode;
import com.hubspot.jinjava.util.HelperStringTokenizer;
/**
* Jinja2 supports putting often used code into macros. These macros can go into different
* templates and get imported from there. This works similar to the import statements in
* Python. It’s important to know that imports are cached and imported templates don’t have
* access to the current template variables, just the globals by default.
*
* @author jstehler
*/
@JinjavaDoc("Jinja2 supports putting often used code into macros. These macros can go into "
+ "different templates and get imported from there. This works similar to the import "
+ "statements in Python. It’s important to know that imports are cached and imported "
+ "templates don’t have access to the current template variables, just the globals by default.")
@SuppressWarnings("unchecked")
public class ImportTag implements Tag {
private static final String IMPORT_PATH_PROPERTY = "__importP@th__";
@Override
public String getName() {
return "import";
}
@Override
public String interpret(TagNode tagNode, JinjavaInterpreter interpreter) {
List helper = new HelperStringTokenizer(tagNode.getHelpers()).allTokens();
if (helper.isEmpty()) {
throw new InterpretException("Tag 'import' expects 1 helper >>> " + helper.size(), tagNode.getLineNumber());
}
String contextVar = "";
if(helper.size() > 2 && "as".equals(helper.get(1))) {
contextVar = helper.get(2);
}
String path = StringUtils.trimToEmpty(helper.get(0));
if(isPathInRenderStack(interpreter.getContext(), path)) {
ENGINE_LOG.debug("Path {} is already in include stack", path);
return "";
}
Set importedPaths = (Set) interpreter.getContext().get(IMPORT_PATH_PROPERTY);
if(importedPaths == null) {
importedPaths = new HashSet();
interpreter.getContext().put(IMPORT_PATH_PROPERTY, importedPaths);
}
importedPaths.add(path);
String templateFile = interpreter.resolveString(path, tagNode.getLineNumber());
try {
String template = interpreter.getResource(templateFile);
Node node = interpreter.parse(template);
if(StringUtils.isBlank(contextVar)) {
interpreter.render(node);
}
else {
JinjavaInterpreter child = new JinjavaInterpreter(interpreter);
child.render(node);
Map childBindings = child.getContext().getSessionBindings();
for(Map.Entry macro : child.getContext().getGlobalMacros().entrySet()) {
childBindings.put(macro.getKey(), macro.getValue());
}
childBindings.remove(Context.GLOBAL_MACROS_SCOPE_KEY);
interpreter.getContext().put(contextVar, childBindings);
}
return "";
} catch (IOException e) {
throw new InterpretException(e.getMessage(), e, tagNode.getLineNumber());
}
}
private boolean isPathInRenderStack(Context context, String path) {
Context current = context;
do {
Set importedPaths = (Set) current.get(IMPORT_PATH_PROPERTY, new HashSet());
if(importedPaths.contains(path)) {
return true;
}
current = current.getParent();
} while(current != null);
return false;
}
@Override
public String getEndTagName() {
return null;
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/lib/tag/IncludeTag.java 0000664 0000000 0000000 00000005641 12511767770 0027322 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.lib.tag;
import static com.hubspot.jinjava.util.Logging.ENGINE_LOG;
import java.io.IOException;
import org.apache.commons.lang3.StringUtils;
import com.hubspot.jinjava.interpret.Context;
import com.hubspot.jinjava.interpret.InterpretException;
import com.hubspot.jinjava.interpret.JinjavaInterpreter;
import com.hubspot.jinjava.tree.Node;
import com.hubspot.jinjava.tree.TagNode;
import com.hubspot.jinjava.util.HelperStringTokenizer;
/**
* {% include 'sidebar.html' %} {% include var_fileName %}
*
* @author anysome
*
*/
public class IncludeTag implements Tag {
private static final String INCLUDE_PATH_PROPERTY = "__includeP@th__";
@Override
public String interpret(TagNode tagNode, JinjavaInterpreter interpreter) {
HelperStringTokenizer helper = new HelperStringTokenizer(tagNode.getHelpers());
if (!helper.hasNext()) {
throw new InterpretException("Tag 'include' expects template path", tagNode.getLineNumber());
}
String path = StringUtils.trimToEmpty(helper.next());
if(isPathInRenderStack(interpreter.getContext(), path)) {
ENGINE_LOG.debug("Path {} is already in include stack", path);
return "";
}
String templateFile = interpreter.resolveString(path, tagNode.getLineNumber());
try {
String template = interpreter.getResource(templateFile);
Node node = interpreter.parse(template);
JinjavaInterpreter child = new JinjavaInterpreter(interpreter);
child.getContext().put(INCLUDE_PATH_PROPERTY, path);
interpreter.getContext().put(JinjavaInterpreter.INSERT_FLAG, true);
return child.render(node);
} catch (IOException e) {
throw new InterpretException(e.getMessage(), e, tagNode.getLineNumber());
}
}
private boolean isPathInRenderStack(Context context, String path) {
Context current = context;
do {
String includePath = (String) current.get(INCLUDE_PATH_PROPERTY);
if(StringUtils.equals(path, includePath)) {
return true;
}
current = current.getParent();
} while(current != null);
return false;
}
@Override
public String getEndTagName() {
return null;
}
@Override
public String getName() {
return "include";
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/lib/tag/MacroTag.java 0000664 0000000 0000000 00000010646 12511767770 0027001 0 ustar 00root root 0000000 0000000 package com.hubspot.jinjava.lib.tag;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.apache.commons.lang3.StringUtils;
import com.google.common.base.Objects;
import com.google.common.base.Splitter;
import com.google.common.collect.Lists;
import com.hubspot.jinjava.interpret.InterpretException;
import com.hubspot.jinjava.interpret.JinjavaInterpreter;
import com.hubspot.jinjava.lib.fn.MacroFunction;
import com.hubspot.jinjava.tree.TagNode;
/**
* Macros are comparable with functions in regular programming languages. They are
* useful to put often used idioms into reusable functions to not repeat yourself.
*
* Here a small example of a macro that renders a form element:
*
*
* {% macro input(name, value='', type='text', size=20) -%}
* <input type="{{ type }}" name="{{ name }}" value="{{ value|e }}" size="{{ size }}">
* {%- endmacro %}
*
*
* The macro can then be called like a function in the namespace:
*
* {{ input('username') }}
* {{ input('password', type='password') }}
*
* If the macro was defined in a different template you have to import it first.
*
* Inside macros you have access to three special variables:
*
* varargs
* If more positional arguments are passed to the macro than accepted by
* the macro they end up in the special varargs variable as list of values.
* kwargs
* Like varargs but for keyword arguments. All unconsumed keyword arguments
* are stored in this special variable.
* caller
* If the macro was called from a call tag the caller is stored in this
* variable as macro which can be called.
*
* Macros also expose some of their internal details. The following attributes
* are available on a macro object:
*
* name
* The name of the macro. {{ input.name }} will print input.
* arguments
* A tuple of the names of arguments the macro accepts.
* defaults
* A tuple of default values.
* catch_kwargs
* This is true if the macro accepts extra keyword arguments (ie: accesses the
* special kwargs variable).
* catch_varargs
* This is true if the macro accepts extra positional arguments (ie: accesses
* the special varargs variable).
* caller
* This is true if the macro accesses the special caller variable and may be
* called from a call tag.
*
* If a macro name starts with an underscore it’s not exported and can’t be imported.
*
*/
public class MacroTag implements Tag {
@Override
public String getName() {
return "macro";
}
@Override
public String getEndTagName() {
return "endmacro";
}
@Override
public String interpret(TagNode tagNode, JinjavaInterpreter interpreter) {
Matcher matcher = MACRO_PATTERN.matcher(tagNode.getHelpers());
if(!matcher.find()) {
throw new InterpretException("Unable to parse macro definition: " + tagNode.getHelpers());
}
String name = matcher.group(1);
String args = Objects.firstNonNull(matcher.group(2), "");
LinkedHashMap argNamesWithDefaults = new LinkedHashMap<>();
List argList = Lists.newArrayList(ARGS_SPLITTER.split(args));
for(int i = 0; i < argList.size(); i++) {
String arg = argList.get(i);
if(arg.contains("=")) {
String argName = StringUtils.substringBefore(arg, "=").trim();
String argValStr = StringUtils.substringAfter(arg, "=").trim();
if(argValStr.startsWith("[") && !argValStr.endsWith("]")) {
while(i + 1 < argList.size() && !argValStr.endsWith("]")) {
argValStr += ", " + argList.get(i + 1);
i++;
}
}
Object argVal = interpreter.resolveELExpression(argValStr, tagNode.getLineNumber());
argNamesWithDefaults.put(argName, argVal);
}
else {
argNamesWithDefaults.put(arg, null);
}
}
boolean catchKwargs = false;
boolean catchVarargs = false;
boolean caller = false;
MacroFunction macro = new MacroFunction(tagNode.getChildren(), name, argNamesWithDefaults,
catchKwargs, catchVarargs, caller, interpreter.getContext());
interpreter.getContext().addGlobalMacro(macro);
return "";
}
private static final Pattern MACRO_PATTERN = Pattern.compile("([a-zA-Z_][\\w_]*)[^\\(]*\\(([^\\)]*)\\)");
private static final Splitter ARGS_SPLITTER = Splitter.on(',').omitEmptyStrings().trimResults();
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/lib/tag/PrintTag.java 0000664 0000000 0000000 00000001412 12511767770 0027023 0 ustar 00root root 0000000 0000000 package com.hubspot.jinjava.lib.tag;
import java.util.Objects;
import com.hubspot.jinjava.doc.annotations.JinjavaDoc;
import com.hubspot.jinjava.doc.annotations.JinjavaParam;
import com.hubspot.jinjava.interpret.JinjavaInterpreter;
import com.hubspot.jinjava.tree.TagNode;
@JinjavaDoc(value="Echos the result of the expression", params=@JinjavaParam(value="expr", type="expression"))
public class PrintTag implements Tag {
@Override
public String getName() {
return "print";
}
@Override
public String interpret(TagNode tagNode,
JinjavaInterpreter interpreter) {
return Objects.toString( interpreter.resolveELExpression(tagNode.getHelpers(), tagNode.getLineNumber()), "" );
}
@Override
public String getEndTagName() {
return null;
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/lib/tag/RawTag.java 0000664 0000000 0000000 00000002372 12511767770 0026466 0 ustar 00root root 0000000 0000000 package com.hubspot.jinjava.lib.tag;
import org.apache.commons.lang3.StringUtils;
import com.hubspot.jinjava.doc.annotations.JinjavaDoc;
import com.hubspot.jinjava.interpret.JinjavaInterpreter;
import com.hubspot.jinjava.tree.Node;
import com.hubspot.jinjava.tree.TagNode;
@JinjavaDoc("process all inner content as plain text, including any template tokens")
public class RawTag implements Tag {
@Override
public String getName() {
return "raw";
}
@Override
public String getEndTagName() {
return "endraw";
}
@Override
public String interpret(TagNode tagNode, JinjavaInterpreter interpreter) {
StringBuilder result = new StringBuilder();
for(Node n : tagNode.getChildren()) {
result.append(renderNodeRaw(n));
}
return result.toString();
}
private String renderNodeRaw(Node n) {
StringBuilder result = new StringBuilder(n.getMaster().getImage());
for(Node child : n.getChildren()) {
result.append(renderNodeRaw(child));
}
if(TagNode.class.isAssignableFrom(n.getClass())) {
TagNode t = (TagNode) n;
if(StringUtils.isNotBlank(t.getEndName())) {
result.append("{% ").append(t.getEndName()).append(" %}");
}
}
return result.toString();
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/lib/tag/SetTag.java 0000664 0000000 0000000 00000005341 12511767770 0026467 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.lib.tag;
import org.apache.commons.lang3.StringUtils;
import com.hubspot.jinjava.doc.annotations.JinjavaDoc;
import com.hubspot.jinjava.doc.annotations.JinjavaParam;
import com.hubspot.jinjava.interpret.InterpretException;
import com.hubspot.jinjava.interpret.JinjavaInterpreter;
import com.hubspot.jinjava.tree.TagNode;
/**
* {% set primary_line_height = primary_font_size_num*1.5 %}
*
* {% set lw_font_size = "font-size: " ~ lw_font_size_base ~ "px; " %}
* {% set lw_secondary_font_size = "font-size: " ~ (lw_font_size_base - 2) ~ "px; " %}
* {% set lw_line_height = "line-height: " ~ lw_font_size_base*1.5 ~ "px; " %}
*
* @author anysome
*
*/
@JinjavaDoc(value="Assigns the result of an expression to a variable",
params={
@JinjavaParam(value="var", type="variable identifier"),
@JinjavaParam(value="expr", type="expression")
})
public class SetTag implements Tag {
private static final String TAGNAME = "set";
@Override
public String getName() {
return TAGNAME;
}
@Override
public String interpret(TagNode tagNode, JinjavaInterpreter interpreter) {
if(!tagNode.getHelpers().contains("=")) {
throw new InterpretException("Tag 'set' expects an assignment expression with '=', but was: " + tagNode.getHelpers(), tagNode.getLineNumber());
}
int eqPos = tagNode.getHelpers().indexOf('=');
String var = tagNode.getHelpers().substring(0, eqPos).trim();
String expr = tagNode.getHelpers().substring(eqPos + 1, tagNode.getHelpers().length());
if(var == null || var.length() == 0) {
throw new InterpretException("Tag 'set' requires a var name to assign to", tagNode.getLineNumber());
}
if(StringUtils.isBlank(expr)) {
throw new InterpretException("Tag 'set' requires an expression to assign to a var", tagNode.getLineNumber());
}
Object val = interpreter.resolveELExpression(expr, tagNode.getLineNumber());
interpreter.getContext().put(var, val);
return "";
}
@Override
public String getEndTagName() {
return null;
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/lib/tag/Tag.java 0000664 0000000 0000000 00000002136 12511767770 0026012 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.lib.tag;
import com.hubspot.jinjava.interpret.JinjavaInterpreter;
import com.hubspot.jinjava.lib.Importable;
import com.hubspot.jinjava.tree.TagNode;
public interface Tag extends Importable {
String interpret(TagNode tagNode, JinjavaInterpreter interpreter);
/**
* @return Get name of end tag lowerCase Null if it's a single tag without content.
*/
String getEndTagName();
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/lib/tag/TagLibrary.java 0000664 0000000 0000000 00000003301 12511767770 0027332 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.lib.tag;
import com.hubspot.jinjava.lib.SimpleLibrary;
public class TagLibrary extends SimpleLibrary {
public TagLibrary(boolean registerDefaults) {
super(registerDefaults);
}
@Override
protected void registerDefaults() {
registerClasses(
AutoEscapeTag.class,
BlockTag.class,
CallTag.class,
CycleTag.class,
ElseTag.class,
ElseIfTag.class,
ExtendsTag.class,
ForTag.class,
FromTag.class,
IfTag.class,
IfchangedTag.class,
ImportTag.class,
IncludeTag.class,
MacroTag.class,
PrintTag.class,
RawTag.class,
SetTag.class,
UnlessTag.class);
}
public Tag getTag(String tagName) {
return fetch(tagName);
}
public void addTag(Tag t) {
register(t);
}
@Override
public void register(Tag t) {
super.register(t);
if(t.getEndTagName() != null) {
register(t.getEndTagName(), new EndTag(t));
}
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/lib/tag/UnlessTag.java 0000664 0000000 0000000 00000002335 12511767770 0027205 0 ustar 00root root 0000000 0000000 package com.hubspot.jinjava.lib.tag;
import com.hubspot.jinjava.doc.annotations.JinjavaDoc;
import com.hubspot.jinjava.doc.annotations.JinjavaParam;
import com.hubspot.jinjava.interpret.JinjavaInterpreter;
import com.hubspot.jinjava.tree.TagNode;
import com.hubspot.jinjava.util.ObjectTruthValue;
/**
* Unless is a conditional just like 'if' but works on the inverse logic.
*
* {% unless x < 0 %} x is greater than zero {% endunless %}
*
*
* @author jstehler
*/
@JinjavaDoc(
value="Unless is a conditional just like 'if' but works on the inverse logic.\n\n" +
"{% unless x < 0 %} x is greater than zero {% endunless %}",
params=@JinjavaParam(value="expr", type="expression"))
public class UnlessTag extends IfTag {
@Override
public String getName() {
return "unless";
}
@Override
public String getEndTagName() {
return "endunless";
}
@Override
protected boolean evaluateIfElseTagNode(TagNode tagNode, JinjavaInterpreter interpreter) {
if(tagNode.getName().equals("unless")) {
return !ObjectTruthValue.evaluate(interpreter.resolveELExpression(tagNode.getHelpers(), tagNode.getLineNumber()));
}
return super.evaluateIfElseTagNode(tagNode, interpreter);
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/loader/ 0000775 0000000 0000000 00000000000 12511767770 0024357 5 ustar 00root root 0000000 0000000 jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/loader/CascadingResourceLocator.java 0000664 0000000 0000000 00000001477 12511767770 0032143 0 ustar 00root root 0000000 0000000 package com.hubspot.jinjava.loader;
import java.io.IOException;
import java.nio.charset.Charset;
import java.util.Arrays;
import com.hubspot.jinjava.interpret.JinjavaInterpreter;
public class CascadingResourceLocator implements ResourceLocator {
private Iterable locators;
public CascadingResourceLocator(ResourceLocator... locators) {
this.locators = Arrays.asList(locators);
}
@Override
public String getString(String fullName, Charset encoding,
JinjavaInterpreter interpreter) throws IOException {
for(ResourceLocator locator : locators) {
try {
return locator.getString(fullName, encoding, interpreter);
}
catch(ResourceNotFoundException e) { /* */ }
}
throw new ResourceNotFoundException("Couldn't find resource: " + fullName);
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/loader/ClasspathResourceLocator.java 0000664 0000000 0000000 00000001153 12511767770 0032200 0 ustar 00root root 0000000 0000000 package com.hubspot.jinjava.loader;
import java.io.IOException;
import java.nio.charset.Charset;
import com.google.common.io.Resources;
import com.hubspot.jinjava.interpret.JinjavaInterpreter;
public class ClasspathResourceLocator implements ResourceLocator {
@Override
public String getString(String fullName, Charset encoding,
JinjavaInterpreter interpreter) throws IOException {
try {
return Resources.toString(Resources.getResource(fullName), encoding);
} catch(IllegalArgumentException e) {
throw new ResourceNotFoundException("Couldn't find resource: " + fullName);
}
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/loader/FileLocator.java 0000664 0000000 0000000 00000003670 12511767770 0027433 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.loader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.nio.charset.Charset;
import com.google.common.io.Files;
import com.hubspot.jinjava.interpret.JinjavaInterpreter;
public class FileLocator implements ResourceLocator {
private File baseDir;
/**
* initializes the locator with the base dir for relative paths set to the current working dir
*/
public FileLocator() {
this.baseDir = new File(".");
}
public FileLocator(File baseDir) throws FileNotFoundException {
if(!baseDir.exists()){
throw new FileNotFoundException(String.format("Specified baseDir [%s] does not exist", baseDir.getAbsolutePath()));
}
this.baseDir = baseDir;
}
private File resolveFileName(String name) {
File f = new File(name);
if(f.isAbsolute()) {
return f;
}
return new File(baseDir, name);
}
@Override
public String getString(String name, Charset encoding, JinjavaInterpreter interpreter) throws IOException {
File file = resolveFileName(name);
if (!file.exists() || !file.isFile()) {
throw new ResourceNotFoundException("Couldn't find resource: " + file);
}
return Files.toString(file, encoding);
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/loader/ResourceLocator.java 0000664 0000000 0000000 00000001750 12511767770 0030340 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.loader;
import java.io.IOException;
import java.nio.charset.Charset;
import com.hubspot.jinjava.interpret.JinjavaInterpreter;
public interface ResourceLocator {
String getString(String fullName, Charset encoding, JinjavaInterpreter interpreter) throws IOException;
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/loader/ResourceNotFoundException.java 0000664 0000000 0000000 00000000403 12511767770 0032342 0 ustar 00root root 0000000 0000000 package com.hubspot.jinjava.loader;
import java.io.IOException;
public class ResourceNotFoundException extends IOException {
private static final long serialVersionUID = 1L;
public ResourceNotFoundException(String message) {
super(message);
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/objects/ 0000775 0000000 0000000 00000000000 12511767770 0024542 5 ustar 00root root 0000000 0000000 jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/objects/PyWrapper.java 0000664 0000000 0000000 00000000243 12511767770 0027335 0 ustar 00root root 0000000 0000000 package com.hubspot.jinjava.objects;
/**
* Marker indicating an object is a python wrapper interface
*
* @author jstehler
*/
public interface PyWrapper {
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/objects/collections/ 0000775 0000000 0000000 00000000000 12511767770 0027060 5 ustar 00root root 0000000 0000000 jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/objects/collections/PyList.java 0000664 0000000 0000000 00000004606 12511767770 0031155 0 ustar 00root root 0000000 0000000 package com.hubspot.jinjava.objects.collections;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import com.hubspot.jinjava.objects.PyWrapper;
public class PyList implements List, PyWrapper {
private List list;
public PyList(List list) {
this.list = list;
}
public List toList() {
return list;
}
@Override
public String toString() {
return list.toString();
}
public int size() {
return list.size();
}
public boolean isEmpty() {
return list.isEmpty();
}
public boolean contains(Object o) {
return list.contains(o);
}
public Iterator iterator() {
return list.iterator();
}
public Object[] toArray() {
return list.toArray();
}
public T[] toArray(T[] a) {
return list.toArray(a);
}
public boolean add(Object e) {
return list.add(e);
}
public boolean append(Object e) {
return add(e);
}
public boolean remove(Object o) {
return list.remove(o);
}
public boolean containsAll(Collection c) {
return list.containsAll(c);
}
public boolean addAll(Collection c) {
return list.addAll(c);
}
public boolean addAll(int index, Collection c) {
return list.addAll(index, c);
}
public boolean removeAll(Collection c) {
return list.removeAll(c);
}
public boolean retainAll(Collection c) {
return list.retainAll(c);
}
public void clear() {
list.clear();
}
public boolean equals(Object o) {
return list.equals(o);
}
public int hashCode() {
return list.hashCode();
}
public Object get(int index) {
return list.get(index);
}
public Object set(int index, Object element) {
return list.set(index, element);
}
public void add(int index, Object element) {
list.add(index, element);
}
public Object remove(int index) {
return list.remove(index);
}
public int indexOf(Object o) {
return list.indexOf(o);
}
public int lastIndexOf(Object o) {
return list.lastIndexOf(o);
}
public ListIterator listIterator() {
return list.listIterator();
}
public ListIterator listIterator(int index) {
return list.listIterator(index);
}
public List subList(int fromIndex, int toIndex) {
return list.subList(fromIndex, toIndex);
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/objects/collections/PyMap.java 0000664 0000000 0000000 00000003201 12511767770 0030745 0 ustar 00root root 0000000 0000000 package com.hubspot.jinjava.objects.collections;
import java.util.Collection;
import java.util.Map;
import java.util.Set;
import com.hubspot.jinjava.objects.PyWrapper;
public class PyMap implements Map, PyWrapper {
private Map map;
public PyMap(Map map) {
this.map = map;
}
public Map toMap() {
return map;
}
@Override
public String toString() {
return map.toString();
}
@Override
public int size() {
return map.size();
}
@Override
public boolean isEmpty() {
return map.isEmpty();
}
@Override
public boolean containsKey(Object key) {
return map.containsKey(key);
}
@Override
public boolean containsValue(Object value) {
return map.containsValue(value);
}
@Override
public Object get(Object key) {
return map.get(key);
}
@Override
public Object put(String key, Object value) {
return map.put(key, value);
}
@Override
public Object remove(Object key) {
return map.remove(key);
}
@Override
public void putAll(Map m) {
map.putAll(m);
}
@Override
public void clear() {
map.clear();
}
@Override
public Set keySet() {
return map.keySet();
}
@Override
public Collection values() {
return map.values();
}
@Override
public Set> entrySet() {
return map.entrySet();
}
public Set> items() {
return entrySet();
}
public void update(Map m) {
putAll(m);
}
} jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/objects/date/ 0000775 0000000 0000000 00000000000 12511767770 0025457 5 ustar 00root root 0000000 0000000 jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/objects/date/FormattedDate.java 0000664 0000000 0000000 00000001036 12511767770 0031045 0 ustar 00root root 0000000 0000000 package com.hubspot.jinjava.objects.date;
import java.time.ZonedDateTime;
public class FormattedDate {
private final String format;
private final String language;
private final ZonedDateTime date;
public FormattedDate(String format, String language, ZonedDateTime date) {
this.format = format;
this.language = language;
this.date = date;
}
public String getFormat() {
return format;
}
public ZonedDateTime getDate() {
return date;
}
public String getLanguage() {
return language;
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/objects/date/PyishDate.java 0000664 0000000 0000000 00000004522 12511767770 0030217 0 ustar 00root root 0000000 0000000 package com.hubspot.jinjava.objects.date;
import java.io.Serializable;
import java.time.Instant;
import java.time.ZoneOffset;
import java.time.ZonedDateTime;
import java.time.temporal.ChronoField;
import java.util.Date;
import java.util.Objects;
import org.apache.commons.lang3.math.NumberUtils;
import com.google.common.base.Optional;
import com.hubspot.jinjava.objects.PyWrapper;
/**
* an object which quacks like a python date
*
* @author jstehler
*
*/
public final class PyishDate extends Date implements Serializable, PyWrapper {
private static final long serialVersionUID = 1L;
private final ZonedDateTime date;
public PyishDate(ZonedDateTime dt) {
super(Objects.requireNonNull(dt).toInstant().toEpochMilli());
this.date = dt;
}
public PyishDate(Date d) {
this(ZonedDateTime.ofInstant(Objects.requireNonNull(d).toInstant(), ZoneOffset.UTC));
}
public PyishDate(String publishDateStr) {
this(NumberUtils.toLong(Objects.requireNonNull(publishDateStr), 0L));
}
public PyishDate(Long epochMillis) {
this(ZonedDateTime.ofInstant(Instant.ofEpochMilli(Optional.fromNullable(epochMillis).or(System.currentTimeMillis())), ZoneOffset.UTC));
}
public String isoformat() {
return strftime("YYYY-MM-DD");
}
public String strftime(String fmt) {
return StrftimeFormatter.format(date, fmt);
}
public int getYear() {
return date.getYear();
}
public int getMonth() {
return date.getMonthValue();
}
public int getDay() {
return date.getDayOfMonth();
}
public int getHour() {
return date.getHour();
}
public int getMinute() {
return date.getMinute();
}
public int getSecond() {
return date.getSecond();
}
public int getMicrosecond() {
return date.get(ChronoField.MILLI_OF_SECOND);
}
public Date toDate() {
return Date.from(date.toInstant());
}
public ZonedDateTime toDateTime() {
return date;
}
@Override
public String toString() {
return strftime("yyyy-MM-dd HH:mm:ss");
}
@Override
public int hashCode() {
return Objects.hashCode(date);
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (obj == null || getClass() != obj.getClass()) return false;
PyishDate that = (PyishDate) obj;
return Objects.equals(toDateTime(), that.toDateTime());
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/objects/date/StrftimeFormatter.java 0000664 0000000 0000000 00000010231 12511767770 0032000 0 ustar 00root root 0000000 0000000 package com.hubspot.jinjava.objects.date;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.lang3.StringUtils;
/**
* Datetime format string formatter, supporting both python and java compatible format strings by
* converting any percent-tokens from python into their java equivalents.
*
* @author jstehler
*/
public class StrftimeFormatter {
public static final String DEFAULT_DATE_FORMAT = "%H:%M / %d-%m-%Y";
/*
* Mapped from http://strftime.org/, http://docs.oracle.com/javase/7/docs/api/java/text/SimpleDateFormat.html
*/
private static final Map CONVERSIONS = new HashMap();
static {
CONVERSIONS.put('a', "EEE");
CONVERSIONS.put('A', "EEEE");
CONVERSIONS.put('b', "MMM");
CONVERSIONS.put('B', "MMMM");
CONVERSIONS.put('c', "EEE MMM dd HH:mm:ss yyyy");
CONVERSIONS.put('d', "dd");
CONVERSIONS.put('e', "dd"); // The day of the month like with %d, but padded with blank (range 1 through 31).
CONVERSIONS.put('f', "SSSS");
CONVERSIONS.put('H', "HH");
CONVERSIONS.put('h', "hh");
CONVERSIONS.put('I', "hh");
CONVERSIONS.put('j', "DDD");
CONVERSIONS.put('k', "HH"); // The hour as a decimal number, using a 24-hour clock like %H, but padded with blank (range 0 through 23).
CONVERSIONS.put('l', "hh"); // The hour as a decimal number, using a 12-hour clock like %I, but padded with blank (range 1 through 12).
CONVERSIONS.put('m', "MM");
CONVERSIONS.put('M', "mm");
CONVERSIONS.put('p', "a");
CONVERSIONS.put('S', "ss");
CONVERSIONS.put('U', "ww");
CONVERSIONS.put('w', "uu");
CONVERSIONS.put('W', "ww");
CONVERSIONS.put('x', "MM/dd/yy");
CONVERSIONS.put('X', "HH:mm:ss");
CONVERSIONS.put('y', "yy");
CONVERSIONS.put('Y', "yyyy");
CONVERSIONS.put('z', "Z");
CONVERSIONS.put('Z', "ZZZ");
CONVERSIONS.put('%', "%");
}
/**
* Parses a string in python strftime format, returning the equivalent string in java date time format.
*
* @param strftime
* @return date formatted as string
*/
private static String toJavaDateTimeFormat(String strftime) {
if(!StringUtils.contains(strftime, '%')) {
return replaceL(strftime);
}
StringBuilder result = new StringBuilder();
for(int i = 0; i < strftime.length(); i++) {
char c = strftime.charAt(i);
if(c == '%') {
c = strftime.charAt(++i);
boolean stripLeadingZero = false;
if(c == '-') {
stripLeadingZero = true;
c = strftime.charAt(++i);
}
if(stripLeadingZero) {
result.append(CONVERSIONS.get(c).substring(1));
}
else {
result.append(CONVERSIONS.get(c));
}
}
else if(Character.isLetter(c)) {
result.append("'");
while(Character.isLetter(c)) {
result.append(c);
if(++i < strftime.length()) {
c = strftime.charAt(i);
}
else {
c = 0;
}
}
result.append("'");
--i; // re-consume last char
}
else {
result.append(c);
}
}
return replaceL(result.toString());
}
private static String replaceL(String s) {
return StringUtils.replaceChars(s, 'L', 'M');
}
public static DateTimeFormatter formatter(String strftime) {
switch (strftime.toLowerCase()) {
case "short":
return DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT);
case "medium":
return DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM);
case "long":
return DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG);
case "full":
return DateTimeFormatter.ofLocalizedDateTime(FormatStyle.FULL);
default:
return DateTimeFormatter.ofPattern(toJavaDateTimeFormat(strftime));
}
}
public static String format(ZonedDateTime d) {
return format(d, DEFAULT_DATE_FORMAT);
}
public static String format(ZonedDateTime d, String strftime) {
return formatter(strftime).format(d);
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/tree/ 0000775 0000000 0000000 00000000000 12511767770 0024050 5 ustar 00root root 0000000 0000000 jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/tree/ExpressionNode.java 0000664 0000000 0000000 00000004103 12511767770 0027656 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.tree;
import java.util.LinkedList;
import org.apache.commons.lang3.StringUtils;
import com.hubspot.jinjava.interpret.JinjavaInterpreter;
import com.hubspot.jinjava.tree.parse.ExpressionToken;
import com.hubspot.jinjava.util.Logging;
import com.hubspot.jinjava.util.ObjectValue;
public class ExpressionNode extends Node {
private static final long serialVersionUID = 341642231109911346L;
private final ExpressionToken master;
public ExpressionNode(ExpressionToken token) {
super(token, token.getLineNumber());
master = token;
}
@Override
public String render(JinjavaInterpreter interpreter) {
Object var = interpreter.resolveELExpression(master.getExpr(), getLineNumber());
String result = ObjectValue.printable(var);
if(!StringUtils.equals(result, master.getImage()) && StringUtils.contains(result, "{{")) {
try {
return interpreter.renderString(result);
}
catch(Exception e) {
Logging.ENGINE_LOG.warn("Error rendering variable node result", e);
}
}
return result;
}
@Override
public String toString() {
return master.toString();
}
@Override
public String getName() {
return getClass().getSimpleName();
}
@Override
public Node clone() {
Node clone = new ExpressionNode(master);
clone.setChildren(new LinkedList<>(this.getChildren()));
return clone;
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/tree/Node.java 0000664 0000000 0000000 00000005301 12511767770 0025577 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.tree;
import java.io.Serializable;
import java.util.LinkedList;
import org.apache.commons.lang3.StringUtils;
import com.hubspot.jinjava.interpret.JinjavaInterpreter;
import com.hubspot.jinjava.tree.parse.Token;
public abstract class Node implements Serializable, Cloneable {
private static final long serialVersionUID = 7323842986596895498L;
private int level;
private int lineNumber;
private Node parent = null;
private LinkedList children = new LinkedList();
private Token master;
public Node(Token master, int lineNumber) {
this.master = master;
this.lineNumber = lineNumber;
}
public int getLevel() {
return level;
}
public Node getParent() {
return parent;
}
public void setParent(Node parent) {
this.parent = parent;
}
public Token getMaster() {
return master;
}
public int getLineNumber() {
return lineNumber;
}
public LinkedList getChildren() {
return children;
}
public void setChildren(LinkedList children) {
this.children = children;
}
@Override
public abstract Node clone();
/**
* trusty call by TreeParser
*
* @param node
*/
void add(Node node) {
node.level = level + 1;
node.parent = this;
children.add(node);
}
void computeLevel(int baseLevel) {
level = baseLevel;
for (Node child : children) {
child.computeLevel(level + 1);
}
}
public abstract String render(JinjavaInterpreter interpreter);
public abstract String getName();
public String toTreeString() {
return toTreeString(0);
}
public String toTreeString(int level) {
String prefix = StringUtils.repeat(" ", level * 4) + " ";
StringBuilder t = new StringBuilder(prefix).append(toString()).append('\n');
for(Node n : getChildren()) {
t.append(n.toTreeString(level + 1));
}
if(getChildren().size() > 0) {
t.append(prefix).append("end :: " + toString()).append('\n');
}
return t.toString();
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/tree/RootNode.java 0000664 0000000 0000000 00000002524 12511767770 0026447 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.tree;
import java.util.LinkedList;
import com.hubspot.jinjava.interpret.JinjavaInterpreter;
public class RootNode extends Node {
private static final long serialVersionUID = 97675838726004658L;
RootNode() {
super(null, 0);
}
@Override
public String render(JinjavaInterpreter interpreter) {
throw new UnsupportedOperationException("Please render RootNode by interpreter");
}
@Override
public String getName() {
return getClass().getSimpleName();
}
@Override
public Node clone() {
Node clone = new RootNode();
clone.setChildren(new LinkedList<>(this.getChildren()));
return clone;
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/tree/TagNode.java 0000664 0000000 0000000 00000004201 12511767770 0026231 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.tree;
import java.util.LinkedList;
import com.hubspot.jinjava.interpret.InterpretException;
import com.hubspot.jinjava.interpret.JinjavaInterpreter;
import com.hubspot.jinjava.lib.tag.Tag;
import com.hubspot.jinjava.tree.parse.TagToken;
public class TagNode extends Node {
private static final long serialVersionUID = 2405693063353887509L;
private final Tag tag;
private final TagToken master;
private final String endName;
public TagNode(Tag tag, TagToken token) {
super(token, token.getLineNumber());
this.master = token;
this.tag = tag;
this.endName = tag.getEndTagName();
}
private TagNode(TagNode n) {
super(n.master, n.getLineNumber());
tag = n.tag;
master = n.master;
endName = n.endName;
}
@Override
public String render(JinjavaInterpreter interpreter) {
try {
return tag.interpret(this, interpreter);
} catch (Exception e) {
throw new InterpretException("Error rendering tag", e, master.getLineNumber());
}
}
@Override
public String toString() {
return master.toString();
}
@Override
public String getName() {
return master.getTagName();
}
public String getEndName() {
return endName;
}
public String getHelpers() {
return master.getHelpers();
}
@Override
public Node clone() {
Node clone = new TagNode(this);
clone.setChildren(new LinkedList<>(this.getChildren()));
return clone;
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/tree/TextNode.java 0000664 0000000 0000000 00000003001 12511767770 0026437 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.tree;
import java.util.LinkedList;
import com.hubspot.jinjava.interpret.JinjavaInterpreter;
import com.hubspot.jinjava.tree.parse.TextToken;
public class TextNode extends Node {
private static final long serialVersionUID = 8488738480534354216L;
private final TextToken master;
public TextNode(TextToken token) {
super(token, token.getLineNumber());
master = token;
}
@Override
public String render(JinjavaInterpreter interpreter) {
return master.output();
}
@Override
public String toString() {
return master.toString();
}
@Override
public String getName() {
return getClass().getSimpleName();
}
@Override
public Node clone() {
Node clone = new TextNode(master);
clone.setChildren(new LinkedList<>(this.getChildren()));
return clone;
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/tree/TreeParser.java 0000664 0000000 0000000 00000010531 12511767770 0026767 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.tree;
import static com.hubspot.jinjava.tree.parse.TokenScannerSymbols.TOKEN_EXPR_START;
import static com.hubspot.jinjava.tree.parse.TokenScannerSymbols.TOKEN_FIXED;
import static com.hubspot.jinjava.tree.parse.TokenScannerSymbols.TOKEN_NOTE;
import static com.hubspot.jinjava.tree.parse.TokenScannerSymbols.TOKEN_TAG;
import com.hubspot.jinjava.interpret.JinjavaInterpreter;
import com.hubspot.jinjava.interpret.MissingEndTagException;
import com.hubspot.jinjava.interpret.TemplateError;
import com.hubspot.jinjava.interpret.TemplateSyntaxException;
import com.hubspot.jinjava.interpret.UnexpectedTokenException;
import com.hubspot.jinjava.interpret.UnknownTagException;
import com.hubspot.jinjava.lib.tag.EndTag;
import com.hubspot.jinjava.lib.tag.Tag;
import com.hubspot.jinjava.tree.parse.ExpressionToken;
import com.hubspot.jinjava.tree.parse.TagToken;
import com.hubspot.jinjava.tree.parse.TextToken;
import com.hubspot.jinjava.tree.parse.Token;
import com.hubspot.jinjava.tree.parse.TokenScanner;
public class TreeParser {
private final TokenScanner scanner;
private final JinjavaInterpreter interpreter;
private Node parent;
public TreeParser(JinjavaInterpreter interpreter, String input){
this.scanner = new TokenScanner(input);
this.interpreter = interpreter;
}
public Node buildTree() {
Node root = new RootNode();
parent = root;
while(scanner.hasNext()) {
Node node = nextNode();
if(node != null) {
parent.getChildren().add(node);
}
}
if(parent != root) {
interpreter.addError(TemplateError.fromException(
new MissingEndTagException(((TagNode) parent).getEndName(), parent.getMaster().getImage(), parent.getLineNumber())));
}
return root;
}
/**
* @return null if EOF or error
*/
private Node nextNode() {
Token token = scanner.next();
switch(token.getType()) {
case TOKEN_FIXED:
return text((TextToken) token);
case TOKEN_EXPR_START:
return expression((ExpressionToken) token);
case TOKEN_TAG:
return tag((TagToken) token);
case TOKEN_NOTE:
break;
default:
interpreter.addError(TemplateError.fromException(new UnexpectedTokenException(token.getImage(), token.getLineNumber())));
}
return null;
}
private Node text(TextToken textToken) {
TextNode n = new TextNode(textToken);
n.setParent(parent);
return n;
}
private Node expression(ExpressionToken expressionToken) {
ExpressionNode n = new ExpressionNode(expressionToken);
n.setParent(parent);
return n;
}
private Node tag(TagToken tagToken) {
Tag tag = interpreter.getContext().getTag(tagToken.getTagName());
if (tag == null) {
interpreter.addError(TemplateError.fromException(new UnknownTagException(tagToken)));
return null;
}
if(tag instanceof EndTag) {
endTag(tag, tagToken);
return null;
}
TagNode node = new TagNode(tag, tagToken);
node.setParent(parent);
if(node.getEndName() != null) {
parent.getChildren().add(node);
parent = node;
return null;
}
return node;
}
private void endTag(Tag tag, TagToken tagToken) {
while(!(parent instanceof RootNode)) {
TagNode parentTag = (TagNode) parent;
parent = parent.getParent();
if(parentTag.getEndName().equals(tag.getEndTagName())) {
break;
}
else {
interpreter.addError(TemplateError.fromException(
new TemplateSyntaxException(tagToken.getImage(), "Mismatched end tag, expected: " + parentTag.getEndName(), tagToken.getLineNumber())));
}
}
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/tree/parse/ 0000775 0000000 0000000 00000000000 12511767770 0025162 5 ustar 00root root 0000000 0000000 jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/tree/parse/ExpressionToken.java 0000664 0000000 0000000 00000003501 12511767770 0031164 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.tree.parse;
import static com.hubspot.jinjava.tree.parse.TokenScannerSymbols.TOKEN_EXPR_START;
import org.apache.commons.lang3.StringUtils;
import com.hubspot.jinjava.util.WhitespaceUtils;
public class ExpressionToken extends Token {
private static final long serialVersionUID = 8307037212944170832L;
private String expr;
public ExpressionToken(String image, int lineNumber) {
super(image, lineNumber);
}
@Override
public String toString() {
StringBuilder s = new StringBuilder("{{ ").append(getExpr()).append("}}");
return s.toString();
}
@Override
public int getType() {
return TOKEN_EXPR_START;
}
@Override
protected void parse() {
this.expr = WhitespaceUtils.unwrap(image, "{{", "}}");
if(WhitespaceUtils.startsWith(expr, "-")) {
setLeftTrim(true);
this.expr = WhitespaceUtils.unwrap(expr, "-", "");
}
if(WhitespaceUtils.endsWith(expr, "-")) {
setRightTrim(true);
this.expr = WhitespaceUtils.unwrap(expr, "", "-");
}
this.expr = StringUtils.trimToEmpty(this.expr);
}
public String getExpr() {
return expr;
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/tree/parse/NoteToken.java 0000664 0000000 0000000 00000002377 12511767770 0027744 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.tree.parse;
import static com.hubspot.jinjava.tree.parse.TokenScannerSymbols.TOKEN_NOTE;
public class NoteToken extends Token {
private static final long serialVersionUID = 6112027107603795408L;
public NoteToken(String image, int lineNumber) {
super(image, lineNumber);
}
@Override
public int getType() {
return TOKEN_NOTE;
}
/**
* remove all content, we don't need it.
*/
@Override
protected void parse() {
content = "";
}
@Override
public String toString() {
return "{# ----comment---- #}";
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/tree/parse/TagToken.java 0000664 0000000 0000000 00000004606 12511767770 0027547 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.tree.parse;
import static com.hubspot.jinjava.tree.parse.TokenScannerSymbols.TOKEN_TAG;
import com.hubspot.jinjava.util.WhitespaceUtils;
public class TagToken extends Token {
private static final long serialVersionUID = 2766011408032384360L;
private String tagName;
private String helpers;
public TagToken(String image, int lineNumber) {
super(image, lineNumber);
}
@Override
public int getType() {
return TOKEN_TAG;
}
/**
* Get tag name
*/
@Override
protected void parse() {
content = image.substring(2, image.length() - 2);
if(WhitespaceUtils.startsWith(content, "-")) {
setLeftTrim(true);
content = WhitespaceUtils.unwrap(content, "-", "");
}
if(WhitespaceUtils.endsWith(content, "-")) {
setRightTrim(true);
content = WhitespaceUtils.unwrap(content, "", "-");
}
int nameStart = -1, pos = 0, len = content.length();
for(; pos < len; pos++) {
char c = content.charAt(pos);
if(nameStart == -1 && Character.isJavaIdentifierStart(c)) {
nameStart = pos;
}
else if(nameStart != -1 && !Character.isJavaIdentifierPart(c)) {
break;
}
}
if(pos < content.length()) {
tagName = content.substring(nameStart, pos).toLowerCase();
helpers = content.substring(pos);
} else {
tagName = content.toLowerCase().trim();
helpers = "";
}
}
public String getTagName() {
return tagName;
}
public String getHelpers() {
return helpers;
}
@Override
public String toString() {
if (helpers.length() == 0) {
return "{% " + tagName + " %}";
}
return "{% " + tagName + " " + helpers + " %}";
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/tree/parse/TextToken.java 0000664 0000000 0000000 00000002744 12511767770 0027761 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.tree.parse;
import static com.hubspot.jinjava.tree.parse.TokenScannerSymbols.TOKEN_FIXED;
import org.apache.commons.lang3.StringUtils;
public class TextToken extends Token {
private static final long serialVersionUID = -5015884072204770458L;
public TextToken(String image, int lineNumber) {
super(image, lineNumber);
}
@Override
public int getType() {
return TOKEN_FIXED;
}
@Override
protected void parse() {
content = image;
}
public boolean isBlank() {
return StringUtils.isBlank(content);
}
public String trim() {
return content.trim();
}
public String output() {
return content;
}
@Override
public String toString() {
if (isBlank()) {
return "{~ ~}";
}
return "{~ " + content + " ~}";
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/tree/parse/Token.java 0000664 0000000 0000000 00000005065 12511767770 0027113 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.tree.parse;
import static com.hubspot.jinjava.tree.parse.TokenScannerSymbols.TOKEN_EXPR_START;
import static com.hubspot.jinjava.tree.parse.TokenScannerSymbols.TOKEN_FIXED;
import static com.hubspot.jinjava.tree.parse.TokenScannerSymbols.TOKEN_NOTE;
import static com.hubspot.jinjava.tree.parse.TokenScannerSymbols.TOKEN_TAG;
import java.io.Serializable;
import com.hubspot.jinjava.interpret.UnexpectedTokenException;
public abstract class Token implements Serializable {
private static final long serialVersionUID = -7513379852268838992L;
protected final String image;
// useful for some token type
protected String content;
protected final int lineNumber;
private boolean leftTrim;
private boolean rightTrim;
public Token(String image, int lineNumber) {
this.image = image;
this.lineNumber = lineNumber;
parse();
}
public String getImage() {
return image;
}
public int getLineNumber() {
return lineNumber;
}
public boolean isLeftTrim() {
return leftTrim;
}
public boolean isRightTrim() {
return rightTrim;
}
public void setLeftTrim(boolean leftTrim) {
this.leftTrim = leftTrim;
}
public void setRightTrim(boolean rightTrim) {
this.rightTrim = rightTrim;
}
@Override
public String toString() {
return image;
}
protected abstract void parse();
public abstract int getType();
static Token newToken(int tokenKind, String image, int lineNumber) {
switch (tokenKind) {
case TOKEN_FIXED:
return new TextToken(image, lineNumber);
case TOKEN_NOTE:
return new NoteToken(image, lineNumber);
case TOKEN_EXPR_START:
return new ExpressionToken(image, lineNumber);
case TOKEN_TAG:
return new TagToken(image, lineNumber);
default:
throw new UnexpectedTokenException(String.valueOf((char) tokenKind), lineNumber);
}
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/tree/parse/TokenScanner.java 0000664 0000000 0000000 00000016324 12511767770 0030425 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.tree.parse;
import static com.hubspot.jinjava.tree.parse.TokenScannerSymbols.TOKEN_EXPR_END;
import static com.hubspot.jinjava.tree.parse.TokenScannerSymbols.TOKEN_EXPR_START;
import static com.hubspot.jinjava.tree.parse.TokenScannerSymbols.TOKEN_FIXED;
import static com.hubspot.jinjava.tree.parse.TokenScannerSymbols.TOKEN_NEWLINE;
import static com.hubspot.jinjava.tree.parse.TokenScannerSymbols.TOKEN_NOTE;
import static com.hubspot.jinjava.tree.parse.TokenScannerSymbols.TOKEN_POSTFIX;
import static com.hubspot.jinjava.tree.parse.TokenScannerSymbols.TOKEN_PREFIX;
import static com.hubspot.jinjava.tree.parse.TokenScannerSymbols.TOKEN_TAG;
import com.google.common.collect.AbstractIterator;
public class TokenScanner extends AbstractIterator {
private final char[] is;
private int currPost = 0;
private int tokenStart = 0;
private int tokenLength = 0;
private int tokenKind = -1;
private int length = 0;
private int lastStart = 0;
private int inComment = 0;
private int inRaw = 0;
private int inBlock = 0;
private char inQuote = 0;
private int currLine = 1;
public TokenScanner(String input) {
is = input.toCharArray();
length = input.length();
currPost = 0;
tokenStart = 0;
tokenKind = -1;
lastStart = 0;
inComment = 0;
inRaw = 0;
inBlock = 0;
inQuote = 0;
currLine = 1;
}
public Token getNextToken() {
char c = 0;
while (currPost < length) {
c = is[currPost++];
if (currPost == length) {
return getEndToken();
}
if(inBlock > 0) {
if(inQuote != 0) {
if(inQuote != c) {
continue;
}
else if(is[currPost - 2] == '\\') {
continue;
}
else {
inQuote = 0;
continue;
}
}
else if(inQuote == 0 && (c == '\'' || c == '"')){
inQuote = c;
continue;
}
}
switch (c) {
case TOKEN_PREFIX:
if (currPost < length) {
c = is[currPost];
switch (c) {
case TOKEN_NOTE:
if(inComment == 1 || inRaw == 1) {
continue;
}
inComment = 1;
tokenLength = currPost - tokenStart - 1;
if (tokenLength > 0) {
// start a new token
lastStart = tokenStart;
tokenStart = --currPost;
tokenKind = c;
inComment = 0;
return newToken(TOKEN_FIXED);
} else {
tokenKind = c;
}
break;
case TOKEN_TAG:
case TOKEN_EXPR_START:
if (inComment > 0) {
continue;
}
if (inRaw > 0 && (c == TOKEN_EXPR_START || !isEndRaw())) {
continue;
}
// match token two ends
if (!matchToken(c) && tokenKind > 0) {
continue;
}
if(inBlock++ > 0) {
continue;
}
tokenLength = currPost - tokenStart - 1;
if (tokenLength > 0) {
// start a new token
lastStart = tokenStart;
tokenStart = --currPost;
tokenKind = c;
return newToken(TOKEN_FIXED);
} else {
tokenKind = c;
}
break;
}
}
// reach the stream end
else {
return getEndToken();
}
break;
// maybe current token is closing
case TOKEN_TAG:
case TOKEN_EXPR_END:
if (inComment > 0) {
continue;
}
if (!matchToken(c)) {
continue;
}
if (currPost < length) {
c = is[currPost];
if (c == TOKEN_POSTFIX) {
inBlock = 0;
tokenLength = currPost - tokenStart + 1;
if (tokenLength > 0) {
// start a new token
lastStart = tokenStart;
tokenStart = ++currPost;
int kind = tokenKind;
tokenKind = TOKEN_FIXED;
return newToken(kind);
}
}
} else {
return getEndToken();
}
break;
case TOKEN_NOTE:
if (!matchToken(c)) {
continue;
}
if (currPost < length) {
c = is[currPost];
if (c == TOKEN_POSTFIX) {
inComment = 0;
tokenLength = currPost - tokenStart + 1;
if (tokenLength > 0) {
// start a new token
lastStart = tokenStart;
tokenStart = ++currPost;
tokenKind = TOKEN_FIXED;
return newToken(TOKEN_NOTE);
}
}
} else {
return getEndToken();
}
break;
case TOKEN_NEWLINE:
currLine++;
if(inComment > 0 || inBlock > 0) {
continue;
}
tokenKind = TOKEN_FIXED;
break;
default:
if (tokenKind == -1) {
tokenKind = TOKEN_FIXED;
}
}
}
return null;
}
private boolean isEndRaw() {
int pos = currPost + 1;
while(pos < length) {
if(!Character.isWhitespace(is[pos++])) {
break;
}
}
if(pos + 5 >= length) {
return false;
}
return "endraw".equals(String.valueOf(is, pos - 1, 6));
}
private Token getEndToken() {
tokenLength = currPost - tokenStart;
int type = TOKEN_FIXED;
if (inComment > 0) {
type = TOKEN_NOTE;
}
return Token.newToken(type, String.valueOf(is, tokenStart, tokenLength), currLine);
}
private Token newToken(int kind) {
Token t = Token.newToken(kind, String.copyValueOf(is, lastStart, tokenLength), currLine);
if(t instanceof TagToken) {
TagToken tt = (TagToken) t;
if("raw".equals(tt.getTagName())) {
inRaw = 1;
return tt;
}
else if("endraw".equals(tt.getTagName())) {
inRaw = 0;
return tt;
}
}
if(inRaw > 0 && t.getType() != TOKEN_FIXED) {
return Token.newToken(TOKEN_FIXED, t.image, currLine);
}
return t;
}
private boolean matchToken(char kind) {
if (kind == TOKEN_EXPR_START) {
return tokenKind == TOKEN_EXPR_END;
} else if (kind == TOKEN_EXPR_END) {
return tokenKind == TOKEN_EXPR_START;
} else {
return kind == tokenKind;
}
}
@Override
protected Token computeNext() {
Token t = getNextToken();
if(t == null) {
return endOfData();
}
return t;
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/tree/parse/TokenScannerSymbols.java 0000664 0000000 0000000 00000001737 12511767770 0032000 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.tree.parse;
public interface TokenScannerSymbols {
int TOKEN_PREFIX = '{';
int TOKEN_POSTFIX = '}';
int TOKEN_FIXED = 0;
int TOKEN_NOTE = '#';
int TOKEN_TAG = '%';
int TOKEN_EXPR_START = '{';
int TOKEN_EXPR_END = '}';
int TOKEN_NEWLINE = '\n';
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/util/ 0000775 0000000 0000000 00000000000 12511767770 0024066 5 ustar 00root root 0000000 0000000 jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/util/ForLoop.java 0000664 0000000 0000000 00000006342 12511767770 0026316 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.util;
import static com.hubspot.jinjava.util.Logging.ENGINE_LOG;
import java.util.Iterator;
public class ForLoop implements Iterator {
private static final int NULL_VALUE = Integer.MIN_VALUE;
private int index = -1;
private int counter = 0;
private int revindex = NULL_VALUE;
private int revcounter = NULL_VALUE;
private int length = NULL_VALUE;
private boolean first = true;
private boolean last;
private int depth;
private Iterator it;
public ForLoop(Iterator ite, int len) {
length = len;
if (len < 2) {
revindex = 1;
revcounter = 2;
last = true;
} else {
revindex = len;
revcounter = len + 1;
last = false;
}
it = ite;
}
public ForLoop(Iterator ite) {
it = ite;
if (it.hasNext()) {
last = false;
} else {
length = 0;
revindex = 1;
revcounter = 2;
last = true;
}
}
public Object next() {
Object res;
if (it.hasNext()) {
index++;
counter++;
if (length != NULL_VALUE) {
revindex--;
revcounter--;
}
res = it.next();
if (!it.hasNext()) {
last = true;
length = counter;
revindex = 0;
revcounter = 1;
}
if (index > 0) {
first = false;
}
} else {
res = null;
}
return res;
}
public int getIndex() {
return index + 1;
}
public int getIndex0() {
return index;
}
public int getDepth() {
return depth + 1;
}
public int getDepth0() {
return depth;
}
public int getCounter() {
return counter;
}
public int getRevindex() {
return getRevindex0() + 1;
}
public int getRevindex0() {
if (revindex == NULL_VALUE) {
ENGINE_LOG.warn("can't compute items' length while looping.");
}
return revindex;
}
public int getRevcounter() {
if (revcounter == NULL_VALUE) {
ENGINE_LOG.warn("can't compute items' length while looping.");
}
return revcounter;
}
public int getLength() {
if (revcounter == NULL_VALUE) {
ENGINE_LOG.warn("can't compute items' length while looping.");
}
return length;
}
public boolean isFirst() {
return first;
}
public boolean isLast() {
return last;
}
@Override
public boolean hasNext() {
return it.hasNext();
}
public Object cycle(Object... items) {
int i = getIndex0() % items.length;
return items[i];
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/util/HelperStringTokenizer.java 0000664 0000000 0000000 00000005620 12511767770 0031235 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.util;
import java.util.List;
import com.google.common.collect.AbstractIterator;
import com.google.common.collect.Lists;
/**
* Whitespace and comma as separator quote to accept them as normal char
*
* @author fangchq
*
*/
public class HelperStringTokenizer extends AbstractIterator {
private char[] helpers;
private int currPost = 0;
private int tokenStart = 0;
private int length = 0;
private char lastChar = ' ';
private boolean useComma = false;
private char quoteChar = 0;
private boolean inQuote = false;
public HelperStringTokenizer(String tobeToken) {
helpers = tobeToken.toCharArray();
length = tobeToken.length();
}
/**
* use Comma as token split or not true use it; false don't use it.
*
* @param onOrOff flag to indicate whether or not to split on commas
* @return this instance for method chaining
*/
public HelperStringTokenizer splitComma(boolean onOrOff) {
useComma = onOrOff;
return this;
}
@Override
protected String computeNext() {
String token;
while (currPost < length) {
token = makeToken();
lastChar = helpers[currPost - 1];
if (token != null) {
return token;
}
}
endOfData();
return null;
}
private String makeToken() {
char c = helpers[currPost++];
if (c == '"' || c == '\'') {
if (inQuote) {
if (quoteChar == c) {
inQuote = false;
}
} else {
inQuote = true;
quoteChar = c;
}
}
if ((Character.isWhitespace(c) || (useComma && c == ',')) && !inQuote) {
return newToken();
}
if (currPost == length) {
return getEndToken();
}
return null;
}
private String getEndToken() {
return String.copyValueOf(helpers, tokenStart, currPost - tokenStart);
}
private String newToken() {
int lastStart = tokenStart;
tokenStart = currPost;
if (Character.isWhitespace(lastChar) || (useComma && lastChar == ',')) {
return null;
}
// startChar = -1;//change to save quote in helper
return String.copyValueOf(helpers, lastStart, currPost - lastStart - 1);
}
public List allTokens() {
return Lists.newArrayList(this);
}
}
JinjavaPropertyNotResolvedException.java 0000664 0000000 0000000 00000001140 12511767770 0034041 0 ustar 00root root 0000000 0000000 jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/util package com.hubspot.jinjava.util;
import com.hubspot.jinjava.interpret.InterpretException;
public class JinjavaPropertyNotResolvedException extends InterpretException {
private static final long serialVersionUID = 1L;
private final Object base;
private final String property;
public JinjavaPropertyNotResolvedException(Object base, String property) {
super("Unable to resolve property: '" + property + "' in " + base);
this.base = base;
this.property = property;
}
public Object getBase() {
return base;
}
public String getProperty() {
return property;
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/util/Logging.java 0000664 0000000 0000000 00000001560 12511767770 0026321 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.util;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public interface Logging {
Logger ENGINE_LOG = LoggerFactory.getLogger("jinjava");
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/util/ObjectIterator.java 0000664 0000000 0000000 00000003674 12511767770 0027663 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.util;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.Map;
import com.google.common.collect.Iterators;
public final class ObjectIterator {
private ObjectIterator() {}
@SuppressWarnings("unchecked")
public static ForLoop getLoop(Object obj) {
if (obj == null) {
return new ForLoop(new ArrayList().iterator(), 0);
}
// collection
if (obj instanceof Collection) {
Collection clt = (Collection) obj;
return new ForLoop(clt.iterator(), clt.size());
}
// array
if (obj.getClass().isArray()) {
Object[] arr = (Object[]) obj;
return new ForLoop(Iterators.forArray(arr), arr.length);
}
// map
if (obj instanceof Map) {
Collection clt = ((Map) obj).values();
return new ForLoop(clt.iterator(), clt.size());
}
// iterable,iterator
if (obj instanceof Iterable) {
return new ForLoop(((Iterable) obj).iterator());
}
if (obj instanceof Iterator) {
return new ForLoop((Iterator) obj);
}
// others
ArrayList res = new ArrayList();
res.add(obj);
return new ForLoop(res.iterator(), 1);
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/util/ObjectTruthValue.java 0000664 0000000 0000000 00000003122 12511767770 0030161 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.util;
import java.lang.reflect.Array;
import java.util.Collection;
import java.util.Map;
public final class ObjectTruthValue {
private ObjectTruthValue() {
}
public static boolean evaluate(Object object) {
if (object == null) {
return false;
}
if (object instanceof Boolean) {
Boolean b = (Boolean) object;
return b.booleanValue();
}
if (object instanceof Number) {
return ((Number) object).intValue() != 0;
}
if (object instanceof String) {
return !"".equals(object) && !"false".equalsIgnoreCase((String) object);
}
if (object.getClass().isArray()) {
return Array.getLength(object) != 0;
}
if (object instanceof Collection) {
return ((Collection) object).size() != 0;
}
if (object instanceof Map) {
return ((Map) object).size() != 0;
}
return true;
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/util/ObjectValue.java 0000664 0000000 0000000 00000001636 12511767770 0027142 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.util;
import java.util.Objects;
public final class ObjectValue {
private ObjectValue(){}
public static String printable(Object variable) {
return Objects.toString(variable, "");
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/util/ScopeMap.java 0000664 0000000 0000000 00000006123 12511767770 0026442 0 ustar 00root root 0000000 0000000 package com.hubspot.jinjava.util;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
public class ScopeMap implements Map {
private final Map scope;
private final ScopeMap parent;
public ScopeMap() {
this(null);
}
public ScopeMap(ScopeMap parent) {
this.scope = new HashMap();
this.parent = parent;
}
public ScopeMap(ScopeMap parent, Map scope) {
this(parent);
this.scope.putAll(scope);
}
public ScopeMap getParent() {
return parent;
}
public Map getScope() {
return scope;
}
@Override
public int size() {
return keySet().size();
}
@Override
public boolean isEmpty() {
return size() == 0;
}
@Override
public boolean containsKey(Object key) {
return get(key) != null;
}
@Override
public boolean containsValue(Object value) {
if(scope.containsValue(value)) {
return true;
}
if(parent != null) {
return parent.containsValue(value);
}
return false;
}
public V get(Object key, V defVal) {
V val = get(key);
if(val != null) {
return val;
}
return defVal;
}
@Override
public V get(Object key) {
V val = scope.get(key);
if(val != null) {
return val;
}
if(parent != null) {
return parent.get(key);
}
return null;
}
@Override
public V put(K key, V value) {
return scope.put(key, value);
}
@Override
public V remove(Object key) {
return scope.remove(key);
}
@Override
public void putAll(Map m) {
scope.putAll(m);
}
@Override
public void clear() {
scope.clear();
}
@Override
public Set keySet() {
Set keys = new HashSet<>();
if(parent != null) {
keys.addAll(parent.keySet());
}
keys.addAll(scope.keySet());
return keys;
}
@Override
public Collection values() {
Set> entrySet = entrySet();
Collection values = new ArrayList<>(entrySet.size());
for(Map.Entry entry : entrySet) {
values.add(entry.getValue());
}
return values;
}
@Override
public Set> entrySet() {
Set> entries = new HashSet<>();
for(K key : keySet()) {
entries.add(new ScopeMapEntry(key, get(key), this));
}
return entries;
}
public static class ScopeMapEntry implements Map.Entry {
private final Map map;
private final K key;
private V value;
public ScopeMapEntry(K key, V value, Map map) {
this.key = key;
this.value = value;
this.map = map;
}
@Override
public K getKey() {
return key;
}
@Override
public V getValue() {
return value;
}
@Override
public V setValue(V value) {
V old = value;
this.value = value;
map.put(key, value);
return old;
}
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/util/Variable.java 0000664 0000000 0000000 00000003665 12511767770 0026470 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.util;
import java.util.List;
import com.google.common.base.Splitter;
import com.google.common.collect.Lists;
import com.hubspot.jinjava.el.JinjavaInterpreterResolver;
import com.hubspot.jinjava.interpret.JinjavaInterpreter;
public class Variable {
private static final Splitter DOT_SPLITTER = Splitter.on('.');
private JinjavaInterpreter interpreter;
private String name;
private List chainList;
public Variable(JinjavaInterpreter interpreter, String variable) {
this.interpreter = interpreter;
split(variable);
}
private void split(String variable) {
if (!variable.contains(".")) {
name = variable;
chainList = null;
return;
}
List parts = Lists.newArrayList(DOT_SPLITTER.split(variable));
name = parts.get(0);
chainList = parts.subList(1, parts.size());
}
public String getName() {
return name;
}
public Object resolve(Object value) {
if (chainList != null) {
return JinjavaInterpreterResolver.wrap(interpreter, new VariableChain(chainList, value).resolve());
} else {
return JinjavaInterpreterResolver.wrap(interpreter, value);
}
}
@Override
public String toString() {
return "";
}
} jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/util/VariableChain.java 0000664 0000000 0000000 00000010430 12511767770 0027417 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.util;
import static com.hubspot.jinjava.util.Logging.ENGINE_LOG;
import java.lang.reflect.Array;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import com.google.common.base.Throwables;
import com.google.common.collect.Maps;
public class VariableChain {
private List chain;
private Object value;
public VariableChain(List chain, Object value) {
this.chain = chain;
this.value = value;
}
public Object resolve() {
for (String name : chain) {
if (value == null) {
return null;
} else {
value = resolveInternal(name);
}
}
return value;
}
private static final ConcurrentMap METHOD_CACHE = Maps.newConcurrentMap();
private Object resolveInternal(String name) {
Class clazz = value.getClass();
Method getter = findGetterMethodCached(clazz, name);
if(getter != null && getter != NULL_METHOD) {
try {
return getter.invoke(value);
} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
ENGINE_LOG.error("resolve variable trigger error.", e);
}
}
// map
if (value instanceof Map) {
Map map = (Map) value;
return map.get(name);
}
try {
int index = Integer.parseInt(name);
// array
if (value.getClass().isArray()) {
return Array.get(value, index);
}
// list
if (value instanceof List) {
return ((List) value).get(index);
}
// collection
if (value instanceof Collection) {
return ((Collection) value).toArray()[index];
}
} catch (Exception e) { /* no-op */ }
throw new JinjavaPropertyNotResolvedException(value, name);
}
private Method findGetterMethodCached(Class clazz, String name) {
Method m = METHOD_CACHE.get(clazz.getName() + ":" + name);
if(m == null) {
m = findGetterMethod(clazz, name);
if(m != null) {
METHOD_CACHE.put(clazz.getName() + ":" + name, m);
}
}
return m;
}
private static final String[] METHOD_PREFIXES = { "get", "is", "" };
private static final Method NULL_METHOD;
static {
try {
NULL_METHOD = VariableChain.class.getDeclaredMethod("resolve");
}
catch(NoSuchMethodException e){
throw Throwables.propagate(e);
}
}
private Method findGetterMethod(Class clazz, String name) {
String transformedName = transformName(name);
for (String prefix : METHOD_PREFIXES) {
try {
Method m = clazz.getMethod(prefix + transformedName);
m.setAccessible(true);
return m;
} catch (NoSuchMethodException | SecurityException e) {
/* no-op */
}
}
return NULL_METHOD;
}
private static final Pattern SNAKE_CASE = Pattern.compile("_([^_]?)");
private String transformName(String name) {
Matcher m = SNAKE_CASE.matcher(name);
StringBuffer result = new StringBuffer();
while (m.find()) {
String replacement = m.group(1).toUpperCase();
m.appendReplacement(result, replacement);
}
m.appendTail(result);
return upperFirst(result.toString());
}
private String upperFirst(String name) {
char c = name.charAt(0);
if (Character.isLowerCase(c)) {
return String.valueOf(c).toUpperCase().concat(name.substring(1));
} else {
return name;
}
}
}
jinjava-jinjava-2.0.1/src/main/java/com/hubspot/jinjava/util/WhitespaceUtils.java 0000664 0000000 0000000 00000004123 12511767770 0030046 0 ustar 00root root 0000000 0000000 package com.hubspot.jinjava.util;
import com.hubspot.jinjava.interpret.InterpretException;
public final class WhitespaceUtils {
public static boolean startsWith(String s, String prefix) {
if(s == null) {
return false;
}
for(int i = 0; i < s.length(); i++) {
if(Character.isWhitespace(s.charAt(i))) {
continue;
}
else {
return s.regionMatches(i, prefix, 0, prefix.length());
}
}
return false;
}
public static boolean endsWith(String s, String suffix) {
if(s == null) {
return false;
}
for(int i = s.length() - 1; i >= 0; i--) {
if(Character.isWhitespace(s.charAt(i))) {
continue;
}
else {
return s.regionMatches(i - suffix.length() + 1, suffix, 0, suffix.length());
}
}
return false;
}
public static boolean isWrappedWith(String s, String prefix, String suffix) {
return startsWith(s, prefix) && endsWith(s, suffix);
}
public static boolean isQuoted(String s) {
if(startsWith(s, "'")) {
if(!endsWith(s, "'")) {
throw new InterpretException("Unbalanced quotes: " + s);
}
return true;
}
else if(startsWith(s, "\"")) {
if(!endsWith(s, "\"")){
throw new InterpretException("Unbalanced quotes: " + s);
}
return true;
}
return false;
}
public static String unquote(String s) {
if(s == null) {
return "";
}
if(startsWith(s, "'")) {
return unwrap(s, "'", "'");
}
else if(startsWith(s, "\"")) {
return unwrap(s, "\"", "\"");
}
return s.trim();
}
public static String unwrap(String s, String prefix, String suffix) {
int start = 0, end = s.length() - 1;
while(start < s.length()) {
if(!Character.isWhitespace(s.charAt(start))) {
break;
}
++start;
}
while(end >= 0) {
if(!Character.isWhitespace(s.charAt(end))) {
break;
}
-- end;
}
return s.substring(start + prefix.length(), end - suffix.length() + 1);
}
private WhitespaceUtils(){}
}
jinjava-jinjava-2.0.1/src/test/ 0000775 0000000 0000000 00000000000 12511767770 0016337 5 ustar 00root root 0000000 0000000 jinjava-jinjava-2.0.1/src/test/java/ 0000775 0000000 0000000 00000000000 12511767770 0017260 5 ustar 00root root 0000000 0000000 jinjava-jinjava-2.0.1/src/test/java/com/ 0000775 0000000 0000000 00000000000 12511767770 0020036 5 ustar 00root root 0000000 0000000 jinjava-jinjava-2.0.1/src/test/java/com/hubspot/ 0000775 0000000 0000000 00000000000 12511767770 0021522 5 ustar 00root root 0000000 0000000 jinjava-jinjava-2.0.1/src/test/java/com/hubspot/jinjava/ 0000775 0000000 0000000 00000000000 12511767770 0023144 5 ustar 00root root 0000000 0000000 jinjava-jinjava-2.0.1/src/test/java/com/hubspot/jinjava/el/ 0000775 0000000 0000000 00000000000 12511767770 0023544 5 ustar 00root root 0000000 0000000 jinjava-jinjava-2.0.1/src/test/java/com/hubspot/jinjava/el/ExpressionResolverTest.java 0000664 0000000 0000000 00000013604 12511767770 0031134 0 ustar 00root root 0000000 0000000 package com.hubspot.jinjava.el;
import static org.assertj.core.api.Assertions.assertThat;
import java.util.Date;
import java.util.List;
import java.util.Map;
import org.junit.Before;
import org.junit.Test;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.hubspot.jinjava.Jinjava;
import com.hubspot.jinjava.interpret.Context;
import com.hubspot.jinjava.interpret.JinjavaInterpreter;
import com.hubspot.jinjava.interpret.TemplateError;
import com.hubspot.jinjava.interpret.TemplateError.ErrorReason;
import com.hubspot.jinjava.objects.date.PyishDate;
@SuppressWarnings("unchecked")
public class ExpressionResolverTest {
private JinjavaInterpreter interpreter;
private Context context;
@Before
public void setup() {
Jinjava jinjava = new Jinjava();
context = new Context();
interpreter = new JinjavaInterpreter(jinjava, context, jinjava.getGlobalConfig());
}
@Test
public void itResolvesListLiterals() throws Exception {
Object val = interpreter.resolveELExpression("['0.5','50']", -1);
List list = (List) val;
assertThat(list).containsExactly("0.5", "50");
}
@Test
public void itResolvesImmutableListLiterals() throws Exception {
Object val = interpreter.resolveELExpression("('0.5','50')", -1);
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