BoonTemplate (boon 0.22 API)

java.lang.Object
- org.boon.template.BoonTemplate

```
public abstract class BoonTemplate
extends Object
```
Created by Richard on 2/27/14. TODO finish making properties configurable TODO add a way to add a single command or function TODO make command object's properties exposed to the jstl... ? (Maybe) TODO implement handlebar templates Template comments with {{! }} or {{!-- --}}. TODO handle different forms of this Handlebars also allows for name conflict resolution between helpers and data fields via a this reference:
{{this.name}}
Any of the above would cause the name field on the current context to be used rather than a helper of the same name.
TODO If you find a "function" (Provider or Function), call it instead of evaluating it and converting it toString. Function gets passed context as argument to apply. TODO Need ability to add Function<> interface implementations as well. TODO loading templates by name jstl.setPrefix("/templates"); jstl.setSuffix(".html"); always search classpath first TODO https://github.com/jknack/handlebars.java block and partial Block and partial helpers work together to provide you Template Inheritance. Usage: {{#block "title"}} ... {{/block}} context: A string literal which define the region's name. Usage: {{#partial "title"}} ... {{/partial}} context: A string literal which define the region's name. NOTE need a way to invoke templates from a jstl // TODO implement include he uses embedded for include {{embedded "user"}} I think I will stick with include but support embedded //https://github.com/jknack/handlebars.java/blob/master/handlebars/src/main/java/com/github/jknack/handlebars/helper/StringHelpers.java I have some too. :) //lower, upper, rpad, etc. https://github.com/jknack/handlebars.java/blob/master/handlebars/src/main/java/com/github/jknack/handlebars/helper/StringHelpers.java TODO implement all standard JSTL functions
```
 fn:contains()  Tests if an input string contains the specified substring.
 fn:containsIgnoreCase()        Tests if an input string contains the specified substring in a case insensitive way.
 fn:endsWith()  Tests if an input string ends with the specified suffix.
 fn:escapeXml() Escapes characters that could be interpreted as XML markup.
 fn:atIndex()   Returns the index withing a string of the first occurrence of a specified substring.
 fn:join()      Joins all elements of an array into a string.
 fn:length()    Returns the number of items in a collection, or the number of characters in a string.
 fn:replace()   Returns a string resulting from replacing in an input string all occurrences with a given string.
 fn:split()     Splits a string into an array of substrings.
 fn:startsWith()        Tests if an input string starts with the specified prefix.
 fn:substring() Returns a subset of a string.
 fn:substringAfter()    Returns a subset of a string following a specific substring.
 fn:substringBefore()   Returns a subset of a string before a specific substring.
 fn:toLowerCase()       Converts all of the characters of a string to lower case.
 fn:toUpperCase()       Converts all of the characters of a string to upper case.
 fn:trim()      Removes white spaces from both ends of a string.
 
```
TODO look at functions here https://github.com/elving/swag

Field Summary

Fields
Modifier and Type	Field and Description
`protected Map<String,Command>`	`commandMap` Commands that we support.
`protected String`	`commandMarker` Command marker.
`protected Object`	`context` Context object that we are getting expressions from.
`protected String`	`elseBlock` I was not sure how to handle this so I punted.
`protected String`	`endBlockEnd` The end of an end block.
`protected String`	`endBlockStart` Sets how the beginning of the end block start should look .
`protected char[]`	`expressionEnd` The end of an end expression.
`protected char[]`	`expressionStart` Set the start of expression demarcation.
`protected char`	`expressionStart1stChar` First char used to search strings quickly for expressions or commands.
`protected Map<String,Function>`	`functionMap` Functions can be used anywhere where expressions can be used.
`protected int`	`lineIndex` Current line number.
`protected char[][]`	`lines` List of lines we are processing.
`protected Map<String,MethodAccess>`	`methodMap` Functions can be used anywhere where expressions can be used.
`protected boolean`	`sameStart` It detects if the escaped and unescaped start with the same char.
`protected boolean`	`strictChecking`
`protected char[]`	`unescapedExpressionEnd`
`protected char[]`	`unescapedExpressionStart` Three {{{Text in here will not get escaped so you can have }}} BoonTemplate does not always support HTML output or rather Boon jstl does not only support HTML so you have to enable HTML escaping for {{HTML ESCAPED}} and {{{HTML UNESCAPED TO WORK}}} By default everything is unescaped.
`protected char`	`unescapedExpressionStartChar` First char used to search strings quickly for expressions or commands.

Constructor Summary

Constructors
Constructor and Description

BoonTemplate()
Constructor

