├── .gitignore
├── tests
    ├── tests
    │   ├── templates
    │   │   └── _template.liquid
    │   ├── classes
    │   │   ├── HundredCentes.cfc
    │   │   ├── CentsDrop.cfc
    │   │   ├── HiFilter.cfc
    │   │   ├── LocalFilter.cfc
    │   │   ├── GlobalFilter.cfc
    │   │   ├── CatchallDrop.cfc
    │   │   ├── ContextDrop.cfc
    │   │   ├── TextDrop.cfc
    │   │   ├── CanadianMoneyFilter.cfc
    │   │   ├── LiquidTestFileSystem.cfc
    │   │   ├── TestClassFilter.cfc
    │   │   ├── MoneyFilter.cfc
    │   │   ├── ProductDrop.cfc
    │   │   └── FunnyFilter.cfc
    │   ├── ParsingQuirksTest.cfc
    │   ├── RawTest.cfc
    │   ├── LiquidFiltersInTemplate.cfc
    │   ├── ParsingErrors.cfc
    │   ├── HtmlTagTest.cfc
    │   ├── RegexpTest.cfc
    │   ├── TemplatesTest.cfc
    │   ├── FilterTest.cfc
    │   ├── VariableResolutionTest.cfc
    │   ├── FilterbankTest.cfc
    │   ├── AssignTest.cfc
    │   ├── BlockTest.cfc
    │   ├── FileSystemTest.cfc
    │   ├── OutputTest.cfc
    │   ├── DropTest.cfc
    │   ├── StatementsTest.cfc
    │   ├── VariableTest.cfc
    │   ├── ContextTest.cfc
    │   ├── IfElseTest.cfc
    │   └── StandardFilterTest.cfc
    ├── index.cfm
    └── helpers.cfm
├── releases
    ├── Liquid-1.0.zip
    ├── Liquid-1.1.zip
    └── Liquid-1.2.zip
├── .settings
    └── org.eclipse.core.resources.prefs
├── lib
    ├── liquid
    │   ├── LiquidException.cfc
    │   ├── LiquidTagComment.cfc
    │   ├── LiquidBlankFileSystem.cfc
    │   ├── LiquidDocument.cfc
    │   ├── LiquidTagAssign.cfc
    │   ├── LiquidTagCapture.cfc
    │   ├── LiquidTagRaw.cfc
    │   ├── LiquidTag.cfc
    │   ├── LiquidTagIncrement.cfc
    │   ├── LiquidTagDecrement.cfc
    │   ├── LiquidRegexp.cfc
    │   ├── LiquidDrop.cfc
    │   ├── LiquidLocalFileSystem.cfc
    │   ├── LiquidVariable.cfc
    │   ├── LiquidTagTablerow.cfc
    │   ├── LiquidTagCycle.cfc
    │   ├── LiquidTagCase.cfc
    │   ├── LiquidTagInclude.cfc
    │   ├── LiquidTemplate.cfc
    │   ├── LiquidDecisionBlock.cfc
    │   ├── LiquidTagIf.cfc
    │   ├── LiquidFilterbank.cfc
    │   ├── LiquidBlock.cfc
    │   ├── LiquidTagFor.cfc
    │   ├── utils.cfm
    │   ├── LiquidContext.cfc
    │   └── LiquidStandardFilters.cfc
    └── Liquid.cfc
├── .project
├── Application.cfc
├── settings.xml
├── LICENSE
├── index.cfm
└── README.md


/.gitignore:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/tests/tests/templates/_template.liquid:
--------------------------------------------------------------------------------
1 | Put Liquid Markup here


--------------------------------------------------------------------------------
/releases/Liquid-1.0.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rip747/cfml-liquid/HEAD/releases/Liquid-1.0.zip


--------------------------------------------------------------------------------
/releases/Liquid-1.1.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rip747/cfml-liquid/HEAD/releases/Liquid-1.1.zip


--------------------------------------------------------------------------------
/releases/Liquid-1.2.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rip747/cfml-liquid/HEAD/releases/Liquid-1.2.zip


--------------------------------------------------------------------------------
/.settings/org.eclipse.core.resources.prefs:
--------------------------------------------------------------------------------
1 | eclipse.preferences.version=1
2 | encoding/<project>=UTF-8
3 | 


--------------------------------------------------------------------------------
/tests/tests/classes/HundredCentes.cfc:
--------------------------------------------------------------------------------
1 | <cfcomponent output="false">
2 | 	
3 | 	<cffunction name="toLiquid">
4 | 		<cfreturn 100>
5 | 	</cffunction>
6 | 	
7 | </cfcomponent>


--------------------------------------------------------------------------------
/tests/tests/classes/CentsDrop.cfc:
--------------------------------------------------------------------------------
1 | <cfcomponent output="false" extends="cfml-liquid.lib.liquid.LiquidDrop">
2 | 
3 | 	<cffunction name="amount">
4 | 		<cfreturn createObject("component", "HundredCentes")>
5 | 	</cffunction>
6 | 	
7 | </cfcomponent>


--------------------------------------------------------------------------------
/tests/tests/classes/HiFilter.cfc:
--------------------------------------------------------------------------------
1 | <cfcomponent output="false">
2 | 	
3 | 	<cffunction name="hi">
4 | 		<cfargument name="value" type="string" required="true">
5 | 		<cfreturn arguments.value & ' hi!'>
6 | 	</cffunction>
7 | 	
8 | </cfcomponent>


--------------------------------------------------------------------------------
/tests/tests/classes/LocalFilter.cfc:
--------------------------------------------------------------------------------
1 | <cfcomponent output="false">
2 | 	
3 | 	<cffunction name="notice">
4 | 		<cfargument name="value" type="string" required="true">
5 | 		<cfreturn "Local #arguments.value#">
6 | 	</cffunction>
7 | 	
8 | </cfcomponent>


--------------------------------------------------------------------------------
/tests/tests/classes/GlobalFilter.cfc:
--------------------------------------------------------------------------------
1 | <cfcomponent output="false">
2 | 	
3 | 	<cffunction name="notice">
4 | 		<cfargument name="value" type="string" required="true">
5 | 		<cfreturn "Global #arguments.value#">
6 | 	</cffunction>
7 | 	
8 | </cfcomponent>


--------------------------------------------------------------------------------
/lib/liquid/LiquidException.cfc:
--------------------------------------------------------------------------------
1 | <cfcomponent output="false">
2 | 
3 | 	<cffunction name="init">
4 | 		<cfargument name="message" type="string" required="true">
5 | 		<cfthrow type="LiquidError" message="#arguments.message#"/>
6 | 	</cffunction>
7 | 
8 | </cfcomponent>


--------------------------------------------------------------------------------
/tests/tests/classes/CatchallDrop.cfc:
--------------------------------------------------------------------------------
1 | <cfcomponent output="false" extends="cfml-liquid.lib.liquid.LiquidDrop">
2 | 
3 | 	<cffunction name="beforeMethod">
4 | 		<cfargument name="method" type="string" required="true">
5 | 		<cfreturn 'method: ' & arguments.method>
6 | 	</cffunction>
7 | 	
8 | </cfcomponent>


--------------------------------------------------------------------------------
/tests/tests/classes/ContextDrop.cfc:
--------------------------------------------------------------------------------
1 | <cfcomponent output="false" extends="cfml-liquid.lib.liquid.LiquidDrop">
2 | 
3 | 	<cffunction name="beforeMethod">
4 | 		<cfargument name="method" type="string" required="true">
5 | 		<cfreturn variables._context.get(arguments.method)>
6 | 	</cffunction>
7 | 	
8 | </cfcomponent>


--------------------------------------------------------------------------------
/.project:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <projectDescription>
 3 | 	<name>cfml-liquid</name>
 4 | 	<comment></comment>
 5 | 	<projects>
 6 | 	</projects>
 7 | 	<buildSpec>
 8 | 	</buildSpec>
 9 | 	<natures>
10 | 		<nature>com.adobe.ide.coldfusion.projectNature</nature>
11 | 	</natures>
12 | </projectDescription>
13 | 


--------------------------------------------------------------------------------
/Application.cfc:
--------------------------------------------------------------------------------
1 | <cfcomponent output="false">
2 | 
3 | 	<cfset this.Name = "liquidtemplate" />
4 | 	<cffunction	name="OnApplicationStart" access="public" returntype="boolean" output="false" hint="Fires when the application is first created.">
5 | 		<!--- Return out. --->
6 | 		<cfreturn true />
7 | 	</cffunction>
8 | 
9 | </cfcomponent>


--------------------------------------------------------------------------------
/tests/tests/classes/TextDrop.cfc:
--------------------------------------------------------------------------------
 1 | <cfcomponent output="false" extends="cfml-liquid.lib.liquid.LiquidDrop">
 2 | 
 3 | 	<cffunction name="get_array">
 4 | 		<cfset var a = ['text1','text2']>
 5 | 		<cfreturn a>
 6 | 	</cffunction>
 7 | 
 8 | 	<cffunction name="text">
 9 | 		<cfreturn 'text1'>
10 | 	</cffunction>
11 | 
12 | </cfcomponent>


--------------------------------------------------------------------------------
/tests/tests/classes/CanadianMoneyFilter.cfc:
--------------------------------------------------------------------------------
 1 | <cfcomponent output="false">
 2 | 	
 3 | 	<cffunction name="init">
 4 | 		<cfreturn this>
 5 | 	</cffunction>
 6 | 
 7 | 	<cffunction name="money">
 8 | 		<cfargument name="value" type="numeric" required="true">
 9 | 		<cfreturn ' #arguments.value#$ CAD '>
10 | 	</cffunction>
11 | 	
12 | </cfcomponent>


--------------------------------------------------------------------------------
/settings.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8" ?><ResourceDetails><ServerName>CF9-local</ServerName><LauncherName></LauncherName><ExternalBrowser></ExternalBrowser><UseStartPage>false</UseStartPage><StartPage useextension="false" ></StartPage><Mappings></Mappings><VariableMappings></VariableMappings><DictionaryVersion>ColdFusion9</DictionaryVersion><CFCMappings></CFCMappings></ResourceDetails>


--------------------------------------------------------------------------------
/tests/tests/classes/LiquidTestFileSystem.cfc:
--------------------------------------------------------------------------------
 1 | <cfcomponent extends="cfml-liquid.lib.liquid.LiquidBlankFileSystem">
 2 | 
 3 | 	<cffunction name="read_template_file">
 4 | 		<cfargument name="template_path" type="any" required="true">
 5 | 
 6 | 		<cfif arguments.template_path eq 'inner'>
 7 | 			<cfreturn "Inner: {{ inner }}{{ other }}">
 8 | 		</cfif>
 9 | 		
10 | 	</cffunction>
11 | 
12 | </cfcomponent>


--------------------------------------------------------------------------------
/lib/liquid/LiquidTagComment.cfc:
--------------------------------------------------------------------------------
 1 | <cfcomponent extends="LiquidBlock" hint="
 2 | Creates a comment; everything inside will be ignored
 3 | 
 4 | @example
 5 | {% comment %} This will be ignored {% endcomment %}
 6 | ">
 7 | 
 8 | 	<cffunction name="render" returntype="string" output="false">
 9 | 		<cfargument name="contenxt" type="any" required="true">
10 | 		<cfreturn "">
11 | 	</cffunction>
12 | 	
13 | </cfcomponent>


--------------------------------------------------------------------------------
/tests/tests/classes/TestClassFilter.cfc:
--------------------------------------------------------------------------------
 1 | <cfcomponent output="false">
 2 | 
 3 | 	<cfset this.variable = 'not set'>
 4 | 	
 5 | 	<cffunction name="static_test">
 6 | 		<cfreturn "worked">
 7 | 	</cffunction>
 8 | 	
 9 | 	<cffunction name="instance_test_one">
10 | 		<cfset this.variable = 'set'>
11 | 		<cfreturn 'set'>
12 | 	</cffunction>
13 | 	
14 | 	<cffunction name="instance_test_two">
15 | 		<cfreturn this.variable>
16 | 	</cffunction>
17 | 	
18 | </cfcomponent>


--------------------------------------------------------------------------------
/tests/tests/classes/MoneyFilter.cfc:
--------------------------------------------------------------------------------
 1 | <cfcomponent output="false">
 2 | 	
 3 | 	<cffunction name="init">
 4 | 		<cfreturn this>
 5 | 	</cffunction>
 6 | 	
 7 | 	<cffunction name="money">
 8 | 		<cfargument name="value" type="numeric" required="true">
 9 | 		<cfreturn ' #arguments.value#$ '>
10 | 	</cffunction>
11 | 	
12 | 	<cffunction name="money_with_underscore">
13 | 		<cfargument name="value" type="numeric" required="true">
14 | 		<cfreturn ' #arguments.value#$ '>	
15 | 	</cffunction>
16 | 	
17 | </cfcomponent>


--------------------------------------------------------------------------------
/tests/tests/ParsingQuirksTest.cfc:
--------------------------------------------------------------------------------
 1 | <cfcomponent output="false" extends="cfml-liquid.tests.Test">
 2 | 	
 3 | 	<cffunction name="setup">
 4 | 		<cfset loc.template = application.liquid.template()>
 5 | 	</cffunction>
 6 | 	
 7 | 	<cffunction name="test_error_with_css">
 8 | 		<cfset loc.text = " div { font-weight: bold; } ">
 9 | 		<cfset loc.template.parse(loc.text)>
10 | 		<cfset loc.nodelist = loc.template.getRoot().getNodelist()>
11 | 		
12 | 		<cfset assert("loc.text eq loc.template.render()")>
13 | 		<cfset assert("IsSimpleValue(loc.nodelist[1])")>
14 | 	</cffunction>
15 | 	
16 | </cfcomponent>


--------------------------------------------------------------------------------
/tests/index.cfm:
--------------------------------------------------------------------------------
 1 | <html>
 2 | <head>
 3 | 	<title>RocketUnit unit tests</title>
 4 | </head>
 5 | <body>
 6 | 
 7 | <cfset StructClear(application)>
 8 | <cfset application.liquid = createObject("component", "cfml-liquid.lib.Liquid").init()>
 9 | 
10 | <cfif !structkeyexists(url, "single")>
11 | 
12 |  	<cfset test = createObject("component", "Test")>
13 | 	<cfset test.runTestPackage("cfml-liquid.tests.tests")>
14 | 
15 | <cfelse>
16 | 
17 | 	<cfset test = createObject("component", "cfml-liquid.tests.tests.RawTest")>
18 | 	<cfset test.runTest("test", "test_output_in_raw")>
19 | 
20 | </cfif>
21 | 
22 | <cfoutput>#test.HTMLFormatTestResults()#</cfoutput>
23 | </body>
24 | </html>


--------------------------------------------------------------------------------
/tests/tests/classes/ProductDrop.cfc:
--------------------------------------------------------------------------------
 1 | <cfcomponent output="false" extends="cfml-liquid.lib.liquid.LiquidDrop">
 2 | 
 3 | 	<cffunction name="top_sales">
 4 | 		<cfthrow type="worked" message="worked">
 5 | 	</cffunction>
 6 | 	
 7 | 	<cffunction name="texts">
 8 | 		<cfreturn createObject("component", "TextDrop")>
 9 | 	</cffunction>
10 | 	
11 | 	<cffunction name="catchall">
12 | 		<cfreturn createObject("component", "CatchallDrop")>
13 | 	</cffunction>
14 | 	
15 | 	<cffunction name="context">
16 | 		<cfreturn createObject("component", "ContextDrop")>
17 | 	</cffunction>
18 | 	
19 | 	<cffunction name="callmenot">
20 | 		<cfreturn "protected">
21 | 	</cffunction>
22 | 
23 | </cfcomponent>


--------------------------------------------------------------------------------
/tests/tests/RawTest.cfc:
--------------------------------------------------------------------------------
 1 | <cfcomponent output="false" extends="cfml-liquid.tests.Test">
 2 | 	
 3 | 	<cffunction name="setup">
 4 | 		<cfset loc.template = application.liquid.template()>
 5 | 	</cffunction>
 6 | 	
 7 | 	<cffunction name="test_tag_in_raw">
 8 | 		<cfset loc.e = "{% comment %} test {% endcomment %}">
 9 | 		<cfset loc.t = "{% raw %}{% comment %} test {% endcomment %}{% endraw %}">
10 | 		<cfset assert_template_result(loc.e, loc.t, loc.template)>
11 | 	</cffunction>
12 | 
13 | 	<cffunction name="test_output_in_raw">
14 | 		<cfset loc.e = "{{ test }}">
15 | 		<cfset loc.t = "{% raw %}{{ test }}{% endraw %}">
16 | 		<cfset assert_template_result(loc.e, loc.t, loc.template)>
17 | 	</cffunction>
18 | 
19 | </cfcomponent>


--------------------------------------------------------------------------------
/lib/liquid/LiquidBlankFileSystem.cfc:
--------------------------------------------------------------------------------
 1 | <cfcomponent output="false" hint="
 2 | A Liquid file system is way to let your templates retrieve other templates for use with the include tag.
 3 | 
 4 | You can implement subclasses that retrieve templates from the database, from the file system using a different 
 5 | path structure, you can provide them as hard-coded inline strings, or any manner that you see fit.
 6 | 
 7 | You can add additional instance variables, arguments, or methods as needed
 8 | ">
 9 | 
10 | 	<cffunction name="init">
11 | 		<cfreturn this>
12 | 	</cffunction>
13 | 
14 | 	<cffunction name="read_template_file" hint="Retrieve a template file">
15 | 		<cfthrow type="LiquidError" message="This liquid context does not allow includes."/>
16 | 	</cffunction>
17 | 	
18 | </cfcomponent>


--------------------------------------------------------------------------------
/tests/tests/LiquidFiltersInTemplate.cfc:
--------------------------------------------------------------------------------
 1 | <cfcomponent output="false" extends="cfml-liquid.tests.Test">
 2 | 	
 3 | 	<cffunction name="test_local_global">
 4 | 		<cfset loc.template = application.liquid.template()>
 5 | 		<cfset loc.m = create_class_instance("MoneyFilter")>
 6 | 		<cfset loc.c = create_class_instance("CanadianMoneyFilter")>
 7 | 		<cfset loc.template.registerFilter(loc.m)>
 8 | 		<cfset loc.template.parse('{{1000 | money}}')>
 9 | 		
10 | 		<cfset loc.e = ' 1000$ '>
11 | 		<cfset loc.r = loc.template.render()>
12 | 		<cfset assert('loc.e eq loc.r')>
13 | 		
14 | 		<cfset loc.e = ' 1000$ CAD '>
15 | 		<cfset loc.a = {}>
16 | 		<cfset loc.r = loc.template.render(loc.a, loc.c)>
17 | 		<cfset assert('loc.e eq loc.r')>
18 | 	</cffunction>
19 | 	
20 | 	<cffunction name="create_class_instance">
21 | 		<cfargument name="klass" type="string" required="true">
22 | 		<cfreturn createObject("component", "classes.#arguments.klass#").init()>
23 | 	</cffunction>
24 | 
25 | </cfcomponent>


--------------------------------------------------------------------------------
/tests/tests/ParsingErrors.cfc:
--------------------------------------------------------------------------------
 1 | <cfcomponent output="false" extends="cfml-liquid.tests.Test">
 2 | 
 3 | 	<cffunction name="setup">
 4 | 		<cfset loc.context = createobject("component", "cfml-liquid.lib.liquid.LiquidContext").init()>
 5 | 	</cffunction>
 6 | 
 7 | 	<cffunction name="test_specifying_filter_delim_with_no_filter_defined">
 8 | 		<cfset loc.v = create_var_instance("var | ")>
 9 | 		<cfset loc.context.set('var', "bla blub")>
10 | 		<cfset loc.e = "bla blub">
11 | 		<cfset loc.r = loc.v.render(loc.context)>
12 | 		<cfset assert('loc.e eq loc.r')>
13 | 	</cffunction>
14 | 	
15 | 	<cffunction name="test_specifying_filter_that_does_not_exists">
16 | 		<cfset loc.v = create_var_instance("var | fdsdfsdfs")>
17 | 		<cfset loc.context.set('var', "bla blub")>
18 | 		<cfset loc.e = "bla blub">
19 | 		<cfset loc.r = loc.v.render(loc.context)>
20 | 		<cfset assert('loc.e eq loc.r')>
21 | 	</cffunction>
22 | 
23 | 	<cffunction name="create_var_instance">
24 | 		<cfargument name="value" type="string" required="true">
25 | 		<cfreturn createObject("component", "cfml-liquid.lib.liquid.LiquidVariable").init(
26 | 			arguments.value
27 | 		)>
28 | 	</cffunction>
29 | 
30 | </cfcomponent>


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2005, 2006 Tobias Luetke
 2 | Copyright (c) 2006 Mateo Murphy
 3 | Copyright (c) 2011 Harald Hanek
 4 | Copyright (c) 2012 Anthony Petruzzi
 5 | 
 6 | Permission is hereby granted, free of charge, to any person obtaining
 7 | a copy of this software and associated documentation files (the
 8 | "Software"), to deal in the Software without restriction, including
 9 | without limitation the rights to use, copy, modify, merge, publish,
10 | distribute, sublicense, and/or sell copies of the Software, and to
11 | permit persons to whom the Software is furnished to do so, subject to
12 | the following conditions:
13 | 
14 | The above copyright notice and this permission notice shall be
15 | included in all copies or substantial portions of the Software.
16 | 
17 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
18 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
19 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
20 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
21 | LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
22 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
23 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


--------------------------------------------------------------------------------
/lib/liquid/LiquidDocument.cfc:
--------------------------------------------------------------------------------
 1 | <cfcomponent output="false" extends="LiquidBlock" hint="This class represents the entire template document">
 2 | 
 3 | 	<cffunction name="init">
 4 | 		<cfargument name="tokens" type="array" required="true">
 5 | 		<cfargument name="file_system" type="any" required="true">
 6 | 
 7 | 		<cfset this.file_system = arguments.file_system>
 8 | 		<cfset this.parse(arguments.tokens)>
 9 | 
10 | 		<cfreturn this>
11 | 	</cffunction>
12 | 
13 | 	<cffunction name="checkIncludes" hint="check for cached includes">
14 | 		<cfset var loc = {}>
15 | 
16 | 		<cfset loc.return = false>
17 | 
18 | 		<cfloop array="#this._nodelist#" index="loc.token">
19 | 			<cfif isObject(loc.token)>
20 | 				<cfif getMetaData(loc.token).name eq 'LiquidTagInclude'>
21 | 					<cfif loc.token.checkIncludes() eq true>
22 | 						<cfset loc.return = true>
23 | 					</cfif>
24 | 				</cfif>
25 | 			</cfif>
26 | 		</cfloop>
27 | 		
28 | 		<cfreturn loc.return>
29 | 	</cffunction>
30 | 
31 | 	<cffunction name="block_delimiter" hint="There isn't a real delimiter">
32 | 		<cfreturn ''>
33 | 	</cffunction>
34 | 
35 | 	<cffunction name="assert_missing_delimitation" hint="Document blocks don't need to be terminated since they are not actually opened">
36 | 	</cffunction>
37 | 	
38 | </cfcomponent>


--------------------------------------------------------------------------------
/lib/liquid/LiquidTagAssign.cfc:
--------------------------------------------------------------------------------
 1 | <cfcomponent output="false" extends="LiquidTag" hint="
 2 | Performs an assignment of one variable to another
 3 | {%assign var = var %}
 4 | {%assign var = 'hello' | upcase %}
 5 | ">
 6 | 
 7 | 	<cffunction name="init">
 8 | 		<cfargument name="markup" type="string" required="true">
 9 | 		<cfargument name="tokens" type="array" required="true">
10 | 		<cfargument name="file_system" type="any" required="true">
11 | 		<cfset var loc = {}>
12 | 		
13 | 		<cfset loc.syntax_regexp = createobject("component", "LiquidRegexp").init('(#application.LiquidConfig.LIQUID_VARIABLE_SIGNATURE#+)\s*=\s*(.*)\s*')>
14 | 
15 | 		<cfif loc.syntax_regexp.match(arguments.markup)>
16 | 			
17 | 			<cfset this._to = loc.syntax_regexp.matches[2]>
18 | 			<cfset this._from = createObject("component", "LiquidVariable").init(loc.syntax_regexp.matches[3])>
19 | 			
20 | 		<cfelse>
21 | 			<cfset createObject("component", "LiquidException").init("Syntax Error in 'assign' - Valid syntax: assign [var] = [source]")>
22 | 		</cfif>
23 | 		
24 | 		<cfreturn this>
25 | 	</cffunction>
26 | 
27 | 
28 | 	<cffunction name="render" hint="Renders the tag">
29 | 		<cfargument name="context" type="any" required="true">
30 | 		<cfset arguments.context.set(this._to, this._from.render(arguments.context))>
31 | 	</cffunction>
32 | 
33 | </cfcomponent>


--------------------------------------------------------------------------------
/lib/liquid/LiquidTagCapture.cfc:
--------------------------------------------------------------------------------
 1 | <cfcomponent extends="LiquidBlock" output="false" hint="
 2 | Captures the output inside a block and assigns it to a variable
 3 | 
 4 | @example
 5 | {% capture foo %} bar {% endcapture %}
 6 | ">
 7 | 
 8 | 	<cfset this._to = "">
 9 | 
10 | 	<cffunction name="init">
11 | 		<cfargument name="markup" type="string" required="true">
12 | 		<cfargument name="tokens" type="array" required="true">
13 | 		<cfargument name="file_system" type="any" required="true" hint="LiquidFileSystem">
14 | 		<cfset var loc = {}>
15 | 
16 | 		<cfset loc.syntax_regexp = createObject("component", "LiquidRegexp").init('(\w+)')>
17 | 		
18 | 		<cfif loc.syntax_regexp.match(arguments.markup)>
19 | 			
20 | 			<cfset this._to = loc.syntax_regexp.matches[2]>
21 | 			<cfset super.init(arguments.markup, arguments.tokens, arguments.file_system)>
22 | 			
23 | 		<cfelse>
24 | 			<cfset createObject("component", "LiquidException").init("Syntax Error in 'capture' - Valid syntax: assign [var] = [source]")>
25 | 		</cfif>
26 | 		
27 | 		<cfreturn this>
28 | 	</cffunction>
29 | 
30 | 	<cffunction name="render">
31 | 		<cfargument name="context" type="any" required="true" hint="">
32 | 		<cfset var loc = {}>
33 | 		
34 | 		<cfset loc.output = super.render(arguments.context)>
35 | 		<cfset arguments.context.set(this._to, loc.output)>
36 | 		
37 | 	</cffunction>	
38 | </cfcomponent>


--------------------------------------------------------------------------------
/lib/liquid/LiquidTagRaw.cfc:
--------------------------------------------------------------------------------
 1 | <cfcomponent extends="LiquidBlock" hint="
 2 |  temporarily disable tag processing to avoid syntax conflicts.
 3 | 
 4 | example:
 5 | {% raw %}{% comment %} test {% endcomment %}{% endraw %}
 6 | 
 7 | will render:
 8 | {% comment %} test {% endcomment %}
 9 | ">
10 | 
11 | 	<cffunction name="parse">
12 | 		<cfargument name="tokens" type="array" required="true">
13 | 		<cfset var loc = {}>
14 | 		<cfset loc.tag_regexp = createObject("component", "LiquidRegexp").init('^#application.LiquidConfig.LIQUID_TAG_START#\s*(\w+)\s*(.*)?#application.LiquidConfig.LIQUID_TAG_END#$')>
15 | 		
16 | 		<cfif !IsArray(arguments.tokens)>
17 | 			<cfreturn>
18 | 		</cfif>
19 | 		
20 | 		<cfloop condition="#ArrayLen(arguments.tokens)#">
21 | 			
22 | 			<cfset loc.temp = array_shift(arguments.tokens)>
23 | 			<cfset arguments.tokens = loc.temp.arr>
24 | 			<cfset loc.token = loc.temp.value>
25 | 			<cfset loc.tag_regexp.match(loc.token)>
26 | 
27 | 			<cfif loc.tag_regexp.match(loc.token)>
28 | 
29 | 				<!--- if we found the proper block delimitor just end parsing here and let the outer block proceed  --->
30 | 				<cfif loc.tag_regexp.matches[2] eq this.block_delimiter()>
31 | 					<cfreturn this.end_tag()>
32 | 				</cfif>
33 | 
34 | 			</cfif>
35 | 
36 | 			<cfset arrayAppend(this._nodelist, loc.token)>
37 | 
38 | 		</cfloop>
39 | 
40 | 		<cfset this.assert_missing_delimitation()>
41 | 	</cffunction>
42 | 	
43 | </cfcomponent>


--------------------------------------------------------------------------------
/tests/tests/classes/FunnyFilter.cfc:
--------------------------------------------------------------------------------
 1 | <cfcomponent output="false">
 2 | 	
 3 | 	<cffunction name="make_funny">
 4 | 		<cfargument name="input" type="string" required="true">
 5 | 		<cfreturn 'LOL'>
 6 | 	</cffunction>
 7 | 	
 8 | 	<cffunction name="cite_funny">
 9 | 		<cfargument name="input" type="string" required="true">