BoonTemplate(char[] expressionStart, char[] expressionEnd, Object functions)

Constructors
Constructor and Description
`BoonTemplate()` Constructor
`BoonTemplate(char[] expressionStart, char[] expressionEnd, Object functions)`

Method Summary

Methods
Modifier and Type	Method and Description
`BoonTemplate`	`addCommandHandlers(Object object)` Adds commandHandlers from class (static methods) or instance (regular methods)).
`BoonTemplate`	`addFunction(String name, Function function)` Adds function with a give name.
`BoonTemplate`	`addFunction(String methodName, Object functions)` Adds function with a give name.
`BoonTemplate`	`addFunctions(Object object)` Adds functions from class (static methods) or instance (regular methods)).
`BoonTemplate`	`addTemplateAsFunctions()` Adds functions from class (static methods) or instance (regular methods)).
`protected Command`	`command(String cmdStr)` Lookup a command.
`Map<String,Command>`	`commandMap()` returns the current command map.
`String`	`commandMarker()` Sets the '#' of {{#if}}
`Object`	`context()` Returns the current context.
`protected void`	`eachListItem(CharBuf output, CharSequence block, Object object)` Handles the for each case in the case of collections and arrays.
`String`	`elseBlock()` Sets else block marker in total.
`String`	`endBlockEnd()` returns the '}}' or {{/if}}
`BoonTemplate`	`endBlockEnd(String v)` returns the '}}' or {{/if}}
`String`	`endBlockStart()`
`BoonTemplate`	`endBlockStart(String v)` /** sets the end of the block start, i.e., the '}}' of {{#if}}
`protected String`	`escape(String charSequence)` Handles string escaping.
`String`	`expressionEnd()` returns the '}}' of {{value}}
`BoonTemplate`	`expressionEnd(String v)` Sets the '}}' of {{value}}
`String`	`expressionStart()`
`BoonTemplate`	`expressionStart(String v)`
`Map<String,MethodAccess>`	`functionMap()` returns the current function map.
`protected Object`	`getObjectFromArguments(String arguments)` This method parses the arguments for {{with}}, {{line}}, and {{each}}.
`Object`	`getThis()` Returns the current context.
`protected void`	`handleExpression(CharBuf output, String command)` Handle an expression
`protected void`	`handleExpressionOrFunction(CharBuf output, String command)` Handles an expression like {{name}} or function call like {{doIt( 1, 2, ${name} ) }}.
`protected void`	`initContext(Object context)` Initialize the context object.
`static BoonTemplate`	`jstl()` Creates a new JSTL jstl.
`String`	`line()` Returns the current line.
`protected abstract boolean`	`lineHasCommand()` These two are here so I can add JSTL style support later for
`int`	`lineIndex()` Returns the current line index
`Object`	`lookup(String objectName)` Lookup an object and use its name as the default value if not found.
`Object`	`lookup(String objectName, String defaultValue)` Lookup an object and supply a default value.
`BoonTemplate`	`parentTemplate()`
`protected void`	`processEach(CharBuf output, String arguments, CharSequence block)` Handles the for each operation, i.e., handles the {{#each}} command.
`protected void`	`processIf(CharBuf output, String arguments, CharSequence[] blocks)` Handles the {{#if}} command.
`protected abstract boolean`	`processLineCommand(CharBuf output, char[] line)` These two are here so I can add JSTL style support later for
`protected void`	`processWith(CharBuf output, String arguments, CharSequence block)` Handles the {{#with}}.
`protected CharSequence`	`readBlock(int startIndexOfFirstLine, String endBlock)` Reads the guts of a block so Given this if block: {{#if}} THIS TEXT WILL BE PART OF THE BLOCK EVERYTHING IN THE IF, INCLUDING SPACES and \n {{/if}}
`protected CharSequence[]`	`readBlocks(int startLine, String elseBlock, String endBlock)` reads a block that has an else and an if.
`CharSequence`	`replace(CharSequence template, Object context)` Replace jstl with properties from context.
`BoonTemplate`	`setStringEscaper(Function<String,String> stringEscaper)`
`boolean`	`strictChecking()`
`BoonTemplate`	`strictChecking(boolean strictChecking)`
`Function<String,String>`	`stringEscaper()` Pluggable String escaper
`static BoonTemplate`	`template()` Creates a new jstl.
`static BoonTemplate`	`template(char[] expStart, char[] expEnd, Object functions)` Creates a new jstl and allows you to define the start expression and the end expression.
`static BoonTemplate`	`template(String expStart, String expEnd)` Creates a new jstl and allows you to define the start expression and the end expression.
`static BoonTemplate`	`templateWithCommandHandlers(Object functions)` BoonTemplate with functions
`static BoonTemplate`	`templateWithFunctions(Object functions)` Template with functions
`String`	`unescapedExpressionEnd()` Returns the end of an unescaped expression, i.e., the "}}}" of value.
`BoonTemplate`	`unescapedExpressionEnd(String v)` Sets the end of an unescaped expression, i.e., the "}}}" of value.
`String`	`unescapedExpressionStart()` Returns the start of an unescaped expression, i.e., "{{{"
`BoonTemplate`	`unescapedExpressionStart(String v)` Sets the start of an unescaped expression, i.e., "{{{"

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - strictChecking
```
protected boolean strictChecking
```
  - expressionStart
```
protected char[] expressionStart
```
    Set the start of expression demarcation. As in {{Hello}} {{Hello}} ^ | |
  - endBlockStart
```
protected String endBlockStart
```
    Sets how the beginning of the end block start should look . {{if}} {{/if}} ^ | |
  - unescapedExpressionStart
```
protected char[] unescapedExpressionStart
```
    Three {{{Text in here will not get escaped so you can have
  - unescapedExpressionEnd
```
protected char[] unescapedExpressionEnd
```
  - sameStart
```
protected final boolean sameStart
```
    It detects if the escaped and unescaped start with the same char.
  - endBlockEnd
```
protected String endBlockEnd
```
    The end of an end block. {{#if}} {{/if}} ^ | |
  - expressionEnd
```
protected char[] expressionEnd
```
    The end of an end expression. {{helloMom}} ^ | |
  - expressionStart1stChar
```
protected char expressionStart1stChar
```
    First char used to search strings quickly for expressions or commands.
  - unescapedExpressionStartChar
```
protected char unescapedExpressionStartChar
```
    First char used to search strings quickly for expressions or commands.
  - commandMarker
```
protected String commandMarker
```
    Command marker. {{#if}} ^ |
  - elseBlock
```
protected String elseBlock
```
    I was not sure how to handle this so I punted.
  - lineIndex
```
protected int lineIndex
```
    Current line number.
  - lines
```
protected char[][] lines
```
    List of lines we are processing.
  - context
```
protected Object context
```
    Context object that we are getting expressions from.
  - commandMap
```
protected Map<String,Command> commandMap
```
    Commands that we support. A command is more or less like a tag handler in JSP.
  - methodMap
```
protected Map<String,MethodAccess> methodMap
```
    Functions can be used anywhere where expressions can be used.
  - functionMap
```
protected Map<String,Function> functionMap
```
    Functions can be used anywhere where expressions can be used.
- Constructor Detail
  - BoonTemplate
```
public BoonTemplate(char[] expressionStart,
            char[] expressionEnd,
            Object functions)
```
  - BoonTemplate
```
public BoonTemplate()
```
    Constructor
- Method Detail
  - lineHasCommand
```
protected abstract boolean lineHasCommand()
```
    These two are here so I can add JSTL style support later for
  - processLineCommand
```
protected abstract boolean processLineCommand(CharBuf output,
                         char[] line)
```
    These two are here so I can add JSTL style support later for
  - command
```
protected Command command(String cmdStr)
```
    Lookup a command. If the commandMap is null and this jstl has a parent jstl then it will look for the command in the parent jstl. Also if a command is not found in the this jstl's commandMap then it will be searched in the parent commandMap. This is how {{#if}}, {{#with}}, and {{#each}} use commands from their parent templates. Every block is its own jstl with a parent jstl.
  - strictChecking
```
public boolean strictChecking()
```
  - strictChecking
```
public BoonTemplate strictChecking(boolean strictChecking)
```
  - addFunctions
```
public BoonTemplate addFunctions(Object object)
```
    Adds functions from class (static methods) or instance (regular methods)). Every method in this object becomes a command handler.
  - addFunction
```
public BoonTemplate addFunction(String name,
                       Function function)
```
    Adds function with a give name.
  - addFunction
```
public BoonTemplate addFunction(String methodName,
                       Object functions)
```
    Adds function with a give name.
  - addTemplateAsFunctions
```
public BoonTemplate addTemplateAsFunctions()
```
    Adds functions from class (static methods) or instance (regular methods)). Every method in this object becomes a command handler. /* functionMap() commandMap() methodMap() lineIndex() line() context() parentTemplate() getThis()
  - addCommandHandlers
```
public BoonTemplate addCommandHandlers(Object object)
```
    Adds commandHandlers from class (static methods) or instance (regular methods)). Every method in this object becomes a command handler.
  - expressionStart
```
public String expressionStart()
```
    Returns:
    returns the start of the expression, ie., the '{{' of {{name}}
  - expressionStart
```
public BoonTemplate expressionStart(String v)
```
    Parameters:
    v - sets the '{{' of {{name}} and the '{{' of '{{#if}}
    
    Returns:
    jstl
  - endBlockStart
```
public String endBlockStart()
```
    Returns:
    returns the end of the block start, i.e., the '}}' of {{#if}}
  - endBlockStart
```
public BoonTemplate endBlockStart(String v)
```
    /** sets the end of the block start, i.e., the '}}' of {{#if}}
    
    Parameters:
    v -
    
    Returns:
  - unescapedExpressionStart
```
public String unescapedExpressionStart()
```
    Returns the start of an unescaped expression, i.e., "{{{"
    
    Returns:
  - unescapedExpressionStart
```
public BoonTemplate unescapedExpressionStart(String v)
```
    Sets the start of an unescaped expression, i.e., "{{{"
    
    Parameters:
    v -
    
    Returns:
  - unescapedExpressionEnd
```
public String unescapedExpressionEnd()
```
    Returns the end of an unescaped expression, i.e., the "}}}" of value.
    
    Returns:
  - unescapedExpressionEnd
```
public BoonTemplate unescapedExpressionEnd(String v)
```
    Sets the end of an unescaped expression, i.e., the "}}}" of value.
  - endBlockEnd
```
public String endBlockEnd()
```
    returns the '}}' or {{/if}}
    
    Returns:
  - endBlockEnd
```
public BoonTemplate endBlockEnd(String v)
```
    returns the '}}' or {{/if}}
    
    Returns:
  - expressionEnd
```
public String expressionEnd()
```
    returns the '}}' of {{value}}
    
    Returns:
  - expressionEnd
```
public BoonTemplate expressionEnd(String v)
```
    Sets the '}}' of {{value}}
    
    Returns:
  - commandMarker
```
public String commandMarker()
```
    Sets the '#' of {{#if}}
    
    Returns:
  - elseBlock
```
public String elseBlock()
```
    Sets else block marker in total. "{{else}}"
    
    Returns:
  - lineIndex
```
public int lineIndex()
```
    Returns the current line index
  - line
```
public String line()
```
    Returns the current line.
  - context
```
public Object context()
```
    Returns the current context.
  - getThis
```
public Object getThis()
```
    Returns the current context.
  - commandMap
```
public Map<String,Command> commandMap()
```
    returns the current command map.
  - functionMap
```
public Map<String,MethodAccess> functionMap()
```
    returns the current function map.
  - parentTemplate
```
public BoonTemplate parentTemplate()
```
  - template
```
public static BoonTemplate template()
```
    Creates a new jstl.
    
    Returns:
  - jstl
```
public static BoonTemplate jstl()
```
    Creates a new JSTL jstl.
    
    Returns:
  - template
```
public static BoonTemplate template(String expStart,
                    String expEnd)
```
    Creates a new jstl and allows you to define the start expression and the end expression.
    
    Parameters:
    expStart -
    expEnd -
    
    Returns:
  - template
```
public static BoonTemplate template(char[] expStart,
                    char[] expEnd,
                    Object functions)
```
    Creates a new jstl and allows you to define the start expression and the end expression.
    
    Parameters:
    expStart -
    expEnd -
    
    Returns:
  - templateWithCommandHandlers
```
public static BoonTemplate templateWithCommandHandlers(Object functions)
```
    BoonTemplate with functions
    
    Parameters:
    functions -
    
    Returns:
  - templateWithFunctions
```
public static BoonTemplate templateWithFunctions(Object functions)
```
    Template with functions
    
    Parameters:
    functions -
    
    Returns:
  - replace
```
public CharSequence replace(CharSequence template,
                   Object context)
```
    Replace jstl with properties from context. The context can be a Java Bean, a hash map or a list of JavaBeans or HashMaps. The search order of the objects is determine by their order in the list.
    
    Parameters:
    template - the jstl (a string or char sequence that constitutes the jstl)
    context - instance, map or list of maps/instances or a JSON string which can be a list or a list of objects(maps)
    
    Returns:
    char sequence of applied results of context to sequence.
  - initContext
```
protected void initContext(Object context)
```
    Initialize the context object.
    
    Parameters:
    context -
  - escape
```
protected String escape(String charSequence)
```
    Handles string escaping.
  - stringEscaper
```
public Function<String,String> stringEscaper()
```
    Pluggable String escaper
    
    Returns:
  - setStringEscaper
```
public BoonTemplate setStringEscaper(Function<String,String> stringEscaper)
```
  - handleExpressionOrFunction
```
protected void handleExpressionOrFunction(CharBuf output,
                              String command)
```
    Handles an expression like {{name}} or function call like {{doIt( 1, 2, ${name} ) }}. You can override this and change the way that expressions and function calls are handled.
    
    Parameters:
    output - output char buffer
    command - name of the command.
  - handleExpression
```
protected void handleExpression(CharBuf output,
                    String command)
```
    Handle an expression
    
    Parameters:
    output -
    command -
  - lookup
```
public Object lookup(String objectName)
```
    Lookup an object and use its name as the default value if not found.
    
    Parameters:
    objectName -
    
    Returns:
  - lookup
```
public Object lookup(String objectName,
            String defaultValue)
```
    Lookup an object and supply a default value.
    
    Parameters:
    objectName -
    defaultValue -
    
    Returns:
  - processEach
```
protected void processEach(CharBuf output,
               String arguments,
               CharSequence block)
```
    Handles the for each operation, i.e., handles the {{#each}} command. You can override this.
    
    Parameters:
    output -
    arguments -
    block -
  - eachListItem
```
protected void eachListItem(CharBuf output,
                CharSequence block,
                Object object)
```
    Handles the for each case in the case of collections and arrays. You can override this.
    
    Parameters:
    output - the output buffer
    block - the jstl block for the each
    object - the actual List or Array like object
  - processWith
```
protected void processWith(CharBuf output,
               String arguments,
               CharSequence block)
```
    Handles the {{#with}}. You can override this.
    
    Parameters:
    output - the output buffer
    arguments - arguments to the with handler
    block - the actual jstl block
  - processIf
```
protected void processIf(CharBuf output,
             String arguments,
             CharSequence[] blocks)
```
    Handles the {{#if}} command. You can override this.
    
    Parameters:
    output - the output buffer
    arguments - arguments to the with handler
    blocks - the actual jstl blocks, the first item is the if, the second item is the else if present
  - readBlocks
```
protected CharSequence[] readBlocks(int startLine,
                        String elseBlock,
                        String endBlock)
```
    reads a block that has an else and an if.
    
    Parameters:
    startLine -
    elseBlock -
    endBlock -
    
    Returns:
  - readBlock
```
protected CharSequence readBlock(int startIndexOfFirstLine,
                     String endBlock)
```
    Reads the guts of a block so Given this if block: {{#if}} THIS TEXT WILL BE PART OF THE BLOCK EVERYTHING IN THE IF, INCLUDING SPACES and \n {{/if}}
    
    Parameters:
    startIndexOfFirstLine -
    endBlock -
    
    Returns:
  - getObjectFromArguments
```
protected Object getObjectFromArguments(String arguments)
```
    This method parses the arguments for {{with}}, {{line}}, and {{each}}. It does not do the ones for {{if}} but the one for {{if}} works the same way. If arguments are JSON, then the JSON object is parsed. JSON is a special type where we use single quotes or double quotes, other than that it is plain JSON. If arguments are not JSON but has " ", then the arguments are split using a String split function. If the arguments contain a ${foo}, then foo is replaced with the foo property out of the context.

Class BoonTemplate

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

strictChecking

expressionStart

endBlockStart

unescapedExpressionStart

unescapedExpressionEnd

sameStart

endBlockEnd

expressionEnd

expressionStart1stChar

unescapedExpressionStartChar

commandMarker

elseBlock

lineIndex

lines

context

commandMap

methodMap

functionMap

Constructor Detail

BoonTemplate

BoonTemplate

Method Detail

lineHasCommand

processLineCommand

command

strictChecking

strictChecking

addFunctions

addFunction

addFunction

addTemplateAsFunctions

addCommandHandlers

expressionStart

expressionStart

endBlockStart

endBlockStart

unescapedExpressionStart

unescapedExpressionStart

unescapedExpressionEnd

unescapedExpressionEnd

endBlockEnd

endBlockEnd

expressionEnd

expressionEnd

commandMarker

elseBlock

lineIndex

line

context

getThis

commandMap

functionMap

parentTemplate

template

jstl

template

template

templateWithCommandHandlers

templateWithFunctions

replace

initContext

escape

stringEscaper

setStringEscaper

handleExpressionOrFunction

handleExpression

lookup

lookup

processEach

eachListItem

processWith

processIf

readBlocks

readBlock