10 | 		<cfreturn 'LOL: '& arguments.input>
11 | 	</cffunction>
12 | 	
13 | 	<cffunction name="add_smiley">
14 | 		<cfargument name="input" type="string" required="true">
15 | 		<cfargument name="smiley" type="string" required="false" default=":-)">
16 | 		<cfreturn arguments.input & ' ' & arguments.smiley>
17 | 	</cffunction>
18 | 	
19 | 	<cffunction name="add_tag">
20 | 		<cfargument name="input" type="string" required="true">
21 | 		<cfargument name="tag" type="string" required="false" default="p">
22 | 		<cfargument name="id" type="string" required="false" default="foo">
23 | 		<cfreturn "<" & arguments.tag & " id=""" & arguments.id & """>" & arguments.input & "</" & arguments.tag & ">">
24 | 	</cffunction>
25 | 
26 | 	<cffunction name="paragraph">
27 | 		<cfargument name="input" type="string" required="true">
28 |     	<cfreturn "<p>" & arguments.input & "</p>">
29 | 	</cffunction>
30 | 
31 | 	<cffunction name="link_to">
32 | 		<cfargument name="name" type="string" required="true">
33 | 		<cfargument name="url" type="string" required="true">
34 | 		<cfreturn "<a href=""" & arguments.url & """>" & arguments.name & "</a>">
35 | 	</cffunction>
36 | 
37 | </cfcomponent>


--------------------------------------------------------------------------------
/tests/tests/HtmlTagTest.cfc:
--------------------------------------------------------------------------------
 1 | <cfcomponent output="false" extends="cfml-liquid.tests.Test">
 2 | 	
 3 | 	<cffunction name="setup">
 4 | 		<cfset loc.template = application.liquid.template()>
 5 | 	</cffunction>
 6 | 	
 7 | 	<cffunction name="test_html_table">
 8 | 		<cfset loc.a = {numbers = [1,2,3,4,5,6]}>
 9 | 		<cfset loc.e = "<tr class=""row1"">#chr(10)#<td class=""col1""> 1 </td><td class=""col2""> 2 </td><td class=""col3""> 3 </td></tr>#chr(10)#<tr class=""row2""><td class=""col1""> 4 </td><td class=""col2""> 5 </td><td class=""col3""> 6 </td></tr>#chr(10)#">
10 | 		<cfset loc.t = "{% tablerow n in numbers cols:3%} {{n}} {% endtablerow %}">
11 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
12 | 
13 |  		<cfset loc.a = {numbers = []}>
14 | 		<cfset loc.e = "<tr class=""row1"">#chr(10)#</tr>#chr(10)#">
15 | 		<cfset loc.t = "{% tablerow n in numbers cols:3%} {{n}} {% endtablerow %}">
16 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
17 | 	</cffunction>
18 | 
19 | 	<cffunction name="test_html_table_with_different_cols">
20 | 		<cfset loc.a = {numbers = [1,2,3,4,5,6]}>
21 | 		<cfset loc.e = "<tr class=""row1"">#chr(10)#<td class=""col1""> 1 </td><td class=""col2""> 2 </td><td class=""col3""> 3 </td><td class=""col4""> 4 </td><td class=""col5""> 5 </td></tr>#chr(10)#<tr class=""row2""><td class=""col1""> 6 </td></tr>#chr(10)#">
22 | 		<cfset loc.t = "{% tablerow n in numbers cols:5%} {{n}} {% endtablerow %}">
23 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
24 | 	</cffunction>
25 | 	
26 | </cfcomponent>


--------------------------------------------------------------------------------
/tests/tests/RegexpTest.cfc:
--------------------------------------------------------------------------------
 1 | <cfcomponent output="false" extends="cfml-liquid.tests.Test">
 2 | 	
 3 | 	<cffunction name="setup">
 4 | 		<cfset loc.liquid = createObject("component", "cfml-liquid.lib.Liquid").init()>
 5 | 		<cfset loc.regex = createObject("component", "cfml-liquid.lib.liquid.LiquidRegexp").init(application.LiquidConfig.LIQUID_QUOTED_FRAGMENT)>
 6 | 	</cffunction>
 7 | 
 8 | 	<cffunction name="test_empty">
 9 | 		<cfset loc.e = []>
10 | 		<cfset loc.r = loc.regex.scan('')>
11 | 		<cfset assert('arrayCompare(loc.e, loc.r)')>
12 | 	</cffunction>
13 | 	
14 | 	<cffunction name="test_quote">
15 | 		<cfset loc.e = ['"arg 1"']>
16 | 		<cfset loc.r = loc.regex.scan('"arg 1"')>
17 | 		<cfset assert('arrayCompare(loc.e, loc.r)')>
18 | 	</cffunction>
19 | 	
20 | 	<cffunction name="test_words">
21 | 		<cfset loc.e = ['arg1', 'arg2']>
22 | 		<cfset loc.r = loc.regex.scan('arg1 arg2')>
23 | 		<cfset assert('arrayCompare(loc.e, loc.r)')>
24 | 	</cffunction>
25 | 	
26 |  	<cffunction name="test_quoted_words">
27 | 		<cfset loc.e = ['arg1', 'arg2', '"arg 3"']>
28 | 		<cfset loc.r = loc.regex.scan('arg1 arg2 "arg 3"')>
29 | 		<cfset assert('arrayCompare(loc.e, loc.r)')>
30 | 	</cffunction>
31 |  	
32 | 	<cffunction name="test_quoted_words2">
33 | 		<cfset loc.e = ['arg1', 'arg2', "'arg 3'"]>
34 | 		<cfset loc.r = loc.regex.scan('arg1 arg2 ''arg 3''')>
35 | 		<cfset assert('arrayCompare(loc.e, loc.r)')>
36 | 	</cffunction>
37 |  	
38 | 	<cffunction name="test_quoted_words_in_the_middle">
39 | 		<cfset loc.e = ['arg1', 'arg2', '"arg 3"', 'arg4']>
40 | 		<cfset loc.r = loc.regex.scan('arg1 arg2 "arg 3" arg4   ')>
41 | 		<cfset assert('arrayCompare(loc.e, loc.r)')>
42 | 	</cffunction>
43 | 
44 | </cfcomponent>


--------------------------------------------------------------------------------
/lib/liquid/LiquidTag.cfc:
--------------------------------------------------------------------------------
 1 | <cfcomponent output="false" hint="Base class for tags">
 2 | 	<cfinclude template="utils.cfm">
 3 | 	
 4 | 	<!--- The markup for the tag --->
 5 | 	<cfset this.markup = "">
 6 | 	
 7 | 	<!--- Filesystem object is used to load included template files --->
 8 | 	<cfset this.file_system = "">
 9 | 	
10 | 	<!--- Additional attributes --->
11 | 	<cfset this.attributes = createObject("Java", "java.util.LinkedHashMap")>
12 | 
13 | 	<cffunction name="init">
14 | 		<cfargument name="markup" type="string" required="true">
15 | 		<cfargument name="tokens" type="array" required="true">
16 | 		<cfargument name="file_system" type="any" required="true">
17 | 
18 | 		<cfset this.markup = arguments.markup>
19 | 		<cfset this.file_system = arguments.file_system>
20 | 
21 | 		<cfreturn this.parse(arguments.tokens)>
22 | 	</cffunction>
23 | 
24 | 	<cffunction name="parse" hint="Parse the given tokens">
25 | 		<cfargument name="tokens" type="array" required="true">
26 | 	</cffunction>
27 | 
28 | 	<cffunction name="extract_attributes" hint="Extracts tag attributes from a markup string">
29 | 		<cfargument name="markup" type="string" required="true">
30 | 		<cfset var loc = {}>
31 | 	
32 | 		<cfset loc.attribute_regexp = createObject("component", "LiquidRegexp").init(application.LiquidConfig.LIQUID_TAG_ATTRIBUTES)>
33 | 		<cfset loc.matches = loc.attribute_regexp.scan(arguments.markup)>
34 | 		<cfset this.attributes = {}>
35 | 
36 | 		<cfloop array="#loc.matches#" index="loc.match">
37 | 			<cfset this.attributes[loc.match[1]] = loc.match[2]>
38 | 		</cfloop>	
39 | 	</cffunction>
40 | 
41 | 	<cffunction name="name" hint="Returns the name of the tag">
42 | 		<cfreturn lcase(getMetaData(this).name)>
43 | 	</cffunction>
44 | 
45 | 	<cffunction name="render" hint="Render the tag with the given context">
46 | 		<cfargument name="context" type="any" required="true">
47 | 		<cfreturn "">
48 | 	</cffunction>
49 | 
50 | 	<cffunction name="pushToNodeList" returntype="void" hint="a way to push a value to the nodelist once parsing is done">
51 | 	</cffunction>
52 | 
53 | </cfcomponent>


--------------------------------------------------------------------------------
/lib/liquid/LiquidTagIncrement.cfc:
--------------------------------------------------------------------------------
 1 | <cfcomponent output="false" extends="LiquidTag" hint="
 2 | Used to increment a counter into a template
 3 | 
 4 | @example 
 5 | {% increment value %}
 6 | 
 7 | ">
 8 | 
 9 | 	<cffunction name="init">
10 | 		<cfargument name="markup" type="string" required="true">
11 | 		<cfargument name="tokens" type="array" required="true">
12 | 		<cfargument name="file_system" type="any" required="true" hint="LiquidFileSystem">
13 | 		<cfset var loc = {}>
14 | 		
15 | 		<!--- Name of the variable to increment --->
16 | 		<cfset this._toIncrement = "">
17 | 		<cfset loc.syntax = createObject("component", "LiquidRegexp").init("(#application.LiquidConfig.LIQUID_ALLOWED_VARIABLE_CHARS#+)")>
18 | 
19 | 		<cfif ($syntax->match($markup)>
20 | 			<cfset this._toIncrement = loc.syntax.matches[1]>
21 | 		<cfelse>
22 | 			<cfset createObject("component", "LiquidException").init("Syntax Error in 'increment' - Valid syntax: increment [var]")>
23 | 		</cfif>
24 | 		
25 | 		<cfreturn this>
26 | 	</cffunction>
27 | 
28 | 	<cffunction name="render" hint="Renders the tag">
29 | 		<cfargument name="context" type="any" required="LiquidContext">
30 | 		<cfset var loc = {}>
31 | 		
32 | 		<!--- 
33 | 		if the value is not set in the environment check to see if it
34 | 		exists in the context, and if not set it to -1
35 | 		 --->
36 | 		<cfif not IsDefined(arguments.context.environments[1][this._toIncrement])>
37 | 		
38 | 			<!--- check for a context value --->
39 | 			<cfset loc.from_context = arguments.context.get(this._toIncrement)>
40 | 			
41 | 			<!--- we already have a value in the context --->
42 | 			<cfif StructKeyExists(loc, "from_context")>
43 | 				<cfset loc.temp = loc.from_context>
44 | 			<cfelse>
45 | 				<cfset loc.temp = -1>
46 | 			</cfif>
47 | 			
48 | 			<cfset arguments.context.environments[1][this._toIncrement] = loc.temp>
49 | 			
50 | 		</cfif>
51 | 
52 | 		<!--- increment the value --->
53 | 		<cfset arguments.context.environments[1][this._toIncrement] = arguments.context.environments[1][this._toIncrement] + 1>
54 | 	</cffunction>
55 | 	
56 | </cfcomponent>


--------------------------------------------------------------------------------
/lib/liquid/LiquidTagDecrement.cfc:
--------------------------------------------------------------------------------
 1 | <cfcomponent output="false" extends="LiquidTag" hint="
 2 | Used to decrement a counter into a template
 3 | 
 4 | @example 
 5 | {% decrement value %}
 6 | ">
 7 | 
 8 | 	<cffunction name="init">
 9 | 		<cfargument name="markup" type="string" required="true">
10 | 		<cfargument name="tokens" type="array" required="true">
11 | 		<cfargument name="file_system" type="any" required="true" hint="LiquidFileSystem">
12 | 		<cfset var loc = {}>
13 | 		
14 | 		<!--- Name of the variable to decrement --->
15 | 		<cfset this._toDecrement = "">
16 | 		
17 | 		<cfset loc.syntax = createObject("component", "LiquidRegexp").init("(#application.LiquidConfig.LIQUID_ALLOWED_VARIABLE_CHARS#+)")>
18 | 
19 | 		<cfif loc.syntax.match(arguments.markup)>
20 | 			<cfset this._toDecrement = loc.syntax.matches[1]>
21 | 		<cfelse>
22 | 			<cfset createObject("component", "LiquidException").init("Syntax Error in 'decrement' - Valid syntax: decrement [var]")>
23 | 		</cfif>
24 | 		
25 | 		<cfreturn this>
26 | 	</cffunction>
27 | 
28 | 	<cffunction name="render" hint="Renders the tag">
29 | 		<cfargument name="context" type="any" required="true" hint="LiquidContext">
30 | 		<cfset var loc = {}>
31 | 		
32 | 		<!--- 
33 | 		if the value is not set in the environment check to see if it
34 | 		exists in the context, and if not set it to 0
35 | 		 --->
36 | 		<cfif not IsDefined(arguments.context.environments[1][this._toDecrement])>
37 | 			<!--- check for a context value --->
38 | 			<cfset loc.from_context = arguments.context.get(this->_toDecrement)>
39 | 			
40 | 			<!--- we already have a value in the context --->
41 | 			<cfif StructKeyExists(loc, "from_context")>
42 | 				<cfset loc.temp = loc.from_context>
43 | 			<cfelse>
44 | 				<cfset loc.temp = 0>
45 | 			</cfif>
46 | 			
47 | 			<cfset arguments.context.environments[1][this._toDecrement] = loc.temp>
48 | 		</cfif>
49 | 
50 | 		<!--- decrement the environment value --->
51 | 		<cfset arguments.context.environments[1][this._toDecrement] = arguments.context.environments[1][this._toDecrement] - 1>
52 | 	</cffunction>
53 | 	
54 | </cfcomponent>


--------------------------------------------------------------------------------
/index.cfm:
--------------------------------------------------------------------------------
 1 | <!--- make sure the liquid library is loaded in the application scope --->
 2 | <cfif !StructKeyExists(application, "liquid")>
 3 | 	<cfset application.liquid = createObject("component", "lib.Liquid").init()>
 4 | </cfif>
 5 | 
 6 | <!--- create our template object --->
 7 | <cfset template = application.liquid.template()>
 8 | 
 9 | <!--- create the source we want to parse --->
10 | <cfsavecontent variable="source">
11 | <h1>{{ pageTitle }}</h1>
12 | {% if query.size %}
13 | <ul>
14 | 	{% for item in query %}
15 | 		<li>{{ item.project }} - <a href="{{ item.link }}">{{ item.link }}</a></li>
16 | 	{% endfor %}
17 | </ul>
18 | {% else %}
19 | <p>No records found</p>
20 | {% endif %}
21 | </cfsavecontent>
22 | 
23 | <!--- lets assign some variables to the source --->
24 | <!--- create a mock query for showing what this thing can do --->
25 | <cfset q = QueryNew("project,link")>
26 | <cfset QueryAddRow(q)>
27 | <cfset QuerySetCell(q, "project", "CFWheels")>
28 | <cfset QuerySetCell(q, "link", "https://github.com/cfwheels/cfwheels")>
29 | <cfset QueryAddRow(q)>
30 | <cfset QuerySetCell(q, "project", "ColdMVC")>
31 | <cfset QuerySetCell(q, "link", "https://github.com/tonynelson19/ColdMVC")>
32 | <cfset QueryAddRow(q)>
33 | <cfset QuerySetCell(q, "project", "FW/1")>
34 | <cfset QuerySetCell(q, "link", "https://github.com/seancorfield/fw1")>
35 | <cfset QueryAddRow(q)>
36 | <cfset QuerySetCell(q, "project", "Fusebox")>
37 | <cfset QuerySetCell(q, "link", "https://github.com/fusebox-framework/Fusebox-ColdFusion")>
38 | 
39 | <!--- create a structure to pass in --->
40 | <cfset assigns = {query = q, pageTitle = "ColdFusion Frameworks on Github"}>
41 | 
42 | <!---
43 | NOTE: if there are any errors in the source, a LiquidError exception will be thrown
44 | Always wrap the calls to Liquid in a try/catch block so you can display
45 | the parsing errors to the user.
46 |  --->
47 | <cftry>
48 | 	<!--- parse the source --->
49 | 	<cfset template.parse(source)>
50 | 	<!--- render the output --->
51 | 	<cfoutput>#template.render(assigns)#</cfoutput>
52 | 	<cfcatch type="LiquidError">
53 | 		<cfoutput>#cfcatch.message#</cfoutput>
54 | 	</cfcatch>
55 | </cftry>


--------------------------------------------------------------------------------
/tests/tests/TemplatesTest.cfc:
--------------------------------------------------------------------------------
 1 | <cfcomponent output="false" extends="cfml-liquid.tests.Test">
 2 | 	
 3 | 	<cffunction name="setup">
 4 | 		<cfset loc.obj = application.liquid.template()>
 5 | 	</cffunction>
 6 | 
 7 | 	<cffunction name="test_tokenize_strings">
 8 | 		
 9 | 		<cfset loc.e = [' ']>
10 | 		<cfset loc.r = loc.obj.tokenize(' ')>
11 | 		<cfset assert('arrayCompare(loc.e, loc.r)')>
12 | 
13 | 		<cfset loc.e = ['hello world']>
14 | 		<cfset loc.r = loc.obj.tokenize('hello world')>
15 | 		<cfset assert('arrayCompare(loc.e, loc.r)')>
16 | 		
17 | 	</cffunction>
18 |  	
19 | 	<cffunction name="test_tokenize_variables">
20 | 		
21 |  		<cfset loc.e = ['{{funk}}']>
22 | 		<cfset loc.r = loc.obj.tokenize('{{funk}}')>
23 | 		<cfset assert('arrayCompare(loc.e, loc.r)')>
24 | 
25 | 		<cfset loc.e = [' ', '{{funk}}', ' ']>
26 | 		<cfset loc.r = loc.obj.tokenize(' {{funk}} ')>
27 | 		<!--- <cfset debug('loc.e')><cfset debug('loc.r')> --->
28 | 		<cfset assert('arrayCompare(loc.e, loc.r)')>
29 |  		
30 |  		<cfset loc.e = [' ', '{{funk}}', ' ', '{{so}}', ' ', '{{brother}}', ' ']>
31 | 		<cfset loc.r = loc.obj.tokenize(' {{funk}} {{so}} {{brother}} ')>
32 | 		<cfset assert('arrayCompare(loc.e, loc.r)')>
33 | 		
34 | 		<cfset loc.e = [' ', '{{  funk  }}', ' ']>
35 | 		<cfset loc.r = loc.obj.tokenize(' {{  funk  }} ')>
36 | 		<cfset assert('arrayCompare(loc.e, loc.r)')>
37 | 
38 | 	</cffunction>
39 | 
40 | 	<cffunction name="test_tokenize_blocks">
41 | 		
42 | 		<cfset loc.e = ['{%comment%}']>
43 | 		<cfset loc.r = loc.obj.tokenize('{%comment%}')>
44 | 		<cfset assert('arrayCompare(loc.e, loc.r)')>
45 | 		
46 | 		<cfset loc.e = [' ', '{%comment%}', ' ']>
47 | 		<cfset loc.r = loc.obj.tokenize(' {%comment%} ')>
48 | 		<cfset assert('arrayCompare(loc.e, loc.r)')>
49 | 		
50 | 		<cfset loc.e = [' ', '{%comment%}', ' ', '{%endcomment%}', ' ']>
51 | 		<cfset loc.r = loc.obj.tokenize(' {%comment%} {%endcomment%} ')>
52 | 		<cfset assert('arrayCompare(loc.e, loc.r)')>
53 | 		
54 | 		<cfset loc.e = ['  ', '{% comment %}', ' ', '{% endcomment %}', ' ']>
55 | 		<cfset loc.r = loc.obj.tokenize('  {% comment %} {% endcomment %} ')>
56 | 		<cfset assert('arrayCompare(loc.e, loc.r)')>
57 | 
58 | 	</cffunction>
59 | 		
60 | </cfcomponent>


--------------------------------------------------------------------------------
/tests/tests/FilterTest.cfc:
--------------------------------------------------------------------------------
 1 | <cfcomponent output="false" extends="cfml-liquid.tests.Test">
 2 | 
 3 | 	<cffunction name="setup">
 4 | 		<cfset loc.context = createobject("component", "cfml-liquid.lib.liquid.LiquidContext").init()>
 5 | 	</cffunction>
 6 | 	
 7 | 	<cffunction name="create_var_instance">
 8 | 		<cfargument name="value" type="string" required="true">
 9 | 		<cfreturn createObject("component", "cfml-liquid.lib.liquid.LiquidVariable").init(
10 | 			arguments.value
11 | 		)>
12 | 	</cffunction>
13 | 	
14 | 	<cffunction name="create_class_instance">
15 | 		<cfargument name="klass" type="string" required="true">
16 | 		<cfreturn createObject("component", "classes.#arguments.klass#").init()>
17 | 	</cffunction>
18 | 	
19 | 	<cffunction name="create_moneyfilter_instance">
20 | 		<cfreturn createObject("component", "classes.MoneyFilter").init()>
21 | 	</cffunction>
22 | 	
23 | 	<cffunction name="test_local_filter">
24 | 		<cfset loc.v = create_var_instance('var | money')>
25 | 		<cfset loc.f = create_class_instance("MoneyFilter")>
26 | 		
27 | 		<cfset loc.context.set('var', 1000)>
28 | 		<cfset loc.context.add_filters(loc.f)>
29 | 		<cfset loc.e = " 1000$ ">
30 | 		<cfset loc.r = loc.v.render(loc.context)>
31 | 		<cfset assert('loc.e eq loc.r')>
32 | 	</cffunction>
33 | 
34 | 	<cffunction name="test_underscore_in_filter_name">
35 | 		<cfset loc.v = create_var_instance('var | money_with_underscore ')>
36 | 		<cfset loc.f = create_class_instance("MoneyFilter")>
37 | 		
38 | 		<cfset loc.context.set('var', 1000)>
39 | 		<cfset loc.context.add_filters(loc.f)>
40 | 		<cfset loc.e = " 1000$ ">
41 | 		<cfset loc.r = loc.v.render(loc.context)>
42 | 		<cfset assert('loc.e eq loc.r')>			
43 | 	</cffunction>
44 | 
45 | 	<cffunction name="test_second_filter_overwrites_first">		
46 | 		<cfset loc.v = create_var_instance('var | money ')>
47 | 		<cfset loc.f = create_class_instance("MoneyFilter")>
48 | 		<cfset loc.context.add_filters(loc.f)>
49 | 		<cfset loc.f = create_class_instance("CanadianMoneyFilter")>
50 | 		<cfset loc.context.add_filters(loc.f)>
51 | 
52 | 		<cfset loc.context.set('var', 1000)>
53 | 		<cfset loc.e = ' 1000$ CAD '>
54 | 		<cfset loc.r = loc.v.render(loc.context)>
55 | 		<cfset assert('loc.e eq loc.r')>				
56 | 	</cffunction>
57 | 
58 | </cfcomponent>


--------------------------------------------------------------------------------
/tests/tests/VariableResolutionTest.cfc:
--------------------------------------------------------------------------------
 1 | <cfcomponent output="false" extends="cfml-liquid.tests.Test">
 2 | 	
 3 | 	<cffunction name="setup">
 4 | 		<cfset loc.template = application.liquid.template()>
 5 | 	</cffunction>
 6 | 	
 7 | 	<cffunction name="test_simple_variable">
 8 | 
 9 | 		<cfset loc.a = {test = 'worked'}>
10 | 		<cfset loc.e = "worked">
11 | 		<cfset loc.template.parse("{{test}}")>
12 | 		<cfset loc.r = loc.template.render(loc.a)>
13 | 		<cfset assert('loc.e eq loc.r')>
14 | 		
15 | 	</cffunction>
16 | 	
17 | 	<cffunction name="test_simple_with_whitespaces">
18 | 
19 |  		<cfset loc.a = {test = 'worked'}>
20 | 		<cfset loc.e = '  worked  '>
21 | 		<cfset loc.template.parse("  {{ test }}  ")>
22 | 		<cfset loc.r = loc.template.render(loc.a)>
23 | 		<cfset assert('len(loc.e) eq len(loc.r)')>
24 | 		
25 | 		<cfset loc.a = {test = 'worked wonderfully'}>
26 | 		<cfset loc.e = '  worked wonderfully  '>
27 | 		<cfset loc.template.parse('  {{ test }}  ')>
28 | 		<cfset loc.r = loc.template.render(loc.a)>
29 | 		<cfset assert('loc.e eq loc.r')>
30 | 
31 | 	</cffunction>
32 | 	
33 | 	<cffunction name="test_ignore_unknown">
34 | 
35 | 		<cfset loc.e = ''>
36 | 		<cfset loc.template.parse('{{ test }}')>
37 | 		<cfset loc.r = loc.template.render()>
38 | 		<cfset assert('loc.e eq loc.r')>
39 | 	
40 | 	</cffunction>
41 | 	
42 | 	<cffunction name="test_array_scoping">
43 | 
44 | 		<cfset loc.a = {test = {test = 'worked'}}>
45 | 		<cfset loc.e = 'worked'>
46 | 		<cfset loc.template.parse('{{ test.test }}')>
47 | 		<cfset loc.r = loc.template.render(loc.a)>
48 | 		<cfset assert('loc.e eq loc.r')>
49 | 
50 | 	</cffunction>
51 | 	
52 | 	<cffunction name="test_using_queries">
53 | 		
54 | 		<cfset loc.q = QueryNew("firstname,lastname")>
55 | 		<cfset QueryAddRow(loc.q)>
56 | 		<cfset QuerySetCell(loc.q, "firstname", "Tony")>
57 | 		<cfset QuerySetCell(loc.q, "lastname", "Petruzzi")>
58 | 		<cfset QueryAddRow(loc.q)>
59 | 		<cfset QuerySetCell(loc.q, "firstname", "Per")>
60 | 		<cfset QuerySetCell(loc.q, "lastname", "Djurner")>
61 | 		
62 | 		<cfset loc.a = {test = {test = loc.q}}>
63 | 		<cfset loc.e = 'tony'>
64 | 		<cfset loc.template.parse('{{ test.test.firstname }}')>
65 | 		<cfset loc.r = loc.template.render(loc.a)>
66 | 		<cfset assert('loc.e eq loc.r')>
67 | 
68 | 	</cffunction>
69 | 	
70 | </cfcomponent>


--------------------------------------------------------------------------------
/tests/tests/FilterbankTest.cfc:
--------------------------------------------------------------------------------
 1 | <cfcomponent output="false" extends="cfml-liquid.tests.Test">
 2 | 	
 3 | 	<!--- LiquidFilterBank --->
 4 | 	<cfset this.context = "">
 5 | 	
 6 | 	<cffunction name="setup">
 7 | 		<cfset this.context = createObject("component", "cfml-liquid.lib.liquid.LiquidContext").init()>
 8 | 	</cffunction>
 9 | <!---
10 | 	WAY too dangerous to allow filter based off of global methods
11 | 	<cffunction name="test_function_filter">
12 | 		<cfset loc.var = createObject("component", "cfml-liquid.lib.liquid.LiquidVariable").init('var | function_filter')>
13 | 		<cfset this.context.function_filter = function_filter>
14 | 		<cfset this.context.set('var', 1000)>
15 | 		<cfset this.context.add_filters('request.function_filter')>
16 | 		<cfset loc.e = 'worked'>
17 | 		<cfset loc.r = loc.var.render(this.context)>
18 | 		<cfset assert("loc.e eq loc.r")>
19 | 	</cffunction>
20 | 	
21 |  	<cffunction name="function_filter">
22 | 		<cfargument name="value" type="string" required="true">
23 | 		<cfreturn "worked">
24 | 	</cffunction>
25 | 	<cfset request.function_filter = function_filter>
26 |  --->
27 | <!--- 
28 | 	CF doesn't have static classes
29 | 	<cffunction name="test_static_class_filter">
30 | 		<cfset loc.var = createObject("component", "cfml-liquid.lib.liquid.LiquidVariable").init('var | static_test')>
31 | 		<cfset this.context.set('var', 1000)>
32 | 		<cfset this.context.add_filters('TestClassFilter')>
33 | 		<cfset loc.e = 'worked'>
34 | 		<cfset loc.r = loc.var.render(this.context)>
35 | 		<cfset assert("loc.e eq loc.r")>	
36 | 	</cffunction>
37 |  --->
38 | 	
39 | 	<cffunction name="test_object_filter">
40 | 		<cfset loc.var = createObject("component", "cfml-liquid.lib.liquid.LiquidVariable").init('var | instance_test_one')>
41 | 		<cfset this.context.set('var', 1000)>
42 | 		<cfset loc.f = createObject("component", "classes.TestClassFilter")>
43 | 		<cfset this.context.add_filters(loc.f)>
44 | 		<cfset loc.e = 'set'>
45 | 		<cfset loc.r = loc.var.render(this.context)>
46 | 		<cfset assert("loc.e eq loc.r")>
47 | 			
48 | 		<cfset loc.var = createObject("component", "cfml-liquid.lib.liquid.LiquidVariable").init('var | instance_test_two')>
49 | 		<cfset loc.e = 'set'>
50 | 		<cfset loc.r = loc.var.render(this.context)>
51 | 		<cfset assert("loc.e eq loc.r")>
52 | 	</cffunction>
53 | 	 
54 | </cfcomponent>


--------------------------------------------------------------------------------
/lib/liquid/LiquidRegexp.cfc:
--------------------------------------------------------------------------------
 1 | <cfcomponent output="false">
 2 | 
 3 | 	<cfinclude template="utils.cfm">
 4 | 	
 5 | 	<cfset this.matches = []>
 6 | 	<cfset this.pattern = "">
 7 | 
 8 | 	<cffunction name="init">
 9 | 		<cfargument name="pattern" type="string" required="true">
10 | 		<cfset this.pattern = arguments.pattern>
11 | 		<cfreturn this>
12 | 	</cffunction>
13 | 
14 | 	<cffunction name="scan" hint="Returns an array of matches for the string in the same way as Ruby's scan method">
15 | 		<cfargument name="str" type="string" required="true">
16 | 		<cfset var loc = {}>
17 | 		
18 | 		<cfset loc.results = []>
19 | 		<cfset loc.matches = preg_match_all(this.pattern, arguments.str)>
20 | 
21 | 		<cfif ArrayIsEmpty(loc.matches)>
22 | 			<cfreturn loc.results>
23 | 		</cfif>
24 | 
25 | 		<cfif ArrayLen(loc.matches) eq 1>
26 | 			<cfreturn loc.matches[1]>
27 | 		</cfif>
28 | 		
29 | 		<cfset loc.temp = array_shift(loc.matches)>
30 | 		<cfset loc.matches = loc.temp.arr>
31 | 		<cfset loc.match = loc.temp.value>
32 | 
33 | 		<cfloop from="1" to="#ArrayLen(loc.matches)#" index="loc.m">
34 | 
35 | 			<cfloop from="1" to="#ArrayLen(loc.matches[loc.m])#" index="loc.i">
36 | 
37 | 				<cfif ArrayLen(loc.results) lt loc.i>
38 | 					<cfset loc.results[loc.i] = []>
39 | 				</cfif>
40 | 				<cfset ArrayAppend(loc.results[loc.i], loc.matches[loc.m][loc.i])>
41 | 
42 | 			</cfloop>
43 | 			
44 | 		</cfloop>
45 | 
46 | 		<cfreturn loc.results>
47 | 	</cffunction>
48 | 
49 | 	<cffunction name="match" hint="Matches the given string. Only matches once.">
50 | 		<cfargument name="str" type="string" required="true">
51 | 		<cfset var loc = {}>
52 | 		<cfset this.matches = preg_match(this.pattern, arguments.str)>
53 | 		<cfreturn not ArrayIsEmpty(this.matches)>
54 | 	</cffunction>
55 | 
56 | 	<cffunction name="match_all" hint="Matches the given string. Matches all.">
57 | 		<cfargument name="str" type="string" required="true">
58 | 		<cfset this.matches = preg_match_all(this.pattern, arguments.str)>
59 | 		<cfreturn ArrayLen(this.matches)>
60 | 	</cffunction>
61 | 
62 | 	<cffunction name="split" hint="Splits the given string">
63 | 		<cfargument name="str" type="string" required="true">
64 | 		<cfargument name="limit" type="numeric" required="false" default="0">
65 | 		<cfset var matches = pregSplit(this.pattern, arguments.str, arguments.limit, false)>
66 | 		<cfreturn matches>
67 | 	</cffunction>
68 | 	
69 | </cfcomponent>


--------------------------------------------------------------------------------
/lib/liquid/LiquidDrop.cfc:
--------------------------------------------------------------------------------
 1 | <cfcomponent output="false" hint="
 2 | 
 3 | A drop in liquid is a class which allows you to to export DOM like things to liquid
 4 | Methods of drops are callable. 
 5 | The main use for liquid drops is the implement lazy loaded objects. 
 6 | If you would like to make data available to the web designers which you don't want loaded unless needed then 
 7 | a drop is a great way to do that
 8 | 
 9 | Example:
10 | 
11 | class ProductDrop extends LiquidDrop {
12 |    function top_sales() {
13 |       Products::find('all', array('order' => 'sales', 'limit' => 10 ));
14 |    }
15 | }
16 | 
17 | tmpl = Liquid::Template.parse( ' {% for product in product.top_sales %} {{ product.name }} {%endfor%} '  )
18 | tmpl.render('product' => ProductDrop.new ) * will invoke top_sales query. 
19 | 
20 | Your drop can either implement the methods sans any parameters or implement the beforeMethod(name) method which is a catch all
21 | 
22 | ">
23 | 
24 | 	<!--- LiquidContext --->
25 | 	<cfset variables._context = "">
26 | 	<cfset variables.PROTECTED_METHODS = "init,beforeMethod,setContext,invokeDrop,hasKey,toLiquid">
27 | 	
28 | 	<cffunction name="init">
29 | 		<cfreturn this>
30 | 	</cffunction>
31 | 
32 | 	<cffunction name="beforeMethod" hint="Catch all method that is invoked before a specific method">
33 | 		<cfargument name="method" type="string" required="true">
34 | 		<cfreturn "">
35 | 	</cffunction>
36 | 
37 | 	<cffunction name="setContext" hint="sets the context of the drop">
38 | 		<cfargument name="context" type="any" required="true">
39 | 		<cfset variables._context = arguments.context>
40 | 	</cffunction>
41 | 
42 | 	<cffunction name="invokeDrop" hint="Invoke a specific method">
43 | 		<cfargument name="method" type="string" required="true">
44 | 		<cfset var loc = {}>
45 | 		
46 | 		<cfif ListFindNoCase(variables.PROTECTED_METHODS, arguments.method)>
47 | 			<cfreturn "">
48 | 		</cfif>
49 | 
50 | 		<cfset loc.ret = this.beforeMethod(arguments.method)>
51 | 		
52 | 		<cfif !StructKeyExists(loc, "ret")>
53 | 			<cfreturn "">
54 | 		</cfif>
55 | 
56 | 		<cfif StructKeyExists(this, arguments.method)>
57 | 			<cfinvoke component="#this#" method="#arguments.method#" returnvariable="loc.ret">
58 | 		</cfif>
59 | 
60 | 		<cfreturn loc.ret>
61 | 	</cffunction>
62 | 
63 | 	<cffunction name="hasKey" hint="Returns true if the drop supports the given method">
64 | 		<cfargument name="name" type="string" required="true">
65 | 		<cfreturn StructKeyExists(this, arguments.name)>
66 | 	</cffunction>
67 | 
68 | 	<cffunction name="toLiquid" hint="return this drop instance">
69 | 		<cfreturn this>
70 | 	</cffunction>
71 | 
72 | </cfcomponent>


--------------------------------------------------------------------------------
/lib/liquid/LiquidLocalFileSystem.cfc:
--------------------------------------------------------------------------------
 1 | <cfcomponent output="false" extends="LiquidBlankFileSystem" hint="This implements an abstract file system which retrieves template files named in a manner similar to Rails partials, ie. with the template name prefixed with an underscore. The extension '.liquid' is also added. For security reasons, template paths are only allowed to contain letters, numbers, and underscore.">
 2 | 
 3 | 	<cffunction name="init">
 4 | 		<cfargument name="root" type="string" required="true">
 5 | 		
 6 | 		<cfset this.root = ListChangeDelims(arguments.root, "/", "\")>
 7 | 		
 8 | 		<cfreturn this>
 9 | 	</cffunction>
10 | 
11 | 	<cffunction name="read_template_file" hint="Retrieve a template file">
12 | 		<cfargument name="template_path" type="string" required="true">
13 | 		<cfset var loc = {}>
14 | 
15 | 		<cfset loc.full_path = this.full_path(arguments.template_path)>
16 | 		<cffile action="read" file="#ExpandPath(loc.full_path)#" variable="loc.contents">
17 | 
18 | 		<cfreturn loc.contents>
19 | 	</cffunction>
20 | 
21 | 	<cffunction name="full_path" hint="Resolves a given path to a full template file path, making sure it's valid">
22 | 		<cfargument name="template_path" type="string" required="true">
23 | 		<cfset var loc = {}>
24 | 
25 | 		<cfset loc.name_regex = createObject("component", "LiquidRegexp").init('^[^\.\/][a-zA-Z0-9_\/]+$')>
26 | 		
27 | 		<cfif !loc.name_regex.match(arguments.template_path)>
28 | 			<cfset createObject("component", "LiquidException").init("Illegal template name '#arguments.template_path#'")>
29 | 		</cfif>
30 | 
31 | 		<cfif FindNoCase('/', arguments.template_path) neq 0>
32 | 			<cfset loc.full_path = [GetDirectoryFromPath(arguments.template_path), "#application.LiquidConfig.LIQUID_INCLUDE_PREFIX##ListLast(arguments.template_path, '/')#.#application.LiquidConfig.LIQUID_INCLUDE_SUFFIX#"]>
33 | 		<cfelse>
34 | 			<cfset loc.full_path = ["#application.LiquidConfig.LIQUID_INCLUDE_PREFIX##arguments.template_path#.#application.LiquidConfig.LIQUID_INCLUDE_SUFFIX#"]>
35 | 		</cfif>
36 | 		
37 | 		<cfset loc.full_path = this.root & ListChangeDelims(ArrayToList(loc.full_path, "/"), "/", "/")>
38 | 		
39 | 		<!--- convert to full path --->
40 | 		<cftry>
41 | 			<cfset loc._full_path = ExpandPath(loc.full_path)>
42 | 			<cfset loc._root = ExpandPath(this.root)>
43 | 			
44 | 			<cfif left(loc._full_path, len(loc._root)) neq loc._root>
45 | 				<cfset createObject("component", "LiquidException").init("Illegal template path #loc.full_path#")>
46 | 			</cfif>
47 | 			
48 | 			<cfcatch type="any">
49 | 				<cfset createObject("component", "LiquidException").init("Illegal template path #loc.full_path#")>
50 | 			</cfcatch>
51 | 		</cftry>
52 | 		
53 | 		<cfreturn loc.full_path>
54 | 	</cffunction>
55 | 	
56 | </cfcomponent>


--------------------------------------------------------------------------------
/tests/helpers.cfm:
--------------------------------------------------------------------------------
 1 | <cfset this.filters = "">
 2 | 
 3 | <cffunction name="arrayCompare" returntype="boolean">
 4 | 	<cfargument name="LeftArray" type="array" required="true">
 5 | 	<cfargument name="RightArray" type="array" required="true">
 6 | 	<cfset var loc = {}>
 7 | 	<cfset loc.results = true>
 8 | 
 9 | 	<cfif !isArray(arguments.LeftArray) OR !isArray(arguments.RightArray)>
10 | 		<cfreturn false>
11 | 	</cfif>
12 |     
13 | 	<cfif arrayLen(arguments.LeftArray) neq arrayLen(arguments.RightArray)>
14 | 		<cfreturn false>
15 | 	</cfif>
16 |     
17 | 	<!--- Loop through the elements and compare them one at a time --->
18 | 	<cfloop from="1" to="#ArrayLen(arguments.LeftArray)#" index="loc.i">
19 |         <!--- elements is a structure --->
20 | 		<cfif isStruct(arguments.LeftArray[loc.i])>
21 | 			<cfset loc.temp1 = arguments.LeftArray[loc.i]>
22 | 			<cfset loc.temp2 = arguments.RightArray[loc.i]>
23 | 			<cfset loc.result = loc.temp1.Equals(loc.temp2)>
24 |             <cfif NOT loc.result>
25 | 				<cfreturn false>
26 | 			</cfif>
27 | 		<!--- elements is an array, call arrayCompare() --->
28 |         <cfelseif isArray(LeftArray[loc.i])>
29 |             <cfset loc.result = arrayCompare(arguments.LeftArray[loc.i],arguments.RightArray[loc.i])>
30 |             <cfif NOT loc.result>
31 | 				<cfreturn false>
32 | 			</cfif>
33 | 		<!--- A simple type comparison here --->
34 | 		<cfelse>
35 |             <cfif arguments.LeftArray[loc.i] IS NOT arguments.RightArray[loc.i]>
36 | 				<cfreturn false>
37 | 			</cfif>
38 | 		</cfif>
39 | 	</cfloop>
40 |     <cfreturn true>
41 | </cffunction>
42 | 
43 | <cffunction name="arrayWrap">
44 | 	<cfargument name="value" type="any" required="true">
45 | 	<cfset var ret = [arguments.value]>
46 | 	<cfreturn ret>
47 | </cffunction>
48 | 
49 | <cffunction name="assert_template_result">
50 | 	<cfargument name="expected" type="string" required="true">
51 | 	<cfargument name="template" type="string" required="true">
52 | 	<cfargument name="templateObj" type="any" required="true">
53 | 	<cfargument name="assigns" type="struct" required="false" default="#StructNew()#">
54 | 
55 | 		<cfset loc.e = arguments.expected>
56 | 		<cfset arguments.templateObj.parse(arguments.template)>
57 | 
58 | 		<cfset loc.r = arguments.templateObj.render(arguments.assigns, this.filters)>
59 | 		<cfset loc.result = CompareNoCase(loc.e, loc.r)>
60 | 		
61 | 		<cfif loc.result neq 0>
62 | 			<cfset this.debug('loc')>
63 | 		</cfif>
64 | 		
65 | 		<cfset this.assert('loc.result eq 0')>
66 | </cffunction>
67 | 	
68 | <cffunction name="getClassName">
69 | 	<cfargument name="obj" type="any" required="true">
70 | 	<cfif IsObject(arguments.obj)>
71 | 		<cfreturn ListLast(getMetaData(arguments.obj).name, ".")>
72 | 	</cfif>
73 | 	<cfreturn "">
74 | </cffunction>


--------------------------------------------------------------------------------
/tests/tests/AssignTest.cfc:
--------------------------------------------------------------------------------
 1 | <cfcomponent output="false" extends="cfml-liquid.tests.Test">
 2 | 	
 3 | 	<cffunction name="setup">
 4 | 		<cfset loc.template = application.liquid.template()>
 5 | 	</cffunction>
 6 | 
 7 | 	<cffunction name="test_invalid_assign" hint="Tests the normal behavior of throwing an exception when the assignment is incorrect">
 8 | 		<cfset loc.r = raised("loc.template.parse('{% assign test %}')")>
 9 | 		<cfset loc.e = 'LiquidError'>
10 | 		<cfset assert("loc.e eq loc.r.type")>
11 | 	</cffunction>
12 | 
13 | 	<cffunction name="test_simple_assign" hint="Tests a simple assignment with no filters">
14 | 		<cfset loc.template.parse('{% assign test = "hello" %}{{ test }}')>
15 | 		<cfset loc.r = loc.template.render()>
16 | 		<cfset loc.e = 'hello'>
17 | 		<cfset assert("loc.e eq loc.r")>
18 | 	</cffunction>
19 | 
20 | 	<cffunction name="test_assign_with_filters" hint="Tests filtered value assignment">
21 | 
22 | 		<cfset loc.template.parse('{% assign test = "hello" | upcase %}{{ test }}')>
23 | 		<cfset loc.r = loc.template.render()>
24 | 		<cfset loc.e = 'HELLO'>
25 | 		<cfset assert("loc.e eq loc.r")>
26 | 
27 |  		<cfset loc.template.parse('{% assign test = "hello" | upcase | downcase | capitalize %}{{ test }}')>
28 | 		<cfset loc.r = loc.template.render()>
29 | 		<cfset loc.e = 'Hello'>
30 | 		<cfset assert("loc.e eq loc.r")>
31 | 
32 | 
33 | 		<cfset loc.a = {}>
34 | 		<cfset loc.a["var1"] = ['a', 'b', 'c']>
35 | 		<cfset loc.template.parse('{% assign test = var1 | first | upcase %}{{ test }}')>
36 | 		<cfset loc.r = loc.template.render(loc.a)>
37 | 		<cfset loc.e = 'A'>
38 | 		<cfset assert("loc.e eq loc.r")>
39 | 
40 | 		<cfset loc.a = {}>
41 | 		<cfset loc.a["var1"] = ['a', 'b', 'c']>
42 | 		<cfset loc.template.parse('{% assign test = var1 | last | upcase %}{{ test }}')>
43 | 		<cfset loc.r = loc.template.render(loc.a)>
44 | 		<cfset loc.e = 'C'>
45 | 		<cfset assert("loc.e eq loc.r")>
46 | 
47 | 		<cfset loc.a = {}>
48 | 		<cfset loc.a["var1"] = ['a', 'b', 'c']>
49 | 		<cfset loc.template.parse('{% assign test = var1 | join %}{{ test }}')>
50 | 		<cfset loc.r = loc.template.render(loc.a)>
51 | 		<cfset loc.e = 'a b c'>
52 | 		<cfset assert("loc.e eq loc.r")>
53 | 
54 | 		<cfset loc.a = {}>
55 | 		<cfset loc.a["var1"] = ['a', 'b', 'c']>
56 | 		<cfset loc.template.parse('{% assign test = var1 | join : "." %}{{ test }}')>
57 | 		<cfset loc.r = loc.template.render(loc.a)>
58 | 		<cfset loc.e = 'a.b.c'>
59 | 		<cfset assert("loc.e eq loc.r")>
60 | 	</cffunction>
61 | 	
62 | 	<cffunction name="test_assign_in_condition">
63 | 		<cfset loc.template.parse('{% assign test1 = "maybe" %}{% if test1 == "maybe" %}{% assign test1 = "yes" %}{% endif %}{{ test1 }}')>
64 | 		<cfset loc.r = loc.template.render()>
65 | 		<cfset loc.e = 'yes'>
66 | 		<cfset assert("loc.e eq loc.r")>
67 | 	</cffunction>
68 | 	
69 | </cfcomponent>


--------------------------------------------------------------------------------
/tests/tests/BlockTest.cfc:
--------------------------------------------------------------------------------
 1 | <cfcomponent output="false" extends="cfml-liquid.tests.Test">
 2 | 	
 3 | 	<cffunction name="setup">
 4 | 		<cfset loc.template = application.liquid.template()>
 5 | 	</cffunction>
 6 | 	
 7 | 	<cffunction name="test_blackspace">
 8 | 		<cfset loc.a = ['  ']>
 9 | 		<cfset loc.template.parse('  ')>
10 | 		<cfset loc.nodelist = loc.template.getRoot().getNodelist()>
11 | 		
12 | 		<cfset assert('IsArray(loc.a) and IsArray(loc.nodelist)')>
13 | 		<cfset assert('ArrayLen(loc.a) eq 1 and ArrayLen(loc.nodelist) eq 1')>
14 | 		<cfset assert('loc.a[1] eq loc.nodelist[1]')>		
15 | 	</cffunction>
16 | 	
17 | 	<cffunction name="test_variable_beginning">
18 | 		<cfset loc.template.parse('{{funk}}  ')>
19 | 		<cfset loc.nodelist = loc.template.getRoot().getNodelist()>
20 | 		<cfset assert("ArrayLen(loc.nodelist) eq 2")>
21 | 		<cfset assert("getClassName(loc.nodelist[1]) eq 'LiquidVariable'")>
22 | 		<cfset assert("IsSimpleValue(loc.nodelist[2])")>
23 | 	</cffunction>
24 | 
25 | 	<cffunction name="test_variable_end">
26 | 		<cfset loc.template.parse('  {{funk}}')>
27 | 		<cfset loc.nodelist = loc.template.getRoot().getNodelist()>
28 | 		
29 | 		<cfset assert("ArrayLen(loc.nodelist) eq 2")>
30 | 		<cfset assert("IsSimpleValue(loc.nodelist[1])")>
31 | 		<cfset assert("getClassName(loc.nodelist[2]) eq 'LiquidVariable'")>
32 | 	</cffunction>
33 | 
34 | 	<cffunction name="test_variable_middle">
35 | 		<cfset loc.template.parse('  {{funk}}  ')>
36 | 		<cfset loc.nodelist = loc.template.getRoot().getNodelist()>
37 | 
38 | 		<cfset assert("ArrayLen(loc.nodelist) eq 3")>
39 | 		<cfset assert("IsSimpleValue(loc.nodelist[1])")>
40 | 		<cfset assert("getClassName(loc.nodelist[2]) eq 'LiquidVariable'")>
41 | 		<cfset assert("IsSimpleValue(loc.nodelist[3])")>
42 | 	</cffunction>	
43 | 
44 | 	<cffunction name="test_variable_many_embedded_fragments">
45 | 		<cfset loc.template.parse('  {{funk}}  {{soul}}  {{brother}} ')>
46 | 		<cfset loc.nodelist = loc.template.getRoot().getNodelist()>
47 | 		
48 | 		<cfset assert("ArrayLen(loc.nodelist) eq 7")>
49 | 		<cfset assert("IsSimpleValue(loc.nodelist[1])")>
50 | 		<cfset assert("getClassName(loc.nodelist[2]) eq 'LiquidVariable'")>
51 | 		<cfset assert("IsSimpleValue(loc.nodelist[3])")>
52 | 		<cfset assert("getClassName(loc.nodelist[4]) eq 'LiquidVariable'")>
53 | 		<cfset assert("IsSimpleValue(loc.nodelist[5])")>
54 | 		<cfset assert("getClassName(loc.nodelist[6]) eq 'LiquidVariable'")>
55 | 		<cfset assert("IsSimpleValue(loc.nodelist[7])")>
56 | 	</cffunction>
57 | 
58 | 	<cffunction name="test_with_block">
59 | 		<cfset loc.template.parse('  {% comment %}  {% endcomment %} ')>
60 | 		<cfset loc.nodelist = loc.template.getRoot().getNodelist()>
61 | 		
62 | 		<cfset assert("ArrayLen(loc.nodelist) eq 3")>
63 | 		<cfset assert("IsSimpleValue(loc.nodelist[1])")>
64 | 		<cfset assert("getClassName(loc.nodelist[2]) eq 'LiquidTagComment'")>
65 | 		<cfset assert("IsSimpleValue(loc.nodelist[3])")>
66 | 	</cffunction>
67 | 
68 | </cfcomponent>


--------------------------------------------------------------------------------
/tests/tests/FileSystemTest.cfc:
--------------------------------------------------------------------------------
 1 | <cfcomponent output="false" extends="cfml-liquid.tests.Test">
 2 | 	
 3 | 	<cffunction name="test_default">
 4 | 		<cfset loc.file_system = createObject("component", "cfml-liquid.lib.liquid.LiquidBlankFileSystem").init()>
 5 | 		<cftry>
 6 | 			<cfset loc.file_system.read_template_file('dummy')>
 7 | 			<cfcatch type="any">
 8 | 				<cfset loc.e = cfcatch.message>
 9 | 				<cfset loc.r = "This liquid context does not allow includes.">
10 | 				<cfset assert('loc.e eq loc.r')>
11 | 			</cfcatch>
12 | 		</cftry>	
13 | 	</cffunction>
14 | 	
15 | 	<cffunction name="test_root">
16 | 		<cfset loc.root = '/cfml-liquid/tests/tests/templates/'>
17 | 
18 | 		<cfset loc.file_system = createObject("component", "cfml-liquid.lib.liquid.LiquidLocalFileSystem").init(loc.root)>
19 | 		
20 | 		<cfset loc.root = ListChangeDelims(loc.root, "/", "\")>
21 | 		
22 | 		<cfset loc.r = loc.file_system.root>
23 | 		<cfset loc.e = loc.root>
24 | 		
25 | 		<cfset assert('loc.e eq loc.r')>
26 | 	</cffunction>
27 | 	
28 | 	<cffunction name="test_local">
29 | 		<cfset loc.root = '/cfml-liquid/tests/tests/templates/'>
30 | 		<cfset loc.root = ListChangeDelims(loc.root, "/", "\")>
31 | 
32 | 		<cfset loc.file_system = createObject("component", "cfml-liquid.lib.liquid.LiquidLocalFileSystem").init(loc.root)>
33 | 		
34 | 		<cfset loc.e = loc.root & "_mypartial.liquid">
35 | 		<cfset loc.r = loc.file_system.full_path("mypartial")>
36 | 		<cfset assert("loc.e eq loc.r")>
37 | 	
38 | 		<cfset loc.e = loc.root & "dir/_mypartial.liquid">
39 | 		<cfset loc.r = loc.file_system.full_path("dir/mypartial")>
40 | 		<cfset assert("loc.e eq loc.r")>
41 | 
42 | 		<cftry>
43 | 			<cfset loc.file_system.full_path("../dir/mypartial")>
44 | 			<cfcatch type="any">
45 | 				<cfset loc.e = cfcatch.message>
46 | 				<cfset loc.r = "Illegal template name '../dir/mypartial'">
47 | 				<cfset assert("loc.e eq loc.e")>
48 | 			</cfcatch>
49 | 		</cftry>
50 | 
51 | 		<cftry>
52 | 			<cfset loc.file_system.full_path("/dir/../../dir/mypartial")>
53 | 			<cfcatch type="any">
54 | 				<cfset loc.e = cfcatch.message>
55 | 				<cfset loc.r = "Illegal template name '/dir/../../dir/mypartial'">
56 | 				<cfset assert("loc.e eq loc.e")>
57 | 			</cfcatch>
58 | 		</cftry>
59 | 
60 | 		<cftry>
61 | 			<cfset loc.file_system.full_path("/etc/passwd")>
62 | 			<cfcatch type="any">
63 | 				<cfset loc.e = cfcatch.message>
64 | 				<cfset loc.r = "Illegal template name '/etc/passwd'">
65 | 				<cfset assert("loc.e eq loc.e")>
66 | 			</cfcatch>
67 | 		</cftry>
68 | 
69 | 	</cffunction>
70 | 	
71 | 	<cffunction name="test_read_local_template">
72 | 		<cfset loc.root = '/cfml-liquid/tests/tests/templates/'>
73 | 		<cfset loc.root = ListChangeDelims(loc.root, "/", "\")>
74 | 
75 | 		<cfset loc.file_system = createObject("component", "cfml-liquid.lib.liquid.LiquidLocalFileSystem").init(loc.root)>
76 | 		
77 | 		<cfset loc.e = "Put Liquid Markup here">
78 | 		<cfset loc.r = loc.file_system.read_template_file('template')>
79 | 		
80 | 		<cfset assert('loc.e eq loc.r')>
81 | 	</cffunction>
82 | 	
83 | </cfcomponent>


--------------------------------------------------------------------------------
/lib/liquid/LiquidVariable.cfc:
--------------------------------------------------------------------------------
 1 | <cfcomponent output="false" hint="Implements a template variable">
 2 | 
 3 | 	<cfinclude template="utils.cfm">
 4 | 
 5 | 	<cffunction name="init">
 6 | 		<cfargument name="markup" type="string" required="true">
 7 | 		<cfset var loc = {}>
 8 | 
 9 | 		<cfset variables._markup = arguments.markup>
10 | 		<cfset variables._filters = []>
11 | 		<cfset variables._name = "">
12 | 		
13 | 		<cfset loc.quoted_fragment_regexp = createObject("component", "LiquidRegexp").init("\s*(#application.LiquidConfig.LIQUID_QUOTED_FRAGMENT#)")>
14 | 		<cfset loc.filter_seperator_regexp = createObject("component", "LiquidRegexp").init("#application.LiquidConfig.LIQUID_FILTER_SEPARATOR#\s*(.*)")>
15 | 		<cfset loc.filter_split_regexp = createObject("component", "LiquidRegexp").init(application.LiquidConfig.LIQUID_FILTER_SEPARATOR)>
16 | 		<cfset loc.filter_name_regexp = createObject("component", "LiquidRegexp").init("\s*(\w+)")>
17 | 		<cfset loc.filter_argument_regexp = createObject("component", "LiquidRegexp").init("(?:#application.LiquidConfig.LIQUID_FILTER_ARGUMENT_SEPARATOR#|#application.LiquidConfig.LIQUID_ARGUMENT_SEPARATOR#)\s*(#application.LiquidConfig.LIQUID_QUOTED_FRAGMENT#)")>
18 | 
19 | 		<cfif loc.quoted_fragment_regexp.match(arguments.markup)>
20 | 			<cfset variables._name = trim(loc.quoted_fragment_regexp.matches[1])>
21 | 		</cfif>
22 | 
23 | 		<cfif loc.filter_seperator_regexp.match(arguments.markup)>
24 | 
25 | 			<cfset loc.$filters = loc.filter_split_regexp.split(loc.filter_seperator_regexp.matches[1])>
26 | 
27 | 			<cfloop array="#loc.$filters#" index="loc.filter">
28 | 				
29 | 				<cfset loc.filter = trim(loc.filter)>
30 | 				<cfset loc.filter_name_regexp.match(loc.filter)>
31 | 				
32 | 				<cfif !ArrayIsEmpty(loc.filter_name_regexp.matches)>
33 | 				
34 | 					<cfset loc.filtername = loc.filter_name_regexp.matches[1]>
35 | 					<cfset loc.filter_argument_regexp.match_all(loc.filter)>
36 | 					<cfset loc.temp = []>
37 | 					<cfset loc.matches = []>
38 | 					
39 | 					<cfif !ArrayIsEmpty(loc.filter_argument_regexp.matches)>
40 | 						<cfset loc.matches = array_flatten(loc.filter_argument_regexp.matches[2])>
41 | 					</cfif>
42 | 	
43 | 					<cfset loc.temp = [loc.filtername, loc.matches]>
44 | 					<cfset arrayAppend(variables._filters, loc.temp)>
45 | 					
46 | 				</cfif>
47 | 
48 | 			</cfloop>
49 | 			
50 | 		</cfif>
51 | 
52 | 		<cfreturn this>
53 | 	</cffunction>
54 | 
55 | 	<cffunction name="render" hint="Renders the variable with the data in the context">
56 | 		<cfargument name="context" type="any" required="true">
57 | 		<cfset var loc = {}>
58 | 
59 | 		<cfset loc.output = arguments.context.get(variables._name)>
60 | 
61 | 		<cfloop array="#variables._filters#" index="loc.filter">
62 | 			
63 | 			<cfset loc.filtername = loc.filter[1]>
64 | 			<cfset loc.filter_arg_keys = loc.filter[2]>
65 | 			<cfset loc.filter_arg_values = []>
66 | 			
67 | 			<cfloop array="#loc.filter_arg_keys#" index="loc.arg_keys">
68 | 				<cfset arrayAppend(loc.filter_arg_values, arguments.context.get(loc.arg_keys))>
69 | 			</cfloop>
70 | 
71 | 			<cfset loc.output = arguments.context.invoke_method(loc.filtername, loc.output, loc.filter_arg_values)>
72 | 
73 | 		</cfloop>
74 | 		
75 | 		<cfreturn loc.output>
76 | 	</cffunction>
77 | 	
78 | 	<cffunction name="getName">
79 | 		<cfreturn variables._name>
80 | 	</cffunction>
81 | 
82 | 	<cffunction name="getFilters">
83 | 		<cfreturn variables._filters>
84 | 	</cffunction>
85 | 
86 | </cfcomponent>


--------------------------------------------------------------------------------
/lib/liquid/LiquidTagTablerow.cfc:
--------------------------------------------------------------------------------
 1 | <cfcomponent output="false" extends="LiquidBlock" hint="
 2 | Quickly create a table from a collection
 3 | ">
 4 | 
 5 | 	<cffunction name="init">
 6 | 		<cfargument name="markup" type="string" required="true">
 7 | 		<cfargument name="tokens" type="array" required="true">
 8 | 		<cfargument name="file_system" type="any" required="true" hint="LiquidFileSystem">
 9 | 		<cfset var loc = {}>
10 | 		
11 | 		<!--- The variable name of the table tag --->
12 | 		<cfset this.variable_name = "">
13 | 		
14 | 		<!--- The collection name of the table tags --->
15 | 		<cfset this.collection_name = "">
16 | 		
17 | 		<!--- Additional attributes --->
18 | 		<cfset this.attributes = []>
19 | 		<cfset super.init(arguments.markup, arguments.tokens, arguments.file_system)>
20 | 		<cfset loc.syntax = createObject("component", "LiquidRegexp").init("(\w+)\s+in\s+(#application.LiquidConfig.LIQUID_ALLOWED_VARIABLE_CHARS#+)")>
21 | 		
22 | 		<cfif loc.syntax.match(arguments.markup)>
23 | 			
24 | 			<cfset this.variable_name = loc.syntax.matches[2]>
25 | 			<cfset this.collection_name = loc.syntax.matches[3]>
26 | 			<cfset this.extract_attributes(arguments.markup)>
27 | 			
28 | 		<cfelse>
29 | 			<cfset createObject("component", "LiquidException").init("Syntax Error in 'table_row loop' - Valid syntax: table_row [item] in [collection] cols=3")>
30 | 		</cfif>
31 | 		
32 | 		<cfreturn this>
33 | 	</cffunction>
34 | 
35 | 	<cffunction name="render">
36 | 		<cfargument name="context" type="any" required="true" hint="LiquidContext">
37 | 		<cfset var loc = {}>
38 | 
39 | 		<cfset loc.collection = arguments.context.get(this.collection_name)>
40 | 
41 | 		<cfif !StructKeyExists(loc, "collection") OR !IsArray(loc.collection)>
42 | 			<cfreturn "">
43 | 		</cfif>
44 | 
45 | 		<cfif StructKeyExists(this.attributes, "limit") OR StructKeyExists(this.attributes, "offset")>
46 | 			<cfset loc.limit = arguments.context.get(this.attributes['limit'])>
47 | 			<cfset loc.offset = arguments.context.get(this.attributes['offset'])>
48 | 			<cfset loc.collection = createObject("java", "java.util.ArrayList").Init(loc.collection).subList(JavaCast("int", loc.offset), JavaCast("int", loc.limit))>
49 | 		</cfif>
50 | 		
51 | 		<cfset loc.length = ArrayLen(loc.collection)>
52 | 		<cfset loc.cols = arguments.context.get(this.attributes['cols'])>
53 | 		<cfset loc.row = 1>
54 | 		<cfset loc.col = 0>
55 | 		<cfset loc.result = '<tr class="row1">#chr(10)#'>
56 | 		<cfset arguments.context.push()>
57 | 		
58 | 		<cfloop from="1" to="#loc.length#" index="loc.index">
59 | 
60 | 			<cfset arguments.context.set(this.variable_name, loc.collection[loc.index])>
61 | 			<cfset loc.temp = {}>
62 | 			<cfset loc.temp.name = this.variable_name>
63 | 			<cfset loc.temp.length = loc.length>
64 | 			<cfset loc.temp.index = loc.index + 1>
65 | 			<cfset loc.temp.index0 = loc.index>
66 | 			<cfset loc.temp.rindex = loc.length - loc.index>
67 | 			<cfset loc.temp.rindex0 = loc.length - loc.index - 1>
68 | 			<cfset loc.temp.first = IIf(loc.index eq 1, de(1), de(0))>
69 | 			<cfset loc.temp.last = IIF(loc.index eq (loc.length - 1), de(1), de(0))>
70 | 			<cfset arguments.context.set('tablerowloop', loc.temp)>
71 | 			
72 | 			<cfset loc.result &= '<td class="col#++loc.col#">' & this.render_all(this._nodelist, arguments.context) & "</td>">
73 | 			
74 | 			<cfif loc.col eq loc.cols AND not (loc.index - 1 eq loc.length - 1)>
75 | 				
76 | 				<cfset loc.col = 0>
77 | 				<cfset loc.result &= '</tr>#chr(10)#<tr class="row#++loc.row#">'>
78 | 				
79 | 			</cfif>
80 | 			
81 | 		</cfloop>
82 | 		
83 | 		<cfset arguments.context.pop()>
84 | 		<cfset loc.result &= "</tr>#chr(10)#">
85 | 		
86 | 		<cfreturn loc.result>
87 | 	</cffunction>
88 | 
89 | </cfcomponent>


--------------------------------------------------------------------------------
/lib/liquid/LiquidTagCycle.cfc:
--------------------------------------------------------------------------------
 1 | <cfcomponent output="false" extends="LiquidTag" hint="
 2 | Cycles between a list of values; calls to the tag will return each value in turn
 3 | 
 4 | @example
 5 | {%cycle 'one', 'two'%} {%cycle 'one', 'two'%} {%cycle 'one', 'two'%}
 6 | 
 7 | this will return:
 8 | one two one
 9 | 
10 | Cycles can also be named, to differentiate between multiple cycle with the same values:
11 | {%cycle 1: 'one', 'two' %} {%cycle 2: 'one', 'two' %} {%cycle 1: 'one', 'two' %} {%cycle 2: 'one', 'two' %}
12 | 
13 | will return
14 | one one two two
15 | ">
16 | 
17 | 	<cffunction name="init">
18 | 		<cfargument name="markup" type="string" required="true">
19 | 		<cfargument name="tokens" type="array" required="true">
20 | 		<cfargument name="file_system" type="any" required="true">
21 | 		<cfset var loc = {}>
22 | 
23 | 		<!--- The name of the cycle; if none is given one is created using the value list --->
24 | 		<cfset this._name = "">
25 | 		<!--- The variables to cycle between --->
26 | 		<cfset this._variables = []>
27 | 		
28 | 		<cfset loc.simple_syntax = createObject("component", "LiquidRegexp").init(application.LiquidConfig.LIQUID_QUOTED_FRAGMENT)>
29 | 		<cfset loc.named_syntax = createObject("component", "LiquidRegexp").init("(#application.LiquidConfig.LIQUID_QUOTED_FRAGMENT#)\s*\:\s*(.*)")>
30 | 		
31 | 		<cfif loc.named_syntax.match(arguments.markup)>
32 | 
33 | 			<cfset this._variables = this._variablesFromString(loc.named_syntax.matches[3])>
34 | 			<cfset this._name = loc.named_syntax.matches[2]>
35 | 			
36 | 		<cfelseif loc.simple_syntax.match(arguments.markup)>
37 | 
38 | 			<cfset this._variables = this._variablesFromString(arguments.markup)>
39 | 			<cfset this._name = "'#ArrayToList(this._variables, '')#'">
40 | 			
41 | 		<cfelse>
42 | 			<cfset createObject("component", "LiquidException").init("Syntax Error in 'cycle' - Valid syntax: cycle [name :] var [, var2, var3 ...]")>
43 | 		</cfif>
44 | 
45 | 		<cfreturn this>
46 | 	</cffunction>
47 | 
48 | 	<cffunction name="render" hint="Renders the tag">
49 | 		<cfargument name="context" type="any" required="true" hint="LiquidContext">
50 | 		<cfset var loc = {}>
51 | 
52 | 		<cfset arguments.context.push()>
53 | 		<cfset loc.key = arguments.context.get(this._name)>
54 | 
55 | 		<cfif
56 | 			StructKeyExists(arguments.context, "registers")
57 | 			AND StructKeyExists(arguments.context.registers, "cycle")
58 | 			AND StructKeyExists(arguments.context.registers.cycle, loc.key)>
59 | 			<cfset loc.iteration = arguments.context.registers['cycle'][loc.key]>
60 | 		<cfelse>
61 | 			<cfset loc.iteration = 1>
62 | 		</cfif>
63 | 
64 | 		<cfset loc.result = arguments.context.get(this._variables[loc.iteration])>
65 | 		<cfset loc.iteration += 1>
66 | 
67 | 		<cfif loc.iteration gt ArrayLen(this._variables)>
68 | 			<cfset loc.iteration = 1>
69 | 		</cfif>
70 | 		
71 | 		<cfset arguments.context.registers['cycle'][loc.key] = loc.iteration>
72 | 		<cfset arguments.context.pop()>
73 | 		
74 | 		<cfreturn loc.result>
75 | 	</cffunction>
76 | 
77 | 	<cffunction name="_variablesFromString" hint="Extract variables from a string of markup">
78 | 		<cfargument name="markup" type="string" required="true">
79 | 		<cfset var loc = {}>
80 | 		
81 | 		<cfset loc.regexp = createObject("component", "LiquidRegexp").init('\s*(#application.LiquidConfig.LIQUID_QUOTED_FRAGMENT#)\s*')>
82 | 		<cfset loc.parts = ListToArray(arguments.markup, ',')>
83 | 		<cfset loc.result = []>
84 | 		
85 | 		<cfloop array="#loc.parts#" index="loc.part">
86 | 			<cfset loc.regexp.match(loc.part)>
87 | 			
88 | 			<cfif len(loc.regexp.matches[2])>
89 | 				<cfset ArrayAppend(loc.result, loc.regexp.matches[2])>
90 | 			</cfif>
91 | 		</cfloop>
92 | 		
93 | 		<cfreturn loc.result>
94 | 	</cffunction>
95 | 		
96 | </cfcomponent>


--------------------------------------------------------------------------------
/tests/tests/OutputTest.cfc:
--------------------------------------------------------------------------------
 1 | <cfcomponent output="false" extends="cfml-liquid.tests.Test">
 2 | 	
 3 | 	<cffunction name="setup">
 4 | 		<cfset loc.a = {}>
 5 | 		<cfset loc.a['best_cars'] = 'bmw'>
 6 | 		<cfset loc.a['car'] = {bmw = 'good', gm = 'bad'}>
 7 | 
 8 | 		<cfset this.filters = createObject("component", "classes.FunnyFilter")>
 9 | 		<cfset loc.template = application.liquid.template()>
10 | 	</cffunction>
11 | 
12 | 	<cffunction name="test_variable">
13 | 		<cfset loc.t = " {{best_cars}} ">
14 | 		<cfset loc.e = " bmw ">
15 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
16 | 	</cffunction>
17 | 	
18 | 	<cffunction name="test_variable_trasversing">
19 | 		<cfset loc.t = " {{car.bmw}} {{car.gm}} {{car.bmw}} ">
20 | 		<cfset loc.e = " good bad good ">
21 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
22 | 	</cffunction>
23 | 	
24 | 	<cffunction name="test_variable_piping">
25 | 		<cfset loc.t = " {{ car.gm | make_funny }} ">
26 | 		<cfset loc.e = " LOL ">
27 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
28 | 	</cffunction>
29 | 	
30 | 	<cffunction name="test_variable_piping_with_input">
31 | 		<cfset loc.t = " {{ car.gm | cite_funny }} ">
32 | 		<cfset loc.e = " LOL: bad ">
33 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
34 | 	</cffunction>
35 | 
36 | 	<cffunction name="test_variable_piping_with_args">
37 | 		<cfset loc.t = " {{ car.gm | add_smiley : ':-(' }} ">
38 | 		<cfset loc.e = " bad :-( ">
39 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
40 | 	</cffunction>
41 | 	
42 | 	<cffunction name="text_variable_piping_with_no_args">
43 | 		<cfset loc.t = " {{ car.gm | add_smile }} ">
44 | 		<cfset loc.e = " bad :-( ">
45 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
46 | 	</cffunction>
47 | 	
48 | 	<cffunction name="test_multiple_variable_piping_with_args">
49 | 		<cfset loc.t = " {{ car.gm | add_smiley : ':-(' | add_smiley : ':-('}} ">
50 | 		<cfset loc.e = " bad :-( :-( ">
51 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
52 | 	</cffunction>
53 | 		
54 | 	<cffunction name="test_variable_piping_with_two_args">
55 | 		<cfset loc.t = " {{ car.gm | add_tag : 'span', 'bar'}} ">
56 | 		<cfset loc.e = " <span id=""bar"">bad</span> ">
57 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>			
58 | 	</cffunction>
59 | 	
60 | 	<cffunction name="test_variable_piping_with_variable_args">
61 | 		<cfset loc.t = " {{ car.gm | add_tag : 'span', car.bmw}} ">
62 | 		<cfset loc.e = " <span id=""good"">bad</span> ">
63 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
64 | 	</cffunction>
65 | 
66 | 	<cffunction name="test_multiple_pipings">
67 | 		<cfset loc.t = " {{ best_cars | cite_funny | paragraph }} ">
68 | 		<cfset loc.e = " <p>LOL: bmw</p> ">
69 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
70 | 	</cffunction>		
71 | 		
72 | 	<cffunction name="test_link_to">
73 | 		<cfset loc.t = " {{ 'Typo' | link_to: 'http://typo.leetsoft.com' }} ">
74 | 		<cfset loc.e = " <a href=""http://typo.leetsoft.com"">Typo</a> ">
75 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
76 | 	</cffunction>
77 | 	
78 | 	<cffunction name="test_filter_with_overloaded_arguments">
79 | 		<cfset loc.t = " {{ car.gm | add_tag : 'span', 'bar', 'foo', 'bas'}} ">
80 | 		<cfset loc.e = " <span id=""bar"">bad</span> ">
81 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>			
82 | 	</cffunction>
83 | 	
84 | 	<cffunction name="test_filter_with_default_arguments">
85 | 		<cfset loc.t = " {{ car.gm | add_tag }} ">
86 | 		<cfset loc.e = " <p id=""foo"">bad</p> ">
87 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>			
88 | 	</cffunction>
89 | 	
90 | </cfcomponent>


--------------------------------------------------------------------------------
/tests/tests/DropTest.cfc:
--------------------------------------------------------------------------------
 1 | <cfcomponent output="false" extends="cfml-liquid.tests.Test">
 2 | 	
 3 | 	<cffunction name="setup">
 4 | 		<cfset loc.template = application.liquid.template()>
 5 | 	</cffunction>
 6 | 	
 7 | 	<cffunction name="test_product_drop">
 8 | 
 9 | 		<cfset loc.template.parse('  ')>
10 | 		<cfset loc.ProductDrop = createObject("component", "classes.ProductDrop")>
11 | 		<cfset loc.a = {product = loc.ProductDrop}>
12 | 		<cfset loc.r = loc.template.render(loc.a)>
13 | 		<cfset loc.e = '  '>
14 |         <cfset assert("loc.e eq loc.r")>
15 | 		
16 |  		<cfset loc.template = application.liquid.template()>
17 | 		<cfset loc.template.parse(' {{ product.top_sales }} ')>
18 | 		<cfset loc.ProductDrop = createObject("component", "classes.ProductDrop")>
19 | 		<cfset loc.a = {product = loc.ProductDrop}>
20 | 		<cfset loc.e = loc.template.render(loc.a)>
21 |         <cfset assert("loc.e eq 'worked'")>
22 | 		
23 | 	</cffunction>
24 | 
25 | 	<cffunction name="test_text_drop">
26 | 		
27 | 		<cfset loc.template.parse(' {{ product.texts.text }} ')>
28 | 		<cfset loc.ProductDrop = createObject("component", "classes.ProductDrop")>
29 | 		<cfset loc.a = {product = loc.ProductDrop}>
30 | 		<cfset loc.e = loc.template.render(loc.a)>
31 |         <cfset assert("loc.e eq ' text1 '")>
32 | 
33 | 		<cfset loc.template = application.liquid.template()>
34 | 		<cfset loc.template.parse(' {{ product.catchall.unknown }} ')>
35 | 		<cfset loc.ProductDrop = createObject("component", "classes.ProductDrop")>
36 | 		<cfset loc.a = {product = loc.ProductDrop}>
37 | 		<cfset loc.e = loc.template.render(loc.a)>
38 |         <cfset assert("loc.e eq ' method: unknown '")>
39 | 		
40 | 	</cffunction>
41 | 	
42 | 	<cffunction name="test_text_array_drop">
43 | 		
44 | 		<cfset loc.template.parse('{% for text in product.texts.get_array %} {{text}} {% endfor %}')>
45 | 		<cfset loc.ProductDrop = createObject("component", "classes.ProductDrop")>
46 | 		<cfset loc.a = {product = loc.ProductDrop}>
47 | 		<cfset loc.e = loc.template.render(loc.a)>
48 |         <cfset assert("loc.e eq ' text1  text2 '")>
49 | 		
50 | 	</cffunction>
51 | 
52 | 	<cffunction name="test_context_drop">
53 | 		
54 | 		<cfset loc.template.parse(' {{ context.bar }} ')>
55 | 		<cfset loc.ContextDrop = createObject("component", "classes.ContextDrop")>
56 | 		<cfset loc.a = {context = loc.ContextDrop, bar = "carrot"}>
57 | 		<cfset loc.e = loc.template.render(loc.a)>
58 |         <cfset assert("loc.e eq ' carrot '")>
59 | 		
60 | 	</cffunction>
61 | 	
62 | 	<cffunction name="test_nested_context_drop">
63 | 
64 | 		<cfset loc.template.parse(' {{ product.context.foo }} ')>
65 | 		<cfset loc.ProductDrop = createObject("component", "classes.ProductDrop")>
66 | 		<cfset loc.a = {product = loc.ProductDrop, foo = "monkey"}>
67 | 		<cfset loc.e = loc.template.render(loc.a)>
68 |         <cfset assert("loc.e eq ' monkey '")>
69 | 		
70 | 	</cffunction>
71 | 	
72 | 	<cffunction name="test_should_not_access_protected_methods">
73 | 		
74 | 		<cfset loc.template = application.liquid.template()>
75 | 		<cfset loc.template.parse('{{ product.init }}{{ product.beforeMethod }}{{ product.setContext }}{{ product.invokeDrop }}{{ product.hasKey }}{{ product.toLiquid }}')>
76 | 		<cfset loc.ProductDrop = createObject("component", "classes.ProductDrop")>
77 | 		<cfset loc.a = {product = loc.ProductDrop}>
78 | 		<cfset loc.e = loc.template.render(loc.a)>
79 | 		<cfset assert("loc.e eq ''")>
80 | 		
81 | 	</cffunction>
82 | 	
83 | 	<cffunction name="test_haskey_should_return_true_if_method_exists">
84 | 		
85 | 		<cfset loc.ProductDrop = createObject("component", "classes.ProductDrop")>
86 | 		<cfset loc.e = loc.ProductDrop.hasKey("top_sales")>
87 | 		<cfset assert("loc.e eq true")>
88 | 		
89 | 	</cffunction>
90 | 	
91 | 	<cffunction name="test_haskey_should_return_false_if_method_does_not_exists">
92 | 		
93 | 		<cfset loc.ProductDrop = createObject("component", "classes.ProductDrop")>
94 | 		<cfset loc.e = loc.ProductDrop.hasKey("blahblah")>
95 | 		<cfset assert("loc.e eq false")>
96 | 		
97 | 	</cffunction>
98 | 	
99 | </cfcomponent>


--------------------------------------------------------------------------------
/lib/Liquid.cfc:
--------------------------------------------------------------------------------
 1 | <cfcomponent output="false">
 2 | 	
 3 | 	<cfset this.version = "1.2">
 4 | 	
 5 | 	<cfset this.config = {}>
 6 | 	
 7 | 	<!--- directory the library is in --->
 8 | 	<cfset this.config.LIQUID_DIR_PATH =  $liquidDirPath()>
 9 | 
10 | 	<cfset this.config.LIQUID_LIB_PATH = ListChangeDelims(this.config.LIQUID_DIR_PATH, ".", "/")>
11 | 
12 | 	<!--- The method is called on objects when resolving variables to see if a given property exists --->
13 | 	<cfset this.config.LIQUID_HAS_PROPERTY_METHOD = "field_exists">
14 | 
15 | 	<!--- This method is called on object when resolving variables when a given property exists --->
16 | 	<cfset this.config.LIQUID_GET_PROPERTY_METHOD = "get">
17 | 
18 | 	<!--- Separator between filters --->
19 | 	<cfset this.config.LIQUID_FILTER_SEPARATOR = "\|">
20 | 
21 | 	<!--- Separator for arguments --->
22 | 	<cfset this.config.LIQUID_ARGUMENT_SEPARATOR = ",">
23 | 	
24 | 	<!--- Separator for argument names and values --->
25 | 	<cfset this.config.LIQUID_FILTER_ARGUMENT_SEPARATOR = ":">
26 | 	
27 | 	<!--- Separator for variable attributes --->
28 | 	<cfset this.config.LIQUID_VARIABLE_ATTRIBUTE_SEPARATOR = ".">
29 | 	
30 | 	<!--- Suffix for include files --->
31 | 	<cfset this.config.LIQUID_INCLUDE_SUFFIX = "liquid">
32 | 	
33 | 	<!--- Prefix for include files --->
34 | 	<cfset this.config.LIQUID_INCLUDE_PREFIX = "_">
35 | 	
36 | 	<!--- Tag start --->
37 | 	<cfset this.config.LIQUID_TAG_START = "\{\%">
38 | 	
39 | 	<!--- Tag end --->
40 | 	<cfset this.config.LIQUID_TAG_END = "\%\}">
41 | 	
42 | 	<!--- Variable start --->
43 | 	<cfset this.config.LIQUID_VARIABLE_START = "\{\{">
44 | 	
45 | 	<!--- Variable end --->
46 | 	<cfset this.config.LIQUID_VARIABLE_END = "\}\}">
47 | 	
48 | 	<!--- Variable Signature --->
49 | 	<cfset this.config.LIQUID_VARIABLE_SIGNATURE = "[\(\w\-\.\[\]\)]">
50 | 		
51 | 	<!--- The characters allowed in a variable --->
52 | 	<cfset this.config.LIQUID_ALLOWED_VARIABLE_CHARS = "[a-zA-Z_.-]">
53 | 	
54 | 	<!--- Regex for quoted fragments --->
55 | 	<cfset this.config.LIQUID_QUOTED_STRING = '"[^"]*"|''[^'']*'''>
56 | 	
57 | 	<!--- Regex for quoted fragments --->
58 | 	<cfset this.config.LIQUID_QUOTED_FRAGMENT = '#this.config.LIQUID_QUOTED_STRING#|(?:[^\s,\|''"]|#this.config.LIQUID_QUOTED_STRING#)+'>
59 | 	
60 | 	<!--- Regex for recognizing tab attributes --->
61 | 	<cfset this.config.LIQUID_TAG_ATTRIBUTES = "(\w+)\s*:\s*(#this.config.LIQUID_QUOTED_FRAGMENT#)">
62 | 	
63 | 	<!--- Regex used to split tokens --->
64 | 	<cfset this.config.LIQUID_TOKENIZATION_REGEXP = "(#this.config.LIQUID_TAG_START#.*?#this.config.LIQUID_TAG_END#|#this.config.LIQUID_VARIABLE_START#.*?#this.config.LIQUID_VARIABLE_END#)">
65 | 
66 | 	<cfset this.config.LIQUID_PATH = expandPath(".")>
67 | 	
68 | 	<cffunction name="init">
69 | 		<cfargument name="config" type="struct" required="false" default="#structNew()#">
70 | 		<cfset structAppend(this.config, arguments.config)>
71 | 		<cfset application["LiquidConfig"] = {}>
72 | 		<cfset StructAppend(application["LiquidConfig"], this.config)>
73 | 		<cfreturn this>
74 | 	</cffunction>
75 | 	
76 | 	<cffunction name="template" hint="return a template object">
77 | 		<cfargument name="path" type="string" required="false" default="">
78 | 		<cfset var templateObj = createObject("component", "liquid.LiquidTemplate").init(
79 | 			path = arguments.path
80 | 		)>
81 | 		<cfreturn templateObj>
82 | 	</cffunction>
83 | 	
84 | 	<cffunction name="$liquidDirPath" access="private">
85 | 		<cfset var loc = {}>
86 | 		<!--- get paths --->
87 | 		<cfset loc.rootPath = expandPath('/')>
88 | 		<cfset loc.thisPath = GetDirectoryFromPath(GetCurrentTemplatePath())>
89 | 		<!--- os file system compatability --->
90 | 		<cfset loc.rootPath = lcase(ListChangeDelims(loc.rootPath, '/', '\'))>
91 | 		<cfset loc.thisPath = lcase(ListChangeDelims(loc.thisPath, '/', '\'))>
92 | 		<cfset loc.liquidDirPath = ReplaceNoCase(loc.thisPath, loc.rootPath, '', 'one')>
93 | 		<cfreturn ListAppend(loc.liquidDirPath, 'liquid', '/')>
94 | 	</cffunction>
95 | 	
96 | </cfcomponent>


--------------------------------------------------------------------------------
/lib/liquid/LiquidTagCase.cfc:
--------------------------------------------------------------------------------
  1 | <cfcomponent output="false" extends="LiquidDecisionBlock" hint="
  2 | A switch statememt
  3 | 
  4 | @example
  5 | {% case condition %}{% when foo %} foo {% else %} bar {% endcase %}
  6 | ">
  7 | 
  8 | 	<cffunction name="init">
  9 | 		<cfargument name="markup" type="string" required="true">
 10 | 		<cfargument name="tokens" type="array" required="true">
 11 | 		<cfargument name="file_system" type="any" required="true" hint="LiquidFileSystem">
 12 | 		<cfset var loc = {}>
 13 | 		
 14 | 		<cfset this.nodelists = []>
 15 | 		<cfset this.left = "">
 16 | 		<cfset this.right = "">
 17 | 		
 18 | 		<cfset super.init(arguments.markup, arguments.tokens, arguments.file_system)>
 19 | 		
 20 | 		<cfset loc.syntax_regexp = createObject("component", "LiquidRegexp").init(application.LiquidConfig.LIQUID_QUOTED_FRAGMENT)>
 21 | 		
 22 | 		<cfif loc.syntax_regexp.match(arguments.markup)>
 23 | 			<cfset this.left = loc.syntax_regexp.matches[1]>
 24 | 		<cfelse>
 25 | 			<cfset createObject("component", "LiquidException").init("Syntax Error in tag 'case' - Valid syntax: case [condition]")>
 26 | 		</cfif>
 27 | 		
 28 | 		<cfreturn this>
 29 | 	</cffunction>
 30 | 
 31 | 	<cffunction name="end_tag" hint="Pushes the last nodelist onto the stack">
 32 | 		<cfset this.push_nodelist()>
 33 | 	</cffunction>
 34 | 
 35 | 	<cffunction name="unknown_tag" hint="Unknown tag handler">
 36 | 		<cfargument name="tag" type="string" required="true">
 37 | 		<cfargument name="params" type="any" required="true">
 38 | 		<cfargument name="tokens" type="array" required="true">
 39 | 		<cfset var loc = {}>
 40 | 
 41 | 		<cfset loc.when_syntax_regexp = createObject("component", "LiquidRegexp").init(application.LiquidConfig.LIQUID_QUOTED_FRAGMENT)>
 42 | 
 43 | 		<cfswitch expression="#arguments.tag#">
 44 | 			<cfcase value="when">
 45 | 
 46 | 				<!--- push the current nodelist onto the stack and prepare for a new one --->
 47 | 				<cfif loc.when_syntax_regexp.match(arguments.params)>
 48 | 
 49 | 					<cfset this.push_nodelist()>
 50 | 					<cfset this.right = loc.when_syntax_regexp.matches[1]>
 51 | 					<cfset this._nodelist = []>
 52 | 
 53 | 				<cfelse>
 54 | 					<cfset createObject("component", "LiquidException").init("Syntax Error in tag 'case' - Valid when condition: when [condition]")>
 55 | 				</cfif>
 56 | 
 57 | 			</cfcase>
 58 | 			<cfcase value="else">
 59 | 
 60 | 				<!--- push the last nodelist onto the stack and prepare to recieve the else nodes --->
 61 | 				<cfset this.push_nodelist()>
 62 | 				<cfset this.right = "">
 63 | 				
 64 | 				<cfif !StructKeyExists(this, "else_nodelist")>
 65 | 					<cfset this.else_nodelist = []>
 66 | 				</cfif>
 67 | 				
 68 | 				<cfset this.else_nodelist = this._nodelist>
 69 | 				<cfset this._nodelist = []>
 70 | 
 71 | 			</cfcase>
 72 | 			<cfdefaultcase>
 73 | 				<cfset super.unknown_tag(arguments.tag, arguments.params, arguments.tokens)>
 74 | 			</cfdefaultcase>
 75 | 		</cfswitch>
 76 | 	</cffunction>
 77 | 
 78 | 	<cffunction name="push_nodelist" hint="Pushes the current right value and nodelist into the nodelist stack">
 79 | 		<cfset var loc = {}>
 80 | 
 81 | 		<cfif len(this.right)>
 82 | 			<cfset loc.temp = [this.right, this._nodelist]>
 83 | 			<cfset ArrayAppend(this.nodelists, loc.temp)>
 84 | 		</cfif>
 85 | 	</cffunction>
 86 | 
 87 | 	<cffunction name="render" hint="Renders the node">
 88 | 		<cfargument name="context" type="any" required="true" hint="LiquidContext">
 89 | 		<cfset var loc = {}>
 90 | 
 91 | 		<cfset loc.output = "">
 92 | 		<cfset loc.run_else_block = true>
 93 | 
 94 | 		<cfloop array="#this.nodelists#" index="loc.data">
 95 | 			<cfset loc.right = loc.data[1]>
 96 | 			<cfset loc.nodelist = loc.data[2]>
 97 | 			
 98 | 			<cfif this.equal_variables(this.left, loc.right, arguments.context)>
 99 | 				<cfset loc.run_else_block = false>
100 | 				
101 | 				<cfset arguments.context.push()>
102 | 				<cfset loc.output &= this.render_all(loc.nodelist, arguments.context)>
103 | 				<cfset arguments.context.pop()>
104 | 			</cfif>
105 | 		</cfloop>
106 | 
107 | 		<cfif loc.run_else_block AND StructKeyExists(this, "else_nodelist")>
108 | 
109 | 			<cfset arguments.context.push()>
110 | 			<cfset loc.output &= this.render_all(this.else_nodelist, arguments.context)>
111 | 			<cfset arguments.context.pop()>
112 | 			
113 | 		</cfif>
114 | 
115 | 		<cfreturn loc.output>
116 | 	</cffunction>
117 | 	
118 | 	<cffunction name="pushToNodeList">
119 | 		<cfif StructKeyExists(this, "else_nodelist")>
120 | 			<cfset this.else_nodelist = this._nodelist>
121 | 		</cfif>
122 | 	</cffunction>
123 | 	
124 | </cfcomponent>


--------------------------------------------------------------------------------
/lib/liquid/LiquidTagInclude.cfc:
--------------------------------------------------------------------------------
  1 | <cfcomponent output="false" extends="LiquidTag" hint="
  2 | Includes another, partial, template
  3 | 
  4 | @example
  5 | {% include 'foo' %}
  6 | 
  7 | Will include the template called 'foo'
  8 | 
  9 | {% include 'foo' with 'bar' %}
 10 | 
 11 | Will include the template called 'foo', with a variable called foo that will have the value of 'bar'
 12 | 
 13 | {% include 'foo' for 'bar' %}
 14 | 
 15 | Will loop over all the values of bar, including the template foo, passing a variable called foo
 16 | with each value of bar
 17 | ">
 18 | 
 19 | 	<!--- The name of the template --->
 20 | 	<cfset this.template_name = "">
 21 | 
 22 | 	<!--- True if the variable is a collection --->
 23 | 	<cfset this.collection = false>
 24 | 
 25 | 	<!--- The value to pass to the child template as the template name --->
 26 | 	<cfset this.variable = "">
 27 | 
 28 | 	<!--- The LiquidDocument that represents the included template --->
 29 | 	<cfset this.document = "">
 30 | 	
 31 | 	<cfset this._hash = "">	
 32 | 
 33 | 	<cffunction name="init">
 34 | 		<cfargument name="markup" type="string" required="true">
 35 | 		<cfargument name="tokens" type="array" required="true">
 36 | 		<cfargument name="file_system" type="any" required="true" hint="LiquidFileSystem">
 37 | 		<cfset var loc = {}>
 38 | 		
 39 | 		<cfset loc.regex = createObject("component", "LiquidRegexp").init('("[^"]+"|''[^'']+'')(\s+(with|for)\s+(#application.LiquidConfig.LIQUID_QUOTED_FRAGMENT#))?')>
 40 | 		
 41 | 		<cfif loc.regex.match(arguments.markup)>
 42 | 
 43 | 			<cfset this.template_name = mid(loc.regex.matches[2], 2, len(loc.regex.matches[2]) - 2)>
 44 | 
 45 | 			<cfif ArrayLen(loc.regex.matches) gte 4 AND loc.regex.matches[4] eq "for">
 46 | 				<cfset this.collection = true>
 47 | 			</cfif>
 48 | 			
 49 | 			<cfif ArrayLen(loc.regex.matches) gte 5>
 50 | 				<cfset this.variable = loc.regex.matches[5]>
 51 | 			</cfif>
 52 | 
 53 | 			<cfset this.extract_attributes(arguments.markup)>
 54 | 			
 55 | 		<cfelse>
 56 | 			<cfset createObject("component", "LiquidException").init("Error in tag 'include' - Valid syntax: include '[template]' (with|for) [object|collection]")>
 57 | 		</cfif>
 58 | 
 59 | 		<cfset super.init(arguments.markup, arguments.tokens, arguments.file_system)>
 60 | 		
 61 | 		<cfreturn this>
 62 | 	</cffunction>
 63 | 
 64 | 	<cffunction name="parse">
 65 | 		<cfargument name="tokens" type="array" required="true">
 66 | 		<cfset var loc = {}>
 67 | 		
 68 | 		<cfif !StructKeyExists(this, "file_system")>
 69 | 			<cfset createObject("component", "LiquidException").init("No file system")>
 70 | 		</cfif>
 71 | 
 72 | 		<!--- read the source of the template and create a new sub document --->
 73 | 		<cfset loc.source = this.file_system.read_template_file(this.template_name)>
 74 | 		<cfset loc.template = createObject("component", "LiquidTemplate")>
 75 | 		<cfset loc.tokens = loc.template.tokenize(loc.source)>
 76 | 		<cfset this.document = createObject("component", "LiquidDocument").init(loc.tokens, this.file_system)>
 77 | 	</cffunction>
 78 | 
 79 | 	<cffunction name="checkIncludes" hint="check for cached includes">
 80 | 		<cfset var loc = {}>
 81 | 		
 82 | 		<cfset loc.cache = application[application.LiquidConfig.LIQUID_CACHE_KEY]>
 83 | 
 84 | 		<cfif this.document.checkIncludes() eq true>
 85 | 			<cfreturn true>
 86 | 		</cfif>
 87 | 	
 88 | 		<cfset loc.source = this.file_system.read_template_file(this.template_name)>
 89 | 		
 90 | 		<cfif loc.cache.exists(hash5(loc.source)) AND this._hash eq hash(loc.source)>
 91 | 			<cfreturn false>
 92 | 		</cfif>
 93 | 		
 94 | 		<cfreturn true>
 95 | 	</cffunction>
 96 | 
 97 | 	<cffunction name="render">
 98 | 		<cfargument name="context" type="any" required="true" hint="LiquidContext">
 99 | 		<cfset var loc = {}>
100 | 
101 | 		<cfset loc.result = "">
102 | 		<cfset loc.variable = arguments.context.get(this.variable)>
103 | 		<cfset arguments.context.push()>
104 | 		
105 | 		<cfloop collection="#this.attributes#" item="loc.key">
106 | 			<cfset arguments.context.set(loc.key, arguments.context.get(this.attributes[loc.key]))>
107 | 		</cfloop>
108 | 		
109 | 		<cfif this.collection>
110 | 			<cfloop array="#loc.variable#" index="loc.item">
111 | 				<cfset arguments.context.set(this.template_name, loc.item)>
112 | 				<cfset loc.result &= this.document.render(arguments.context)>
113 | 			</cfloop>
114 | 		<cfelse>
115 | 			<cfif len(this.variable)>
116 | 				<cfset arguments.context.set(this.template_name, loc.variable)>
117 | 			</cfif>
118 | 			<cfset loc.result &= this.document.render(arguments.context)>
119 | 		</cfif>
120 | 		
121 | 		<cfset arguments.context.pop()>
122 | 
123 | 		<cfreturn loc.result>
124 | 	</cffunction>
125 | 
126 | </cfcomponent>


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | This project aims to port the [Liquid Templating Language](https://github.com/Shopify/liquid) over to [CFML](http://www.getrailo.org/). For the port I'm using the [PHP port](https://github.com/harrydeluxe/php-liquid) of the language.
  2 | 
  3 | 
  4 | How To Use
  5 | ==========
  6 | 
  7 | ```coldfusion
  8 | <!--- make sure the liquid library is loaded in the application scope --->
  9 | <cfif !StructKeyExists(application, "liquid")>
 10 | 	<cfset application.liquid = createObject("component", "lib.Liquid").init()>
 11 | </cfif>
 12 | 
 13 | <!--- create our template object --->
 14 | <cfset template = application.liquid.template()>
 15 | 
 16 | <!--- create the source we want to parse --->
 17 | <cfsavecontent variable="source">
 18 | <h1>{{ pageTitle }}</h1>
 19 | {% if query.size %}
 20 | <ul>
 21 | 	{% for item in query %}
 22 | 		<li>{{ item.project }} - <a href="{{ item.link }}">{{ item.link }}</a></li>
 23 | 	{% endfor %}
 24 | </ul>
 25 | {% else %}
 26 | <p>No records found</p>
 27 | {% endif %}
 28 | </cfsavecontent>
 29 | 
 30 | <!--- lets assign some variables to the source --->
 31 | <!--- create a mock query for showing what this thing can do --->
 32 | <cfset q = QueryNew("project,link")>
 33 | <cfset QueryAddRow(q)>
 34 | <cfset QuerySetCell(q, "project", "CFWheels")>
 35 | <cfset QuerySetCell(q, "link", "https://github.com/cfwheels/cfwheels")>
 36 | <cfset QueryAddRow(q)>
 37 | <cfset QuerySetCell(q, "project", "ColdMVC")>
 38 | <cfset QuerySetCell(q, "link", "https://github.com/tonynelson19/ColdMVC")>
 39 | <cfset QueryAddRow(q)>
 40 | <cfset QuerySetCell(q, "project", "FW/1")>
 41 | <cfset QuerySetCell(q, "link", "https://github.com/seancorfield/fw1")>
 42 | <cfset QueryAddRow(q)>
 43 | <cfset QuerySetCell(q, "project", "Fusebox")>
 44 | <cfset QuerySetCell(q, "link", "https://github.com/fusebox-framework/Fusebox-ColdFusion")>
 45 | 
 46 | <!--- create a structure to pass in --->
 47 | <cfset assigns = {query = q, pageTitle = "ColdFusion Frameworks on Github"}>
 48 | 
 49 | <!---
 50 | NOTE: if there are any errors in the source, a LiquidError exception will be thrown
 51 | Always wrap the calls to Liquid in a try/catch block so you can display
 52 | the parsing errors to the user.
 53 |  --->
 54 | <cftry>
 55 | 	<!--- parse the source --->
 56 | 	<cfset template.parse(source)>
 57 | 	<!--- render the output --->
 58 | 	<cfoutput>#template.render(assigns)#</cfoutput>
 59 | 	<cfcatch type="LiquidError">
 60 | 		<cfoutput>#cfcatch.message#</cfoutput>
 61 | 	</cfcatch>
 62 | </cftry>
 63 | ```
 64 | would produce
 65 | 
 66 | ```html
 67 | <h1>ColdFusion Frameworks on Github</h1>
 68 | <ul>
 69 | 		<li>CFWheels - <a href="https://github.com/cfwheels/cfwheels">https://github.com/cfwheels/cfwheels</a></li>
 70 | 		<li>ColdMVC - <a href="https://github.com/tonynelson19/ColdMVC">https://github.com/tonynelson19/ColdMVC</a></li>
 71 | 		<li>FW/1 - <a href="https://github.com/seancorfield/fw1">https://github.com/seancorfield/fw1</a></li>
 72 | 		<li>Fusebox - <a href="https://github.com/fusebox-framework/Fusebox-ColdFusion">https://github.com/fusebox-framework/Fusebox-ColdFusion</a></li>
 73 | </ul>
 74 | ```
 75 | 
 76 | More examples and information can be found in the original [Liquid documentation](https://github.com/Shopify/liquid/wiki/Liquid-for-Designers)
 77 | 
 78 | Currect State
 79 | =============
 80 | 
 81 | Currently this project is in a state that I'm happy with. As a result, I will be focusing my attention on [CFWheels](https://github.com/cfwheels/cfwheels). If you would like to take over the project as the maintainer, please contact me through github.
 82 | 
 83 | 
 84 | What's left to do
 85 | =================
 86 | 
 87 | I was going to add caching but I'm deciding against it as (from what I can tell) the original Liquid library doesn't have it. Feel free to implement it if you desire.
 88 | 
 89 | 
 90 | Running Tests
 91 | =============
 92 | 
 93 | Tests are written using the [RocketUnit framework](http://rocketunit.riaforge.org/). To run the tests first clone the project into a directory off your webroot called `cfml-liquid`. Next point your browser to `http://localhost/cfml-liquid/tests`.
 94 | 
 95 | 
 96 | Issues and Enhancements
 97 | ====================
 98 | 
 99 | I will be taking issues requests until the project is passed to a maintainer. Please file your issues in the issue tracker for this repo.
100 | 
101 | I will **not** be taking enhancement requests. If there is something that you want added to the project, please fork the project, code the enhancement and send me a pull requst.
102 | 
103 | Latest Release
104 | ==============
105 | 
106 | [Releases can be downloaded directly from Github](https://github.com/rip747/cfml-liquid/releases)
107 | 
108 | Changelog
109 | =========
110 | 
111 | v1.2
112 | ----
113 | 
114 | * added RAW tag
115 | * added the following filters
116 |   * append
117 |   * prepend
118 |   * escape
119 |   * remove
120 |   * remove_first
121 |   * replace
122 |   * replace_first
123 |   * sort
124 | 


--------------------------------------------------------------------------------
/lib/liquid/LiquidTemplate.cfc:
--------------------------------------------------------------------------------
  1 | <cfcomponent output="false" hint="
  2 | The template class.
  3 | 
  4 | $tpl = new LiquidTemplate();
  5 | $tpl->parse(template_source);
  6 | $tpl->render(array('foo'=>1, 'bar'=>2);
  7 | ">
  8 | 
  9 | 	<cfinclude template="utils.cfm">
 10 | 	
 11 | 		
 12 | 	<!--- LiquidDocument The _root of the node tree --->
 13 | 	<cfset this._root = "">
 14 | 	
 15 | 	<!--- LiquidBlankFileSystem The file system to use for includes --->
 16 | 	<cfset this._fileSystem = "">
 17 | 	
 18 | 	<!--- array Globally included filters --->
 19 | 	<cfset this._filters = []>
 20 | 	
 21 | 	<!--- struct Custom tags --->
 22 | 	<cfset this._tags = {}>
 23 | 
 24 | 	<cffunction name="init">
 25 | 		<cfargument name="path" type="string" required="false" default="">
 26 | 
 27 | 		<cfif len(arguments.path) AND directoryExists(arguments.path)>
 28 | 			<cfset this._fileSystem = createObject("component", "LiquidLocalFileSystem").init(arguments.path)>
 29 | 		<cfelse>
 30 | 			<cfset this._fileSystem = createObject("component", "LiquidBlankFileSystem").init()>
 31 | 		</cfif>
 32 | 		
 33 | 		<cfreturn this>
 34 | 	</cffunction>
 35 | 	
 36 | 	<cffunction name="setFileSystem">
 37 | 		<cfargument name="fileSystem" type="any" required="true">
 38 | 		<cfset this._fileSystem = arguments.fileSystem>
 39 | 	</cffunction>
 40 | 	
 41 | 	<cffunction name="getRoot">
 42 | 		<cfreturn this._root>
 43 | 	</cffunction>
 44 | 	
 45 | 	<cffunction name="getTags">
 46 | 		<cfreturn this._tags>
 47 | 	</cffunction>
 48 | 	
 49 | 	<cffunction name="registerTag">
 50 | 		<cfargument name="name" type="string" required="true">
 51 | 		<cfargument name="obj" type="any" required="true">
 52 | 		<cfset this._tags[arguments.name] = arguments.obj>
 53 | 	</cffunction>
 54 | 
 55 | 	<cffunction name="registerFilter">
 56 | 		<cfargument name="filter" type="any" required="true">
 57 | 		<cfset arrayAppend(this._filters, arguments.filter)>
 58 | 	</cffunction>
 59 | 
 60 | 	<cffunction name="tokenize" hint="Tokenizes the given source string">
 61 | 		<cfargument name="source" type="string" required="true">
 62 | 		<cfset var loc = {}>
 63 | 
 64 | 		<!--- use a java array list since we need to pass the parsed token by reference. THIS IS THE KEY TO ALL OF THIS! --->
 65 | 		<cfset loc.arr = CreateObject("java","java.util.ArrayList").Init()>
 66 | 
 67 | 		<cfif !len(arguments.source)>
 68 | 			<cfreturn loc.arr>
 69 | 		</cfif>
 70 | 		<!--- need to put the values from the returning array into our reference array --->
 71 | 		<cfset arguments.source = pregSplit3(application.LiquidConfig.LIQUID_TOKENIZATION_REGEXP, arguments.source)>
 72 | 
 73 | 		<cfloop array="#arguments.source#" index="loc.i">
 74 | 			<cfset ArrayAppend(loc.arr, loc.i)>
 75 | 		</cfloop>
 76 | 
 77 | 		<cfreturn loc.arr>
 78 | 	</cffunction>
 79 | 
 80 | 	<cffunction name="parse" hint="Parses the given source string">
 81 | 		<cfargument name="source" type="string" required="true">
 82 | 		
 83 | 		<cfset this._root = createObject("component", "LiquidDocument").init(
 84 | 				this.tokenize(arguments.source)
 85 | 				,this._fileSystem
 86 | 			)>
 87 | 
 88 | 		<cfreturn this>
 89 | 	</cffunction>
 90 | 
 91 | 	<cffunction name="render" hint="Renders the current template">
 92 | 		<cfargument name="assigns" type="struct" required="false" default="#Createobject('java', 'java.util.LinkedHashMap').init()#" hint="A struct of values for the template">
 93 | 		<cfargument name="filters" type="any" required="false" default="" hint="Additional filters for the template">
 94 | 		<cfargument name="registers" type="any" required="false" default="#StructNew()#" hint="Additional registers for the template">
 95 | 		<cfset var loc = {}>
 96 | 		
 97 |  		<cftry>
 98 | 			<cfset loc.result = _render(argumentCollection=arguments)>
 99 | 
100 | 			<cfcatch type="any">
101 | 				<cfset loc.result = cfcatch.message>
102 | 			</cfcatch>
103 | 		</cftry>
104 | 
105 | 		<cfreturn loc.result>
106 | 	</cffunction>
107 | 	
108 | 	<cffunction name="_render" hint="Renders the current template. throws errors">
109 | 		<cfargument name="assigns" type="struct" required="false" default="#Createobject('java', 'java.util.LinkedHashMap').init()#" hint="A struct of values for the template">
110 | 		<cfargument name="filters" type="any" required="false" default="" hint="Additional filters for the template">
111 | 		<cfargument name="registers" type="any" required="false" default="#StructNew()#" hint="Additional registers for the template">
112 | 		<cfset var loc = {}>
113 | 		
114 | 		<cfset loc.result = "">
115 | 			
116 | 		<cfset loc.context = createObject("component", "LiquidContext").init(arguments.assigns, arguments.registers)>
117 | 
118 | 		<cfif !isSimpleValue(arguments.filters)>
119 | 				
120 | 			<cfif isArray(arguments.filters)>
121 | 				<cfset this._filters.addAll(arguments.filters)>
122 | 			<cfelseif IsObject(arguments.filters)>
123 | 				<cfset arrayAppend(this._filters, arguments.filters)>
124 | 			</cfif>
125 | 		
126 | 		</cfif>
127 | 		
128 | 		<cfloop array="#this._filters#" index="loc.filter">
129 | 			<cfset loc.context.add_filters(loc.filter)>
130 | 		</cfloop>
131 | 		
132 | 		<cfset loc.result = this._root.render(loc.context)>
133 | 
134 | 		<cfreturn loc.result>
135 | 	</cffunction>
136 | 
137 | </cfcomponent>


--------------------------------------------------------------------------------
/lib/liquid/LiquidDecisionBlock.cfc:
--------------------------------------------------------------------------------
  1 | <cfcomponent output="false" extends="LiquidBlock">
  2 | 
  3 | 	<!--- The current left variable to compare --->
  4 | 	<cfset this._left = "">
  5 | 
  6 | 	<!--- The current right variable to compare --->
  7 | 	<cfset this._right = "">
  8 | 	
  9 | 	<cffunction name="string_value" hint="Returns a string value of an array for comparisons">
 10 | 		<cfargument name="value" type="any" required="true">
 11 | 		
 12 | 		<!--- objects should have a to_string a value to compare to --->
 13 | 		<cfif isObject(arguments.value)>
 14 | 			<cfif StructKeyExists(arguments.value, "to_string")>
 15 | 				<cfset arguments.value = arguments.value.to_string()>
 16 | 			<cfelse>
 17 | 				<cfthrow type="LiquidError" message="Cannot convert $value to string">
 18 | 			</cfif>
 19 | 		</cfif>
 20 | 
 21 | 		<!--- arrays simply return true --->
 22 | 		<cfif isArray(arguments.value)>
 23 | 			<cfreturn arguments.value>
 24 | 		</cfif>
 25 | 		
 26 | 		<cfreturn arguments.value>
 27 | 	</cffunction>
 28 | 
 29 | 	<cffunction name="equal_variables" hint="Check to see if to variables are equal in a given context">
 30 | 		<cfargument name="left" type="string" required="true">
 31 | 		<cfargument name="right" type="string" required="true">
 32 | 		<cfargument name="context" type="any" required="true">
 33 | 		
 34 | 		<cfset this._left = this.string_value(arguments.context.get(arguments.left))>
 35 | 		<cfset this._right = this.string_value(arguments.context.get(arguments.right))>
 36 | 
 37 | 		<cfreturn this._left eq this._right>
 38 | 	</cffunction>
 39 | 
 40 | 	<cffunction name="interpret_condition" hint="Interpret a comparison">
 41 | 		<cfargument name="left" type="string" required="true">
 42 | 		<cfargument name="right" type="string" required="true">
 43 | 		<cfargument name="op" type="string" required="true">
 44 | 		<cfargument name="context" type="any" required="true">
 45 | 		<cfset var loc = {}>
 46 | 
 47 | 		<cfif !len(arguments.op)>
 48 | 			<cfset loc.value = this.string_value(arguments.context.get(arguments.left))>
 49 | 			<cfreturn loc.value>
 50 | 		</cfif>
 51 | 		
 52 | 		<!--- values of 'empty' have a special meaning in array comparisons --->
 53 | 		<cfif arguments.right eq "empty" AND isArray(arguments.context.get(arguments.left))>
 54 | 			<cfset arguments.left = ArrayLen(arguments.context.get(arguments.left))>
 55 | 			<cfset arguments.right = 0>
 56 | 		<cfelseif arguments.right eq "empty" AND IsStruct(arguments.context.get(arguments.left))>
 57 | 			<cfset arguments.left = StructCount(arguments.context.get(arguments.left))>
 58 | 			<cfset arguments.right = 0>
 59 | 		<cfelseif arguments.right eq "empty" AND IsQuery(arguments.context.get(arguments.left))>
 60 | 			<cfset loc.temp = arguments.context.get(arguments.left)>
 61 | 			<cfset arguments.left = loc.temp.recordcount>
 62 | 			<cfset arguments.right = 0>
 63 | 		<cfelseif arguments.left eq "empty" AND isArray(arguments.context.get(arguments.right))>
 64 | 			<cfset arguments.right = ArrayLen(arguments.context.get(arguments.right))>
 65 | 			<cfset arguments.left = 0>
 66 | 		<cfelseif arguments.left eq "empty" AND IsStruct(arguments.context.get(arguments.right))>
 67 | 			<cfset arguments.right = StructCount(arguments.context.get(arguments.right))>
 68 | 			<cfset arguments.left = 0>
 69 | 		<cfelseif arguments.left eq "empty" AND IsQuery(arguments.context.get(arguments.right))>
 70 | 			<cfset loc.temp = arguments.context.get(arguments.right)>
 71 | 			<cfset arguments.right = loc.temp.recordcount>
 72 | 			<cfset arguments.left = 0>
 73 | 		<cfelse>
 74 | 			<cfset arguments.left = arguments.context.get(arguments.left)>
 75 | 			<cfset arguments.right = arguments.context.get(arguments.right)>
 76 | 
 77 | 			<cfset arguments.left = this.string_value(arguments.left)>
 78 | 			<cfset arguments.right = this.string_value(arguments.right)>
 79 | 		</cfif>
 80 | 
 81 | 		<!--- special rules for null values --->
 82 | 		<cfif !len(arguments.left) OR !len(arguments.right)>
 83 | 		
 84 | 			<!--- null == null returns true --->
 85 | 			<cfif arguments.op eq "==">
 86 | 				<cfreturn true>
 87 | 			</cfif>
 88 | 
 89 | 			<!--- null != anything other than null return true --->
 90 | 			<cfif arguments.op eq "!=" AND (len(arguments.left) OR len(arguments.right))>
 91 | 				<cfreturn true>
 92 | 			</cfif>
 93 | 
 94 | 			<!--- everything else, return false; --->
 95 | 			<cfreturn false>
 96 | 		</cfif>
 97 | 
 98 | 		<!--- regular rules --->
 99 | 		<cfswitch expression="#arguments.op#">
100 | 			<cfcase value="==">
101 | 				<cfreturn arguments.left eq arguments.right>
102 | 			</cfcase>
103 | 			<cfcase value="!=">
104 | 				<cfreturn arguments.left neq arguments.right>
105 | 			</cfcase>
106 | 			<cfcase value=">">
107 | 				<cfreturn arguments.left gt arguments.right>
108 | 			</cfcase>
109 | 			<cfcase value="<">
110 | 				<cfreturn arguments.left lt arguments.right>
111 | 			</cfcase>
112 | 			<cfcase value=">=">
113 | 				<cfreturn arguments.left gte arguments.right>
114 | 			</cfcase>
115 | 			<cfcase value="<=">
116 | 				<cfreturn arguments.left lte arguments.right>
117 | 			</cfcase>
118 | 			<cfcase value="contains">
119 | 				<cfif isArray(arguments.left)>
120 | 					<cfreturn arguments.left.indexOf(arguments.right)>
121 | 				<cfelse>
122 | 					<cfreturn arguments.left CONTAINS arguments.right>
123 | 				</cfif>
124 | 			</cfcase>
125 | 			<cfdefaultcase>
126 | 				<cfthrow type="LiquidError" message="Error in tag '#arguments.this.name()#' - Unknown operator">
127 | 			</cfdefaultcase>
128 | 		</cfswitch>
129 | 	</cffunction>
130 | 	
131 | </cfcomponent>


--------------------------------------------------------------------------------
/lib/liquid/LiquidTagIf.cfc:
--------------------------------------------------------------------------------
  1 | <cfcomponent output="false" extends="LiquidDecisionBlock" hint="
  2 | An if statement
  3 | example
  4 | {% if true %} YES {% else %} NO {% endif %}
  5 | 
  6 | will return:
  7 | YES
  8 | ">
  9 | 
 10 | 	<cfset this._nodelistHolders = CreateObject("java","java.util.ArrayList").Init()>
 11 | 	
 12 | 	<cfset this._blocks = CreateObject("java","java.util.ArrayList").Init()>
 13 | 
 14 | 	<cffunction name="init">
 15 | 		<cfargument name="markup" type="string" required="true">
 16 | 		<cfargument name="tokens" type="array" required="true">
 17 | 		<cfargument name="file_system" type="any" required="true">
 18 | 		<cfset var loc = {}>
 19 | 
 20 | 		<cfset loc.temp = ['if', arguments.markup,  this._nodelist]>
 21 | 		<cfset arrayAppend(this._blocks, loc.temp)>
 22 | 		<cfset super.init(arguments.markup, arguments.tokens, arguments.file_system)>
 23 | 		
 24 | 		<cfreturn this>
 25 | 	</cffunction>
 26 | 
 27 | 	<cffunction name="unknown_tag" hint="Handler for unknown tags, handle else tags">
 28 | 		<cfargument name="tag" type="string" required="true">
 29 | 		<cfargument name="params" type="any" required="true">
 30 | 		<cfargument name="tokens" type="any" required="true">
 31 | 		<cfset var loc = {}>
 32 | 
 33 | 		<cfif arguments.tag eq 'else' OR arguments.tag eq 'elsif' OR arguments.tag eq 'elseif'>
 34 | 
 35 | 			<cfset this._blocks[ArrayLen(this._blocks)][3] = duplicate(this._nodelist)>
 36 | 			<cfset this._nodelist = this._nodelistHolders>
 37 | 			<cfset loc.temp = [arguments.tag, arguments.params, this._nodelist]>
 38 | 			<cfset ArrayAppend(this._blocks, loc.temp)>
 39 | 			<cfset ArrayClear(this._nodelist)>
 40 | 
 41 | 		<cfelse>
 42 | 			<cfset super.unknown_tag(arguments.tag, arguments.params, arguments.tokens)>
 43 | 		</cfif>
 44 | 	</cffunction>
 45 | 
 46 | 	<cffunction name="render" hint="Render the tag">
 47 | 		<cfargument name="context" type="any" required="true">
 48 | 		<cfset var loc = {}>
 49 | 
 50 | 		<cfset loc.logicalRegex = createObject("component", "LiquidRegexp").init("\s+(and|or)\s+")>
 51 | 		<cfset loc.conditionalRegex = createObject("component", "LiquidRegexp").init('(#application["LiquidConfig"]["LIQUID_QUOTED_FRAGMENT"]#)\s*([=!<>a-z_]+)?\s*(#application["LiquidConfig"]["LIQUID_QUOTED_FRAGMENT"]#)?')>
 52 | 		<cfset loc.result = "">
 53 | 
 54 | 		<cfloop array="#this._blocks#" index="loc.block">
 55 | 
 56 | 			<cfif loc.block[1] eq "else">
 57 | 				
 58 | 				<cfset loc.result = this.render_all(loc.block[3], arguments.context)>
 59 | 				<cfset arguments.context.push()>
 60 | 				<cfbreak>
 61 | 				
 62 | 			</cfif>
 63 | 
 64 | 			<cfif loc.block[1] eq 'if' OR loc.block[1] eq 'elsif'OR loc.block[1] eq 'elseif'>
 65 | 			
 66 | 				<!--- Extract logical operators --->
 67 | 				<cfset loc.logicalRegex.match(loc.block[2])>
 68 | 				<cfset loc.logicalOperators = loc.logicalRegex.matches>
 69 | 				<cfset loc.temp = array_shift(loc.logicalOperators)>
 70 | 				<cfset loc.logicalOperators = loc.temp.arr>
 71 | 
 72 | 				<!--- Extract individual conditions --->
 73 | 				<cfset loc.temp = loc.logicalRegex.split(loc.block[2])>
 74 | 				<cfset loc.conditions = []>
 75 | 
 76 | 				<cfloop array="#loc.temp#" index="loc.condition">
 77 | 					
 78 | 					<cfif loc.conditionalRegex.match(loc.condition)>
 79 | 					
 80 | 						<cfset loc.t = {}>
 81 | 
 82 | 						<cfset loc.t.left = "">
 83 | 						<cfif ArrayLen(loc.conditionalRegex.matches) gte 2>
 84 | 							<cfset loc.t.left = loc.conditionalRegex.matches[2]>
 85 | 						</cfif>
 86 | 
 87 | 						<cfset loc.t.operator = "">
 88 | 						<cfif ArrayLen(loc.conditionalRegex.matches) gte 3>
 89 | 							<cfset loc.t.operator = loc.conditionalRegex.matches[3]>
 90 | 						</cfif>
 91 | 						
 92 | 						<cfset loc.t.right = "">
 93 | 						<cfif ArrayLen(loc.conditionalRegex.matches) gte 4>
 94 | 							<cfset loc.t.right = loc.conditionalRegex.matches[4]>
 95 | 						</cfif>
 96 | 
 97 | 						<cfset arrayAppend(loc.conditions, loc.t)>
 98 | 
 99 | 					<cfelse>
100 | 						<cfthrow type="LiquidError" message="Syntax Error in tag 'if' - Valid syntax: if [condition]">
101 | 					</cfif>
102 | 					<cfset arguments.context.push()>
103 | 					
104 | 				</cfloop>
105 | 				
106 | 				<cfif ArrayLen(loc.logicalOperators)>
107 | 
108 | 					<!--- If statement contains and/or --->
109 | 					<cfset loc.display = true>
110 | 
111 | 					<cfloop from="1" to="#ArrayLen(loc.logicalOperators)#" index="loc.i">
112 | 						
113 | 						<cfset loc.t = loc.conditions[loc.i]>
114 | 						<cfset loc.iLeft = this.interpret_condition(loc.t['left'], loc.t['right'], loc.t['operator'], arguments.context)>
115 | 						<cfset loc.tt = loc.conditions[loc.i + 1]>
116 | 						<cfset loc.iRight = this.interpret_condition(loc.tt['left'], loc.tt['right'], loc.tt['operator'], arguments.context)>
117 | 
118 | 						<cfif loc.logicalOperators[loc.i] eq 'and'>
119 | 							<cfset loc.display = loc.iLeft AND loc.iRight>
120 | 						<cfelse>
121 | 							<cfset loc.display = loc.iLeft OR loc.iRight>
122 | 						</cfif>
123 | 						
124 | 					</cfloop>
125 | 
126 | 				<cfelse>
127 | 				
128 | 					<!--- If statement is a single condition --->
129 | 					<cfset loc.display = this.interpret_condition(loc.conditions[1]['left'], loc.conditions[1]['right'], loc.conditions[1]['operator'], arguments.context)>
130 | 					
131 | 				</cfif>
132 | 
133 | 				<cfif (IsBoolean(loc.display) and loc.display) OR (!IsBoolean(loc.display) AND len(loc.display) AND loc.display neq "null")>
134 | 					
135 | 					<cfset loc.result = this.render_all(loc.block[3], arguments.context)>
136 | 					<cfset arguments.context.push()>
137 | 					<cfbreak>
138 | 					
139 | 				</cfif>
140 | 				
141 | 			</cfif>
142 | 		</cfloop>
143 | 
144 | 		<cfset arguments.context.pop()>
145 | 
146 | 		<cfreturn loc.result>
147 | 	</cffunction>
148 | 
149 | 	<cffunction name="pushToNodeList">
150 | 		<cfset this._blocks[ArrayLen(this._blocks)][3] = this._nodelist>
151 | 	</cffunction>
152 | 
153 | </cfcomponent>


--------------------------------------------------------------------------------
/lib/liquid/LiquidFilterbank.cfc:
--------------------------------------------------------------------------------
  1 | <cfcomponent output="false" hint="The filter bank is where all registered filters are stored, and where filter invocation is handled it supports a variety of different filter types; objects, class, and simple methods">
  2 | 
  3 | 	<!--- The registerd filter objects --->
  4 | 	<cfset this.filters = {}>
  5 | 
  6 | 	<!--- A map of all filters and the class that contain them (in the case of methods) --->
  7 | 	<cfset this.method_map = {}>
  8 | 
  9 | 	<!--- Reference to the current context object --->
 10 | 	<cfset this.context = "">
 11 | 
 12 | 	<cffunction name="init">
 13 | 		<cfargument name="context" type="any" required="true">
 14 | 
 15 | 		<cfset this.context = arguments.context>
 16 | 		<cfset this.add_filter("LiquidStandardFilters")>
 17 | 		
 18 | 		<cfreturn this>
 19 | 	</cffunction>
 20 | 
 21 | 	<cffunction name="add_filter" hint="Adds a filter to the bank" returntype="boolean">
 22 | 		<cfargument name="filter" type="any" required="true" hint="Can either be an object, the name of a class (in which case the filters will be called statically) or the name of a function">
 23 | 		<cfset var loc = {}>
 24 | 		
 25 | 		<cfif not IsObject(arguments.filter) AND !isSimpleValue(arguments.filter)>
 26 | 			<cfset createObject("component", "LiquidException").init("Parameter passed to add_filter must be an object or a string")>
 27 | 		</cfif>
 28 | 		
 29 | 		<!--- if the passed filter was an object, store the object for future reference. --->
 30 | 		<cfif isObject(arguments.filter)>
 31 | 			
 32 | 			<cfset arguments.filter.context = this.context>
 33 | 			<cfset loc.name = getMetaData(arguments.filter).name>
 34 | 			<cfset this.filters[loc.name] = arguments.filter>
 35 | 			<cfset arguments.filter = loc.name>
 36 | 			
 37 | 		</cfif>
 38 | 		
 39 | 		<cftry>
 40 | 			<cfset loc.methods = getComponentMetaData(arguments.filter).functions>
 41 | 			<cfcatch type="any">
 42 | 				<cfset loc.methods = []>
 43 | 			</cfcatch>
 44 | 		</cftry>
 45 | 
 46 | 		<cfif !ArrayIsEmpty(loc.methods)>
 47 | 			<cfloop array="#loc.methods#" index="loc.method">
 48 | 				<cfif loc.method.name neq "init">
 49 | 					<cfset this.method_map[loc.method.name] = arguments.filter>
 50 | 				</cfif>
 51 | 			</cfloop>
 52 | 			<cfreturn true>
 53 | 		</cfif>
 54 | 
 55 | 		<!--- if it wasn't an object an isn't a string either, it's a bad parameter --->
 56 | 		<cfif IsCustomFunction(arguments.filter)>
 57 | 			<cfset this.method_map[arguments.filter] = false>
 58 | 			<cfreturn true>
 59 | 		</cfif>
 60 | 
 61 | 		<cfset createObject("component", "LiquidException").init("Parameter passed to add_filter must a class or a function")>
 62 | 	</cffunction>
 63 | 
 64 | 	<cffunction name="invoke_method" hint="Invokes the filter with the given name">
 65 | 		<cfargument name="name" type="string" required="true" hint="The name of the filter">
 66 | 		<cfargument name="value" type="any" required="true" hint="The value to filter">
 67 | 		<cfargument name="args" type="any" required="true" hint="The additional arguments for the filter">
 68 | 
 69 | 		<cfif !IsArray(arguments.args)>
 70 | 			<cfset arguments.args = []>
 71 | 		</cfif>
 72 | 
 73 | 		<cfset ArrayPrepend(arguments.args, arguments.value)>
 74 | 
 75 | 		<!--- consult the mapping  --->
 76 | 		<cfif StructKeyExists(this.method_map, arguments.name) OR StructKeyExists(this.method_map, "_#arguments.name#")>
 77 | 			<cfif StructKeyExists(this.method_map, "_#arguments.name#")>
 78 | 				<cfset arguments.name = "_#arguments.name#">
 79 | 			</cfif>
 80 | 			<cfset loc.class = this.method_map[arguments.name]>
 81 | 
 82 | 			<!--- if we have a registered object for the class, use that instead --->
 83 | 			<cfif StructKeyExists(this.filters, loc.class)>
 84 | 				<cfset loc.class = this.filters[loc.class]>
 85 | 			</cfif>
 86 | 
 87 | 			<!--- if we're calling a function --->
 88 | 			<cfif IsSimpleValue(loc.class) and loc.class eq false>
 89 | 				<cfset loc.method_args = build_method_args(arguments.args, arguments.name)>
 90 | 				<cfinvoke method="#arguments.name#" argumentcollection="#loc.method_args#" returnvariable="loc.ret">
 91 | 				<cfreturn loc.ret>
 92 | 			<cfelse>
 93 | 				<cfset loc.method_args = build_method_args(arguments.args, arguments.name, loc.class)>
 94 | 				<cfinvoke component="#loc.class#" method="#arguments.name#" argumentcollection="#loc.method_args#" returnvariable="loc.ret">
 95 | 				<cfreturn loc.ret>
 96 | 			</cfif>
 97 | 		</cfif>
 98 | 		
 99 | 		<cfreturn arguments.value>
100 | 	</cffunction>
101 | 	
102 | 	<cffunction name="build_method_args" returntype="struct">
103 | 		<cfargument name="args" type="array" required="true">
104 | 		<cfargument name="method" type="string" required="true">
105 | 		<cfargument name="class" type="any" required="false">
106 | 		<cfset var loc = {}>
107 | 		
108 | 		<cfset loc.ret = {}>
109 | 
110 | 		<cfif StructKeyExists(arguments, "class")>
111 | 		
112 | 			<cfif IsObject(arguments.class)>
113 | 				<cfset loc.class_methods = getMetaData(arguments.class).functions>
114 | 			<cfelse>
115 | 				<cfset loc.class_methods = getComponentMetaData(arguments.class).functions>
116 | 			</cfif>
117 | 
118 | 			<cfloop array="#loc.class_methods#" index="loc.class_method">
119 | 				<cfif loc.class_method.name eq arguments.method>
120 | 					<cfset loc.method_args = loc.class_method.parameters>
121 | 					<cfbreak>
122 | 				</cfif>
123 | 			</cfloop>
124 | 			
125 | 		<cfelse>
126 | 		
127 | 			<cfset loc.method_args = getMetaData(arguments.name).parameters>
128 | 			
129 | 		</cfif>
130 | 		
131 | 		<cfset loc.counter = ArrayLen(loc.method_args)>
132 | 		<cfset loc.args_counter = ArrayLen(arguments.args)>
133 | 		
134 | 		<cfloop from="1" to="#loc.counter#" index="loc.i">
135 | 			<cfif loc.args_counter gte loc.i>
136 | 				<cfset loc.method_arg = loc.method_args[loc.i].name>
137 | 				<cfset loc.ret[loc.method_arg] = arguments.args[loc.i]>
138 | 			</cfif>
139 | 		</cfloop>
140 | 		
141 | 		<cfreturn loc.ret>
142 | 	</cffunction>
143 | 
144 | </cfcomponent>


--------------------------------------------------------------------------------
/tests/tests/StatementsTest.cfc:
--------------------------------------------------------------------------------
  1 | <cfcomponent output="false" extends="cfml-liquid.tests.Test">
  2 | 	
  3 | 	<cffunction name="setup">
  4 | 		<cfset loc.template = application.liquid.template()>
  5 | 	</cffunction>
  6 | 
  7 | 	<cffunction name="test_true_eql_true">
  8 | 		<cfset loc.tpl = " {% if true == true %} true {% else %} false {% endif %} ">
  9 | 		<cfset loc.expected = "  true  ">
 10 | 		<cfset assert_template_result(loc.expected, loc.tpl, loc.template)>
 11 | 	</cffunction>
 12 | 
 13 | 	<cffunction name="test_true_not_eql_true">
 14 | 		<cfset loc.tpl = " {% if true != true %} true {% else %} false {% endif %} ">
 15 | 		<cfset loc.expected = "  false  ">
 16 | 		<cfset assert_template_result(loc.expected, loc.tpl, loc.template)>
 17 | 	</cffunction>
 18 | 
 19 | 	<cffunction name="test_true_lq_true">
 20 | 		<cfset loc.tpl = " {% if 0 > 0 %} true {% else %} false {% endif %} ">
 21 | 		<cfset loc.expected = "  false  ">
 22 | 		<cfset assert_template_result(loc.expected, loc.tpl, loc.template)>
 23 | 	</cffunction>
 24 | 		
 25 | 	<cffunction name="test_one_lq_zero">
 26 | 		<cfset loc.tpl = " {% if 1 > 0 %} true {% else %} false {% endif %} ">
 27 | 		<cfset loc.expected = "  true  ">
 28 | 		<cfset assert_template_result(loc.expected, loc.tpl, loc.template)>
 29 | 	</cffunction>
 30 |  		
 31 | 	<cffunction name="test_zero_lq_one">
 32 | 		<cfset loc.tpl = " {% if 0 < 1 %} true {% else %} false {% endif %} ">
 33 | 		<cfset loc.expected = "  true  ">
 34 | 		<cfset assert_template_result(loc.expected, loc.tpl, loc.template)>
 35 | 	</cffunction>
 36 | 		
 37 | 	<cffunction name="test_zero_lq_or_equal_one">
 38 | 		<cfset loc.tpl = " {% if 0 <= 0 %} true {% else %} false {% endif %} ">
 39 | 		<cfset loc.expected = "  true  ">
 40 | 		<cfset assert_template_result(loc.expected, loc.tpl, loc.template)>
 41 | 	</cffunction>
 42 | 
 43 | 	<cffunction name="test_zero_lq_or_equal_one_involving_nil">
 44 | 		<cfset loc.tpl = " {% if null <= 0 %} true {% else %} false {% endif %} ">
 45 | 		<cfset loc.expected = "  false  ">
 46 | 		<cfset assert_template_result(loc.expected, loc.tpl, loc.template)>
 47 | 		
 48 | 		<cfset loc.tpl = " {% if 0 <= null %} true {% else %} false {% endif %} ">
 49 | 		<cfset loc.expected = "  false  ">
 50 | 		<cfset assert_template_result(loc.expected, loc.tpl, loc.template)>
 51 | 	</cffunction>
 52 |  		
 53 | 	<cffunction name="test_zero_lqq_or_equal_one">
 54 | 		<cfset loc.tpl = " {% if 0 >= 0 %} true {% else %} false {% endif %} ">
 55 | 		<cfset loc.expected = "  true  ">
 56 | 		<cfset assert_template_result(loc.expected, loc.tpl, loc.template)>
 57 | 	</cffunction>
 58 | 		
 59 | 	<cffunction name="test_strings">
 60 | 		<cfset loc.tpl = " {% if 'test' == 'test' %} true {% else %} false {% endif %} ">
 61 | 		<cfset loc.expected = "  true  ">
 62 | 		<cfset assert_template_result(loc.expected, loc.tpl, loc.template)>
 63 | 	</cffunction>
 64 | 		
 65 | 	<cffunction name="test_strings_not_equal">
 66 | 		<cfset loc.tpl = " {% if 'test' != 'test' %} true {% else %} false {% endif %} ">
 67 | 		<cfset loc.expected = "  false  ">
 68 | 		<cfset assert_template_result(loc.expected, loc.tpl, loc.template)>
 69 | 	</cffunction>
 70 | 		
 71 | 	<cffunction name="test_var_strings_equal">
 72 | 		<cfset loc.a = {var="hello there!"}>
 73 | 		<cfset loc.tpl = ' {% if var == "hello there!" %} true {% else %} false {% endif %} '>
 74 | 		<cfset loc.expected = "  true  ">
 75 | 		<cfset assert_template_result(loc.expected, loc.tpl, loc.template, loc.a)>
 76 | 	</cffunction>
 77 | 
 78 | 	<cffunction name="test_var_strings_are_not_equal">
 79 | 		<cfset loc.a = {var="hello there!"}>
 80 | 		<cfset loc.tpl = " {% if ""hello there!"" == var %} true {% else %} false {% endif %} ">
 81 | 		<cfset loc.expected = "  true  ">
 82 | 		<cfset assert_template_result(loc.expected, loc.tpl, loc.template, loc.a)>
 83 | 	</cffunction>
 84 | 		
 85 | 	<cffunction name="test_var_and_long_string_are_equal">
 86 | 		<cfset loc.a = {var="hello there!"}>
 87 | 		<cfset loc.tpl = " {% if var == 'hello there!' %} true {% else %} false {% endif %} ">
 88 | 		<cfset loc.expected = "  true  ">
 89 | 		<cfset assert_template_result(loc.expected, loc.tpl, loc.template, loc.a)>
 90 | 	</cffunction>
 91 | 
 92 | 	<cffunction name="test_var_and_long_string_are_equal_backwards">
 93 | 		<cfset loc.a = {var="hello there!"}>
 94 | 		<cfset loc.tpl = " {% if 'hello there!' == var %} true {% else %} false {% endif %} ">
 95 | 		<cfset loc.expected = "  true  ">
 96 | 		<cfset assert_template_result(loc.expected, loc.tpl, loc.template, loc.a)>
 97 | 	</cffunction>
 98 | 
 99 | 	<cffunction name="test_is_collection_empty">
100 | 		<cfset loc.a = {array=[]}>
101 | 		<cfset loc.tpl = " {% if array == empty %} true {% else %} false {% endif %} ">
102 | 		<cfset loc.expected = "  true  ">
103 | 		<cfset assert_template_result(loc.expected, loc.tpl, loc.template, loc.a)>
104 | 	</cffunction>
105 | 	
106 | 	<cffunction name="test_is_not_collection_empty">
107 | 		<cfset loc.a = {array = [1,2,3]}>
108 | 		<cfset loc.tpl = " {% if array == empty %} true {% else %} false {% endif %} ">
109 | 		<cfset loc.expected = "  false  ">
110 | 		<cfset assert_template_result(loc.expected, loc.tpl, loc.template, loc.a)>
111 | 	</cffunction>
112 | 
113 | 	<cffunction name="test_nil">
114 | 		<cfset loc.a = {var = "null"}>
115 | 		<cfset loc.tpl = " {% if var == null %} true {% else %} false {% endif %} ">
116 | 		<cfset loc.expected = "  true  ">
117 | 		<cfset assert_template_result(loc.expected, loc.tpl, loc.template, loc.a)>
118 | 
119 |  		<cfset loc.a = {var = "null"}>
120 | 		<cfset loc.tpl = " {% if var == null %} true {% else %} false {% endif %} ">
121 | 		<cfset loc.expected = "  true  ">
122 | 		<cfset assert_template_result(loc.expected, loc.tpl, loc.template, loc.a)>
123 | 	</cffunction>
124 | 
125 | 	<cffunction name="test_not_nil">
126 |  		<cfset loc.a = {var = 1}>
127 | 		<cfset loc.tpl = " {% if var != null %} true {% else %} false {% endif %} ">
128 | 		<cfset loc.expected = "  true  ">
129 | 		<cfset assert_template_result(loc.expected, loc.tpl, loc.template, loc.a)>
130 | 
131 |  		<cfset loc.a = {var = 1}>
132 | 		<cfset loc.tpl = " {% if var != null %} true {% else %} false {% endif %} ">
133 | 		<cfset loc.expected = "  true  ">
134 | 		<cfset assert_template_result(loc.expected, loc.tpl, loc.template, loc.a)>
135 | 	</cffunction>
136 | 
137 | </cfcomponent>


--------------------------------------------------------------------------------
/lib/liquid/LiquidBlock.cfc:
--------------------------------------------------------------------------------
  1 | <cfcomponent output="false" extends="LiquidTag" hint="Base class for blocks.">
  2 | 	
  3 | 	<cfset this._nodelist = CreateObject("java","java.util.ArrayList").Init()>
  4 | 
  5 | 	<cffunction name="getNodelist">
  6 | 		<cfreturn this._nodelist>
  7 | 	</cffunction>
  8 | 	
  9 | 	<cffunction name="setNodeList">
 10 | 		<cfargument name="value" type="any" required="true">
 11 | 		<cfset arrayAppend(this._nodelist, arguments.value)>
 12 | 	</cffunction>
 13 | 
 14 | 	<cffunction name="parse">
 15 | 		<cfargument name="tokens" type="array" required="true">
 16 | 		<cfset var loc = {}>
 17 | 		<cfset loc.start_regexp = createObject("component", "LiquidRegexp").init('^#application.LiquidConfig.LIQUID_TAG_START#')>
 18 | 		<cfset loc.tag_regexp = createObject("component", "LiquidRegexp").init('^#application.LiquidConfig.LIQUID_TAG_START#\s*(\w+)\s*(.*)?#application.LiquidConfig.LIQUID_TAG_END#$')>
 19 | 		<cfset loc.variable_start_regexp = createObject("component", "LiquidRegexp").init('^#application.LiquidConfig.LIQUID_VARIABLE_START#')>
 20 | 		
 21 | 		<cfif !IsArray(arguments.tokens)>
 22 | 			<cfreturn>
 23 | 		</cfif>
 24 | 		
 25 | 		<cfset loc.tags = createObject("component", "LiquidTemplate").getTags()>
 26 | 
 27 | 		<cfloop condition="#ArrayLen(arguments.tokens)#">
 28 | 			
 29 | 			<cfset loc.temp = array_shift(arguments.tokens)>
 30 | 			<cfset arguments.tokens = loc.temp.arr>
 31 | 			<cfset loc.token = loc.temp.value>
 32 | 			<cfset loc.start_regexp.match(loc.token)>
 33 | 			<cfset loc.tag_regexp.match(loc.token)>
 34 | 
 35 | 			<cfif loc.start_regexp.match(loc.token)>
 36 | 
 37 | 				<cfif loc.tag_regexp.match(loc.token)>
 38 | 
 39 | 					<!--- if we found the proper block delimitor just end parsing here and let the outer block proceed  --->
 40 | 					<cfif loc.tag_regexp.matches[2] eq this.block_delimiter()>
 41 | 						<cfreturn this.end_tag()>
 42 | 					</cfif>
 43 | 
 44 | 					<cfif StructKeyExists(loc.tags, loc.tag_regexp.matches[2])>
 45 | 						<cfset loc.tag_name = loc.tags[loc.tag_regexp.matches[2]]>
 46 | 					<cfelse>
 47 | 						<!--- search for a defined class of the right name, instead of searching in an array --->
 48 | 						<cfset loc.tag_name = 'LiquidTag' & rereplace(loc.tag_regexp.matches[2], "\b(\w)","\u\1", "all")>
 49 | 					</cfif>
 50 | 					
 51 | 					<cfset loc.tag_name_fullPath = "#application.LiquidConfig.LIQUID_DIR_PATH#/#loc.tag_name#.cfc">
 52 | 					<cfset loc.tag_name_cfcPath = "#application.LiquidConfig.LIQUID_LIB_PATH#.#loc.tag_name#">
 53 | 
 54 | 					<cfif fileExists(ExpandPath(loc.tag_name_fullPath))>
 55 | 
 56 | 						<cfset loc.temp = createObject("component", loc.tag_name_cfcPath).init(loc.tag_regexp.matches[3], arguments.tokens, this.file_system)>
 57 | 						<cfset loc.temp.pushToNodeList()>
 58 | 						<cfset arrayAppend(this._nodelist, loc.temp)>
 59 | 
 60 | 					<cfelse>
 61 | 
 62 | 						<cfset this.unknown_tag(loc.tag_regexp.matches[2], loc.tag_regexp.matches[3], arguments.tokens)>
 63 | 						
 64 | 					</cfif>
 65 | 				
 66 | 				<cfelse>
 67 | 
 68 | 					<cfset createobject("component", "LiquidException").init("Tag #loc.token# was not properly terminated")>
 69 | 				</cfif>
 70 | 				
 71 | 			<cfelseif loc.variable_start_regexp.match(loc.token)>
 72 | 
 73 | 				<cfset loc.temp = this.create_variable(loc.token)>
 74 | 				<cfset arrayAppend(this._nodelist, loc.temp)>
 75 | 
 76 | 			<cfelseif len(loc.token)>
 77 | 
 78 | 				<cfset arrayAppend(this._nodelist, loc.token)>
 79 | 
 80 | 			</cfif>
 81 | 		</cfloop>
 82 | 
 83 | 		<cfset this.assert_missing_delimitation()>
 84 | 	</cffunction>
 85 | 
 86 | 	<cffunction name="end_tag" hint="An action to execute when the end tag is reached">
 87 | 		<cfreturn this>
 88 | 	</cffunction>
 89 | 
 90 | 	<cffunction name="unknown_tag" hint="Handler for unknown tags">
 91 | 		<cfargument name="tag" type="string" required="true">
 92 | 		<cfargument name="params" type="any" required="true">
 93 | 		<cfargument name="tokens" type="any" required="true">
 94 | 		<cfset var loc = {}>
 95 | 		<cfswitch expression="#arguments.tag#">
 96 | 			<cfcase value="else">
 97 | 				<cfset createobject("component", "LiquidException").init(this.block_name() & " does not expect else tag")>
 98 | 			</cfcase>
 99 | 			<cfcase value="end">
100 | 				<cfset createobject("component", "LiquidException").init("'end' is not a valid delimiter for " & this.block_name() & " tags. Use " & this.block_delimiter())>
101 | 			</cfcase>
102 | 			<cfdefaultcase>
103 | 				<cfset createobject("component", "LiquidException").init("Unkown tag #arguments.tag#")>
104 | 			</cfdefaultcase>
105 | 		</cfswitch>
106 | 	</cffunction>
107 | 
108 | 	<cffunction name="block_delimiter" hint="Returns the string that delimits the end of the block">
109 | 		<cfreturn "end#this.block_name()#">
110 | 	</cffunction>
111 | 
112 | 	<cffunction name="block_name" hint="Returns the name of the block">
113 | 		<cfreturn replacenocase(ListLast(getMetaData(this).name, "."), 'liquidtag', '')>
114 | 	</cffunction>
115 | 
116 | 	<cffunction name="create_variable" hint="Create a variable for the given token">
117 | 		<cfargument name="token" type="string" required="true">
118 | 		<cfset var loc = {}>
119 | 		<cfset loc.variable_regexp = createObject("component", "LiquidRegexp").init('^#application.LiquidConfig.LIQUID_VARIABLE_START#(.*)#application.LiquidConfig.LIQUID_VARIABLE_END#$')>
120 | 		<cfif loc.variable_regexp.match(arguments.token)>
121 | 			<cfset loc.ret = createObject("component", "LiquidVariable").init(loc.variable_regexp.matches[2])>
122 | 			<cfreturn loc.ret>
123 | 		</cfif>
124 | 		<cfset createobject("component", "LiquidException").init("Variable #loc.token# was not properly terminated")>
125 | 	</cffunction>
126 | 
127 | 	<cffunction name="render" hint="Render the block.">
128 | 		<cfargument name="context" type="any" required="true">
129 | 		<cfreturn this.render_all(this._nodelist, arguments.context)>
130 | 	</cffunction>
131 | 
132 | 	<cffunction name="assert_missing_delimitation" hint="This method is called at the end of parsing, and will through an error unless this method is subclassed, like it is for LiquidDocument">
133 | 		<cfset createobject("component", "LiquidException").init(this.block_name() & " tag was never closed")>
134 | 	</cffunction>
135 | 
136 | 	<cffunction name="render_all" hint="Renders all the given nodelist's nodes">
137 | 		<cfargument name="list" type="array" required="true">
138 | 		<cfargument name="context" type="any" required="true">
139 | 		<cfset var loc = {}>
140 | 		<cfset loc.result = []>
141 | 
142 | 		<cfloop array="#arguments.list#" index="loc.token">
143 | 
144 | 			<cfif isObject(loc.token) AND StructKeyExists(loc.token, "render")>
145 | 				
146 | 				<cfset loc.token = loc.token.render(arguments.context)>
147 | 
148 | 			</cfif>
149 | 			
150 | 			<cfif StructKeyExists(loc, "token")>
151 | 			
152 | 				<cfif !IsSimpleValue(loc.token)>
153 | 					<cfset loc.token = loc.token.toString()>
154 | 				</cfif>
155 | 				
156 | 				<cfset ArrayAppend(loc.result, loc.token)>
157 | 				
158 | 			</cfif>
159 | 
160 | 		</cfloop>
161 | 
162 | 		<cfreturn ArrayToList(loc.result, "")>
163 | 	</cffunction>
164 | 	
165 | </cfcomponent>


--------------------------------------------------------------------------------
/lib/liquid/LiquidTagFor.cfc:
--------------------------------------------------------------------------------
  1 | <cfcomponent output="false" extends="LiquidBlock" hint="
  2 |  * Loops over an array, assigning the current value to a given variable
  3 |  * 
  4 |  * @example
  5 |  * {%for item in array%} {{item}} {%endfor%}
  6 |  * 
  7 |  * With an array of 1, 2, 3, 4, will return 1 2 3 4
  8 |  * 
  9 |  * @package Liquid
 10 | ">
 11 | 
 12 | 	<!--- The collection to loop over --->
 13 | 	<cfset this._collectionName = "">
 14 | 	
 15 | 	<!--- The variable name to assign collection elements to --->
 16 | 	<cfset this._variableName = "">
 17 | 
 18 | 	<!--- The name of the loop, which is a compound of the collection and variable names --->
 19 | 	<cfset this._name = "">
 20 | 
 21 | 	<cffunction name="init">
 22 | 		<cfargument name="markup" type="string" required="true">
 23 | 		<cfargument name="tokens" type="array" required="true">
 24 | 		<cfargument name="file_system" type="any" required="true" hint="LiquidFileSystem">
 25 | 		<cfset var loc = {}>
 26 | 
 27 | 		<cfset super.init(arguments.markup, arguments.tokens, arguments.file_system)>
 28 | 	
 29 | 		<cfset loc.syntax_regexp = createObject("component", "LiquidRegexp").init('(\w+)\s+in\s+(#application["LiquidConfig"]["LIQUID_ALLOWED_VARIABLE_CHARS"]#+)')>
 30 | 		
 31 | 		<cfif loc.syntax_regexp.match(arguments.markup)>
 32 | 
 33 | 			<cfset this._variableName = loc.syntax_regexp.matches[2]>
 34 | 			<cfset this._collectionName = loc.syntax_regexp.matches[3]>
 35 | 			<cfset this._name = loc.syntax_regexp.matches[2] & '-' & loc.syntax_regexp.matches[3]>
 36 | 			<cfset this.extract_attributes(arguments.markup)>
 37 | 			
 38 | 		<cfelse>		
 39 | 			<cfset createobject("component", "LiquidException").init("Syntax Error in 'for loop' - Valid syntax: for [item] in [collection]")>
 40 | 		</cfif>
 41 | 
 42 | 		<cfreturn this>
 43 | 	</cffunction>
 44 | 	
 45 | 	<cffunction name="render">
 46 | 		<cfargument name="context" type="any" required="true" hint="LiquidContext">
 47 | 		<cfset var loc = {}>
 48 | 		
 49 | 		<cfset loc.results = "">
 50 | 
 51 | 		<cfif !IsDefined("arguments.context.registers") OR !StructKeyExists(arguments.context.registers, "for")>
 52 | 			<cfset arguments.context.registers["for"] = {}>
 53 | 		</cfif>
 54 | 		
 55 | 		<cfset loc.collection = arguments.context.get(this._collectionName)>
 56 | 		
 57 | 		<cfif
 58 | 			!StructKeyExists(loc, "collection")
 59 | 			OR IsSimpleValue(loc.collection)
 60 | 			OR IsStruct(loc.collection)
 61 | 			OR (IsArray(loc.collection) AND ArrayIsEmpty(loc.collection))
 62 | 			OR (IsQuery(loc.collection) AND loc.collection.recordcount eq 0)>
 63 | 			<cfreturn "">
 64 | 		</cfif>
 65 | 		
 66 | 		<cfset arguments.context.push()>		
 67 | 	
 68 | 		<cfif IsArray(loc.collection)>
 69 | 			<cfset loc.result = _renderArray(loc.collection, arguments.context)>
 70 | 		<cfelseif IsQuery(loc.collection)>
 71 | 			<cfset loc.result = _renderQuery(loc.collection, arguments.context)>
 72 | 		</cfif>
 73 | 	
 74 | 		<cfset arguments.context.pop()>
 75 | 		
 76 | 		<cfreturn loc.result>
 77 | 	</cffunction>
 78 | 	
 79 | 	<cffunction name="_renderArray">
 80 | 		<cfargument name="collection" type="array" required="true">
 81 | 		<cfargument name="context" type="any" required="true">
 82 | 		<cfset var loc = {}>
 83 | 		
 84 | 		<cfset loc.result = "">
 85 | 		<cfset loc.range = [0, ArrayLen(arguments.collection)]>
 86 | 		
 87 | 		<cfif StructKeyExists(this.attributes, "limit") OR StructKeyExists(this.attributes, "offset")>
 88 | 
 89 | 			<cfset loc.offset = 0>
 90 | 			<cfset loc.limit = 0>
 91 | 			
 92 | 			<cfif StructKeyExists(this.attributes, 'offset')>
 93 | 			
 94 | 				<cfif this.attributes['offset'] eq "continue">
 95 | 					<cfset loc.offset = arguments.context.registers['for'][this._name]>
 96 | 				<cfelse>
 97 | 					<cfset loc.offset = arguments.context.get(this.attributes['offset'])>
 98 | 				</cfif>
 99 | 				
100 | 				<cfif loc.offset GTE ArrayLen(arguments.collection)>
101 | 					<cfset loc.offset = ArrayLen(arguments.collection)>
102 | 				</cfif>
103 | 				
104 | 				<cfset loc.offset = abs(fix(val(loc.offset)))>
105 | 				
106 | 			</cfif>
107 | 
108 | 			<cfif StructKeyExists(this.attributes, 'limit')>
109 | 				
110 | 				<cfset loc.limit = arguments.context.get(this.attributes['limit'])>
111 | 				<cfset loc.limit = abs(fix(val(loc.limit)))>
112 | 				
113 | 			</cfif>
114 | 			
115 | 			<cfif loc.limit gt 0>
116 | 				<cfset loc.limit = loc.limit + loc.offset>
117 | 			</cfif>
118 | 			
119 | 			<cfif loc.limit GTE ArrayLen(arguments.collection)>
120 | 				
121 | 				<cfset loc.limit = ArrayLen(arguments.collection)>
122 | 			</cfif>
123 | 
124 | 			<cfif loc.limit gt 0 AND loc.limit lte ArrayLen(arguments.collection)>
125 | 				<cfset loc.range_end = loc.limit>
126 | 			<cfelse>
127 | 				<cfset loc.range_end = ArrayLen(arguments.collection)>
128 | 			</cfif>
129 | 			
130 | 			<cfset loc.range = [loc.offset, loc.range_end]>
131 | 			<cfset arguments.context.registers['for'][this._name] = loc.range_end>
132 | 
133 | 		</cfif>
134 | 		
135 | 		<cfset arguments.collection = createObject("java", "java.util.ArrayList").Init(arguments.collection).subList(JavaCast("int", loc.range[1]), JavaCast("int", loc.range[2]))>
136 | 		
137 | 		<cfset loc.length = ArrayLen(arguments.collection)>
138 | 
139 | 		<cfloop from="1" to="#loc.length#" index="loc.index">
140 | 
141 | 			<cfset arguments.context.set(this._variableName, arguments.collection[loc.index])>
142 | 			<cfset loc.temp = {}>
143 | 			<cfset loc.temp.name = this._name>
144 | 			<cfset loc.temp.length = loc.length>
145 | 			<cfset loc.temp.index = loc.index>
146 | 			<cfset loc.temp.index0 = loc.index - 1>
147 | 			<cfset loc.temp.rindex = loc.length - loc.index + 1>
148 | 			<cfset loc.temp.rindex0 = loc.length - loc.index>
149 | 			<cfset loc.temp.first = IIf(loc.index eq 1, de(1), de(0))>
150 | 			<cfset loc.temp.last = IIF(loc.index eq (loc.length), de(1), de(0))>
151 | 			<cfset arguments.context.set('forloop', loc.temp)>
152 | 			<cfset loc.result &= this.render_all(this._nodelist, arguments.context)>
153 | 			
154 | 		</cfloop>
155 | 		
156 | 		<cfreturn loc.result>
157 | 	</cffunction>
158 | 	
159 | 	<cffunction name="_renderQuery">
160 | 		<cfargument name="collection" type="query" required="true">
161 | 		<cfargument name="context" type="any" required="true">
162 | 		<cfset var loc = {}>
163 | 
164 | 		<cfset loc.result = "">
165 | 		<cfset loc.range = [0, arguments.collection.recordcount]>
166 | 		<cfset loc.length = arguments.collection.recordcount>
167 | 		<cfset loc.columnList = arguments.collection.columnlist>
168 | 		
169 | 		<cfloop from="1" to="#loc.length#" index="loc.index">
170 | 			
171 | 			<cfset loc.segment = {}>
172 | 			
173 | 			<cfloop list="#loc.columnList#" index="loc.column">
174 | 				<cfset loc.segment[loc.column] = arguments.collection[loc.column][loc.index]>
175 | 			</cfloop>
176 | 
177 | 			<cfset arguments.context.set(this._variableName, loc.segment)>
178 | 			<cfset loc.temp = {}>
179 | 			<cfset loc.temp.name = this._name>
180 | 			<cfset loc.temp.length = loc.length>
181 | 			<cfset loc.temp.index = loc.index>
182 | 			<cfset loc.temp.index0 = loc.index - 1>
183 | 			<cfset loc.temp.rindex = loc.length - loc.index + 1>
184 | 			<cfset loc.temp.rindex0 = loc.length - loc.index>
185 | 			<cfset loc.temp.first = IIf(loc.index eq 1, de(1), de(0))>
186 | 			<cfset loc.temp.last = IIF(loc.index eq (loc.length), de(1), de(0))>
187 | 			<cfset arguments.context.set('forloop', loc.temp)>
188 | 			<cfset loc.result &= this.render_all(this._nodelist, arguments.context)>
189 | 			
190 | 		</cfloop>
191 | 		<cfreturn loc.result>
192 | 	</cffunction>
193 | 	
194 | </cfcomponent>


--------------------------------------------------------------------------------
/tests/tests/VariableTest.cfc:
--------------------------------------------------------------------------------
  1 | <cfcomponent output="false" extends="cfml-liquid.tests.Test">
  2 | 	
  3 | 	<cffunction name="setup">
  4 | 		<cfset loc.liquid = createObject("component", "cfml-liquid.lib.Liquid").init()>
  5 | 	</cffunction>
  6 | 	
  7 | 	<cffunction name="create_instance">
  8 | 		<cfargument name="value" type="string" required="true">
  9 | 		<cfreturn createObject("component", "cfml-liquid.lib.liquid.LiquidVariable").init(
 10 | 			arguments.value
 11 | 		)>
 12 | 	</cffunction>
 13 | 	
 14 | 	<cffunction name="test_variable">
 15 | 		<cfset loc.e = 'hello'>
 16 | 		<cfset loc.r = create_instance('hello').getName()>
 17 | 		<cfset assert('loc.e eq loc.r')>
 18 | 	</cffunction>
 19 | 
 20 | 	<cffunction name="test_filters">
 21 | 		
 22 |  		<cfset loc.e = 'hello'>
 23 | 		<cfset loc.r = create_instance('hello | textileze')>
 24 | 		<cfset assert('loc.e eq loc.r.getName()')>
 25 | 		<cfset loc.e = []>
 26 | 		<cfset loc.temp = ["textileze", ArrayNew(1)]>
 27 | 		<cfset arrayAppend(loc.e, loc.temp)>
 28 | 		<cfset assert('arrayCompare(loc.e, loc.r.getFilters())')>
 29 |  
 30 |  		<cfset loc.e = 'hello'>
 31 | 		<cfset loc.r = create_instance('hello | textileze | paragraph')>
 32 | 		<cfset assert('loc.e eq loc.r.getName()')>
 33 | 		<cfset loc.e = []>
 34 | 		<cfset loc.temp = ["textileze", ArrayNew(1)]>
 35 | 		<cfset arrayAppend(loc.e, loc.temp)>
 36 | 		<cfset loc.temp = ["paragraph", ArrayNew(1)]>
 37 | 		<cfset arrayAppend(loc.e, loc.temp)>
 38 | 		<cfset assert('arrayCompare(loc.e, loc.r.getFilters())')>
 39 | 
 40 |  		<cfset loc.e = 'hello'>
 41 | 		<cfset loc.r = create_instance(" hello | strftime: '%Y'")>
 42 | 		<cfset assert('loc.e eq loc.r.getName()')>
 43 | 		<cfset loc.e = []>
 44 | 		<cfset loc.args = ["'%Y'"]>
 45 | 		<cfset loc.temp = ["strftime", loc.args]>
 46 | 		<cfset arrayAppend(loc.e, loc.temp)>
 47 | 		<cfset assert('arrayCompare(loc.e, loc.r.getFilters())')>
 48 | 	
 49 |  		<cfset loc.e = "'typo'">
 50 | 		<cfset loc.r = create_instance(" 'typo' | link_to: 'Typo', true ")>
 51 | 		<cfset assert('loc.e eq loc.r.getName()')>
 52 | 		<cfset loc.e = []>
 53 | 		<cfset loc.args = ["'Typo'", "true"]>
 54 | 		<cfset loc.temp = ["link_to", loc.args]>
 55 | 		<cfset arrayAppend(loc.e, loc.temp)>
 56 | 		<cfset assert('arrayCompare(loc.e, loc.r.getFilters())')>
 57 | 		
 58 |  		<cfset loc.e = "'typo'">
 59 | 		<cfset loc.r = create_instance(" 'typo' | link_to: 'Typo', false ")>
 60 | 		<cfset assert('loc.e eq loc.r.getName()')>
 61 | 		<cfset loc.e = []>
 62 | 		<cfset loc.args = ["'Typo'", "false"]>
 63 | 		<cfset loc.temp = ["link_to", loc.args]>
 64 | 		<cfset arrayAppend(loc.e, loc.temp)>
 65 | 		<cfset assert('arrayCompare(loc.e, loc.r.getFilters())')>
 66 | 
 67 |  		<cfset loc.e = "'foo'">
 68 | 		<cfset loc.r = create_instance(" 'foo' | repeat: 3 ")>
 69 | 		<cfset assert('loc.e eq loc.r.getName()')>
 70 | 		<cfset loc.e = []>
 71 | 		<cfset loc.args = ["3"]>
 72 | 		<cfset loc.temp = ["repeat", loc.args]>
 73 | 		<cfset arrayAppend(loc.e, loc.temp)>
 74 | 		<cfset assert('arrayCompare(loc.e, loc.r.getFilters())')>
 75 | 		
 76 |  		<cfset loc.e = "'foo'">
 77 | 		<cfset loc.r = create_instance(" 'foo' | repeat: 3, 3")>
 78 | 		<cfset assert('loc.e eq loc.r.getName()')>
 79 | 		<cfset loc.e = []>
 80 | 		<cfset loc.args = ["3", "3"]>
 81 | 		<cfset loc.temp = ["repeat", loc.args]>
 82 | 		<cfset arrayAppend(loc.e, loc.temp)>
 83 | 		<cfset assert('arrayCompare(loc.e, loc.r.getFilters())')>
 84 | 		
 85 |  		<cfset loc.e = "'foo'">
 86 | 		<cfset loc.r = create_instance(" 'foo' | repeat: 3, 3, 3 ")>
 87 | 		<cfset assert('loc.e eq loc.r.getName()')>
 88 | 		<cfset loc.e = []>
 89 | 		<cfset loc.args = ["3", "3", "3"]>
 90 | 		<cfset loc.temp = ["repeat", loc.args]>
 91 | 		<cfset arrayAppend(loc.e, loc.temp)>
 92 | 		<cfset assert('arrayCompare(loc.e, loc.r.getFilters())')>
 93 | 		
 94 |  		<cfset loc.e = 'hello'>
 95 | 		<cfset loc.r = create_instance(" hello | strftime: '%Y, okay?'")>
 96 | 		<cfset assert('loc.e eq loc.r.getName()')>
 97 | 		<cfset loc.e = []>
 98 | 		<cfset loc.args = ["'%Y, okay?'"]>
 99 | 		<cfset loc.temp = ["strftime", loc.args]>
100 | 		<cfset arrayAppend(loc.e, loc.temp)>
101 | 		<cfset assert('arrayCompare(loc.e, loc.r.getFilters())')>
102 | 		
103 |  		<cfset loc.e = 'hello'>
104 | 		<cfset loc.r = create_instance(" hello | things: ""%Y, okay?"", 'the other one'")>
105 | 		<cfset assert('loc.e eq loc.r.getName()')>
106 | 		<cfset loc.e = []>
107 | 		<cfset loc.args = ['"%Y, okay?"', "'the other one'"]>
108 | 		<cfset loc.temp = ["things", loc.args]>
109 | 		<cfset arrayAppend(loc.e, loc.temp)>
110 | 		<cfset assert('arrayCompare(loc.e, loc.r.getFilters())')>
111 | 
112 | 	</cffunction>
113 | 
114 | 
115 | 	<cffunction name="test_filters_without_whitespace">
116 | 		
117 |  		<cfset loc.e = 'hello'>
118 | 		<cfset loc.r = create_instance('hello | textileze | paragraph')>
119 | 		<cfset assert('loc.e eq loc.r.getName()')>
120 | 		<cfset loc.e = []>
121 | 		<cfset loc.args = []>
122 | 		<cfset loc.temp = ["textileze", loc.args]>
123 | 		<cfset arrayAppend(loc.e, loc.temp)>
124 | 		<cfset loc.args = []>
125 | 		<cfset loc.temp = ["paragraph", loc.args]>
126 | 		<cfset arrayAppend(loc.e, loc.temp)>
127 | 		<cfset assert('arrayCompare(loc.e, loc.r.getFilters())')>
128 | 		
129 |  		<cfset loc.e = 'hello'>
130 | 		<cfset loc.r = create_instance('hello|textileze|paragraph')>
131 | 		<cfset assert('loc.e eq loc.r.getName()')>
132 | 		<cfset loc.e = []>
133 | 		<cfset loc.args = []>
134 | 		<cfset loc.temp = ["textileze", loc.args]>
135 | 		<cfset arrayAppend(loc.e, loc.temp)>
136 | 		<cfset loc.args = []>
137 | 		<cfset loc.temp = ["paragraph", loc.args]>
138 | 		<cfset arrayAppend(loc.e, loc.temp)>
139 | 		<cfset assert('arrayCompare(loc.e, loc.r.getFilters())')>
140 | 		
141 | 	</cffunction>
142 | 	
143 | 	<cffunction name="test_symbol">
144 | 		
145 |  		<cfset loc.e = 'http://disney.com/logo.gif'>
146 | 		<cfset loc.r = create_instance("http://disney.com/logo.gif | image: 'med' ")>
147 | 		<cfset assert('loc.e eq loc.r.getName()')>
148 | 		<cfset loc.e = []>
149 | 		<cfset loc.args = ["'med'"]>
150 | 		<cfset loc.temp = ["image", loc.args]>
151 | 		<cfset arrayAppend(loc.e, loc.temp)>
152 | 		<cfset assert('arrayCompare(loc.e, loc.r.getFilters())')>
153 | 		
154 | 	</cffunction>
155 | 		
156 | 	<cffunction name="test_string_single_quoted">
157 | 		
158 |  		<cfset loc.e = '"hello"'>
159 | 		<cfset loc.r = create_instance(' "hello" ')>
160 | 		<cfset assert('loc.e eq loc.r.getName()')>
161 | 
162 | 	</cffunction>
163 | 	
164 | 	<cffunction name="test_string_double_quoted">
165 | 		
166 |  		<cfset loc.e = "'hello'">
167 | 		<cfset loc.r = create_instance(" 'hello' ")>
168 | 		<cfset assert('loc.e eq loc.r.getName()')>
169 | 			
170 | 	</cffunction>
171 | 	
172 | 	<cffunction name="test_integer">
173 | 		
174 |  		<cfset loc.e = '1000'>
175 | 		<cfset loc.r = create_instance(' 1000 ')>
176 | 		<cfset assert('loc.e eq loc.r.getName()')>
177 | 
178 | 	</cffunction>
179 | 	
180 | 	<cffunction name="test_float">
181 | 		
182 |  		<cfset loc.e = '1000.01'>
183 | 		<cfset loc.r = create_instance(' 1000.01 ')>
184 | 		<cfset assert('loc.e eq loc.r.getName()')>
185 | 	
186 | 	</cffunction>
187 |  	
188 | 	<cffunction name="test_string_with_special_chars">
189 | 		
190 |  		<cfset loc.e = "'hello! $!@.;""ddasd"" '">
191 | 		<cfset loc.r = create_instance("'hello! $!@.;""ddasd"" ' ")>
192 | 		<cfset assert('loc.e eq loc.r.getName()')>
193 | 
194 | 	</cffunction>
195 | 	
196 | 	<cffunction name="test_string_dot">
197 | 		
198 |  		<cfset loc.e = 'test.test'>
199 | 		<cfset loc.r = create_instance(" test.test ")>
200 | 		<cfset assert('loc.e eq loc.r.getName()')>
201 | 		
202 | 	</cffunction>
203 | 
204 | </cfcomponent>


--------------------------------------------------------------------------------
/tests/tests/ContextTest.cfc:
--------------------------------------------------------------------------------
  1 | <cfcomponent output="false" extends="cfml-liquid.tests.Test">
  2 | 
  3 | 	<cffunction name="setup">
  4 | 		<cfset loc.context = createobject("component", "cfml-liquid.lib.liquid.LiquidContext").init()>
  5 | 	</cffunction>
  6 | 
  7 | 	<cffunction name="test_variables">
  8 | 		<cfset loc.context.set('test', 'test')>
  9 | 		<cfset loc.e = loc.context.get('test')>
 10 | 		<cfset assert("loc.e eq 'test'")>
 11 | 		
 12 | 		<!--- we add this text to make sure we can return values that evaluate to false properly --->
 13 | 		<cfset loc.context.set('test_0', 0)>
 14 | 		<cfset loc.e = loc.context.get('test_0')>
 15 | 		<cfset assert("loc.e eq 0")>
 16 | 	</cffunction>
 17 | 
 18 | 	<cffunction name="test_variables_not_existing">
 19 | 		<cfset loc.e = loc.context.get('test')>
 20 | 		<cfset assert("loc.e eq ''")>
 21 | 	</cffunction>
 22 | 
 23 | 	<cffunction name="test_scoping">
 24 | 		<cfset loc.context.push()>
 25 | 		<cfset loc.e = loc.context.pop()>
 26 | 		<cfset assert("loc.e eq ''")>
 27 | 	</cffunction>
 28 | 	
 29 | 	<cffunction name="test_length_query">
 30 | 		<cfset loc.a = [1, 2, 3, 4]>
 31 | 		<cfset loc.context.set('numbers', loc.a)>
 32 | 		<cfset loc.e = loc.context.get('numbers.size')>
 33 | 		<cfset assert("loc.e eq 4")>
 34 | 		
 35 | 		<cfset loc.a = {1=1, 2=2, 3=3, 4=4, 5=5}>
 36 | 		<cfset loc.context.set('numbers', loc.a)>
 37 | 		<cfset loc.e = loc.context.get('numbers.size')>
 38 | 		<cfset assert("loc.e eq 5")>
 39 | 
 40 | 		<cfset loc.a = QueryNew("firstname,lastname")>
 41 | 		<cfset QueryAddRow(loc.a)>
 42 | 		<cfset QuerySetCell(loc.a, "firstname", "Tony")>
 43 | 		<cfset QuerySetCell(loc.a, "lastname", "Petruzzi")>
 44 | 		<cfset QueryAddRow(loc.a)>
 45 | 		<cfset QuerySetCell(loc.a, "firstname", "Per")>
 46 | 		<cfset QuerySetCell(loc.a, "lastname", "Djurner")>
 47 | 		<cfset loc.context.set('numbers', loc.a)>
 48 | 		<cfset loc.e = loc.context.get('numbers.size')>
 49 | 		<cfset assert("loc.e eq 2")>
 50 | 	</cffunction>
 51 | 
 52 | 	<cffunction name="test_add_filter">
 53 | 		<cfset loc.context = createobject("component", "cfml-liquid.lib.liquid.LiquidContext").init()>
 54 | 		<cfset loc.filter = createobject("component", "classes.HiFilter")>
 55 | 		<cfset loc.context.add_filters(loc.filter)>
 56 |  		<cfset loc.e = loc.context.invoke_method('hi', 'hi?')>
 57 | 		<cfset assert("loc.e eq 'hi? hi!'")>
 58 | 
 59 | 		<cfset loc.context = createobject("component", "cfml-liquid.lib.liquid.LiquidContext").init()>
 60 | 		<cfset loc.e = loc.context.invoke_method('hi', 'hi?')>
 61 | 		<cfset assert("loc.e eq 'hi?'")>
 62 | 
 63 | 		<cfset loc.context.add_filters(loc.filter)>
 64 | 		<cfset loc.e = loc.context.invoke_method('hi', 'hi?')>
 65 | 		<cfset assert("loc.e eq 'hi? hi!'")>
 66 | 	</cffunction>
 67 | 	
 68 | 	<cffunction name="test_override_global_filter" hint="skip this one for now, as we haven't implemented global filters yet">
 69 | 
 70 | 		<cfset loc.template = application.liquid.template()>
 71 | 		<cfset loc.GlobalFilter = createObject("component", "classes.GlobalFilter")>
 72 | 		<cfset loc.template.registerFilter(loc.GlobalFilter)>
 73 | 		
 74 | 		<cfset loc.template.parse("{{'test' | notice }}")>
 75 | 		<cfset loc.e = loc.template.render()>
 76 |  		<cfset assert("loc.e eq 'Global test'")>
 77 | 		
 78 | 		<cfset loc.LocalFilter = createObject("component", "classes.LocalFilter")>
 79 | 		<cfset loc.e = loc.template.render(StructNew(), loc.LocalFilter)>
 80 | 		<cfset assert("loc.e eq 'Local test'")>
 81 | 	</cffunction>
 82 | 	
 83 | 	<cffunction name="test_add_item_in_outer_scope">
 84 | 		<cfset loc.context.set('test', 'test')>
 85 | 		<cfset loc.context.push()>
 86 | 		<cfset loc.e = loc.context.get('test')>
 87 | 		<cfset assert("loc.e eq 'test'")>
 88 | 		<cfset loc.context.pop()>
 89 | 		<cfset loc.e = loc.context.get('test')>
 90 | 		<cfset assert("loc.e eq 'test'")>
 91 | 	</cffunction>
 92 | 
 93 | 	<cffunction name="test_add_item_in_inner_scope">
 94 | 		<cfset loc.context.push()>
 95 | 		<cfset loc.context.set('test', 'test')>
 96 | 		<cfset loc.e = loc.context.get('test')>
 97 | 		<cfset assert("loc.e eq 'test'")>
 98 | 		<cfset loc.context.pop()>
 99 | 		<cfset loc.e = loc.context.get('test')>
100 | 		<cfset assert("loc.e eq ''")>
101 | 	</cffunction>
102 | 		
103 | 	<cffunction name="test_hierchal_data">
104 | 		<cfset loc.a = {name = "tobi"}>
105 | 		<cfset loc.context.set('hash', loc.a)>
106 | 		<cfset loc.e = loc.context.get('hash.name')>
107 | 		<cfset assert("loc.e eq 'tobi'")>
108 | 	</cffunction>
109 | 
110 | 	<cffunction name="test_keywords">
111 | 		<cfset loc.e = loc.context.get('true')>
112 | 		<cfset assert("loc.e eq 'true'")>
113 | 		<cfset loc.e = loc.context.get('false')>
114 | 		<cfset assert("loc.e eq 'false'")>
115 | 	</cffunction>
116 | 	
117 | 	<cffunction name="test_digits">
118 | 		<cfset loc.e = loc.context.get(100)>
119 | 		<cfset assert("loc.e eq 100")>
120 | 		<cfset loc.e = loc.context.get(100.00)>
121 | 		<cfset assert("loc.e eq 100.00")>
122 | 	</cffunction>
123 | 	
124 | 	<cffunction name="test_string">
125 | 		<cfset loc.e = loc.context.get("'hello!'")>
126 | 		<cfset assert("loc.e eq 'hello!'")>
127 | 		<cfset loc.e = loc.context.get('"hello!"')>
128 | 		<cfset assert("loc.e eq 'hello!'")>
129 | 	</cffunction>	
130 | 
131 | 	<cffunction name="test_merge">
132 | 		<cfset loc.a = {test = 'test'}>
133 | 		<cfset loc.context.merge(loc.a)>
134 | 		<cfset loc.e = loc.context.get('test')>
135 | 		<cfset assert("loc.e eq 'test'")>
136 | 		
137 | 		<cfset loc.a = {test = 'newvalue', foo = 'bar'}>
138 | 		<cfset loc.context.merge(loc.a)>
139 | 		<cfset loc.e = loc.context.get('test')>
140 | 		<cfset assert("loc.e eq 'newvalue'")>
141 | 		<cfset loc.e = loc.context.get('foo')>
142 | 		<cfset assert("loc.e eq 'bar'")>
143 | 	</cffunction>
144 | 	
145 | 	<cffunction name="test_cents">
146 | 		<cfset loc.HundredCentes = createObject("component", "classes.HundredCentes")>
147 | 		<cfset loc.a = {cents = loc.HundredCentes}>
148 | 		<cfset loc.context.merge(loc.a)>
149 | 		<cfset loc.e = loc.context.get('cents')>
150 | 		<cfset assert("loc.e eq 100")>
151 | 	</cffunction>
152 | 
153 | 	<cffunction name="test_nested_cents">
154 | 		<cfset loc.HundredCentes = createObject("component", "classes.HundredCentes")>
155 | 		<cfset loc.b = {amount = loc.HundredCentes}>
156 | 		<cfset loc.a = {cents = loc.b}>
157 | 		<cfset loc.context.merge(loc.a)>
158 | 		<cfset loc.e = loc.context.get('cents.amount')>
159 | 		<cfset assert("loc.e eq 100")>
160 | 
161 | 		<cfset loc.HundredCentes = createObject("component", "classes.HundredCentes")>
162 | 		<cfset loc.b = {amount = loc.HundredCentes}>
163 | 		<cfset loc.a = {cents = {cents = loc.b}}>
164 | 		<cfset loc.context.merge(loc.a)>
165 | 		<cfset loc.e = loc.context.get('cents.cents.amount')>
166 | 		<cfset assert("loc.e eq 100")>
167 | 	</cffunction>
168 | 	
169 | 	<cffunction name="test_cents_through_drop">
170 | 		<cfset loc.CentsDrop = createObject("component", "classes.CentsDrop")>
171 | 		<cfset loc.a = {cents = loc.CentsDrop}>
172 | 		<cfset loc.context.merge(loc.a)>
173 | 		<cfset loc.e = loc.context.get('cents.amount')>
174 | 		<cfset assert("loc.e eq 100")>
175 | 	</cffunction>
176 | 	
177 | 	<cffunction name="test_cents_through_drop_nestedly">
178 | 		<cfset loc.CentsDrop = createObject("component", "classes.CentsDrop")>
179 | 		<cfset loc.a = {cents = {cents = loc.CentsDrop}}>
180 | 		<cfset loc.context.merge(loc.a)>
181 | 		<cfset loc.e = loc.context.get('cents.cents.amount')>
182 | 		<cfset assert("loc.e eq 100")>
183 |  		
184 | 		<cfset loc.CentsDrop = createObject("component", "classes.CentsDrop")>
185 | 		<cfset loc.a = {cents = {cents = {cents = loc.CentsDrop}}}>
186 | 		<cfset loc.context.merge(loc.a)>
187 | 		<cfset loc.e = loc.context.get('cents.cents.cents.amount')>
188 | 		<cfset assert("loc.e eq 100")>
189 | 	</cffunction>
190 | 
191 | </cfcomponent>


--------------------------------------------------------------------------------
/lib/liquid/utils.cfm:
--------------------------------------------------------------------------------
  1 | <cffunction name="array_flatten" output="false">
  2 | 	<cfargument name="arr" type="any" required="true">
  3 | 	<cfset var loc = {}>
  4 | 	
  5 | 	<cfset loc.ret = []>
  6 | 
  7 | 	<cfloop array="#arguments.arr#" index="loc.element">
  8 | 		
  9 | 		<cfif IsArray(loc.element)>
 10 | 			<cfset loc.ret.addAll(array_flatten(loc.element))>
 11 | 		<cfelse>
 12 | 			<cfset arrayAppend(loc.ret, loc.element)>
 13 | 		</cfif>
 14 | 		
 15 | 	</cfloop>
 16 | 	
 17 | 	<cfreturn loc.ret>
 18 | </cffunction>
 19 | 
 20 | 
 21 | <cffunction name="pregSplit3" output="false">
 22 | 	<cfargument name="regex" type="string" required="true" hint="I am the regular expression being used to split the string." />
 23 | 	<cfargument name="str" type="string" required="true" hint="I am the string being split." />
 24 | 	<cfargument name="limit" type="numeric" required="false" default="0" hint="the number of results to limit to" />
 25 | 	<cfargument name="captureDelim" type="boolean" required="false" default="true" hint="should we capture the delim also" />
 26 | 	<cfset var loc = {}>
 27 | 
 28 | 	<cfset loc.results = arrayNew(1)>
 29 | 	<cfset loc.matches = ReMatchNoCase(arguments.regex, arguments.str)>
 30 | 	
 31 |     <cfif ArrayIsEmpty(loc.matches)>
 32 | 		
 33 | 		<cfset loc.results[1] = arguments.str>
 34 | 		<cfreturn loc.results>
 35 | 		
 36 |     </cfif>
 37 | 	
 38 | 	<cfset loc.matcheslen = ArrayLen(loc.matches)>
 39 | 	
 40 | 	<cfloop from="1" to="#loc.matcheslen#" index="loc.i">
 41 | 		<cfset loc.match = loc.matches[loc.i]>
 42 | 		<cfset loc.f = FindNoCase(loc.match, arguments.str)>
 43 | 		
 44 | 		<cfif loc.f gt 1>
 45 | 			<cfset ArrayAppend(loc.results, left(arguments.str, loc.f - 1))>
 46 | 		</cfif>
 47 | 		
 48 | 		<cfset ArrayAppend(loc.results, loc.match)>
 49 | 		<cfset loc.counter = loc.f + len(loc.match)>
 50 | 		<cfset loc.strlen = len(arguments.str)>
 51 | 
 52 | 		<cfif loc.counter lte loc.strlen>
 53 | 			<cfset arguments.str = right(arguments.str, loc.strlen - loc.counter + 1)>
 54 | 		</cfif>
 55 | 		
 56 | 	</cfloop>
 57 | 
 58 | 	<cfif len(arguments.str) and FindNoCase(loc.match, arguments.str) eq 0>
 59 | 		<cfset ArrayAppend(loc.results, arguments.str)>
 60 | 	</cfif>
 61 | 	
 62 | 	<cfreturn loc.results>
 63 | </cffunction>
 64 | 
 65 | 
 66 | <cffunction name="pregSplit" output="false">
 67 | 	<cfargument name="regex" type="string" required="true" hint="I am the regular expression being used to split the string." />
 68 | 	<cfargument name="str" type="string" required="true" hint="I am the string being split." />
 69 | 	<cfargument name="limit" type="numeric" required="false" default="0" hint="the number of results to limit to" />
 70 | 	<cfargument name="captureDelim" type="boolean" required="false" default="true" hint="should we capture the delim also" />
 71 | 	<cfset var loc = {}>
 72 | 	
 73 | 	<cfset loc.results = arrayNew(1)>
 74 | 	<cfset loc.test = REFind(arguments.regex, arguments.str,1,1)>
 75 | 	<cfset loc.pos = loc.test.pos[1]>
 76 | 	<cfset loc.len = loc.test.len[1]>
 77 | 	<cfset loc.oldpos = 1>
 78 | 	
 79 |     <cfif not loc.pos>
 80 | 		<cfset loc.results[1] = arguments.str>
 81 |     </cfif>
 82 | 	
 83 |     <cfloop condition="loc.pos gt 0">
 84 | 		
 85 | 		<cfif arguments.limit and ArrayLen(loc.results) gte arguments.limit>
 86 | 			<cfbreak>
 87 | 		</cfif>
 88 | 		
 89 | 	    <cfif loc.pos-loc.oldpos gt 0>
 90 | 	        <cfset arrayAppend(loc.results, mid(arguments.str, loc.oldpos, loc.pos-loc.oldpos))>
 91 |         </cfif>
 92 | 		
 93 | 		<cfif arguments.captureDelim>
 94 | 	        <cfset arrayAppend(loc.results, mid(arguments.str, loc.pos, loc.len))>
 95 | 		</cfif>
 96 | 		
 97 |         <cfset loc.oldpos = loc.pos+loc.test.len[1]>
 98 |         <cfset loc.test = REFind(arguments.regex, arguments.str, loc.oldpos+1, 1)>
 99 |         <cfset loc.pos = loc.test.pos[1]>
100 |         <cfset loc.len = loc.test.len[1]>
101 | 		
102 | 	</cfloop>
103 | 	
104 | 	<cfif !arguments.limit OR (arguments.limit and ArrayLen(loc.results) lt arguments.limit)>
105 | 		<cfif (len(arguments.str) - loc.oldpos gte 0) AND loc.oldpos gt 1>
106 | 			<cfif len(arguments.str) - loc.oldpos eq 0>
107 | 				<cfset arrayappend(loc.results, right(arguments.str,1))>
108 | 			<cfelse>
109 | 				<cfset arrayappend(loc.results, right(arguments.str,len(arguments.str)-loc.oldpos+1))>
110 | 			</cfif>
111 | 		</cfif>
112 | 	</cfif>
113 | 
114 | 	<cfreturn loc.results>
115 | </cffunction>
116 | 
117 | 
118 | <cffunction name="method_exists" output="false">
119 | 	<cfargument name="class" type="any" required="true">
120 | 	<cfargument name="method" type="string" required="true">
121 | 	<cfset var loc = {}>
122 | 
123 | 	<cfif IsObject(arguments.class)>
124 | 		<cfset loc.class_methods = getMetaData(arguments.class).functions>
125 | 	<cfelse>
126 | 		<cfset loc.class_methods = getComponentMetaData(arguments.class).functions>
127 | 	</cfif>
128 | 
129 | 	<cfloop array="#loc.class_methods#" index="loc.class_method">
130 | 		<cfif loc.class_method.name eq arguments.method>
131 | 			<cfreturn true>
132 | 		</cfif>
133 | 	</cfloop>
134 | 	
135 | 	<cfreturn false>
136 | </cffunction>
137 | 
138 | 
139 | <cffunction name="preg_match" output="false" hint="
140 |  * Emulates the preg_match function in PHP for returning a regex match along with any backreferences.
141 |  * 
142 |  * @param regex 	 Regular expression. (Required)
143 |  * @param str 	 String to search. (Required)
144 |  * @return Returns an array. 
145 |  * @author Aaron Eisenberger (aaron@x-clothing.com)
146 |  * @version 1, February 15, 2004 
147 | ">
148 | 	<cfargument name="regex" type="string" required="true">
149 | 	<cfargument name="str" type="string" required="true">
150 | 	<cfset var loc = {}>
151 | 	
152 | 	<cfset loc.results = []>
153 | 	<cfset loc.match = "">
154 | 	<cfset loc.x = 1>
155 | 	
156 | 	<cfif REFindNoCase(arguments.regex, arguments.str, 1)>
157 | 		
158 | 		<cfset loc.match = REFindNoCase(arguments.regex, arguments.str, 1, true)>
159 | 		<cfset loc.l = ArrayLen(loc.match.pos)>
160 | 		
161 | 		<cfloop from="1" to="#loc.l#" index="loc.i">
162 | 			
163 | 			<cfset loc.results[loc.i] = "">
164 | 			
165 | 			<cfif loc.match.len[loc.i]>
166 | 				<cfset loc.results[loc.i] = mid(arguments.str, loc.match.pos[loc.i], loc.match.len[loc.i])>
167 | 			</cfif>
168 | 			
169 | 		</cfloop>
170 | 	</cfif>
171 | 	
172 | 	<cfreturn loc.results>
173 | </cffunction>
174 | 
175 | <cffunction name="preg_match_all" output="false" hint="
176 |  * Emulates the preg_match_all function in PHP for returning all regex matches along with their backreferences.
177 |  * 
178 |  * @param regex      Regular expression. (Required)
179 |  * @param str      String to search. (Required)
180 |  * @return Returns an array. 
181 |  * @author Aaron Eisenberger (aaron@x-clothing.com) 
182 |  * @version 1, February 15, 2004 
183 | ">
184 | 	<cfargument name="regex" type="string" required="true">
185 | 	<cfargument name="str" type="string" required="true">
186 | 	<cfset var loc = {}>
187 |     
188 | 	<cfset loc.results = ArrayNew(2)>
189 |     <cfset loc.pos = 1>
190 |     <cfset loc.loop = 1>
191 |     <cfset loc.match = "">
192 |     
193 |     <cfloop condition="REFindNoCase(arguments.regex, arguments.str, loc.pos)">
194 | 		
195 |         <cfset loc.match = REFindNoCase(arguments.regex, arguments.str, loc.pos, true)>
196 | 		<cfset loc.l = ArrayLen(loc.match.pos)>
197 | 		
198 |         <cfloop from="1" to="#loc.l#" index="loc.i">
199 | 			
200 | 			<cfset loc.results[loc.i][loc.loop] = "">
201 | 			
202 |             <cfif loc.match.len[loc.i]>
203 |                 <cfset loc.results[loc.i][loc.loop] = mid(arguments.str, loc.match.pos[loc.i], loc.match.len[loc.i])>
204 |             </cfif>
205 | 			
206 | 		</cfloop>
207 |         
208 | 		<cfset loc.pos = loc.match.pos[1] + loc.match.len[1]>
209 | 		<cfset loc.loop++>
210 | 
211 |     </cfloop>
212 | 	
213 |     <cfreturn loc.results>
214 | </cffunction>
215 | 
216 | <cffunction name="array_shift">
217 | 	<cfargument name="arr" type="array" required="true">
218 | 	<cfset var loc = {}>
219 | 	
220 | 	<cfset loc.ret.value = "">
221 | 	<cfset loc.ret.arr = []>
222 | 	
223 | 	<cfif !ArrayIsEmpty(arguments.arr)>
224 | 		<cfset loc.ret.value = arguments.arr[1]>
225 | 		<cfset ArrayDeleteAt(arguments.arr, 1)>
226 | 		<cfset loc.ret.arr = arguments.arr>
227 | 	</cfif>
228 | 	
229 | 	<cfreturn loc.ret>
230 | </cffunction>


--------------------------------------------------------------------------------
/lib/liquid/LiquidContext.cfc:
--------------------------------------------------------------------------------
  1 | <cfcomponent output="false" hint="Context keeps the variable stack and resolves variables, as well as keywords">
  2 | 
  3 | 	<cfinclude template="utils.cfm">
  4 | 
  5 | 	<cffunction name="init">
  6 | 		<cfargument name="assigns" type="struct" required="false" default="#StructNew()#">
  7 | 		<cfargument name="registers" type="struct" required="false" default="#StructNew()#">
  8 | 				
  9 | 		<cfset this.registers = arguments.registers>
 10 | 		<cfset this.assigns = arguments.assigns>
 11 | 		<cfset this.filterbank = createObject("component", "LiquidFilterbank").init(this)>
 12 | 		<cfset this.environments = {}>
 13 | 		<cfset this.scopes = [this.assigns]>
 14 | 
 15 | 		<cfreturn this>
 16 | 	</cffunction>
 17 | 
 18 | 	<cffunction name="add_filters" hint="Add a filter to the context">
 19 | 		<cfargument name="filter" type="any" required="true">
 20 | 		<cfset this.filterbank.add_filter(arguments.filter)>
 21 | 	</cffunction>
 22 | 
 23 | 	<cffunction name="invoke_method" hint="Invoke the filter that matches given name">
 24 | 		<cfargument name="name" type="string" required="true" hint="The name of the filter">
 25 | 		<cfargument name="value" type="any" required="true" hint="The value to filter">
 26 | 		<cfargument name="args" type="array" required="false" default="#ArrayNew(1)#" hint="Additional arguments for the filter">
 27 | 		<cfreturn this.filterbank.invoke_method(arguments.name, arguments.value, arguments.args)>
 28 | 	</cffunction>
 29 | 
 30 | 	<cffunction name="merge" hint="Merges the given assigns into the current assigns">
 31 | 		<cfargument name="new_assigns" type="struct" required="true">
 32 | 		<cfset StructAppend(this.scopes[1], arguments.new_assigns, true)>
 33 | 	</cffunction>
 34 | 
 35 | 	<cffunction name="push" hint="Push new local scope on the stack.">
 36 | 		
 37 | 		<cfif ArrayIsEmpty(this.scopes)>
 38 | 			<cfreturn false>
 39 | 		</cfif>
 40 | 		<cfset ArrayPrepend(this.scopes, StructNew())>
 41 | 		<cfset this.assigns = this.scopes[1]>
 42 | 		
 43 | 		<cfreturn true>
 44 | 	</cffunction>
 45 | 
 46 | 	<cffunction name="pop" hint="Pops the current scope from the stack.">
 47 | 		
 48 | 		<cfif ArrayLen(this.scopes) eq 1>
 49 | 			<cfset createObject("component", "LiquidException").init('No elements to pop')>
 50 | 		</cfif>
 51 | 		
 52 | 		<cfset ArrayDeleteAt(this.scopes, 1)>
 53 | 		<cfset this.assigns = this.scopes[1]>
 54 | 		<cfif StructIsEmpty(this.assigns)>
 55 | 			<cfreturn "">
 56 | 		</cfif>
 57 | 
 58 | 		<cfreturn true>
 59 | 	</cffunction>
 60 | 
 61 | 	<cffunction name="get" hint="Replaces []">
 62 | 		<cfargument name="key" type="string" required="true">
 63 | 		<cfreturn this.resolve(arguments.key)>
 64 | 	</cffunction>
 65 | 
 66 | 	<cffunction name="set" hint="Replaces []=">
 67 | 		<cfargument name="key" type="string" required="true">
 68 | 		<cfargument name="value" type="any" required="true">
 69 | 		<cfset this.assigns[arguments.key] = arguments.value>
 70 | 	</cffunction>
 71 | 
 72 | 	<cffunction name="has_key" returntype="boolean" hint="Returns true if the given key will properly resolve">
 73 | 		<cfargument name="key" type="string" required="true">
 74 | 		<cfreturn !!len(this.resolve(arguments.key))>
 75 | 	</cffunction>
 76 | 
 77 | 	<cffunction name="resolve" returntype="any" hint="Resolve a key by either returning the appropriate literal or by looking up the appropriate variable. Test for empty has been moved to interpret condition, in LiquidDecisionBlock">
 78 | 		<cfargument name="key" type="string" required="true">
 79 | 		<cfset var loc = {}>
 80 | 
 81 | 		<cfif !len(arguments.key) OR arguments.key eq "null">		
 82 | 			<cfreturn "">
 83 | 		</cfif>
 84 | 	
 85 | 		<cfif !IsNumeric(arguments.key) AND IsBoolean(arguments.key) and arguments.key eq "true">
 86 | 			<cfreturn true>
 87 | 		</cfif>
 88 | 		
 89 | 		<cfif !IsNumeric(arguments.key) AND IsBoolean(arguments.key) and arguments.key eq "false">
 90 | 			<cfreturn false>
 91 | 		</cfif>
 92 | 		
 93 | 		<cfset loc.temp = preg_match("^'(.*)'$", arguments.key)>
 94 | 		<cfif !ArrayIsEmpty(loc.temp)>
 95 | 			<cfreturn loc.temp[2]>
 96 | 		</cfif>
 97 | 
 98 | 		<cfset loc.temp = preg_match('^"(.*)"$', arguments.key)>
 99 | 		<cfif !ArrayIsEmpty(loc.temp)>
100 | 			<cfreturn loc.temp[2]>
101 | 		</cfif>
102 | 
103 | 		<cfset loc.temp = preg_match('^(\d+)$', arguments.key)>
104 | 		<cfif !ArrayIsEmpty(loc.temp)>
105 | 			<cfreturn loc.temp[2]>
106 | 		</cfif>
107 | 
108 | 		<cfset loc.temp = preg_match('^(\d[\d\.]+)$', arguments.key)>
109 | 		<cfif !ArrayIsEmpty(loc.temp)>
110 | 			<cfreturn loc.temp[2]>
111 | 		</cfif>
112 | 
113 | 		<cfreturn this.parse(arguments.key)>		
114 | 	</cffunction>
115 | 
116 | 	<cffunction name="fetch" hint="Fetches the current key in all the scopes">
117 | 		<cfargument name="key" type="string" required="true">
118 | 		<cfset var loc = {}>
119 | 		
120 | 		<cfloop collection="#this.environments#" item="loc.environment">
121 | 			<cfif StructKeyExists(loc.environment, arguments.key)>
122 | 				<cfreturn loc.environment[arguments.key]>
123 | 			</cfif>
124 | 		</cfloop>
125 | 
126 | 		<cfloop array="#this.scopes#" index="loc.scope">
127 | 
128 | 			<cfif StructKeyExists(loc.scope, arguments.key)>
129 | 
130 | 				<cfset loc.obj = loc.scope[arguments.key]>
131 | 				<cfif IsInstanceof(loc.obj, "LiquidDrop")>
132 | 					<cfset loc.obj.setContext(this)>
133 | 				</cfif>
134 | 				<cfreturn loc.obj>
135 | 			</cfif>
136 | 
137 | 		</cfloop>
138 | 		
139 | 		<cfreturn "">
140 | 	</cffunction>
141 | 
142 | 	<cffunction name="parse" returntype="any" hint="Resolved the namespaced queries gracefully.">
143 | 		<cfargument name="key" type="string" required="true">
144 | 		<cfset var loc = {}>
145 | 		
146 | 		<!--- Support [0] style array indicies --->
147 | 		<cfif ReFindNoCase("|\[[0-9]+\]|", arguments.key)>
148 | 			<cfset arguments.key = ReReplaceNoCase(arguments.key, "|\[([0-9]+)\]|", ".\1")>
149 | 		</cfif>
150 | 
151 | 		<cfset loc.parts = ListToArray(arguments.key, application.LiquidConfig.LIQUID_VARIABLE_ATTRIBUTE_SEPARATOR)>
152 | 		<cfset loc.temp = array_shift(loc.parts)>
153 | 		<cfset loc.parts = loc.temp.arr>
154 | 		<cfset loc.object = this.fetch(loc.temp.value)>
155 | 
156 | 		<cfif isObject(loc.object)>
157 | 			<cfif !IsInstanceof(loc.object, "LiquidDrop") AND !StructKeyExists(loc.object, "toLiquid")>
158 | 				<cfthrow type="LiquidError" message="Method 'toLiquid' not exists!">
159 | 			</cfif>
160 | 			<cfset loc.object = loc.object.toLiquid()>
161 | 		</cfif>
162 | 
163 | 		<cfif !IsSimpleValue(loc.object) OR len(loc.object)>
164 | 
165 | 			<cfloop condition="#ArrayLen(loc.parts)# gt 0">
166 | 
167 | 				<cfif IsInstanceOf(loc.object, "LiquidDrop")>
168 | 					<cfset loc.object.setContext(this)>
169 | 				</cfif>
170 | 				
171 | 				<cfset loc.temp = array_shift(loc.parts)>
172 | 				<cfset loc.parts = loc.temp.arr>
173 | 				<cfset loc.next_part_name = loc.temp.value>
174 | 
175 | 				<cfif !IsObject(loc.object)>
176 | 				
177 | 					<cfif
178 | 						loc.next_part_name eq 'size'
179 | 						AND ArrayLen(loc.parts) eq 0
180 | 						AND (
181 | 								(IsStruct(loc.object) || IsObject(loc.object)) AND !StructKeyExists(loc.object, "size")
182 | 								OR (IsArray(loc.object) || IsQuery(loc.object))
183 | 						)>
184 | 						<cfif IsArray(loc.object)>
185 | 							<cfreturn ArrayLen(loc.object)>
186 | 						<cfelseif IsQuery(loc.object)>
187 | 							<cfreturn loc.object.recordcount>
188 | 						<cfelseif IsSimpleValue(loc.object)>
189 | 							<cfreturn len(loc.object)>
190 | 						<cfelseif IsStruct(loc.object)>
191 | 							<cfreturn StructCount(loc.object)>
192 | 						</cfif>
193 | 					</cfif>
194 | 					<cfif StructKeyExists(loc.object, loc.next_part_name)>
195 | 						<cfset loc.object = loc.object[loc.next_part_name]>
196 | 					<cfelse>
197 | 						<cfreturn "">
198 | 					</cfif>
199 | 				
200 | 				<cfelseif isObject(loc.object)>
201 | 				
202 | 					<cfif IsInstanceOf(loc.object, "LiquidDrop")>
203 | 					
204 | 						<cfset loc.object = loc.object.invokeDrop(loc.next_part_name)>
205 | 
206 | 					<cfelseif StructKeyExists(loc.object, application.LiquidConfig.LIQUID_HAS_PROPERTY_METHOD) AND IsCustomFunction(loc.next_part_name)>
207 | 
208 | 						<cfset loc.args = {method = loc.next_part_name}>
209 | 						<cfinvoke component="#loc.object#" method="#application.LiquidConfig.LIQUID_GET_PROPERTY_METHOD#" argumentcollection="#loc.args#" returnvariable="loc.object">
210 | 
211 | 					<cfelse>
212 | 					
213 | 						<!--- if it's just a regular object, attempt to access a property --->
214 | 						<cfif !StructKeyExists(loc.object, loc.next_part_name)>
215 | 							<cfreturn "">	
216 | 						</cfif>
217 | 						<cfinvoke component="#loc.object#" method="#loc.next_part_name#" returnvariable="loc.object">
218 | 					</cfif>
219 | 					
220 | 				</cfif>
221 | 
222 | 				<cfif isObject(loc.object) AND StructKeyExists(loc.object, "toLiquid")>
223 | 					<cfset loc.object = loc.object.toLiquid()>
224 | 				</cfif>
225 | 
226 | 			</cfloop>
227 | 
228 | 			<cfreturn loc.object>
229 | 			
230 | 		<cfelse>
231 | 
232 | 			<cfreturn "">
233 | 			
234 | 		</cfif>
235 | 	</cffunction>
236 | 	
237 | 	<cffunction name="inspect">
238 | 		<cfreturn this>
239 | 	</cffunction>
240 | 	
241 | </cfcomponent>


--------------------------------------------------------------------------------
/tests/tests/IfElseTest.cfc:
--------------------------------------------------------------------------------
  1 | <cfcomponent output="false" extends="cfml-liquid.tests.Test">
  2 | 
  3 | 	<cffunction name="setup">
  4 | 		<cfset loc.template = application.liquid.template()>
  5 | 	</cffunction>
  6 | 
  7 | 	<cffunction name="test_if">
  8 | 		<cfset loc.e = "  ">
  9 | 		<cfset loc.t = " {% if false %} this text should not go into the output {% endif %} ">
 10 | 		<cfset assert_template_result(loc.e, loc.t, loc.template)>
 11 | 
 12 | 		<cfset loc.e = "  this text should go into the output  ">
 13 | 		<cfset loc.t = " {% if true %} this text should go into the output {% endif %} ">
 14 | 		<cfset assert_template_result(loc.e, loc.t, loc.template)>
 15 | 
 16 | 		<cfset loc.e = "  you rock ?">
 17 | 		<cfset loc.t = "{% if false %} you suck {% endif %} {% if true %} you rock {% endif %}?">
 18 | 		<cfset assert_template_result(loc.e, loc.t, loc.template)>
 19 | 	</cffunction>
 20 | 		
 21 | 	<cffunction name="test_if_else">
 22 | 		<cfset loc.e = " YES ">
 23 | 		<cfset loc.t = "{% if false %} NO {% else %} YES {% endif %}">
 24 | 		<cfset assert_template_result(loc.e, loc.t, loc.template)>
 25 | 
 26 | 		<cfset loc.e = " YES ">
 27 | 		<cfset loc.t = "{% if true %} YES {% else %} NO {% endif %}">
 28 | 		<cfset assert_template_result(loc.e, loc.t, loc.template)>
 29 | 
 30 | 		<cfset loc.e = " YES ">
 31 | 		<cfset loc.t = "{% if ""foo"" %} YES {% else %} NO {% endif %}">
 32 | 		<cfset assert_template_result(loc.e, loc.t, loc.template)>
 33 | 	</cffunction>
 34 | 		
 35 | 	<cffunction name="test_if_boolean">
 36 | 		<cfset loc.a = {var = true}>
 37 | 		<cfset loc.e = " YES ">
 38 | 		<cfset loc.t = "{% if var %} YES {% endif %}">
 39 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
 40 | 	</cffunction>
 41 | 
 42 | 	<cffunction name="test_if_from_variable">
 43 | 		<cfset loc.a = {var = false}>
 44 | 		<cfset loc.e = "">
 45 | 		<cfset loc.t = "{% if var %} NO {% endif %}">
 46 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
 47 | 
 48 | 		<cfset loc.a = {var = ""}>
 49 | 		<cfset loc.e = "">
 50 | 		<cfset loc.t = "{% if var %} NO {% endif %}">
 51 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
 52 | 
 53 | 		<cfset loc.a = {foo = {bar = "false"}}>
 54 | 		<cfset loc.e = "">
 55 | 		<cfset loc.t = "{% if foo.bar %} NO {% endif %}">
 56 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
 57 | 
 58 | 		<cfset loc.a = {foo = {}}>
 59 | 		<cfset loc.e = "">
 60 | 		<cfset loc.t = "{% if foo.bar %} NO {% endif %}">
 61 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
 62 | 
 63 | 		<cfset loc.a = {foo = ""}>
 64 | 		<cfset loc.e = "">
 65 | 		<cfset loc.t = "{% if foo.bar %} NO {% endif %}">
 66 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
 67 | 
 68 | 		<cfset loc.a = {var = "text"}>
 69 | 		<cfset loc.e = ' YES '>
 70 | 		<cfset loc.t = "{% if var %} YES {% endif %}">
 71 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
 72 | 	
 73 | 		<cfset loc.a = {var = "true"}>
 74 | 		<cfset loc.e = ' YES '>
 75 | 		<cfset loc.t = "{% if var %} YES {% endif %}">
 76 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
 77 | 
 78 | 		<cfset loc.a = {var = 1}>
 79 | 		<cfset loc.e = ' YES '>
 80 | 		<cfset loc.t = "{% if var %} YES {% endif %}">
 81 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
 82 | 
 83 | 		<cfset loc.e = ' YES '>
 84 | 		<cfset loc.t = "{% if ""foo"" %} YES {% endif %}">
 85 | 		<cfset assert_template_result(loc.e, loc.t, loc.template)>
 86 | 
 87 | 		<cfset loc.a = {foo = {bar = true}}>
 88 | 		<cfset loc.e = ' YES '>
 89 | 		<cfset loc.t = "{% if foo.bar %} YES {% endif %}">
 90 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
 91 | 
 92 | 		<cfset loc.a = {foo = {bar = "text"}}>
 93 | 		<cfset loc.e = ' YES '>
 94 | 		<cfset loc.t = "{% if foo.bar %} YES {% endif %}">
 95 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
 96 | 
 97 | 		<cfset loc.a = {foo = {bar = 1}}>
 98 | 		<cfset loc.e = ' YES '>
 99 | 		<cfset loc.t = "{% if foo.bar %} YES {% endif %}">
100 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
101 | 		
102 | 		<cfset loc.a = {var = false}>
103 | 		<cfset loc.e = ' YES '>
104 | 		<cfset loc.t = "{% if var %} NO {% else %} YES {% endif %}">
105 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
106 | 
107 | 		<cfset loc.a = {var = "null"}>
108 | 		<cfset loc.e = ' YES '>
109 | 		<cfset loc.t = "{% if var %} NO {% else %} YES {% endif %}">
110 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
111 | 
112 | 		<cfset loc.a = {var = true}>
113 | 		<cfset loc.e = ' YES '>
114 | 		<cfset loc.t = "{% if var %} YES {% else %} NO {% endif %}">
115 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
116 | 
117 | 		<cfset loc.a = {var = "text"}>
118 | 		<cfset loc.e = ' YES '>
119 | 		<cfset loc.t = "{% if ""foo"" %} YES {% else %} NO {% endif %}">
120 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
121 | 
122 | 
123 | 		<cfset loc.a = {foo = {bar = false}}>
124 | 		<cfset loc.e = ' YES '>
125 | 		<cfset loc.t = "{% if foo.bar %} NO {% else %} YES {% endif %}">
126 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
127 | 
128 | 		<cfset loc.a = {foo = {bar = true}}>
129 | 		<cfset loc.e = ' YES '>
130 | 		<cfset loc.t = "{% if foo.bar %} YES {% else %} NO {% endif %}">
131 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
132 | 
133 | 		<cfset loc.a = {foo = {bar = "text"}}>
134 | 		<cfset loc.e = ' YES '>
135 | 		<cfset loc.t = "{% if foo.bar %} YES {% else %} NO {% endif %}">
136 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
137 | 
138 | 		<cfset loc.a = {notbar = true}>
139 | 		<cfset loc.e = ' YES '>
140 | 		<cfset loc.t = "{% if foo.bar %} NO {% else %} YES {% endif %}">
141 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
142 | 		
143 | 		<cfset loc.a = {foo = {}}>
144 | 		<cfset loc.e = ' YES '>
145 | 		<cfset loc.t = "{% if foo.bar %} NO {% else %} YES {% endif %}">
146 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
147 | 		
148 | 		<cfset loc.a = {notfoo = {bar = true}}>
149 | 		<cfset loc.e = ' YES '>
150 | 		<cfset loc.t = "{% if foo.bar %} NO {% else %} YES {% endif %}">
151 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
152 | 	</cffunction>
153 | 
154 | 	<cffunction name="test_nested_if">
155 | 		<cfset loc.e = ''>
156 | 		<cfset loc.t = "{% if false %}{% if false %} NO {% endif %}{% endif %}">
157 | 		<cfset assert_template_result(loc.e, loc.t, loc.template)>
158 | 		
159 |  		<cfset loc.e = ''>
160 | 		<cfset loc.t = "{% if false %}{% if true %} NO {% endif %}{% endif %}">
161 | 		<cfset assert_template_result(loc.e, loc.t, loc.template)>
162 | 
163 | 		<cfset loc.e = ''>
164 | 		<cfset loc.t = "{% if true %}{% if false %} NO {% endif %}{% endif %}">
165 | 		<cfset assert_template_result(loc.e, loc.t, loc.template)>
166 | 
167 | 		<cfset loc.e = ' YES '>
168 | 		<cfset loc.t = "{% if true %}{% if true %} YES {% endif %}{% endif %}">
169 | 		<cfset assert_template_result(loc.e, loc.t, loc.template)>
170 | 
171 | 		
172 | 		<cfset loc.e = ' YES '>
173 | 		<cfset loc.t = "{% if true %}{% if true %} YES {% else %} NO {% endif %}{% else %} NO {% endif %}">
174 | 		<cfset assert_template_result(loc.e, loc.t, loc.template)>
175 | 		
176 | 		<cfset loc.e = ' YES '>
177 | 		<cfset loc.t = "{% if true %}{% if false %} NO {% else %} YES {% endif %}{% else %} NO {% endif %}">
178 | 		<cfset assert_template_result(loc.e, loc.t, loc.template)>
179 | 		
180 | 		<cfset loc.e = ' YES '>
181 | 		<cfset loc.t = "{% if false %}{% if true %} NO {% else %} NONO {% endif %}{% else %} YES {% endif %}">
182 | 		<cfset assert_template_result(loc.e, loc.t, loc.template)>
183 | 	</cffunction>
184 |   
185 | 	<cffunction name="test_comparisons_on_null">
186 | 		<cfset loc.a = {}>
187 | 		<cfset loc.e = ''>
188 | 		
189 | 		<cfset loc.t = "{% if null < 10 %} NO {% endif %}">
190 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
191 | 		
192 | 		<cfset loc.t = "{% if null <= 10 %} NO {% endif %}">
193 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
194 | 		
195 | 		<cfset loc.t = "{% if null >= 10 %} NO {% endif %}">
196 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
197 | 		
198 | 		<cfset loc.t = "{% if null > 10 %} NO {% endif %}">
199 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
200 | 
201 | 		<cfset loc.t = "{% if 10 < null %} NO {% endif %}">
202 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
203 | 
204 | 		<cfset loc.t = "{% if 10 <= null %} NO {% endif %}">
205 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
206 | 		
207 | 		<cfset loc.t = "{% if 10 >= null %} NO {% endif %}">
208 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
209 | 		
210 | 		<cfset loc.t = "{% if 10 > null %} NO {% endif %}">
211 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
212 | 	</cffunction>
213 | 
214 | 	<cffunction name="test_syntax_error_no_variable">
215 | 		<cfset loc.e = ''>
216 | 		<cfset loc.t = "{% if jerry == 1 %}">
217 | 		<cfset loc.e = "if tag was never closed">
218 | 		<cfset loc.r = raised('assert_template_result(loc.e, loc.t, loc.template)')>
219 | 		<cfset assert('loc.e eq loc.r.message')>
220 | 	</cffunction>
221 |  
222 | 	<cffunction name="test_elsif">
223 | 		<cfset loc.e = "Hello">
224 | 		<cfset loc.t = "{% assign test = 'hello' %}{% if test == 'bye' %}Bye{% elsif test == 'hello' %}Hello{% elseif test == 'ciao' %}Ciao{% else %}Rude{% endif %}">
225 | 		<cfset assert_template_result(loc.e, loc.t, loc.template)>
226 | 		
227 | 		<cfset loc.e = "Bye">
228 | 		<cfset loc.t = "{% assign test = 'bye' %}{% if test == 'bye' %}Bye{% elsif test == 'hello' %}Hello{% elseif test == 'ciao' %}Ciao{% else %}Rude{% endif %}">
229 | 		<cfset assert_template_result(loc.e, loc.t, loc.template)>
230 | 		
231 | 		<cfset loc.e = "Ciao">
232 | 		<cfset loc.t = "{% assign test = 'ciao' %}{% if test == 'bye' %}Bye{% elsif test == 'hello' %}Hello{% elseif test == 'ciao' %}Ciao{% else %}Rude{% endif %}">
233 | 		<cfset assert_template_result(loc.e, loc.t, loc.template)>
234 | 		
235 | 		<cfset loc.e = "Rude">
236 | 		<cfset loc.t = "{% assign test = 'nothing' %}{% if test == 'bye' %}Bye{% elsif test == 'hello' %}Hello{% elseif test == 'ciao' %}Ciao{% else %}Rude{% endif %}">
237 | 		<cfset assert_template_result(loc.e, loc.t, loc.template)>
238 | 	</cffunction>
239 | 
240 | 	<cffunction name="test_multiple_conditions">
241 | 		<cfset loc.e = "no">
242 | 		<cfset loc.t = "{% assign test1 = 'test1' %}{% assign test2 = 'test2' %}{% if test1 == 'test1' and test2 != 'test2' %}yes{% else %}no{% endif %}">
243 | 		<cfset assert_template_result(loc.e, loc.t, loc.template)>
244 | 	</cffunction>
245 | 
246 | </cfcomponent>


--------------------------------------------------------------------------------
/lib/liquid/LiquidStandardFilters.cfc:
--------------------------------------------------------------------------------
  1 | <cfcomponent output="false" hint="A selection of standard filters">
  2 | 
  3 | 	<cffunction name="init">
  4 | 		<cfreturn this>
  5 | 	</cffunction>
  6 | 	
  7 | 	<cffunction name="append" hint="append a string">
  8 | 		<cfargument name="input" type="any" required="true">
  9 | 		<cfargument name="str" type="any" required="false" default="">
 10 | 		
 11 | 		<cfset arguments.input = arguments.input.toString()>
 12 | 		<cfset arguments.str = arguments.str.toString()>
 13 | 
 14 | 		<cfreturn arguments.input & arguments.str>
 15 | 	</cffunction>
 16 | 	
 17 | 	<cffunction name="prepend" hint="prepend a string">
 18 | 		<cfargument name="input" type="any" required="true">
 19 | 		<cfargument name="str" type="any" required="false" default="">
 20 | 		
 21 | 		<cfset arguments.input = arguments.input.toString()>
 22 | 		<cfset arguments.str = arguments.str.toString()>
 23 | 
 24 | 		<cfreturn arguments.str & arguments.input>
 25 | 	</cffunction>
 26 | 	
 27 | 	<cffunction name="capitalize" hint="Capitalize words in the input sentence">
 28 | 		<cfargument name="input" type="any" required="true">
 29 | 		
 30 | 		<cfset arguments.input = arguments.input.toString()>
 31 | 		
 32 | 		<cfreturn rereplace(arguments.input, "\b(\w)","\u\1","all")>
 33 | 	</cffunction>
 34 | 	
 35 | 	<cffunction name="date_format" hint="Formats a date">
 36 | 		<cfargument name="input" type="any" required="true">
 37 | 		<cfargument name="format" type="any" required="false" default="mm/dd/yyyy">
 38 | 		
 39 | 		<cfset arguments.input = arguments.input.toString()>
 40 | 		<cfset arguments.format = arguments.format.toString()>
 41 | 		
 42 | 		<cfif IsDate(arguments.input) AND len(arguments.format)>
 43 | 			<cfset arguments.input = Dateformat(arguments.input, arguments.format)>
 44 | 		</cfif>
 45 | 		
 46 | 		<cfreturn arguments.input>
 47 | 	</cffunction>
 48 | 	
 49 | 	<cffunction name="divided_by" hint="division">
 50 | 		<cfargument name="input" type="any" required="true">
 51 | 		<cfargument name="operand" type="any" required="false" default="1">
 52 | 		
 53 | 		<cfset arguments.input = val(arguments.input)>
 54 | 		<cfset arguments.operand = val(arguments.operand)>
 55 | 		
 56 | 		<cfif arguments.operand eq 0>
 57 | 			<cfreturn 0>
 58 | 		</cfif>
 59 | 		
 60 | 		<cfreturn arguments.input / arguments.operand>
 61 | 	</cffunction>
 62 | 	
 63 | 	<cffunction name="downcase" hint="Convert an input to lowercase">
 64 | 		<cfargument name="input" type="any" required="true">
 65 | 		
 66 | 		<cfset arguments.input = arguments.input.toString()>
 67 | 		<cfset arguments.input = lcase(arguments.input)>
 68 | 
 69 | 		<cfreturn arguments.input>
 70 | 	</cffunction>
 71 | 	
 72 | 	<cffunction name="escape" hint="escape a string">
 73 | 		<cfargument name="input" type="any" required="true">
 74 | 		
 75 | 		<cfset arguments.input = arguments.input.toString()>
 76 | 
 77 | 		<cfreturn HtmlEditFormat(arguments.input)>
 78 | 	</cffunction>
 79 | 	
 80 | 	<cffunction name="first" hint="Returns the first element of an array">
 81 | 		<cfargument name="input" type="any" required="true">
 82 | 
 83 | 		<cfif IsArray(arguments.input)>
 84 | 			<cfif !ArrayIsEmpty(arguments.input)>
 85 | 				<cfset arguments.input = arguments.input[1]>
 86 | 			<cfelse>
 87 | 				<cfset arguments.input = "">
 88 | 			</cfif>
 89 | 		</cfif>
 90 | 		
 91 | 		<cfreturn arguments.input>
 92 | 	</cffunction>
 93 | 	
 94 | 	<cffunction name="join" hint="Joins elements of an array with a given character between them">
 95 | 		<cfargument name="input" type="any" required="true">
 96 | 		<cfargument name="glue" type="any" required="false" default=" ">
 97 | 		
 98 | 		<cfif IsArray(arguments.input)>
 99 | 			<cfset arguments.glue = arguments.glue.toString()>
100 | 			<cfset arguments.input = ArrayToList(arguments.input, arguments.glue)>
101 | 		</cfif>
102 | 		
103 | 		<cfreturn arguments.input>
104 | 	</cffunction>
105 | 
106 | 	<cffunction name="last" hint="Returns the last element of an array">
107 | 		<cfargument name="input" type="any" required="true">
108 | 		
109 | 		<cfif IsArray(arguments.input)>
110 | 			<cfif !ArrayIsEmpty(arguments.input)>
111 | 				<cfset arguments.input = arguments.input[ArrayLen(arguments.input)]>
112 | 			<cfelse>
113 | 				<cfset arguments.input = "">
114 | 			</cfif>
115 | 		</cfif>
116 | 		
117 | 		<cfreturn arguments.input>
118 | 	</cffunction>
119 | 	
120 | 	<cffunction name="minus" hint="subtraction">
121 | 		<cfargument name="input" type="any" required="true">
122 | 		<cfargument name="operand" type="any" required="false" default="0">
123 | 		<cfreturn val(arguments.input) - val(arguments.operand)>	
124 | 	</cffunction>
125 | 	
126 | 	<cffunction name="modulo" hint="modulo">
127 | 		<cfargument name="input" type="any" required="true">
128 | 		<cfargument name="operand" type="any" required="false" default="1">
129 | 		<cfreturn val(arguments.input) % val(arguments.operand)>	
130 | 	</cffunction>
131 | 	
132 | 	<cffunction name="newline_to_br" hint="Replace each newline (\n) with html break">
133 | 		<cfargument name="input" type="any" required="true">
134 | 		
135 | 		<cfset arguments.input = arguments.input.toString()>
136 | 		<cfset arguments.input = ReReplaceNoCase(arguments.input, "\n\r|\\n\\r|\n|\\n", "<br/>", "all")>
137 | 		
138 | 		<cfreturn arguments.input>
139 | 	</cffunction>
140 | 	
141 | 	<cffunction name="plus" hint="addition">
142 | 		<cfargument name="input" type="any" required="false">
143 | 		<cfargument name="operand" type="any" required="false" default="0">
144 | 		<cfreturn val(arguments.input) + val(arguments.operand)>		
145 | 	</cffunction>
146 | 	
147 | 	<cffunction name="remove" hint="remove each occurrence">
148 | 		<cfargument name="input" type="any" required="true">
149 | 		<cfargument name="string" type="any" required="false" default="">
150 | 		
151 | 		<cfset arguments.input = arguments.input.toString()>
152 | 		<cfset arguments.string = arguments.string.toString()>
153 | 		
154 | 		<cfreturn ReplaceNoCase(arguments.input, arguments.string, "", "all")>
155 | 	</cffunction>
156 | 	
157 | 	<cffunction name="remove_first" hint="remove each occurrence">
158 | 		<cfargument name="input" type="any" required="true">
159 | 		<cfargument name="string" type="any" required="false" default="">
160 | 		
161 | 		<cfset arguments.input = arguments.input.toString()>
162 | 		<cfset arguments.string = arguments.string.toString()>
163 | 		
164 | 		<cfreturn ReplaceNoCase(arguments.input, arguments.string, "", "one")>
165 | 	</cffunction>
166 | 	
167 | 	<cffunction name="_replace" hint="replace each occurrence">
168 | 		<cfargument name="input" type="any" required="true">
169 | 		<cfargument name="string1" type="any" required="false" default="">
170 | 		<cfargument name="string2" type="any" required="false" default="">
171 | 		
172 | 		<cfset arguments.input = arguments.input.toString()>
173 | 		<cfset arguments.string1 = arguments.string1.toString()>
174 | 		<cfset arguments.string2 = arguments.string2.toString()>
175 | 		
176 | 		<cfreturn ReplaceNoCase(arguments.input, arguments.string1, arguments.string2, "all")>
177 | 	</cffunction>
178 | 	
179 | 	<cffunction name="replace_first" hint="replace the first occurrence">
180 | 		<cfargument name="input" type="any" required="true">
181 | 		<cfargument name="string1" type="any" required="false" default="">
182 | 		<cfargument name="string2" type="any" required="false" default="">
183 | 		
184 | 		<cfset arguments.input = arguments.input.toString()>
185 | 		<cfset arguments.string1 = arguments.string1.toString()>
186 | 		<cfset arguments.string2 = arguments.string2.toString()>
187 | 		
188 | 		<cfreturn ReplaceNoCase(arguments.input, arguments.string1, arguments.string2, "one")>
189 | 	</cffunction>
190 | 
191 | 	<cffunction name="size" hint="Return the size of an array or of an string or hash">
192 | 		<cfargument name="input" type="any" required="true">
193 | 		<cfset var ret = arguments.input>
194 | 		
195 | 		<cfif isSimpleValue(arguments.input)>
196 | 			<cfset ret = len(arguments.input)>
197 | 		<cfelseif isArray(arguments.input)>
198 | 			<cfset ret = ArrayLen(arguments.input)>
199 | 		<cfelseif isStruct(arguments.input)>
200 | 			<cfset ret = StructCount(arguments.input)>
201 | 		</cfif>
202 | 		
203 | 		<cfreturn ret>
204 | 	</cffunction>
205 | 	
206 | 	<cffunction name="sort" hint="sorts an array">
207 | 		<cfargument name="input" type="any" required="true">
208 | 		<cfargument name="type" type="any" required="false" default="textnocase">
209 | 		<cfargument name="order" type="any" required="false" default="asc">
210 | 		
211 | 		<cfif IsArray(arguments.input)>
212 | 		
213 | 			<cfset arguments.type = arguments.type.toString()>
214 | 			<cfset arguments.order = arguments.order.toString()>
215 | 			
216 | 			<cfif !ListFindNoCase("numeric,text,textnocase", arguments.type)>
217 | 				<cfset arguments.type = "textnocase">
218 | 			</cfif>
219 | 			
220 | 			<cfif !ListFindNoCase("asc,desc", arguments.order)>
221 | 				<cfset arguments.order = "asc">
222 | 			</cfif>
223 | 			
224 | 			<cfset ArraySort(arguments.input, arguments.type, arguments.order)>
225 | 		
226 | 		</cfif>
227 | 		
228 | 		<cfreturn arguments.input>
229 | 	</cffunction>
230 | 
231 | 	<cffunction name="split" hint="Split input string into an array of substrings separated by given pattern.">
232 | 		<cfargument name="input" type="any" required="true">
233 | 		<cfargument name="pattern" type="any" required="false" default=" ">
234 | 		
235 | 		<cfset arguments.input = arguments.input.toString()>
236 | 		<cfset arguments.pattern = arguments.pattern.toString()>
237 | 
238 | 		<cfreturn ListToArray(arguments.input, arguments.pattern)>
239 | 	</cffunction>
240 | 
241 | 	<cffunction name="strip_html" hint="Removes html tags from text">
242 | 		<cfargument name="input" type="any" required="true">
243 | 		
244 | 		<cfset arguments.input = arguments.input.toString()>
245 | 		<cfset arguments.input = REReplaceNoCase(arguments.input, "<\ *[a-z].*?>", "", "all")>
246 | 		<cfset arguments.input = REReplaceNoCase(arguments.input, "<\ */\ *[a-z].*?>", "", "all")>
247 | 		
248 | 		<cfreturn arguments.input>
249 | 	</cffunction>
250 | 
251 | 	<cffunction name="strip_newlines" hint="Strip all newlines (\n, \r) from string">
252 | 		<cfargument name="input" type="any" required="true">
253 | 		<cfargument name="replacement" type="any" required="false" default="">
254 | 		
255 | 		<cfset arguments.input = arguments.input.toString()>
256 | 
257 | 		<cfreturn ReReplaceNoCase(arguments.input, "\n\r|\\n\\r|\n|\\n", arguments.replacement, "all")>
258 | 	</cffunction>
259 | 	
260 | 	<cffunction name="time_format" hint="Formats a time">
261 | 		<cfargument name="input" type="any" required="true">
262 | 		<cfargument name="format" type="any" required="false" default="hh:mm tt">
263 | 
264 | 		<cfset arguments.input = arguments.input.toString()>
265 | 		<cfset arguments.format = arguments.format.toString()>
266 | 
267 | 		<cfif IsValid("time", arguments.input) AND len(arguments.format)>
268 | 			<cfreturn Timeformat(arguments.input, arguments.format)>
269 | 		</cfif>
270 | 
271 | 		<cfreturn arguments.input>
272 | 	</cffunction>
273 | 	
274 | 	<cffunction name="times" hint="multiplication">
275 | 		<cfargument name="input" type="any" required="true">
276 | 		<cfargument name="operand" type="any" required="false" default="1">
277 | 		<cfreturn val(arguments.input) * val(arguments.operand)>		
278 | 	</cffunction>
279 | 	
280 | 	<cffunction name="truncate" hint="Truncate a string down to x characters">
281 | 		<cfargument name="input" type="any" required="true">
282 | 		<cfargument name="count" type="any" required="false" default="100">
283 | 		<cfargument name="overflow" type="string" required="false" default="&hellip;">
284 | 		
285 | 		<cfset arguments.input = arguments.input.toString()>
286 | 		<cfset arguments.count = fix(val(arguments.count))>
287 | 		<cfset arguments.overflow = arguments.overflow.toString()>
288 | 		
289 | 		<cfif Len(arguments.input) gt arguments.count>
290 | 			<cfset arguments.input = Left(arguments.input, arguments.count) & arguments.overflow>
291 | 		</cfif>
292 | 		
293 | 		<cfreturn arguments.input>
294 | 	</cffunction>
295 | 
296 | 	<cffunction name="truncatewords" hint="Truncate string down to x words">
297 | 		<cfargument name="input" type="any" required="true">
298 | 		<cfargument name="words" type="any" required="false" default="3">
299 | 		<cfargument name="overflow" type="string" required="false" default="&hellip;">
300 | 		<cfset var loc = {}>
301 | 		<cfset loc.delim = " ">
302 | 		
303 | 		<cfset arguments.input = arguments.input.toString()>
304 | 		<cfset arguments.words = abs(fix(val(arguments.words)))>
305 | 		
306 | 		<cfif ListLen(arguments.input, loc.delim) gt arguments.words>
307 | 			<cfset arguments.input = ListToArray(arguments.input, loc.delim)>
308 | 			<cfset loc.a = createObject("java", "java.util.ArrayList").Init(arguments.input)>
309 | 			<cfset arguments.input = loc.a.subList(0, arguments.words)>
310 | 			<cfset arguments.input = ArrayToList(arguments.input, loc.delim) & arguments.overflow>
311 | 		</cfif>
312 | 
313 | 		<cfreturn arguments.input>
314 | 	</cffunction>
315 | 	
316 | 	<cffunction name="truncate_words" hint="alias for truncatewords">
317 | 		<cfargument name="input" type="any" required="true">
318 | 		<cfargument name="words" type="any" required="false" default="3">
319 | 		<cfargument name="overflow" type="string" required="false" default="&hellip;">
320 | 		<cfreturn this.truncatewords(argumentCollection=arguments)>
321 | 	</cffunction>
322 | 
323 | 	<cffunction name="upcase" hint="Convert an input to uppercase">
324 | 		<cfargument name="input" type="any" required="true">
325 | 		
326 | 		<cfset arguments.input = arguments.input.toString()>
327 | 		<cfreturn ucase(arguments.input)>
328 | 	</cffunction>
329 | 
330 | </cfcomponent>


--------------------------------------------------------------------------------
/tests/tests/StandardFilterTest.cfc:
--------------------------------------------------------------------------------
  1 | <cfcomponent output="false" extends="cfml-liquid.tests.Test">
  2 | 
  3 | 	<cffunction name="setup">
  4 | 		<cfset loc.template = application.liquid.template()>
  5 | 	</cffunction>
  6 | 	
  7 | 	<cffunction name="test_append">
  8 | 		<cfset loc.a["var"] = "foo">
  9 | 		<cfset loc.e = "foobar">
 10 | 		<cfset loc.t = "{{ var | append:'bar' }}">
 11 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
 12 | 	</cffunction>
 13 | 	
 14 | 	<cffunction name="test_capitalize">
 15 | 		<!--- empty string --->
 16 | 		<cfset loc.a["var"] = "">
 17 | 		<cfset loc.e = "">
 18 | 		<cfset loc.t = "{{ var | capitalize }}">
 19 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
 20 | 		
 21 | 		<!--- one word --->
 22 | 		<cfset loc.a["var"] = "tony">
 23 | 		<cfset loc.e = "Tony">
 24 | 		<cfset loc.t = "{{ var | capitalize }}">
 25 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
 26 | 		
 27 | 		<!--- multiple words --->
 28 | 		<cfset loc.a["var"] = "liquid is great">
 29 | 		<cfset loc.e = "Liquid is great">
 30 | 		<cfset loc.t = "{{ var | capitalize }}">
 31 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
 32 | 	</cffunction>
 33 | 	
 34 | 	<cffunction name="test_date_format">
 35 | 		<!--- valid date --->
 36 | 		<cfset loc.a["var"] = "08/14/2012">
 37 | 		<cfset loc.e = "2012-08-14">
 38 | 		<cfset loc.t = "{{ var | date_format:'yyyy-mm-dd' }}">
 39 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
 40 | 		
 41 | 		<!--- invalid date --->
 42 | 		<cfset loc.a["var"] = "not a date">
 43 | 		<cfset loc.e = "not a date">
 44 | 		<cfset loc.t = "{{ var | date_format:'yyyy-mm-dd' }}">
 45 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
 46 | 		
 47 | 		<!--- invalid format --->
 48 | 		<cfset loc.a["var"] = "08/14/2012">
 49 | 		<cfset loc.e = "08/14/2012">
 50 | 		<cfset loc.t = "{{ var | date_format:'' }}">
 51 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
 52 | 	</cffunction>
 53 | 	
 54 | 	<cffunction name="test_divided_by">
 55 | 		<!--- valid --->
 56 | 		<cfset loc.a["var"] = 20>
 57 | 		<cfset loc.e = 4>
 58 | 		<cfset loc.t = "{{ var | divided_by:5 }}">
 59 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
 60 | 		
 61 | 		<!--- without operand --->
 62 | 		<cfset loc.a["var"] = 5>
 63 | 		<cfset loc.e = 5>
 64 | 		<cfset loc.t = "{{ var | divided_by }}">
 65 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
 66 | 		
 67 | 		<!--- divide by zero returns zero --->
 68 | 		<cfset loc.a["var"] = 5>
 69 | 		<cfset loc.e = 0>
 70 | 		<cfset loc.t = "{{ var | divided_by:0 }}">
 71 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
 72 | 	</cffunction>
 73 | 	
 74 | 	<cffunction name="test_downcase">
 75 | 		<!--- empty string --->
 76 | 		<cfset loc.a["var"] = "">
 77 | 		<cfset loc.e = "">
 78 | 		<cfset loc.t = "{{ var | downcase }}">
 79 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
 80 | 		
 81 | 		<!--- one word --->
 82 | 		<cfset loc.a["var"] = "Tony">
 83 | 		<cfset loc.e = "tony">
 84 | 		<cfset loc.t = "{{ var | downcase }}">
 85 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
 86 | 		
 87 | 		<!--- multiple words --->
 88 | 		<cfset loc.a["var"] = "Liquid Is Great">
 89 | 		<cfset loc.e = "liquid is great">
 90 | 		<cfset loc.t = "{{ var | downcase }}">
 91 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
 92 | 	</cffunction>
 93 | 	
 94 | 	<cffunction name="test_escape">
 95 | 		<cfset loc.str = "<html><head></head><body></body></html>">
 96 | 		<cfset loc.a["var"] = loc.str>
 97 | 		<cfset loc.e = HtmlEditFormat(loc.str)>
 98 | 		<cfset loc.t = "{{ var | escape }}">
 99 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
100 | 	</cffunction>
101 | 	
102 | 	<cffunction name="test_first">
103 | 		<!--- valid array --->
104 | 		<cfset loc.a["var"] = [1, 2, 3, 4]>
105 | 		<cfset loc.e = "1">
106 | 		<cfset loc.t = "{{ var | first }}">
107 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
108 | 		
109 | 		<!--- invalid array --->
110 | 		<cfset loc.a["var"] = "dddd">
111 | 		<cfset loc.e = "dddd">
112 | 		<cfset loc.t = "{{ var | first }}">
113 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
114 | 	</cffunction>
115 | 
116 | 	<cffunction name="test_join">
117 | 		<!--- valid array --->
118 | 		<cfset loc.a["var"] = [1, 2, 3, 4]>
119 | 		<cfset loc.e = "1 2 3 4">
120 | 		<cfset loc.t = "{{ var | join }}">
121 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
122 | 		
123 | 		<!--- invalid array --->
124 | 		<cfset loc.a["var"] = "dddd">
125 | 		<cfset loc.e = "dddd">
126 | 		<cfset loc.t = "{{ var | join }}">
127 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
128 | 	</cffunction>
129 | 	
130 | 	<cffunction name="test_last">
131 | 		<!--- valid array --->
132 | 		<cfset loc.a["var"] = [1, 2, 3, 4]>
133 | 		<cfset loc.e = "4">
134 | 		<cfset loc.t = "{{ var | last }}">
135 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
136 | 		
137 | 		<!--- invalid array --->
138 | 		<cfset loc.a["var"] = "dddd">
139 | 		<cfset loc.e = "dddd">
140 | 		<cfset loc.t = "{{ var | last }}">
141 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
142 | 	</cffunction>
143 | 	
144 | 	<cffunction name="test_minus">
145 | 		<!--- valid --->
146 | 		<cfset loc.a["var"] = 20>
147 | 		<cfset loc.e = 15>
148 | 		<cfset loc.t = "{{ var | minus:5 }}">
149 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
150 | 		
151 | 		<!--- without operand --->
152 | 		<cfset loc.a["var"] = 5>
153 | 		<cfset loc.e = 5>
154 | 		<cfset loc.t = "{{ var | minus }}">
155 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
156 | 	</cffunction>
157 | 	
158 | 	<cffunction name="test_modulo">
159 | 		<!--- valid --->
160 | 		<cfset loc.a["var"] = 20>
161 | 		<cfset loc.e = 2>
162 | 		<cfset loc.t = "{{ var | modulo:3 }}">
163 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
164 | 		
165 | 		<!--- without operand --->
166 | 		<cfset loc.a["var"] = 5>
167 | 		<cfset loc.e = 0>
168 | 		<cfset loc.t = "{{ var | modulo }}">
169 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
170 | 	</cffunction>
171 | 	
172 | 	<cffunction name="test_newline_to_br">
173 |  		<!--- empty string --->
174 | 		<cfset loc.a["var"] = "">
175 | 		<cfset loc.e = "">
176 | 		<cfset loc.t = "{{ var | newline_to_br }}">
177 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
178 | 		
179 | 		<!--- newline and carriage return (windows) --->
180 | 		<cfset loc.a["var"] = "liquid#chr(10)##chr(13)#kewl">
181 | 		<cfset loc.e = "liquid<br/>kewl">
182 | 		<cfset loc.t = "{{ var | newline_to_br }}">
183 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
184 | 		
185 | 		<cfset loc.a["var"] = "liquid\n\rkewl">
186 | 		<cfset loc.e = "liquid<br/>kewl">
187 | 		<cfset loc.t = "{{ var | newline_to_br }}">
188 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
189 | 
190 | 		<!--- multiple newlinease --->
191 | 		<cfset loc.a["var"] = "liquid\n\nkewl">
192 | 		<cfset loc.e = "liquid<br/><br/>kewl">
193 | 		<cfset loc.t = "{{ var | newline_to_br }}">
194 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
195 | 	</cffunction>
196 | 	
197 | 	<cffunction name="test_plus">
198 | 		<!--- valid --->
199 | 		<cfset loc.a["var"] = 20>
200 | 		<cfset loc.e = 25>
201 | 		<cfset loc.t = "{{ var | plus:5 }}">
202 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
203 | 		
204 | 		<!--- without operand --->
205 | 		<cfset loc.a["var"] = 5>
206 | 		<cfset loc.e = 5>
207 | 		<cfset loc.t = "{{ var | plus }}">
208 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
209 | 	</cffunction>
210 | 	
211 | 	<cffunction name="test_prepend">
212 | 		<cfset loc.a["var"] = "foo">
213 | 		<cfset loc.e = "barfoo">
214 | 		<cfset loc.t = "{{ var | prepend:'bar' }}">
215 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
216 | 	</cffunction>
217 | 	
218 | 	<cffunction name="test_remove">
219 | 		<cfset loc.a["var"] = "foobarfoobar">
220 | 		<cfset loc.e = "barbar">
221 | 		<cfset loc.t = "{{ var | remove:'foo' }}">
222 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
223 | 	</cffunction>
224 | 	
225 | 	<cffunction name="test_remove_first">
226 | 		<cfset loc.a["var"] = "barbar">
227 | 		<cfset loc.e = "bar">
228 | 		<cfset loc.t = "{{ var | remove_first:'bar' }}">
229 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
230 | 	</cffunction>
231 | 	
232 | 	<cffunction name="test_replace">
233 | 		<cfset loc.a["var"] = "foofoo">
234 | 		<cfset loc.e = "barbar">
235 | 		<cfset loc.t = "{{ var | replace:'foo','bar' }}">
236 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
237 | 	</cffunction>
238 | 	
239 | 	<cffunction name="test_replace_first">
240 | 		<cfset loc.a["var"] = "foofoo">
241 | 		<cfset loc.e = "barfoo">
242 | 		<cfset loc.t = "{{ var | replace_first:'foo','bar' }}">
243 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
244 | 	</cffunction>
245 | 	
246 | 	<cffunction name="test_size">
247 | 		<!--- array --->
248 | 		<cfset loc.a["var"] = [1, 2, 3, 4]>
249 | 		<cfset loc.e = 4>
250 | 		<cfset loc.t = "{{ var | size }}">
251 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
252 | 		
253 | 		<!--- string --->
254 | 		<cfset loc.a["var"] = "ddddd">
255 | 		<cfset loc.e = 5>
256 | 		<cfset loc.t = "{{ var | size }}">
257 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
258 | 		
259 | 		<!--- struct --->
260 | 		<cfset loc.a["var"] = {a=1, b=2, c=3}>
261 | 		<cfset loc.e = 3>
262 | 		<cfset loc.t = "{{ var | size }}">
263 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
264 | 		
265 | 		<!--- using split --->
266 | 		<cfset loc.a["var"] = "tony per chris">
267 | 		<cfset loc.e = 3>
268 | 		<cfset loc.t = "{{ var | split |size }}">
269 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
270 | 	</cffunction>
271 | 	
272 | 	<cffunction name="test_sort">
273 | 		<!--- non array --->
274 |   		<cfset loc.a["var"] = "tony per chris">
275 | 		<cfset loc.e = "tony per chris">
276 | 		<cfset loc.t = "{{ var | sort }}">
277 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
278 | 		
279 | 		<!--- default sort --->
280 |   		<cfset loc.a["var"] = "tony per chris">
281 | 		<cfset loc.e = "chris">
282 | 		<cfset loc.t = "{{ var | split | sort |first }}">
283 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
284 | 		
285 | 		<!--- specify type --->
286 | 		<cfset loc.a["var"] = "4 2 1 3">
287 | 		<cfset loc.e = "4">
288 | 		<cfset loc.t = "{{ var | split | sort:'numeric' | last }}">
289 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
290 | 		
291 | 		<!--- specify order --->
292 | 		<cfset loc.a["var"] = "4 2 1 3">
293 | 		<cfset loc.e = "1">
294 | 		<cfset loc.t = "{{ var | split | sort:'numeric','desc' | last }}">
295 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
296 | 	</cffunction>
297 | 	
298 | 	<cffunction name="test_split">
299 | 		<!--- empty string --->
300 |   		<cfset loc.a["var"] = "">
301 | 		<cfset loc.e = "">
302 | 		<cfset loc.t = "{{ var | split | first }}">
303 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
304 |  		
305 | 		<!--- default seperator --->
306 | 		<cfset loc.a["var"] = "tony per chris">
307 | 		<cfset loc.e = "chris">
308 | 		<cfset loc.t = "{{ var | split | last }}">
309 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
310 | 		
311 | 		<!--- specify seperator --->
312 | 		<cfset loc.a["var"] = "tony,per,chris">
313 | 		<cfset loc.e = "chris">
314 | 		<cfset loc.t = "{{ var | split:',' | last }}">
315 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
316 | 		
317 | 		<!--- invalid seperator --->
318 | 		<cfset loc.a["var"] = "tony per chris">
319 | 		<cfset loc.e = "tony per chris">
320 | 		<cfset loc.t = "{{ var | split:',' | last }}">
321 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
322 | 		
323 | 		<!--- not return position returns string representation of array --->
324 | 		<cfset loc.a["var"] = "tony per chris">
325 | 		<cfset loc.e = "[tony, per, chris]">
326 | 		<cfset loc.t = "{{ var | split }}">
327 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
328 | 	</cffunction>
329 | 	
330 | 	<cffunction name="test_strip_html">
331 | 		<cfset loc.a["var"] = "<b>bla blub</a>">
332 | 		<cfset loc.e = "bla blub">
333 | 		<cfset loc.t = "{{ var | strip_html }}">
334 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
335 | 	</cffunction>
336 | 	
337 | 	<cffunction name="test_strip_newlines">
338 |  		<!--- empty string --->
339 |  		<cfset loc.a["var"] = "">
340 | 		<cfset loc.e = "">
341 | 		<cfset loc.t = "{{ var | strip_newlines }}">
342 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
343 | 		
344 | 		<!--- newline and carriage return (windows) --->
345 | 		<cfset loc.a["var"] = "liquid#chr(10)##chr(13)#kewl">
346 | 		<cfset loc.e = "liquidkewl">
347 | 		<cfset loc.t = "{{ var | strip_newlines }}">
348 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
349 | 		
350 | 		<cfset loc.a["var"] = "liquid\n\rkewl">
351 | 		<cfset loc.e = "liquidkewl">
352 | 		<cfset loc.t = "{{ var | strip_newlines }}">
353 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
354 | 
355 | 		<!--- multiple newlinease --->
356 | 		<cfset loc.a["var"] = "liquid\n\nkewl">
357 | 		<cfset loc.e = "liquidkewl">
358 | 		<cfset loc.t = "{{ var | strip_newlines }}">
359 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
360 | 		
361 | 		<!--- specify replacement --->
362 | 		<cfset loc.a["var"] = "liquid\n\nkewl">
363 | 		<cfset loc.e = "liquid**kewl">
364 | 		<cfset loc.t = "{{ var | strip_newlines:'*' }}">
365 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
366 | 	</cffunction>
367 | 	
368 | 	<cffunction name="test_time_format">
369 | 		<!--- valid time --->
370 | 		<cfset loc.a["var"] = "08/14/2012 05:22 PM">
371 | 		<cfset loc.e = "22:17">
372 | 		<cfset loc.t = "{{ var | time_format:'mm:HH' }}">
373 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
374 | 		
375 | 		<!--- invalid time --->
376 | 		<cfset loc.a["var"] = "not a date">
377 | 		<cfset loc.e = "not a date">
378 | 		<cfset loc.t = "{{ var | time_format:mm:HH }}">
379 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
380 | 		
381 | 		<!--- invalid format --->
382 | 		<cfset loc.a["var"] = "08/14/2012 05:22 PM">
383 | 		<cfset loc.e = "08/14/2012 05:22 PM">
384 | 		<cfset loc.t = "{{ var | time_format:'' }}">
385 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
386 | 	</cffunction>
387 | 	
388 | 	<cffunction name="test_times">
389 | 		<!--- valid --->
390 | 		<cfset loc.a["var"] = 5>
391 | 		<cfset loc.e = 20>
392 | 		<cfset loc.t = "{{ var | times:4 }}">
393 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
394 | 		
395 | 		<!--- without operand --->
396 | 		<cfset loc.a["var"] = 5>
397 | 		<cfset loc.e = 5>
398 | 		<cfset loc.t = "{{ var | times }}">
399 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
400 | 	</cffunction>
401 | 	
402 | 	<cffunction name="test_truncate">
403 | 		<!--- valid truncate --->
404 | 		<cfset loc.a["var"] = "123456789">
405 | 		<cfset loc.e = "1234&hellip;">
406 | 		<cfset loc.t = "{{ var | truncate:4 }}">
407 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
408 | 		
409 | 		<!--- blank string --->
410 | 		<cfset loc.a["var"] = "">
411 | 		<cfset loc.e = "">
412 | 		<cfset loc.t = "{{ var | truncate:4 }}">
413 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
414 | 
415 | 		<!--- specify overflow --->
416 | 		<cfset loc.a["var"] = "123456789">
417 | 		<cfset loc.e = "1234@@@">
418 | 		<cfset loc.t = "{{ var | truncate:4,'@@@' }}">
419 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
420 | 		
421 | 		<!--- no arguments --->
422 | 		<cfset loc.a["var"] = "123456789">
423 | 		<cfset loc.e = "123456789">
424 | 		<cfset loc.t = "{{ var | truncate }}">
425 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
426 | 	</cffunction>
427 | 	
428 | 	<cffunction name="test_truncatewords">
429 | 		<!--- valid truncate --->
430 | 		<cfset loc.a["var"] = "This is a test to see if this works or not">
431 | 		<cfset loc.e = "This is a test&hellip;">
432 | 		<cfset loc.t = "{{ var | truncatewords:4 }}">
433 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
434 | 		
435 | <!---  		<!--- blank string --->
436 | 		<cfset loc.a["var"] = "">
437 | 		<cfset loc.e = "">
438 | 		<cfset loc.t = "{{ var | truncate_words:4 }}">
439 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
440 | 
441 | 		<!--- specify overflow --->
442 | 		<cfset loc.a["var"] = "This is a test to see if this works or not">
443 | 		<cfset loc.e = "This is a test@@@">
444 | 		<cfset loc.t = "{{ var | truncate_words:4,'@@@' }}">
445 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
446 | 		
447 | 		<!--- no arguments --->
448 | 		<cfset loc.a["var"] = "This is a test to see if this works or not">
449 | 		<cfset loc.e = "This is a&hellip;">
450 | 		<cfset loc.t = "{{ var | truncate_words }}">
451 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)> --->
452 | 	</cffunction>
453 | 
454 | 	<cffunction name="test_upcase">
455 | 		<!--- empty string --->
456 | 		<cfset loc.a["var"] = "">
457 | 		<cfset loc.e = "">
458 | 		<cfset loc.t = "{{ var | upcase }}">
459 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
460 | 		
461 | 		<!--- one word --->
462 | 		<cfset loc.a["var"] = "Tony">
463 | 		<cfset loc.e = "TONY">
464 | 		<cfset loc.t = "{{ var | upcase }}">
465 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
466 | 		
467 | 		<!--- multiple words --->
468 | 		<cfset loc.a["var"] = "liquid is great">
469 | 		<cfset loc.e = "LIQUID IS GREAT">
470 | 		<cfset loc.t = "{{ var | upcase }}">
471 | 		<cfset assert_template_result(loc.e, loc.t, loc.template, loc.a)>
472 | 	</cffunction>
473 | 
474 | </cfcomponent>


--------------------------------------------------------------------------------