├── restfulcf
    ├── test
    │   ├── Application.cfc
    │   ├── tests
    │   │   ├── util
    │   │   │   ├── ArrayMergeFixture.cfc
    │   │   │   ├── XMLTest.cfc
    │   │   │   ├── InflectorTest.cfc
    │   │   │   └── ArraysTest.cfc
    │   │   └── core
    │   │   │   ├── ControllerTest.cfc
    │   │   │   ├── cache
    │   │   │       ├── EmptyCacheTest.cfc
    │   │   │       ├── ApplicationCacheTest.cfc
    │   │   │       └── AbstractCacheTest.cfc
    │   │   │   ├── ErrorCollectionTest.cfc
    │   │   │   ├── AuthenticatorTest.cfc
    │   │   │   ├── ResourceFixture.cfc
    │   │   │   ├── ResourceCountTest.cfc
    │   │   │   ├── RouteCollectionTest.cfc
    │   │   │   ├── RouteTest.cfc
    │   │   │   ├── ResponseTest.cfc
    │   │   │   ├── ResourceCollectionTest.cfc
    │   │   │   └── ResourceTest.cfc
    │   └── index.cfm
    ├── sample
    │   └── helloworld
    │   │   ├── public
    │   │       ├── .htaccess
    │   │       ├── rest.cfm
    │   │       └── Application.cfc
    │   │   ├── rest
    │   │       ├── Dispatcher.cfc
    │   │       ├── resources
    │   │       │   └── World.cfc
    │   │       └── controllers
    │   │       │   └── Worlds.cfc
    │   │   └── README.markdown
    └── framework
    │   ├── core
    │       ├── cache
    │       │   ├── EmptyCache.cfc
    │       │   ├── ApplicationCache.cfc
    │       │   └── AbstractCache.cfc
    │       ├── Authenticator.cfc
    │       ├── ErrorCollection.cfc
    │       ├── RouteCollection.cfc
    │       ├── ResourceCount.cfc
    │       ├── Controller.cfc
    │       ├── Route.cfc
    │       ├── ResourceCollection.cfc
    │       ├── Response.cfc
    │       ├── Request.cfc
    │       ├── Resource.cfc
    │       └── Dispatcher.cfc
    │   ├── util
    │       ├── XML.cfc
    │       ├── Arrays.cfc
    │       └── Inflector.cfc
    │   └── tags
    │       └── endpoint.cfm
├── LICENSE
└── TODO.markdown


/restfulcf/test/Application.cfc:
--------------------------------------------------------------------------------
1 | <cfcomponent output="false">
2 | 
3 | 	<cfset this.name = "restfulcf_test_runner">
4 | 	<cfset this.mappings["/restfulcf"] = expandpath("..")>
5 | 
6 | </cfcomponent>
7 | 


--------------------------------------------------------------------------------
/restfulcf/sample/helloworld/public/.htaccess:
--------------------------------------------------------------------------------
 1 | ##
 2 | # This Apache rewrite file is to remove the need for everything to explicitly
 3 | # run through rest.cfm for much cleaner URLs.  Instead of:
 4 | #
 5 | #     http://localhost/rest.cfm/resource.xml
 6 | #
 7 | # this rewrite allows us to drop the "rest.cfm" part as follows:
 8 | #
 9 | #     http://localhost/resource.xml
10 | #
11 | 
12 | RewriteEngine on
13 | RewriteCond %{REQUEST_FILENAME} !-f
14 | RewriteRule ([a-z]{1}.*)?$ rest.cfm/$1 [QSA,L]
15 | 


--------------------------------------------------------------------------------
/restfulcf/sample/helloworld/public/rest.cfm:
--------------------------------------------------------------------------------
 1 | <!--- -->
 2 | <fusedoc fuse="restfulcf/sample/helloworld/public/rest.cfm" language="ColdFusion" specification="2.0">
 3 | 	<responsibilities>
 4 | 		I am the entry point for all REST calls
 5 | 	</responsibilities>
 6 | </fusedoc>
 7 | --->
 8 | 
 9 | <!--- import the endpoint custom tag --->
10 | <cfimport taglib="../../../framework/tags/" prefix="restfulcf">
11 | 
12 | <!--- run the request --->
13 | <restfulcf:endpoint
14 | 	name     = application.applicationname,
15 | 	engine   = "restfulcf.sample.helloworld.rest.Dispatcher"
16 | 	reload   = TRUE
17 | 	response = "variables.response">
18 | 


--------------------------------------------------------------------------------
/restfulcf/test/tests/util/ArrayMergeFixture.cfc:
--------------------------------------------------------------------------------
 1 | <!--- -->
 2 | <fusedoc fuse="restfulcf/test/tests/util/ArrayMergeFixture.cfc" language="ColdFusion" specification="2.0">
 3 | 	<responsibilities>
 4 | 		I am a fixture component that allows testing of merging arrays containing component instances
 5 | 	</responsibilities>
 6 | </fusedoc>
 7 | --->
 8 | 
 9 | <cfcomponent>
10 | 
11 | 	<cfset this.id = 0>
12 | 
13 | 	<cffunction name="init" access="public" returntype="ArrayMergeFixture" output="no">
14 | 		<cfargument name="id" type="numeric" required="yes">
15 | 		<cfset this.id = arguments.id>
16 | 		<cfreturn this>
17 | 	</cffunction>
18 | 
19 | 	<cffunction name="getID" access="public" returntype="numeric" output="no">
20 | 		<cfreturn this.id>
21 | 	</cffunction>
22 | 
23 | </cfcomponent>


--------------------------------------------------------------------------------
/restfulcf/framework/core/cache/EmptyCache.cfc:
--------------------------------------------------------------------------------
 1 | <!--- -->
 2 | <fusedoc fuse="restfulcf/framework/core/cache/EmptyCache.cfc" language="ColdFusion" specification="2.0">
 3 | 	<responsibilities>
 4 | 		I am a concrete implementation of an abstract cache which doesn't actually cache anything.
 5 | 		This is the default cache instance for the framework.
 6 | 	</responsibilities>
 7 | </fusedoc>
 8 | --->
 9 | 
10 | <cfcomponent extends="restfulcf.framework.core.cache.AbstractCache" output="no">
11 | 
12 | 	<cffunction name="getKey" access="public" returntype="string" output="no" hint="Get a response from the cache"><cfreturn ""></cffunction>
13 | 	<cffunction name="setKey" access="public" returntype="string" output="no" hint="Sets a given value for a given key in the cache"></cffunction>
14 | 	<cffunction name="deleteKey" access="public" returntype="void" output="no" hint="Deletes a given key from the cache"></cffunction>
15 | 
16 | </cfcomponent>
17 | 


--------------------------------------------------------------------------------
/restfulcf/test/tests/core/ControllerTest.cfc:
--------------------------------------------------------------------------------
 1 | <!--- -->
 2 | <fusedoc fuse="restfulcf/test/tests/core/ControllerTest.cfc" language="ColdFusion" specification="2.0">
 3 | 	<responsibilities>
 4 | 		I test the base controller
 5 | 	</responsibilities>
 6 | </fusedoc>
 7 | --->
 8 | 
 9 | <cfcomponent extends="mxunit.framework.TestCase">
10 | 
11 | 	<cffunction name="setup">
12 | 		<cfset controller = createobject("component", "restfulcf.framework.core.Controller").init()>
13 | 	</cffunction>
14 | 
15 | 	<cffunction name="init_should_return_instance_of_controller">
16 | 		<cfset assertIsTypeOf(controller, "restfulcf.framework.core.Controller")>
17 | 	</cffunction>
18 | 
19 | 	<cffunction name="shortcut_http_status_codes_should_be_available_and_correct">
20 | 		<cfset var msg = "">
21 | 		<cfloop list="ok|200,created|201,not_found|404,method_not_allowed|405,not_acceptable|406,unsupported_media_type|415,unprocessable_entity|422,internal_server_error|500" index="msg">
22 | 			<cfset assertEquals(listgetat(msg, 2, "|"), controller.HTTP_STATUS_CODES[listgetat(msg, 1, "|")])>
23 | 		</cfloop>
24 | 	</cffunction>
25 | 
26 | </cfcomponent>
27 | 


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


--------------------------------------------------------------------------------
/restfulcf/sample/helloworld/public/Application.cfc:
--------------------------------------------------------------------------------
 1 | <!--- -->
 2 | <fusedoc fuse="restfulcf/sample/helloworld/public/Application.cfc" language="ColdFusion" specification="2.0">
 3 | 	<responsibilities>
 4 | 		I define the application settings for RESTfulCF example applicatino
 5 | 	</responsibilities>
 6 | </fusedoc>
 7 | --->
 8 | 
 9 | <cfcomponent output="false">
10 | 
11 | 	<cfset this.name = "restfulcf_example_app_helloworld">
12 | 	<cfset this.applicationtimeout = createtimespan(0,2,0,0)>
13 | 
14 | 	<cffunction name="onApplicationStart" returntype="boolean" output="no">
15 | 		<!--- set up a couple of example worlds --->
16 | 		<cfset application.worlds = [
17 | 			{ id = 1, name = "Hello", created_at = "1978-09-22 12:34:56", updated_at = NOW() },
18 | 			{ id = 2, name = "Goodbye", created_at = NOW(), updated_at = NOW() }
19 | 		]>
20 | 		<cfreturn TRUE>
21 | 	</cffunction>
22 | 
23 | 	<cffunction name="onRequestStart" returntype="boolean" output="false">
24 | 		<cfargument name="thePage" type="string" required="true">
25 | 		<cfif structkeyexists(url, "_reload") AND isboolean(url['_reload']) AND url['_reload']>
26 | 			<cfset onApplicationStart()>
27 | 		</cfif>
28 | 		<cfreturn TRUE>
29 | 	</cffunction>
30 | 
31 | </cfcomponent>
32 | 


--------------------------------------------------------------------------------
/restfulcf/test/index.cfm:
--------------------------------------------------------------------------------
 1 | <!--- -->
 2 | <fusedoc fuse="restfulcf/test//runner.cfm" language="ColdFusion" specification="2.0">
 3 | 	<responsibilities>
 4 | 		I am the test scripts runner
 5 | 	</responsibilities>
 6 | </fusedoc>
 7 | --->
 8 | 
 9 | <cfparam name="URL.output" default="extjs">
10 | <cfparam name="URL.quiet" default="false">
11 | 
12 | <cfparam name="URL.tests" default="">
13 | <cfset comp_path = "">
14 | <cfif len(url.tests)><cfset comp_path = "." & url.tests></cfif>
15 | 
16 | <cfset dir = expandPath("tests/" & url.tests)>
17 | <cfoutput><h1>#dir#</h1></cfoutput>
18 | 
19 | <cfset DTS = createObject("component","mxunit.runner.DirectoryTestSuite")>
20 | <cfset excludes = "InvalidMarkupTest,FiveSecondTest">
21 | <cfinvoke component="#DTS#"
22 |   method="run"
23 |   directory="#dir#"
24 |   recurse="true"
25 |   excludes="#excludes#"
26 |   returnvariable="Results"
27 |   componentPath="restfulcf.test.tests#comp_path#" />
28 | 
29 | <cfif NOT URL.quiet>
30 |   <cfif NOT StructIsEmpty(DTS.getCatastrophicErrors())>
31 |     <cfdump var="#DTS.getCatastrophicErrors()#" expand="false" label="#StructCount(DTS.getCatastrophicErrors())# Catastrophic Errors">
32 |   </cfif>
33 | 
34 |   <cfsetting showdebugoutput="true">
35 |   <cfoutput>#results.getResultsOutput(URL.output)#</cfoutput>
36 | </cfif>
37 | 


--------------------------------------------------------------------------------
/TODO.markdown:
--------------------------------------------------------------------------------
 1 | # RESTfulCF To-Do List
 2 | 
 3 | In no particular order...
 4 | 
 5 | ## Framework Features
 6 | 
 7 | * Regex or similar support for route parameters, e.g. /resources/[0-9]+
 8 | * Use of Accept: header for defining the response type, in addition to file extension
 9 | * Error handling
10 |     * Handling of CF errors
11 |     * Needs to be extracted from existing WLD implementation and refined
12 |     * Unit tests required
13 |     * Error capturing examples
14 | * Remove dependancy on `CGI['PATH_INFO']` and SES enabling via `web.xml`
15 | * Support for deserialising JSON-encoded body content on `POST`/`PUT`
16 | * Route aliases, e.g. `/x/1/y/2 => /y/2?x=1`
17 | 
18 | ## Bugs and Known Issues
19 | 
20 | * Controllers don't know the location of the API to output `Location` headers on successful `POST`
21 | 
22 | ## Supporting Material
23 | 
24 | * Tests
25 |     * Unit tests required for Dispatcher and Request
26 | * More complex sample application, including:
27 |     * Nested resources
28 |     * Resource collections
29 | * Documentation
30 |     * Much more detail required than just the README
31 |     * "How to use RESTfulCF"
32 |     * "How RESTfulCF works"
33 |     * Packaged within app, or using Github wiki/pages?
34 |     * Should tie in with project website
35 | * Project website including basic details, package downloads, update blog, docs etc
36 | * Build script to package up for download
37 | 


--------------------------------------------------------------------------------
/restfulcf/framework/core/Authenticator.cfc:
--------------------------------------------------------------------------------
 1 | <!--- -->
 2 | <fusedoc fuse="restfulcf/framework/core/Authenticator.cfc" language="ColdFusion" specification="2.0">
 3 | 	<responsibilities>
 4 | 		I am the base component that any authenticator should extend
 5 | 	</responsibilities>
 6 | </fusedoc>
 7 | --->
 8 | 
 9 | <cfcomponent output="no">
10 | 
11 | 	<cfset variables.instance = { realm = "Access Denied" }>
12 | 
13 | 	<cffunction name="init" access="public" returntype="restfulcf.framework.core.Authenticator" output="no" hint="Intialise this component">
14 | 		<cfargument name="realm" type="string" required="yes" hint="The authentication realm">
15 | 		<cfset variables.instance.realm = arguments.realm>
16 | 		<cfreturn this>
17 | 	</cffunction>
18 | 
19 | 	<cffunction name="isAuthenticated" access="public" returntype="boolean" output="no" hint="The actual authentication method; should be overridden, else returns TRUE for everything.">
20 | 		<cfargument name="user" type="string" required="yes" hint="The username">
21 | 		<cfargument name="pass" type="string" required="yes" hint="The password">
22 | 		<cfargument name="request" type="restfulcf.framework.core.Request" required="yes" hint="The request object">
23 | 		<cfreturn TRUE>
24 | 	</cffunction>
25 | 
26 | 	<cffunction name="getRealm" access="public" returntype="string" output="no" hint="Returns the authentication realm">
27 | 		<cfreturn variables.instance.realm>
28 | 	</cffunction>
29 | 
30 | </cfcomponent>
31 | 


--------------------------------------------------------------------------------
/restfulcf/sample/helloworld/rest/Dispatcher.cfc:
--------------------------------------------------------------------------------
 1 | <!--- -->
 2 | <fusedoc fuse="restfulcf/sample/helloworld/rest/Dispatcher.cfc" language="ColdFusion" specification="2.0">
 3 | 	<responsibilities>
 4 | 		I am a concrete representation of a ReSTful Dispatcher for the 'Hello World' sample app
 5 | 	</responsibilities>
 6 | </fusedoc>
 7 | --->
 8 | 
 9 | <cfcomponent extends="restfulcf.framework.core.Dispatcher" output="no">
10 | 
11 | 	<!--- set the location of our controllers --->
12 | 	<cfset variables.controller_path = "restfulcf.sample.helloworld.rest.controllers">
13 | 	<!--- automatically translated hyphens in property key names to underscores --->
14 | 	<cfset variables.argument_translation = TRUE>
15 | 
16 | 	<cffunction name="init" access="public" returntype="restfulcf.sample.helloworld.rest.Dispatcher" output="no" hint="I initialise this instance of the dispatcher.">
17 | 		<!--- run the parent class constructor to initialise the component --->
18 | 		<cfset super.init(argumentcollection=arguments)>
19 | 		<!--- use an application scope cache --->
20 | 		<cfset setCache(createobject("component", "restfulcf.framework.core.cache.ApplicationCache").init())>
21 | 		<!--- we're using the app scope for persistence for the sample app --->
22 | 		<cfparam name="application.worlds" default="#arraynew(1)#">
23 | 		<!--- add the 'world' resource: automatically creates routes based on the
24 | 		      Worlds controller; uses the controller_path set above to find it --->
25 | 		<cfset addResource("world")>
26 | 		<cfreturn this>
27 | 	</cffunction>
28 | 
29 | </cfcomponent>
30 | 


--------------------------------------------------------------------------------
/restfulcf/test/tests/core/cache/EmptyCacheTest.cfc:
--------------------------------------------------------------------------------
 1 | <!--- -->
 2 | <fusedoc fuse="restfulcf/test/tests/core/cache/EmptyCacheTest.cfc" language="ColdFusion" specification="2.0">
 3 | 	<responsibilities>
 4 | 		I test the empty ("does nothing") cache
 5 | 	</responsibilities>
 6 | </fusedoc>
 7 | --->
 8 | 
 9 | <cfcomponent extends="mxunit.framework.TestCase">
10 | 
11 | 	<cffunction name="setup">
12 | 		<cfset cache = createobject("component", "restfulcf.framework.core.cache.EmptyCache").init()>
13 | 		<cfset cache_args = {
14 | 			key     = createuuid(),
15 | 			value   = createuuid(),
16 | 			expires = dateadd('s', 100, now())
17 | 		}>
18 | 	</cffunction>
19 | 
20 | 	<cffunction name="getting_any_key_should_return_an_empty_string">
21 | 		<cfset var i = 0>
22 | 		<cfloop from="1" to="10" index="i">
23 | 			<cfset assertEquals("", cache.getKey(createuuid()))>
24 | 		</cfloop>
25 | 	</cffunction>
26 | 
27 | 	<cffunction name="empty_key_should_be_returned_after_setting_a_key">
28 | 		<cfset cache.setKey(argumentcollection=cache_args)>
29 | 		<cfset assertEquals("", cache.getKey(cache_args.key))>
30 | 	</cffunction>
31 | 	<cffunction name="key_should_not_exist_after_deleting_it">
32 | 		<cfset cache.setKey(argumentcollection=cache_args)>
33 | 		<cfset assertEquals("", cache.getKey(cache_args.key))>
34 | 		<cfset cache.deleteKey(cache_args.key)>
35 | 		<cfset assertEquals("", cache.getKey(cache_args.key))>
36 | 	</cffunction>
37 | 	<cffunction name="key_with_expiry_in_the_past_should_not_available">
38 | 		<cfset cache_args.expires = dateadd('s', -1, now())>
39 | 		<cfset cache.setKey(argumentcollection=cache_args)>
40 | 		<cfset assertEquals("", cache.getKey(cache_args.key))>
41 | 	</cffunction>
42 | 
43 | </cfcomponent>
44 | 


--------------------------------------------------------------------------------
/restfulcf/sample/helloworld/rest/resources/World.cfc:
--------------------------------------------------------------------------------
 1 | <!--- -->
 2 | <fusedoc fuse="restfulcf/sample/helloworld/rest/resources/World.cfc" language="ColdFusion" specification="2.0">
 3 | 	<responsibilities>
 4 | 		I am an example resource descriptor for a world for the "Hello World" sample app
 5 | 	</responsibilities>
 6 | </fusedoc>
 7 | --->
 8 | 
 9 | <cfcomponent extends="restfulcf.framework.core.Resource" output="no">
10 | 
11 | 	<!--- resource property fields: setter/getter methods for these properties are
12 | 	      automatically "created" via onMissingMethod; we could optionally provide
13 | 	      precision levels for numeric and date fields (id is automatically an int) --->
14 | 	<cfproperty name="id"               type="numeric"   default="0">
15 | 	<cfproperty name="name"             type="string"    default="">
16 | 	<cfproperty name="created_at"       type="date"      default="{ts '1900-01-01 00:00:00'}">
17 | 	<cfproperty name="updated_at"       type="date"      default="{ts '1900-01-01 00:00:00'}">
18 | 
19 | 	<!--- an example of overriding a default representation of this resource type --->
20 | 	<cffunction name="toTXT" access="public" returntype="string" output="no" hint="Outputs a textual representation of this world">
21 | 		<cfreturn variables.instance.name & " world">
22 | 	</cffunction>
23 | 
24 | 	<!--- an example of extending the world resource and adding an additional representation --->
25 | 	<cffunction name="toPDF" access="public" returntype="string" output="no" hint="Outputs a PDF representation of this world">
26 | 		<cfset var pdf = "">
27 | 		<cfsavecontent variable="pdf">
28 | 			<cfdocument format="pdf">
29 | 				<cfoutput>#variables.instance.name# world</cfoutput>
30 | 			</cfdocument>
31 | 		</cfsavecontent>
32 | 		<cfreturn pdf>
33 | 	</cffunction>
34 | 
35 | </cfcomponent>
36 | 


--------------------------------------------------------------------------------
/restfulcf/test/tests/core/cache/ApplicationCacheTest.cfc:
--------------------------------------------------------------------------------
 1 | <!--- -->
 2 | <fusedoc fuse="restfulcf/test/tests/core/cache/ApplicationCacheTest.cfc" language="ColdFusion" specification="2.0">
 3 | 	<responsibilities>
 4 | 		I test the application-scope cache
 5 | 	</responsibilities>
 6 | </fusedoc>
 7 | --->
 8 | 
 9 | <cfcomponent extends="mxunit.framework.TestCase">
10 | 
11 | 	<cffunction name="setup">
12 | 		<cfset application['_restfulcf'] = {}>
13 | 		<cfset cache = createobject("component", "restfulcf.framework.core.cache.ApplicationCache").init()>
14 | 		<cfset cache_args = {
15 | 			key     = createuuid(),
16 | 			value   = createuuid(),
17 | 			expires = dateadd('s', 100, now())
18 | 		}>
19 | 	</cffunction>
20 | 
21 | 	<cffunction name="getting_any_non_existent_key_should_return_an_empty_string">
22 | 		<cfset var i = 0>
23 | 		<cfloop from="1" to="10" index="i">
24 | 			<cfset assertEquals("", cache.getKey(createuuid()))>
25 | 		</cfloop>
26 | 	</cffunction>
27 | 
28 | 	<cffunction name="correct_key_should_be_returned_after_setting_a_key">
29 | 		<cfset cache.setKey(argumentcollection=cache_args)>
30 | 		<cfset assertEquals(cache_args.value, cache.getKey(cache_args.key))>
31 | 	</cffunction>
32 | 	<cffunction name="key_should_not_exist_after_deleting_it">
33 | 		<cfset cache.setKey(argumentcollection=cache_args)>
34 | 		<cfset assertEquals(cache_args.value, cache.getKey(cache_args.key))>
35 | 		<cfset cache.deleteKey(cache_args.key)>
36 | 		<cfset assertEquals("", cache.getKey(cache_args.key))>
37 | 	</cffunction>
38 | 	<cffunction name="key_with_expiry_in_the_past_should_not_available">
39 | 		<cfset cache_args.expires = dateadd('s', -1, now())>
40 | 		<cfset cache.setKey(argumentcollection=cache_args)>
41 | 		<cfset assertEquals("", cache.getKey(cache_args.key))>
42 | 	</cffunction>
43 | 
44 | </cfcomponent>
45 | 


--------------------------------------------------------------------------------
/restfulcf/test/tests/core/ErrorCollectionTest.cfc:
--------------------------------------------------------------------------------
 1 | <!--- -->
 2 | <fusedoc fuse="restfulcf/test/tests/core/ErrorCollectionTest.cfc" language="ColdFusion" specification="2.0">
 3 | 	<responsibilities>
 4 | 		I test the error collection component
 5 | 	</responsibilities>
 6 | </fusedoc>
 7 | --->
 8 | 
 9 | <cfcomponent extends="mxunit.framework.TestCase">
10 | 
11 | 	<cffunction name="setup">
12 | 		<cfset var errors = [ "Error 1", "Error 2", "Error 3" ]>
13 | 		<cfset empty = createobject("component", "restfulcf.framework.core.ErrorCollection")>
14 | 		<cfset collection = createobject("component", "restfulcf.framework.core.ErrorCollection").init(errors)>
15 | 	</cffunction>
16 | 
17 | 	<cffunction name="base_init_should_return_instance_of_resource">
18 | 		<cfset assertIsTypeOf(empty, "restfulcf.framework.core.Resource")>
19 | 	</cffunction>
20 | 	<cffunction name="extended_init_should_return_instance_of_resource">
21 | 		<cfset assertIsTypeOf(collection, "restfulcf.framework.core.Resource")>
22 | 	</cffunction>
23 | 
24 | 	<cffunction name="get_on_empty_collection_should_return_no_errors">
25 | 		<cfset assertEquals(0, arraylen(empty.getErrors()))>
26 | 	</cffunction>
27 | 	<cffunction name="count_on_empty_collection_should_return_a_zero_error_count">
28 | 		<cfset assertEquals(0, empty.getErrorCount())>
29 | 	</cffunction>
30 | 
31 | 	<cffunction name="get_on_populated_collection_should_return_all_errors">
32 | 		<cfset assertEquals(3, arraylen(collection.getErrors()))>
33 | 	</cffunction>
34 | 	<cffunction name="count_on_populated_collection_should_a_correct_error_count">
35 | 		<cfset assertEquals(3, collection.getErrorCount())>
36 | 	</cffunction>
37 | 	<cffunction name="get_on_populated_collection_should_correct_errors">
38 | 		<cfset var errors = collection.getErrors()>
39 | 		<cfset var i = 0>
40 | 		<cfloop from="1" to="#arraylen(errors)#" index="i">
41 | 			<cfset assertEquals("Error #i#", errors[i])>
42 | 		</cfloop>
43 | 	</cffunction>
44 | 
45 | </cfcomponent>
46 | 


--------------------------------------------------------------------------------
/restfulcf/test/tests/core/AuthenticatorTest.cfc:
--------------------------------------------------------------------------------
 1 | <!--- -->
 2 | <fusedoc fuse="restfulcf/test/tests/core/AuthenticatorTest.cfc" language="ColdFusion" specification="2.0">
 3 | 	<responsibilities>
 4 | 		I test the base authenticator
 5 | 	</responsibilities>
 6 | </fusedoc>
 7 | --->
 8 | 
 9 | <cfcomponent extends="mxunit.framework.TestCase">
10 | 
11 | 	<cffunction name="setup">
12 | 		<cfset authenticator = createobject("component", "restfulcf.framework.core.Authenticator").init("test_realm")>
13 | 	</cffunction>
14 | 
15 | 	<cffunction name="init_should_return_instance_of_authenticator">
16 | 		<cfset assertIsTypeOf(authenticator, "restfulcf.framework.core.Authenticator")>
17 | 	</cffunction>
18 | 
19 | 	<cffunction name="is_authenticated_should_always_return_true">
20 | 		<cfset var i = 0>
21 | 		<cfloop from="1" to="10" index="i">
22 | 			<cfset assertTrue(authenticator.isAuthenticated(random_string(), random_string(), createobject("component", "restfulcf.framework.core.Request")))>
23 | 		</cfloop>
24 | 	</cffunction>
25 | 
26 | 	<cffunction name="intialised_authentication_realm_should_be_correct">
27 | 		<cfset assertEquals("test_realm", authenticator.getRealm())>
28 | 	</cffunction>
29 | 	<cffunction name="default_authentication_realm_should_be_access_denied">
30 | 		<cfset assertEquals("Access Denied", createobject("component", "restfulcf.framework.core.Authenticator").getRealm())>
31 | 	</cffunction>
32 | 
33 | 	<cffunction name="random_string" access="private" returntype="string" output="no" hint="Returns a randomly generated string">
34 | 		<cfset var chars = "0123456789abcdefghijklmnopqrstuvwxyzABCEDFGHIJKLMNOPQRSTUVWXYZ">
35 | 		<cfset var string = []>
36 | 		<cfset var i = 0>
37 | 		<cfset randomize(right(gettickcount(), 6) * rand())>
38 | 		<cfloop from="1" to="#ceiling(rand() * 10)#" index="i">
39 | 			<cfset arrayappend(string, mid(chars, ceiling(rand() * len(chars)), 1))>
40 | 		</cfloop>
41 | 		<cfreturn arraytolist(string, "")>
42 | 	</cffunction>
43 | 
44 | </cfcomponent>
45 | 


--------------------------------------------------------------------------------
/restfulcf/test/tests/core/ResourceFixture.cfc:
--------------------------------------------------------------------------------
 1 | <!--- -->
 2 | <fusedoc fuse="restfulcf/test/tests/core/ResourceFixture.cfc" language="ColdFusion" specification="2.0">
 3 | 	<responsibilities>
 4 | 		I am a test resource
 5 | 	</responsibilities>
 6 | </fusedoc>
 7 | --->
 8 | 
 9 | <cfcomponent extends="restfulcf.framework.core.Resource" output="no">
10 | 
11 | 	<!--- standard 'model' fields --->
12 | 	<cfproperty name="id"                type="numeric"  default="1">
13 | 	<cfproperty name="name"              type="string"   default="Default">
14 | 	<cfproperty name="email"             type="string"   default="test@test.com">
15 | 	<cfproperty name="location">
16 | 	<cfproperty name="created_at"        type="date"     default="{ts '1978-09-22 00:00:00'}">
17 | 	<cfproperty name="updated_at"        type="date"     default="{ts '1978-09-22 00:00:00'}">
18 | 
19 | 	<!--- 'foreign keys' (anything with _id is an integer by default)--->
20 | 	<cfproperty name="remote_id"                         default="2">
21 | 	<cfproperty name="numeric_id"        type="numeric"  default="3">
22 | 	<cfproperty name="decimal_id"        type="numeric"  default="3.45" precision="decimal">
23 | 	<cfproperty name="string_id"         type="string"   default="x">
24 | 
25 | 	<!--- numeric preceision --->
26 | 	<cfproperty name="numeric"           type="numeric"  default="0.2e3"  precision="any">
27 | 	<cfproperty name="integer"           type="numeric"  default="3"      precision="integer">
28 | 	<cfproperty name="decimal"           type="numeric"  default="4.56"   precision="decimal">
29 | 	<cfproperty name="float"             type="numeric"  default="7.8"    precision="float">
30 | 
31 | 	<!--- date precision --->
32 | 	<cfproperty name="date_only"         type="date"     default="{ts '1978-09-22 00:00:00'}"   precision="date">
33 | 	<cfproperty name="time_only"         type="date"     default="{ts '1978-09-22 12:34:56'}"   precision="time">
34 | 	<cfproperty name="date_and_time"     type="date"     default="{ts '1978-09-22 12:34:56'}"   precision="datetime">
35 | 
36 | 	<!--- boolean coercing --->
37 | 	<cfproperty name="boolean"           type="boolean"  default="1">
38 | 
39 | </cfcomponent>
40 | 


--------------------------------------------------------------------------------
/restfulcf/framework/core/ErrorCollection.cfc:
--------------------------------------------------------------------------------
 1 | <!--- -->
 2 | <fusedoc fuse="restfulcf/framework/core/RouteCollection.cfc" language="ColdFusion" specification="2.0">
 3 | 	<responsibilities>
 4 | 		I am a collection of routes
 5 | 	</responsibilities>
 6 | </fusedoc>
 7 | --->
 8 | 
 9 | <cfcomponent extends="restfulcf.framework.core.Resource" output="no">
10 | 
11 | 	<cfproperty name="errors" type="array">
12 | 	<cfset variables.instance = { errors = [] }>
13 | 
14 | 	<cffunction name="init" access="public" returntype="restfulcf.framework.core.ErrorCollection" output="no" hint="I am a general initialiser for this resource">
15 | 		<cfargument name="errors" type="array" required="yes" hint="The array of simple error values">
16 | 		<cfset super.init(argumentcollection=arguments)>
17 | 		<cfreturn this>
18 | 	</cffunction>
19 | 
20 | 	<cffunction name="getErrors" access="public" returntype="array" output="no" hint="Returns the raw array of errors">
21 | 		<cfreturn duplicate(variables.instance.errors)>
22 | 	</cffunction>
23 | 
24 | 	<cffunction name="getErrorCount" access="public" returntype="numeric" output="no" hint="Returns the number of errors in this collection">
25 | 		<cfreturn arraylen(variables.instance.errors)>
26 | 	</cffunction>
27 | 
28 | 	<cffunction name="toXML" access="public" returntype="xml" output="no">
29 | 		<cfset var xml = "">
30 | 		<cfset var error = "">
31 | 		<cfloop array="#variables.instance.errors#" index="error">
32 | 			<cfset xml = xml & "<error>" & xmlformat(error) & "</error>">
33 | 		</cfloop>
34 | 		<cfreturn '<errors type="array">' & xml & '</errors>'>
35 | 	</cffunction>
36 | 
37 | 	<cffunction name="toJSON" access="public" returntype="string" output="no">
38 | 		<cfreturn serializejson(variables.instance.errors)>
39 | 	</cffunction>
40 | 
41 | 	<cffunction name="toHTML" access="public" returntype="string" output="no">
42 | 		<cfset var html = "">
43 | 		<cfset var error = "">
44 | 		<cfloop array="#variables.instance.errors#" index="error">
45 | 			<cfset html = html & "<li>" & htmleditformat(error) & "</li>">
46 | 		</cfloop>
47 | 		<cfreturn '<ul>' & html & '</ul>'>
48 | 	</cffunction>
49 | 
50 | 	<cffunction name="toTxt" access="public" returntype="string" output="no">
51 | 		<cfreturn arraytolist(variables.instance.errors, chr(10))>
52 | 	</cffunction>
53 | 
54 | </cfcomponent>
55 | 


--------------------------------------------------------------------------------
/restfulcf/framework/core/RouteCollection.cfc:
--------------------------------------------------------------------------------
 1 | <!--- -->
 2 | <fusedoc fuse="restfulcf/framework/core/RouteCollection.cfc" language="ColdFusion" specification="2.0">
 3 | 	<responsibilities>
 4 | 		I am a collection of routes
 5 | 	</responsibilities>
 6 | </fusedoc>
 7 | --->
 8 | 
 9 | <cfcomponent output="no">
10 | 
11 | 	<cfset variables.routes = {}>
12 | 
13 | 	<cffunction name="init" access="public" returntype="restfulcf.framework.core.RouteCollection" output="no" hint="I intialise the routes collection">
14 | 		<cfset variables.routes = {}>
15 | 		<cfreturn this>
16 | 	</cffunction>
17 | 
18 | 	<cffunction name="addRoute" access="public" returntype="void" output="no" hint="Adds a given route to the collection">
19 | 		<cfargument name="route" type="restfulcf.framework.core.Route" required="yes" hint="The route to add to the collection">
20 | 		<cfif NOT structkeyexists(variables.routes, arguments.route.getVerb())>
21 | 			<cfset variables.routes[arguments.route.getVerb()] = []>
22 | 		</cfif>
23 | 		<cfset arrayappend(variables.routes[arguments.route.getVerb()], arguments.route)>
24 | 	</cffunction>
25 | 
26 | 	<cffunction name="findRoute" access="public" returntype="restfulcf.framework.core.Route" output="no" hint="Find a route that matches the given request method and path info">
27 | 		<cfargument name="verb" type="string" required="yes" hint="The request method (e.g. GET, POST etc)">
28 | 		<cfargument name="path" type="string" required="yes" hint="The request path to find a route for (e.g. /users/1)">
29 | 		<cfset var route = "">
30 | 		<cfif structkeyexists(variables.routes, arguments.verb)>
31 | 			<cfloop array="#variables.routes[arguments.verb]#" index="route">
32 | 				<cfif route.matches(arguments.verb, arguments.path)>
33 | 					<cfreturn route>
34 | 				</cfif>
35 | 			</cfloop>
36 | 		</cfif>
37 | 		<cfreturn createobject("component", "restfulcf.framework.core.Route")>
38 | 	</cffunction>
39 | 
40 | 	<cffunction name="getRoutes" access="public" returntype="struct" output="no" hint="">
41 | 		<cfreturn variables.routes>
42 | 	</cffunction>
43 | 
44 | 	<cffunction name="toStruct" access="public" returntype="struct" output="no" hint="Returns a basic structure of this route collection">
45 | 		<cfset var rts   = {}>
46 | 		<cfset var verb  = "">
47 | 		<cfset var route = "">
48 | 		<cfloop collection="#variables.routes#" item="verb">
49 | 			<cfloop array="#variables.routes[verb]#" index="route">
50 | 				<cfset rts[route.getVerb() & " " & route.getURI()] = route.getController() & "##" & route.getMethod()>
51 | 			</cfloop>
52 | 		</cfloop>
53 | 		<cfreturn rts>
54 | 	</cffunction>
55 | 
56 | </cfcomponent>
57 | 


--------------------------------------------------------------------------------
/restfulcf/framework/core/ResourceCount.cfc:
--------------------------------------------------------------------------------
 1 | <!--- -->
 2 | <fusedoc fuse="restfulcf/framework/core/ResourceCount.cfc" language="ColdFusion" specification="2.0">
 3 | 	<responsibilities>
 4 | 		I am a resource that represents a simple count
 5 | 	</responsibilities>
 6 | </fusedoc>
 7 | --->
 8 | 
 9 | <cfcomponent extends="restfulcf.framework.core.Resource" output="no">
10 | 
11 | 	<cfset variables.instance.type = "resource">
12 | 	<cfset variables.instance.count = 0>
13 | 
14 | 	<cffunction name="init" access="public" returntype="restfulcf.framework.core.ResourceCount" output="no" hint="I initialise the component">
15 | 		<cfargument name="type" type="string" required="yes" hint="The type of resource that the collection holds">
16 | 		<cfargument name="count" type="numeric" required="no" hint="An optional initial count with which to populate this resource">
17 | 		<cfset var inflector = createobject("component", "restfulcf.framework.util.Inflector")>
18 | 		<cfset variables.instance.type = inflector.variablise(inflector.pluralise(arguments.type))>
19 | 		<cfif structkeyexists(arguments, "count")><cfset variables.instance.count = arguments.count></cfif>
20 | 		<cfreturn this>
21 | 	</cffunction>
22 | 
23 | 	<cffunction name="setCount" access="public" returntype="void" output="no" hint="Sets the count for this resource">
24 | 		<cfargument name="count" type="numeric" required="yes" hint="The count">
25 | 		<cfset variables.instance.count = arguments.count>
26 | 	</cffunction>
27 | 	<cffunction name="incCount" access="public" returntype="void" output="no" hint="Increases the count">
28 | 		<cfargument name="by" type="numeric" required="no" default="1" hint="The amount to increment the count by">
29 | 		<cfset variables.instance.count = variables.instance.count + arguments.by>
30 | 	</cffunction>
31 | 	<cffunction name="decCount" access="public" returntype="void" output="no" hint="Decreases the count">
32 | 		<cfargument name="by" type="numeric" required="no" default="1" hint="The amount to decrease the count by">
33 | 		<cfset variables.instance.count = variables.instance.count - arguments.by>
34 | 	</cffunction>
35 | 
36 | 	<cffunction name="toXML" access="public" returntype="xml" output="no" hint="Returns this resource in XML format">
37 | 		<cfreturn "<#variables.instance.type#><count type=""integer"">#variables.instance.count#</count></#variables.instance.type#>">
38 | 	</cffunction>
39 | 	<cffunction name="toHTML" access="public" returntype="string" output="no" hint="Returns this resource in HTML format">
40 | 		<cfreturn "Number of " & createobject("component", "restfulcf.framework.util.Inflector").humanise(variables.instance.type) & " = " & variables.instance.count>
41 | 	</cffunction>
42 | 
43 | </cfcomponent>
44 | 


--------------------------------------------------------------------------------
/restfulcf/framework/core/cache/ApplicationCache.cfc:
--------------------------------------------------------------------------------
 1 | <!--- -->
 2 | <fusedoc fuse="restfulcf/framework/core/cache/ApplicationCache.cfc" language="ColdFusion" specification="2.0">
 3 | 	<responsibilities>
 4 | 		I am a concrete implementation of an abstract cache that uses the application scope.
 5 | 
 6 | 		NOTE: You probably don't want to use this: there's no reaper, so it could end up being
 7 | 		quite a memory hog, plus it's not the most efficient.  Just use it as an example of
 8 | 		what you need to do to create your own concrete cache (using memcached or something
 9 | 		similar, maybe...)
10 | 	</responsibilities>
11 | </fusedoc>
12 | --->
13 | 
14 | <cfcomponent extends="restfulcf.framework.core.cache.AbstractCache" output="no">
15 | 
16 | 	<cffunction name="init" access="public" returntype="restfulcf.framework.core.cache.ApplicationCache" output="no" hint="Initialises this cache">
17 | 		<cfargument name="timeout" type="numeric" required="no" hint="">
18 | 		<cfset super.init(argumentcollection=arguments)>
19 | 		<cfif NOT structkeyexists(application['_restfulcf'], application.applicationname & "_cache")>
20 | 			<cfset application['_restfulcf'][application.applicationname & "_cache"] = {}>
21 | 		</cfif>
22 | 		<cfset variables.cache = application['_restfulcf'][application.applicationname & "_cache"]>
23 | 		<cfreturn this>
24 | 	</cffunction>
25 | 
26 | 	<cffunction name="getKey" access="public" returntype="string" output="no" hint="Get a response from the cache">
27 | 		<cfargument name="key" type="string" required="yes" hint="The key to retrieve">
28 | 		<cfset var resp = "">
29 | 		<cfif structkeyexists(variables.cache, arguments.key)>
30 | 			<cfif structkeyexists(variables.cache[arguments.key], "expires") AND variables.cache[arguments.key].expires GT NOW()>
31 | 				<cfset resp = variables.cache[arguments.key].value>
32 | 			<cfelse>
33 | 				<cfset deleteKey(arguments.key)>
34 | 			</cfif>
35 | 		</cfif>
36 | 		<cfreturn resp>
37 | 	</cffunction>
38 | 	<cffunction name="setKey" access="public" returntype="string" output="no" hint="Sets a given value for a given key in the cache">
39 | 		<cfargument name="key" type="string" required="yes" hint="The key to set">
40 | 		<cfargument name="value" type="string" required="yes" hint="The value to store">
41 | 		<cfargument name="expires" type="numeric" required="yes" hint="The cache expiry date time">
42 | 		<cfset variables.cache[arguments.key] = { value = arguments.value, expires = arguments.expires }>
43 | 	</cffunction>
44 | 	<cffunction name="deleteKey" access="public" returntype="void" output="no" hint="Deletes a given key from the cache">
45 | 		<cfargument name="key" type="string" required="yes" hint="The key to delete">
46 | 		<cfset structdelete(variables.cache, arguments.key)>
47 | 	</cffunction>
48 | 
49 | </cfcomponent>
50 | 


--------------------------------------------------------------------------------
/restfulcf/framework/util/XML.cfc:
--------------------------------------------------------------------------------
 1 | <!--- -->
 2 | <fusedoc fuse="restfulcf/framework/util/XML.cfc" language="ColdFusion" specification="2.0">
 3 | 	<responsibilities>
 4 | 		Conversion of XML to useable structure/array.
 5 | 	</responsibilities>
 6 | </fusedoc>
 7 | --->
 8 | 
 9 | <cfcomponent output="no">
10 | 
11 | 	<cffunction name="toStruct" access="public" returntype="any" output="no" hint="A very simple functino for converting an XML document to a simple combination of structures and arrays.">
12 | 		<cfargument name="xml" type="xml" required="yes" hint="The XML to convert to a structure, either as an XML string or node object">
13 | 		<cfargument name="depth" type="numeric" required="no" default="999" hint="How deep in to the XML structure should we go?">
14 | 		<cfargument name="include_attr" type="boolean" required="no" default="TRUE" hint="Should XML attributes also be included in the returned structure?">
15 | 		<cfargument name="include_root" type="boolean" required="no" default="TRUE" hint="Should the root node be included?">
16 | 		<cfset var local = {}>
17 | 		<cfset local.xml_str = {}>
18 | 		<cfset local.root = xmlparse(arguments.xml).xmlroot>
19 | 		<cfif arraylen(local.root.xmlchildren) AND arguments.depth GTE 1>
20 | 			<cfloop array="#local.root.xmlchildren#" index="local.child">
21 | 				<cfset local.child_str = toStruct(local.child, arguments.depth-1, arguments.include_attr, FALSE)>
22 | 				<cfif structkeyexists(local.xml_str, local.child.xmlname)>
23 | 					<cfif NOT isarray(local.xml_str[local.child.xmlname])>
24 | 						<cfset local.orig_val = local.xml_str[local.child.xmlname]>
25 | 						<cfset local.xml_str[local.child.xmlname] = [local.orig_val]>
26 | 						<cfif arguments.include_attr>
27 | 							<cfset local.orig_attr = local.xml_str[local.child.xmlname & "::attributes"]>
28 | 							<cfset local.xml_str[local.child.xmlname & "::attributes"] = [local.orig_attr]>
29 | 						</cfif>
30 | 					</cfif>
31 | 					<cfset arrayappend(local.xml_str[local.child.xmlname], local.child_str)>
32 | 					<cfif arguments.include_attr>
33 | 						<cfset arrayappend(local.xml_str[local.child.xmlname & "::attributes"],  local.child.xmlattributes)>
34 | 					</cfif>
35 | 				<cfelse>
36 | 					<cfset local.xml_str[local.child.xmlname] = local.child_str>
37 | 					<cfif arguments.include_attr>
38 | 						<cfset local.xml_str[local.child.xmlname & "::attributes"] = local.child.xmlattributes>
39 | 					</cfif>
40 | 				</cfif>
41 | 			</cfloop>
42 | 		<cfelse>
43 | 			<cfset local.xml_str = local.root.xmltext>
44 | 		</cfif>
45 | 		<cfif arguments.include_root>
46 | 			<cfset local.rooted_xml = {}>
47 | 			<cfset local.rooted_xml[local.root.xmlname] = local.xml_str>
48 | 			<cfif arguments.include_attr>
49 | 				<cfset local.rooted_xml[local.root.xmlname & "::attributes"] = local.root.xmlattributes>
50 | 			</cfif>
51 | 			<cfset local.xml_str = local.rooted_xml>
52 | 		</cfif>
53 | 		<cfreturn local.xml_str>
54 | 	</cffunction>
55 | 
56 | </cfcomponent>
57 | 


--------------------------------------------------------------------------------
/restfulcf/framework/core/Controller.cfc:
--------------------------------------------------------------------------------
 1 | <!--- -->
 2 | <fusedoc fuse="restfulcf/framework/core/Controller.cfc" language="ColdFusion" specification="2.0">
 3 | 	<responsibilities>
 4 | 		I am the base of all controllers which hold domain over the various resources
 5 | 	</responsibilities>
 6 | </fusedoc>
 7 | --->
 8 | 
 9 | <cfcomponent output="no">
10 | 
11 | 	<!--- static lookup for HTTP response codes --->
12 | 	<cfset this.HTTP_STATUS_CODES = {
13 | 		continue                         = "100",
14 | 		switching_protocols              = "101",
15 | 		processing                       = "102",
16 | 		ok                               = "200",
17 | 		created                          = "201",
18 | 		accepted                         = "202",
19 | 		non_authoritative_information    = "203",
20 | 		no_content                       = "204",
21 | 		reset_content                    = "205",
22 | 		partial_content                  = "206",
23 | 		multi_status                     = "207",
24 | 		im_used                          = "226",
25 | 		multiple_choices                 = "300",
26 | 		moved_permanently                = "301",
27 | 		found                            = "302",
28 | 		see_other                        = "303",
29 | 		not_modified                     = "304",
30 | 		use_proxy                        = "305",
31 | 		temporary_redirect               = "307",
32 | 		bad_request                      = "400",
33 | 		unauthorized                     = "401",
34 | 		payment_required                 = "402",
35 | 		forbidden                        = "403",
36 | 		not_found                        = "404",
37 | 		method_not_allowed               = "405",
38 | 		not_acceptable                   = "406",
39 | 		proxy_authentication_required    = "407",
40 | 		request_timeout                  = "408",
41 | 		conflict                         = "409",
42 | 		gone                             = "410",
43 | 		length_required                  = "411",
44 | 		precondition_failed              = "412",
45 | 		request_entity_too_large         = "413",
46 | 		request_uri_too_long             = "414",
47 | 		unsupported_media_type           = "415",
48 | 		requested_range_not_satisfiable  = "416",
49 | 		expectation_failed               = "417",
50 | 		unprocessable_entity             = "422",
51 | 		locked                           = "423",
52 | 		failed_dependency                = "424",
53 | 		upgrade_required                 = "426",
54 | 		internal_server_error            = "500",
55 | 		not_implemented                  = "501",
56 | 		bad_gateway                      = "502",
57 | 		service_unavailable              = "503",
58 | 		gateway_timeout                  = "504",
59 | 		http_version_not_supported       = "505",
60 | 		insufficient_storage             = "507",
61 | 		not_extended                     = "510"
62 | 	}>
63 | 
64 | 	<cffunction name="init" access="public" returntype="restfulcf.framework.core.Controller" output="no" hint="Basic contructor that just returns the instance">
65 | 		<cfreturn this>
66 | 	</cffunction>
67 | 
68 | </cfcomponent>
69 | 


--------------------------------------------------------------------------------
/restfulcf/test/tests/core/ResourceCountTest.cfc:
--------------------------------------------------------------------------------
 1 | <!--- -->
 2 | <fusedoc fuse="restfulcf/test/tests/core/ResourceCountTest.cfc" language="ColdFusion" specification="2.0">
 3 | 	<responsibilities>
 4 | 		I test the resource count component
 5 | 	</responsibilities>
 6 | </fusedoc>
 7 | --->
 8 | 
 9 | <cfcomponent extends="mxunit.framework.TestCase">
10 | 
11 | 	<cffunction name="setup">
12 | 		<cfset counter = createobject("component", "restfulcf.framework.core.ResourceCount").init("resource_fixtures", 10)>
13 | 	</cffunction>
14 | 
15 | 	<!--- basic counts --->
16 | 	<cffunction name="the_count_for_an_uninitalised_counter_should_be_zero">
17 | 		<cfset assertEquals(0, createobject("component", "restfulcf.framework.core.ResourceCount").getCount())>
18 | 	</cffunction>
19 | 	<cffunction name="the_count_for_an_initialised_counter_should_be_correct">
20 | 		<cfset assertEquals(10, counter.getCount())>
21 | 	</cffunction>
22 | 	<cffunction name="the_count_should_be_correct_after_being_set">
23 | 		<cfset counter.setCount(20)>
24 | 		<cfset assertEquals(20, counter.getCount())>
25 | 	</cffunction>
26 | 
27 | 	<!--- increasing and decreasing --->
28 | 	<cffunction name="increasing_the_count_should_with_no_arguments_should_inc_by_1">
29 | 		<cfset counter.incCount()>
30 | 		<cfset assertEquals(11, counter.getCount())>
31 | 	</cffunction>
32 | 	<cffunction name="increasing_the_count_by_2_should_inc_by_2">
33 | 		<cfset counter.incCount(2)>
34 | 		<cfset assertEquals(12, counter.getCount())>
35 | 	</cffunction>
36 | 	<cffunction name="increasing_the_count_by_minus_1_should_dec_by_1">
37 | 		<cfset counter.incCount(-1)>
38 | 		<cfset assertEquals(9, counter.getCount())>
39 | 	</cffunction>
40 | 	<cffunction name="decreasing_the_count_should_with_no_arguments_should_dec_by_1">
41 | 		<cfset counter.decCount()>
42 | 		<cfset assertEquals(9, counter.getCount())>
43 | 	</cffunction>
44 | 	<cffunction name="decreasing_the_count_should_by_2_should_dec_by_2">
45 | 		<cfset counter.decCount(2)>
46 | 		<cfset assertEquals(8, counter.getCount())>
47 | 	</cffunction>
48 | 	<cffunction name="decreasing_the_count_by_minus_1_should_inc_by_1">
49 | 		<cfset counter.decCount(-1)>
50 | 		<cfset assertEquals(11, counter.getCount())>
51 | 	</cffunction>
52 | 
53 | 	<!--- transforms --->
54 | 	<cffunction name="to_xml_should_return_a_valid_xml_packet">
55 | 		<cfset assertTrue(isxml(counter.toXML()))>
56 | 	</cffunction>
57 | 	<cffunction name="to_xml_should_return_a_root_node_with_the_correct_name">
58 | 		<cfset assertXpath("/resource_fixtures", xmlparse(counter.toXML()))>
59 | 	</cffunction>
60 | 	<cffunction name="to_xml_should_return_a_count_node">
61 | 		<cfset var xml = xmlparse(counter.toXML())>
62 | 		<cfset var nodes = xmlsearch(xml, "/resource_fixtures/count")>
63 | 		<cfset assertEquals(1, arraylen(nodes))>
64 | 		<cfset assertEquals(10, nodes[1].xmltext)>
65 | 	</cffunction>
66 | 	<cffunction name="to_html_should_return_a_string_containing_the_type_and_count">
67 | 		<cfset assertEquals("Number of resource fixtures = 10", counter.toHTML())>
68 | 	</cffunction>
69 | 
70 | </cfcomponent>
71 | 


--------------------------------------------------------------------------------
/restfulcf/test/tests/core/RouteCollectionTest.cfc:
--------------------------------------------------------------------------------
 1 | <!--- -->
 2 | <fusedoc fuse="restfulcf/test/tests/core/RouteCollectionTest.cfc" language="ColdFusion" specification="2.0">
 3 | 	<responsibilities>
 4 | 		I test the route collection component
 5 | 	</responsibilities>
 6 | </fusedoc>
 7 | --->
 8 | 
 9 | <cfcomponent extends="mxunit.framework.TestCase">
10 | 
11 | 	<cffunction name="setup">
12 | 		<cfset collection = createobject("component", "restfulcf.framework.core.RouteCollection").init()>
13 | 	</cffunction>
14 | 
15 | 	<cffunction name="empty_collection_should_return_no_routes">
16 | 		<cfset assertTrue(structisempty(collection.getRoutes()))>
17 | 	</cffunction>
18 | 
19 | 	<cffunction name="collection_should_correctly_assign_routes_by_verb">
20 | 		<cfset var get = createobject("component", "restfulcf.framework.core.Route").init("GET", "x", "x", "x")>
21 | 		<cfset var put = createobject("component", "restfulcf.framework.core.Route").init("PUT", "x", "x", "x")>
22 | 		<cfset var routes = {}>
23 | 		<cfset collection.addRoute(get)>
24 | 		<cfset collection.addRoute(put)>
25 | 		<cfset assertFalse(structisempty(collection.getRoutes()))>
26 | 		<cfset routes = collection.getRoutes()>
27 | 		<cfset assertTrue(structkeyexists(routes, "GET") AND isarray(routes['GET']), "GET route was provided to collection but hasn't been returned")>
28 | 		<cfset assertTrue(structkeyexists(routes, "PUT") AND isarray(routes['PUT']), "PUT route was provided to collection but hasn't been returned")>
29 | 		<cfset assertFalse(structkeyexists(routes, "POST"), "POST route exists in collection when not provided")>
30 | 		<cfset assertSame(routes['GET'][1], get, "GET route from collection doesn't match provided route")>
31 | 		<cfset assertSame(routes['PUT'][1], put, "PUT route from collection doesn't match provided route")>
32 | 	</cffunction>
33 | 
34 | 	<cffunction name="collection_should_find_matching_route">
35 | 		<cfset var route = createobject("component", "restfulcf.framework.core.Route").init("GET", "/test/route/:id", "x", "x")>
36 | 		<cfset collection.addRoute(route)>
37 | 		<cfset collection.addRoute(createobject("component", "restfulcf.framework.core.Route").init("PUT", "/test/route/:id", "x", "x"))>
38 | 		<cfset collection.addRoute(createobject("component", "restfulcf.framework.core.Route").init("POST", "/test/route/:id", "x", "x"))>
39 | 		<cfset collection.addRoute(createobject("component", "restfulcf.framework.core.Route").init("DELETE", "/test/route/:id", "x", "x"))>
40 | 		<cfset assertSame(route, collection.findRoute("GET", "/test/route/1"))>
41 | 	</cffunction>
42 | 
43 | 	<cffunction name="collection_should_return_invalid_route_for_unmatched_uri">
44 | 		<cfset collection.addRoute(createobject("component", "restfulcf.framework.core.Route").init("GET", "/test/route/:id", "x", "x"))>
45 | 		<cfset collection.addRoute(createobject("component", "restfulcf.framework.core.Route").init("PUT", "/test/route/:id", "x", "x"))>
46 | 		<cfset assertEquals("INVALID", collection.findRoute("GET", "/fail/route").getVerb())>
47 | 		<cfset assertEquals("INVALID", collection.findRoute("POST", "/fail/route").getVerb())>
48 | 	</cffunction>
49 | 
50 | 	<cffunction name="collection_should_return_all_routes_as_a_simple_struct">
51 | 		<cfset var uris = ["PUT /test/route/:id", "POST /test/route/:id", "DELETE /test/route/:id"]>
52 | 		<cfset var uri = "">
53 | 		<cfset var routes = {}>
54 | 		<cfloop array="#uris#" index="uri">
55 | 			<cfset collection.addRoute(createobject("component", "restfulcf.framework.core.Route").init(listfirst(uri, " "), listrest(uri, " "), "test", lcase(listfirst(uri, " "))))>
56 | 		</cfloop>
57 | 		<cfset routes = collection.toStruct()>
58 | 		<cfloop array="#uris#" index="uri">
59 | 			<cfif NOT structkeyexists(routes, uri)><cfset fail("Could not find expected route #uri#")></cfif>
60 | 			<cfset assertEquals("test##" & lcase(listfirst(uri, " ")), routes[uri])>
61 | 		</cfloop>
62 | 	</cffunction>
63 | 
64 | </cfcomponent>
65 | 


--------------------------------------------------------------------------------
/restfulcf/test/tests/core/RouteTest.cfc:
--------------------------------------------------------------------------------
  1 | <!--- -->
  2 | <fusedoc fuse="restfulcf/test/tests/core/RouteTest.cfc" language="ColdFusion" specification="2.0">
  3 | 	<responsibilities>
  4 | 		I test the route component
  5 | 	</responsibilities>
  6 | </fusedoc>
  7 | --->
  8 | 
  9 | <cfcomponent extends="mxunit.framework.TestCase">
 10 | 
 11 | 	<cffunction name="setup">
 12 | 		<cfset args = {
 13 | 			verb       = "GET",
 14 | 			uri        = "/resources/:id",
 15 | 			controller = "resources",
 16 | 			method     = "index"
 17 | 		}>
 18 | 		<cfset route = createobject("component", "restfulcf.framework.core.Route").init(argumentcollection=args)>
 19 | 	</cffunction>
 20 | 
 21 | 	<cffunction name="uninitialised_route_should_have_invalid_verb">
 22 | 		<cfset assertEquals("INVALID", createobject("component", "restfulcf.framework.core.Route").getVerb())>
 23 | 	</cffunction>
 24 | 
 25 | 	<cffunction name="route_should_return_correct_verb">
 26 | 		<cfset assertEquals(args.verb, route.getVerb())>
 27 | 	</cffunction>
 28 | 	<cffunction name="route_should_return_correct_uri">
 29 | 		<cfset assertEquals(args.uri, route.getURI())>
 30 | 	</cffunction>
 31 | 	<cffunction name="route_should_return_correct_controller_name">
 32 | 		<cfset assertEquals(args.controller, route.getController())>
 33 | 	</cffunction>
 34 | 	<cffunction name="route_should_return_correct_method_name">
 35 | 		<cfset assertEquals(args.method, route.getMethod())>
 36 | 	</cffunction>
 37 | 
 38 | 	<cffunction name="route_should_return_correct_verb_after_changing_verb">
 39 | 		<cfset route.setVerb("POST")>
 40 | 		<cfset assertEquals("POST", route.getVerb())>
 41 | 	</cffunction>
 42 | 	<cffunction name="route_should_return_correct_uri_after_changing_uri">
 43 | 		<cfset route.setURI("/changes/:id")>
 44 | 		<cfset assertEquals("/changes/:id", route.getURI())>
 45 | 	</cffunction>
 46 | 	<cffunction name="route_should_return_correct_controller_name_after_changing_controller">
 47 | 		<cfset route.setController("changes")>
 48 | 		<cfset assertEquals("changes", route.getController())>
 49 | 	</cffunction>
 50 | 	<cffunction name="route_should_return_correct_method_name_after_changing_method">
 51 | 		<cfset route.setMethod("changed")>
 52 | 		<cfset assertEquals("changed", route.getMethod())>
 53 | 	</cffunction>
 54 | 
 55 | 	<cffunction name="route_should_raise_exception_on_invalid_verb">
 56 | 		<cftry>
 57 | 			<cfset route.setVerb("INVALID")>
 58 | 			<cfset fail("Setting invalid verb for route should have raised an exception")>
 59 | 			<cfcatch type="coldfusion.tagext.validations.AttributeValueNotFromListException"></cfcatch>
 60 | 		</cftry>
 61 | 	</cffunction>
 62 | 
 63 | 	<cffunction name="route_should_match_for_valid_uri_path">
 64 | 		<cfset assertTrue(route.matches(route.getVerb(), "/resources/1"))>
 65 | 	</cffunction>
 66 | 	<cffunction name="route_should_not_match_for_invalid_uri_path">
 67 | 		<cfset assertFalse(route.matches(route.getVerb(), "/fail/test"))>
 68 | 	</cffunction>
 69 | 	<cffunction name="route_should_not_match_for_invalid_verb">
 70 | 		<cfset assertFalse(route.matches("INVALID", "/resources/1"))>
 71 | 	</cffunction>
 72 | 	<cffunction name="complex_uri_route_should_match_for_valid_uri_path">
 73 | 		<cfset route.setURI("/complex/:id/route/:part/:another")>
 74 | 		<cfset assertTrue(route.matches(route.getVerb(), "/complex/1/route/2/3"))>
 75 | 	</cffunction>
 76 | 	<cffunction name="complex_uri_route_should_not_match_for_invalid_uri_path">
 77 | 		<cfset route.setURI("/complex/:id/route/:part/:another")>
 78 | 		<cfset assertFalse(route.matches(route.getVerb(), "/complex/1/route/2/3/fail"))>
 79 | 	</cffunction>
 80 | 
 81 | 	<cffunction name="route_should_return_correct_path_vars">
 82 | 		<cfset var vars = route.getPathVars("/resources/1")>
 83 | 		<cfset assertEquals(1, arraylen(structkeyarray(vars)), "Wrong number of path variables returned")>
 84 | 		<cfset assertTrue(structkeyexists(vars, "id"), "Path var 'id' expected but not present")>
 85 | 		<cfset assertEquals(1, vars['id'], "Path var 'id' has unexpected value")>
 86 | 	</cffunction>
 87 | 	<cffunction name="complex_uri_route_should_return_path_vars">
 88 | 		<cfset var ret = "">
 89 | 		<cfset var vars = "id|1,part|2,another|3">
 90 | 		<cfset var bit = "">
 91 | 		<cfset route.setURI("/complex/:id/route/:part/:another")>
 92 | 		<cfset ret = route.getPathVars("/complex/1/route/2/3")>
 93 | 		<cfset assertEquals(3, arraylen(structkeyarray(ret)), "Wrong number of path variables returned")>
 94 | 		<cfloop list="#vars#" index="bit">
 95 | 			<cfset assertTrue(structkeyexists(ret, listgetat(bit, 1, '|')), "Path var '#listgetat(bit, 1, '|')#' expected but not present")>
 96 | 			<cfset assertEquals(listgetat(bit, 2, '|'), ret[listgetat(bit, 1, '|')], "Path var '#listgetat(bit, 1, '|')#' has unexpected value")>
 97 | 		</cfloop>
 98 | 	</cffunction>
 99 | 
100 | </cfcomponent>
101 | 


--------------------------------------------------------------------------------
/restfulcf/test/tests/core/ResponseTest.cfc:
--------------------------------------------------------------------------------
  1 | <!--- -->
  2 | <fusedoc fuse="restfulcf/test/tests/core/ResponseTest.cfc" language="ColdFusion" specification="2.0">
  3 | 	<responsibilities>
  4 | 		I test the response object
  5 | 	</responsibilities>
  6 | </fusedoc>
  7 | --->
  8 | 
  9 | <cfcomponent extends="mxunit.framework.TestCase">
 10 | 
 11 | 	<cffunction name="setup">
 12 | 		<cfset response = createobject("component", "restfulcf.framework.core.Response").init()>
 13 | 	</cffunction>
 14 | 
 15 | 	<!--- initialisation --->
 16 | 	<cffunction name="init_should_return_the_response_object">
 17 | 		<cfset assertIsTypeOf(response, "restfulcf.framework.core.Response")>
 18 | 	</cffunction>
 19 | 
 20 | 	<!--- basic gets/sets --->
 21 | 	<cffunction name="should_have_a_default_status_code_of_200">
 22 | 		<cfset assertEquals(200, response.getStatusCode())>
 23 | 	</cffunction>
 24 | 	<cffunction name="should_have_a_default_response_type_of_application_xml">
 25 | 		<cfset assertEquals("application/xml", response.getResponseType())>
 26 | 	</cffunction>
 27 | 	<cffunction name="should_return_the_correct_status_code_after_set">
 28 | 		<cfset response.setStatusCode(500)>
 29 | 		<cfset assertEquals(500, response.getStatusCode())>
 30 | 	</cffunction>
 31 | 	<cffunction name="should_return_the_correct_status_text_after_set">
 32 | 		<cfset response.setStatusText("OK")>
 33 | 		<cfset assertEquals("OK", response.getStatusText())>
 34 | 	</cffunction>
 35 | 	<cffunction name="should_return_the_correct_response_type_after_set">
 36 | 		<cfset response.setResponseType("text/plain")>
 37 | 		<cfset assertEquals("text/plain", response.getResponseType())>
 38 | 	</cffunction>
 39 | 	<cffunction name="should_return_the_correct_response_uri_after_set">
 40 | 		<cfset response.setResponseURI("/test/1")>
 41 | 		<cfset assertEquals("/test/1", response.getResponseURI())>
 42 | 	</cffunction>
 43 | 	<cffunction name="should_return_the_correct_response_body_after_set">
 44 | 		<cfset response.setResponseBody("body")>
 45 | 		<cfset assertEquals("body", response.getResponseBody())>
 46 | 	</cffunction>
 47 | 
 48 | 	<!--- error handling --->
 49 | 	<cffunction name="should_have_no_errors_before_any_errors_have_been_added">
 50 | 		<cfset assertFalse(response.hasErrors())>
 51 | 	</cffunction>
 52 | 	<cffunction name="should_have_errors_after_an_error_has_been_added">
 53 | 		<cfset response.addError("Error 1")>
 54 | 		<cfset assertTrue(response.hasErrors())>
 55 | 	</cffunction>
 56 | 	<cffunction name="should_return_an_empty_error_collection_without_errors">
 57 | 		<cfset assertEquals(0, response.getErrorCollection().getErrorCount())>
 58 | 	</cffunction>
 59 | 	<cffunction name="should_return_a_populated_error_collection_with_errors">
 60 | 		<cfset response.addError("Error 1")>
 61 | 		<cfset assertEquals(1, response.getErrorCollection().getErrorCount())>
 62 | 		<cfset response.addError("Error 2")>
 63 | 		<cfset assertEquals(2, response.getErrorCollection().getErrorCount())>
 64 | 	</cffunction>
 65 | 	<cffunction name="should_return_an_error_collection_with_the_correct_errors">
 66 | 		<cfset var err = []>
 67 | 		<cfset response.addError("Error 1")>
 68 | 		<cfset response.addError("Error 2")>
 69 | 		<cfset err = response.getErrorCollection().getErrors()>
 70 | 		<cfset assertEquals("Error 1", err[1])>
 71 | 		<cfset assertEquals("Error 2", err[2])>
 72 | 	</cffunction>
 73 | 
 74 | 	<!--- cache handling --->
 75 | 	<cffunction name="default_cache_status_should_be_false">
 76 | 		<cfset assertFalse(response.getCacheStatus())>
 77 | 	</cffunction>
 78 | 	<cffunction name="cache_status_should_be_true_after_setting_to_true">
 79 | 		<cfset response.setCacheStatus(TRUE)>
 80 | 		<cfset assertTrue(response.getCacheStatus())>
 81 | 	</cffunction>
 82 | 	<cffunction name="default_cache_expiry_should_be_zero">
 83 | 		<cfset assertEquals(0, response.getCacheExpiry())>
 84 | 	</cffunction>
 85 | 	<cffunction name="cache_expiry_should_be_correct_after_setting">
 86 | 		<cfset var timeout = createtimespan(1,2,3,4)>
 87 | 		<cfset response.setCacheExpiry(timeout)>
 88 | 		<cfset assertEquals(timeout, response.getCacheExpiry())>
 89 | 	</cffunction>
 90 | 	<cffunction name="default_cache_hit_status_should_be_false">
 91 | 		<cfset assertFalse(response.getCacheHit())>
 92 | 	</cffunction>
 93 | 	<cffunction name="cache_hit_status_should_be_true_after_setting_to_true">
 94 | 		<cfset response.setCacheHit(TRUE)>
 95 | 		<cfset assertTrue(response.getCacheHit())>
 96 | 	</cffunction>
 97 | 	<cffunction name="default_cache_key_should_be_empty">
 98 | 		<cfset assertEquals("", response.getCacheKey())>
 99 | 	</cffunction>
100 | 	<cffunction name="cache_key_should_be_correct_after_setting">
101 | 		<cfset var key = createuuid()>
102 | 		<cfset response.setCacheKey(key)>
103 | 		<cfset assertEquals(key, response.getCacheKey())>
104 | 	</cffunction>
105 | 
106 | </cfcomponent>
107 | 


--------------------------------------------------------------------------------
/restfulcf/framework/tags/endpoint.cfm:
--------------------------------------------------------------------------------
 1 | <cfsetting enablecfoutputonly="yes">
 2 | <!--- -->
 3 | <fusedoc fuse="restfulcf/framework/tags/endpoint.cfm" language="ColdFusion" specification="2.0">
 4 | 	<responsibilities>
 5 | 		I am the custom tag that pulls all REST requests together
 6 | 	</responsibilities>
 7 | </fusedoc>
 8 | --->
 9 | 
10 | <!--- tags get called twice if there are closing tags --->
11 | <cfif thisTag.executionMode NEQ "start"><cfexit method="exittemplate"></cfif>
12 | 
13 | <!--- must provide name and engine; reload and debug options are optional --->
14 | <cfparam name="attributes.name" type="string">
15 | <cfparam name="attributes.engine" type="string">
16 | <cfparam name="attributes.reload" type="boolean" default="false">
17 | <!--- optional parameter of somewhere to put the response for further processing --->
18 | <cfparam name="attributes.response" type="string">
19 | 
20 | <!--- reset any previously generated content straight away --->
21 | <cfcontent reset="true">
22 | 
23 | <!--- intialise the RestfulCF instance engine if required --->
24 | <cfif NOT structKeyExists(application, "_restfulcf") OR attributes.reload>
25 | 	<cfset variables.app = createobject("component", attributes.engine)>
26 | 	<cflock scope="application" type="exclusive" timeout="25" throwontimeout="true">
27 | 		<cfset application['_restfulcf'][attributes.name] = variables.app>
28 | 	</cflock>
29 | 	<cfset variables.app.init()>
30 | </cfif>
31 | 
32 | <!--- work out the request method (PUT and DELETE can be simulated via a POST using a _method=X parameter) --->
33 | <cfset variables.request_method = cgi.request_method>
34 | <cfif variables.request_method EQ "POST">
35 | 	<cfif structkeyexists(url, "_method") AND listfind("PUT,DELETE", url['_method'])>
36 | 		<cfset variables.request_method = ucase(url['_method'])>
37 | 		<cfset structdelete(url, "_method")>
38 | 	</cfif>
39 | 	<cfif structkeyexists(form, "_method") AND listfind("PUT,DELETE", form['_method'])>
40 | 		<cfset variables.request_method = ucase(form['_method'])>
41 | 		<cfset structdelete(form, "_method")>
42 | 		<cfif structkeyexists(form, "fieldnames") AND listfindnocase(form.fieldnames, "_method")>
43 | 			<cfset form.fieldnames = listdeleteat(form.fieldnames, listfindnocase(form.fieldnames, "_method"))>
44 | 		</cfif>
45 | 	</cfif>
46 | </cfif>
47 | 
48 | <!--- dispatch the request --->
49 | <cfset variables.response = application['_restfulcf'][attributes.name].dispatch(variables.request_method, cgi.path_info)>
50 | 
51 | <!--- set the location header if there's anything to set (e.g. after a create) --->
52 | <cfif len(variables.response.getResponseURI())><cfheader name="Location" value="#variables.response.getResponseURI()#"></cfif>
53 | <!--- serve up binary content straight from a file if there's a filename --->
54 | <cfif len(variables.response.getResponseFile())>
55 | 	<cfif fileexists(variables.response.getResponseFile())>
56 | 		<cfcontent reset="true" type="#variables.response.getResponseType()#" file="#variables.response.getResponseFile()#">
57 | 	<cfelse>
58 | 		<cfset variables.response.setStatusCode("404")>
59 | 		<cfset variables.response.setStatusText("Static file not found")>
60 | 	</cfif>
61 | <!--- output main content if anything's been generated --->
62 | <cfelseif len(variables.response.getResponseBody())>
63 | 	<!--- final checks and mungings --->
64 | 	<cfswitch expression="#variables.response.getResponseType()#">
65 | 		<!--- handling of XML in case the response isn't actually XML at all... --->
66 | 		<cfcase value="application/xml">
67 | 			<cfif isxml(variables.response.getResponseBody())>
68 | 				<cfset variables.response.setResponseBody('<?xml version="1.0" encoding="UTF-8"?>#chr(10)#' & variables.response.getResponseBody())>
69 | 			<cfelse>
70 | 				<cfset variables.response.setResponseType("text/html")>
71 | 			</cfif>
72 | 		</cfcase>
73 | 		<!--- and handling to allow JSONP with a __callback request option --->
74 | 		<cfcase value="text/javascript">
75 | 			<cfset variables.request_options = variables.response.getRequest().getOptions()>
76 | 			<cfif structkeyexists(variables.request_options, "callback")>
77 | 				<cfset variables.response.setResponseBody(variables.request_options['callback'] & "(" & variables.response.getResponseBody() & ")")>
78 | 			</cfif>
79 | 		</cfcase>
80 | 	</cfswitch>
81 | 	<cfcontent reset="true" type="#variables.response.getResponseType()#; charset=utf-8"><cfoutput>#variables.response.getResponseBody()#</cfoutput>
82 | </cfif>
83 | <cfif len(variables.response.getStatusText())>
84 | 	<cfheader statuscode="#variables.response.getStatusCode()#" statustext="#variables.response.getStatusText()#">
85 | <cfelse>
86 | 	<cfheader statuscode="#variables.response.getStatusCode()#">
87 | </cfif>
88 | 
89 | <!--- push the response object out if required --->
90 | <cfif structkeyexists(attributes, "response")><cfset caller[attributes.response] = variables.response></cfif>
91 | 


--------------------------------------------------------------------------------
/restfulcf/test/tests/util/XMLTest.cfc:
--------------------------------------------------------------------------------
 1 | <!--- -->
 2 | <fusedoc fuse="restfulcf/test/tests/util/XMLTest.cfc" language="ColdFusion" specification="2.0">
 3 | 	<responsibilities>
 4 | 		I test the XML component functions to make sure they work
 5 | 	</responsibilities>
 6 | </fusedoc>
 7 | --->
 8 | 
 9 | <cfcomponent extends="mxunit.framework.TestCase">
10 | 
11 | 	<cffunction name="setup">
12 | 		<cfset short_xml_string = '<root attr="attr"><node1>node1</node1><node2><field1>field1</field1><field2>field2</field2><field3 attr="attr">field3a</field3><field3>field3b</field3></node2><node3 attr="attr">node3</node3></root>'>
13 | 		<cfset xml = createObject("component", "restfulcf.framework.util.XML")>
14 | 	</cffunction>
15 | 
16 | 	<cffunction name="tostruct_should_return_a_structure_given_an_xml_string">
17 | 		<cfset assertTrue(isstruct(xml.toStruct(short_xml_string)))>
18 | 	</cffunction>
19 | 	<cffunction name="tostruct_should_return_a_structure_given_an_xml_node">
20 | 		<cfset assertTrue(isstruct(xml.toStruct(xmlparse(short_xml_string))))>
21 | 	</cffunction>
22 | 
23 | 	<cffunction name="tostruct_should_return_node_attributes_by_default">
24 | 		<cfset var str = xml.toStruct(short_xml_string)>
25 | 		<cfset assertTrue(structkeyexists(str, "root::attributes") AND isstruct(str["root::attributes"]), "Root node has no attributes collection")>
26 | 		<cfset assertEquals(structcount(str["root::attributes"]), 1, "Root node has incorrect number of attributes")>
27 | 		<cfset assertTrue(structkeyexists(str.root, "node3::attributes") AND isstruct(str.root["node3::attributes"]), "Child node has no attributes collection")>
28 | 		<cfset assertEquals(structcount(str.root["node3::attributes"]), 1, "Child node has incorrect number of attributes")>
29 | 	</cffunction>
30 | 	<cffunction name="tostruct_should_not_return_node_attributes_when_told_not_to">
31 | 		<cfset var str = xml.toStruct(xml=short_xml_string, include_attr = FALSE)>
32 | 		<cfset assertFalse(structkeyexists(str, "root::attributes"), "Root node has attributes but shouldn't")>
33 | 	</cffunction>
34 | 
35 | 	<cffunction name="tostruct_should_return_all_nodes_by_default">
36 | 		<cfset var str = xml.toStruct(xml=short_xml_string, include_root=FALSE)>
37 | 		<cfset assertTrue(structkeyexists(str, "node2") AND isstruct(str.node2), "Node should have children")>
38 | 		<cfset assertTrue(structkeyexists(str.node2, "field2") AND issimplevalue(str.node2.field2), "Child node should have a value")>
39 | 		<cfset assertEquals(str.node2.field2, "field2", "Child node value is incorrect")>
40 | 	</cffunction>
41 | 	<cffunction name="tostruct_should_only_return_nodes_to_a_given_depth">
42 | 		<cfset var str = xml.toStruct(xml=short_xml_string, depth=1, include_root=FALSE)>
43 | 		<cfset assertTrue(structkeyexists(str, "node2") AND issimplevalue(str.node2) AND NOT len(str.node2))>
44 | 	</cffunction>
45 | 
46 | 	<cffunction name="tostruct_should_return_the_root_node_by_default">
47 | 		<cfset assertTrue(structkeyexists(xml.toStruct(xml=short_xml_string), "root"), "Root node doesn't exist")>
48 | 	</cffunction>
49 | 	<cffunction name="tostruct_should_not_return_the_root_node_when_told_not_to">
50 | 		<cfset var str = xml.toStruct(xml=short_xml_string, include_root=FALSE)>
51 | 		<cfset assertFalse(structkeyexists(str, "root"), "Root node exists but shouldn't")>
52 | 		<cfset assertTrue(structkeyexists(str, "node1"), "Child node should exist at root but doesn't")>
53 | 	</cffunction>
54 | 
55 | 	<cffunction name="tostruct_should_return_array_for_multiple_nodes_with_same_name">
56 | 		<cfset var str = xml.toStruct(xml=short_xml_string, include_root=FALSE)>
57 | 		<cfset assertTrue(structkeyexists(str, "node2") AND structkeyexists(str.node2, "field3"), "Expected child node doesn't exist")>
58 | 		<cfset assertTrue(isarray(str.node2.field3), "Expected array of node values but not an array")>
59 | 		<cfset assertEquals(arraylen(str.node2.field3), 2, "Node array length not correct")>
60 | 		<cfset assertEquals(str.node2.field3[1], "field3a", "Node array item incorrect")>
61 | 	</cffunction>
62 | 	<cffunction name="tostruct_should_return_attributes_array_for_multiple_nodes_with_same_name">
63 | 		<cfset var str = xml.toStruct(xml=short_xml_string, include_root=FALSE)>
64 | 		<cfset assertTrue(structkeyexists(str, "node2") AND structkeyexists(str.node2, "field3::attributes"), "Expected attributes don't exist")>
65 | 		<cfset assertTrue(isarray(str.node2["field3::attributes"]), "Expected array of attributes but not an array")>
66 | 		<cfset assertEquals(arraylen(str.node2["field3::attributes"]), 2, "Attributes array length not correct")>
67 | 		<cfset assertTrue(isstruct(str.node2["field3::attributes"][1]), "Attributes for first node not a struct but should be")>
68 | 		<cfset assertTrue(structkeyexists(str.node2["field3::attributes"][1], "attr"), "Attribute not found")>
69 | 		<cfset assertEquals(str.node2["field3::attributes"][1].attr, "attr", "Attribute value incorrect")>
70 | 	</cffunction>
71 | 
72 | </cfcomponent>
73 | 


--------------------------------------------------------------------------------
/restfulcf/framework/core/Route.cfc:
--------------------------------------------------------------------------------
 1 | <!--- -->
 2 | <fusedoc fuse="restfulcf/framework/core/Route.cfc" language="ColdFusion" specification="2.0">
 3 | 	<responsibilities>
 4 | 		I am a simple component representing a route
 5 | 	</responsibilities>
 6 | </fusedoc>
 7 | --->
 8 | 
 9 | <cfcomponent output="no">
10 | 
11 | 	<cfset variables.instance = {
12 | 		verb       = "INVALID",
13 | 		controller = "",
14 | 		method     = "",
15 | 		uri        = "/x-invalid-route",
16 | 		pattern    = "/x-invalid-route"
17 | 	}>
18 | 
19 | 	<cffunction name="init" access="public" returntype="restfulcf.framework.core.Route" output="no" hint="I intialise the route">
20 | 		<cfargument name="verb" type="string" required="yes" hint="The HTTP method to use (one of GET, POST, PUT, DELETE)">
21 | 		<cfargument name="uri" type="string" required="yes" hint="The URI pattern (e.g. '/users/:id')">
22 | 		<cfargument name="controller" type="string" required="yes" hint="The controller name">
23 | 		<cfargument name="method" type="string" required="yes" hint="The controller method name">
24 | 		<cfset setVerb(arguments.verb)>
25 | 		<cfset setURI(arguments.uri)>
26 | 		<cfset setController(arguments.controller)>
27 | 		<cfset setMethod(arguments.method)>
28 | 		<cfreturn this>
29 | 	</cffunction>
30 | 
31 | 	<cffunction name="getVerb" access="public" returntype="string" output="no" hint="Gets the HTTP method (verb) for this route">
32 | 		<cfreturn variables.instance.verb>
33 | 	</cffunction>
34 | 	<cffunction name="setVerb" access="public" returntype="void" output="no" hint="Gets the HTTP method (verb) for this route">
35 | 		<cfargument name="verb" type="string" required="yes" hint="The HTTP method to use (one of GET, POST, PUT, DELETE)">
36 | 		<cfif NOT listfind("GET,POST,PUT,DELETE", ucase(arguments.verb))>
37 | 			<cfthrow type="coldfusion.tagext.validations.AttributeValueNotFromListException" message="GET, POST, PUT, DELETE">
38 | 		</cfif>
39 | 		<cfset variables.instance.verb = ucase(arguments.verb)>
40 | 	</cffunction>
41 | 
42 | 	<cffunction name="getController" access="public" returntype="string" output="no" hint="Gets the controller name for this route">
43 | 		<cfreturn variables.instance.controller>
44 | 	</cffunction>
45 | 	<cffunction name="setController" access="public" returntype="void" output="no" hint="Sets the controller name for this route">
46 | 		<cfargument name="controller" type="string" required="yes" hint="The controller name">
47 | 		<cfset variables.instance.controller = arguments.controller>
48 | 	</cffunction>
49 | 
50 | 	<cffunction name="getMethod" access="public" returntype="string" output="no" hint="Gets the controller method name for this route">
51 | 		<cfreturn variables.instance.method>
52 | 	</cffunction>
53 | 	<cffunction name="setMethod" access="public" returntype="void" output="no" hint="Sets the controller method name for this route">
54 | 		<cfargument name="method" type="string" required="yes" hint="The controller method name">
55 | 		<cfset variables.instance.method = arguments.method>
56 | 	</cffunction>
57 | 
58 | 	<cffunction name="getURI" access="public" returntype="string" output="no" hint="Gets the URI pattern for this route">
59 | 		<cfreturn variables.instance.uri>
60 | 	</cffunction>
61 | 	<cffunction name="setURI" access="public" returntype="void" output="no" hint="Sets the URI pattern for this route">
62 | 		<cfargument name="uri" type="string" required="yes" hint="The URI pattern (e.g. '/users/:id')">
63 | 		<cfset variables.instance.uri = arguments.uri>
64 | 		<cfset variables.instance.pattern = "^" & rereplace(arguments.uri, ":([[:alnum:]-_]*)", "([^/]+?)", "ALL") & "$">
65 | 	</cffunction>
66 | 
67 | 	<cffunction name="matches" access="public" returntype="boolean" output="no" hint="Does this given given match this route?">
68 | 		<cfargument name="verb" type="string" required="yes" hint="The HTTP method (verb) for this request">
69 | 		<cfargument name="path" type="string" required="yes" hint="The requested path">
70 | 		<cfreturn arguments.verb EQ variables.instance.verb AND refind(variables.instance.pattern, arguments.path)>
71 | 	</cffunction>
72 | 
73 | 	<cffunction name="getPathVars" access="public" returntype="struct" output="no" hint="Get the path vars for this request.  For example, if the route URI pattern is /users/:id and the requested path is /users/1, this function will return a structure with a single KVP of id=1.">
74 | 		<cfargument name="path" type="string" required="yes" hint="The requested path">
75 | 		<cfset var vars = {}>
76 | 		<cfset var uri_parts = listtoarray(variables.instance.uri, "/")>
77 | 		<cfset var i = 0>
78 | 		<cfloop from="1" to="#arraylen(uri_parts)#" index="i">
79 | 			<cfif left(uri_parts[i], 1) EQ ":">
80 | 				<cfset vars[right(uri_parts[i], len(uri_parts[i])-1)] = listgetat(arguments.path, i, "/")>
81 | 			</cfif>
82 | 		</cfloop>
83 | 		<cfreturn vars>
84 | 	</cffunction>
85 | 
86 | 	<cffunction name="toStruct" access="public" returntype="struct" output="no" hint="Returns a copy of the routing information for this route">
87 | 		<cfset var meta = {
88 | 			verb       = variables.instance.verb,
89 | 			uri        = variables.instance.uri,
90 | 			controller = variables.instance.controller,
91 | 			method     = variables.instance.method
92 | 		}>
93 | 		<cfreturn meta>
94 | 	</cffunction>
95 | 
96 | </cfcomponent>
97 | 


--------------------------------------------------------------------------------
/restfulcf/test/tests/core/cache/AbstractCacheTest.cfc:
--------------------------------------------------------------------------------
  1 | <!--- -->
  2 | <fusedoc fuse="restfulcf/test/tests/core/cache/AbstractCacheTest.cfc" language="ColdFusion" specification="2.0">
  3 | 	<responsibilities>
  4 | 		I test the abstract (base) cache component
  5 | 	</responsibilities>
  6 | </fusedoc>
  7 | --->
  8 | 
  9 | <cfcomponent extends="mxunit.framework.TestCase">
 10 | 
 11 | 	<cffunction name="setup">
 12 | 		<cfset cache = createobject("component", "restfulcf.framework.core.cache.AbstractCache")>
 13 | 	</cffunction>
 14 | 
 15 | 	<cffunction name="init_of_abstract_cache_should_fail">
 16 | 		<cftry>
 17 | 			<cfset cache.init()>
 18 | 			<cfset fail("Call to init() of abstract cache should have failed but didn't")>
 19 | 			<cfcatch type="RESTfulCF.AbstractCache.CannotInitAbstractCache"></cfcatch>
 20 | 		</cftry>
 21 | 	</cffunction>
 22 | 
 23 | 	<cffunction name="call_to_getkey_on_abstract_cache_should_fail">
 24 | 		<cftry>
 25 | 			<cfset cache.getKey("x")>
 26 | 			<cfset fail("Call to getKey() of abstract cache should have failed but didn't")>
 27 | 			<cfcatch type="RESTfulCF.AbstractCache.NotImplemented"></cfcatch>
 28 | 		</cftry>
 29 | 	</cffunction>
 30 | 	<cffunction name="call_to_setkey_on_abstract_cache_should_fail">
 31 | 		<cftry>
 32 | 			<cfset cache.getKey("x", "x", 0)>
 33 | 			<cfset fail("Call to setKey() of abstract cache should have failed but didn't")>
 34 | 			<cfcatch type="RESTfulCF.AbstractCache.NotImplemented"></cfcatch>
 35 | 		</cftry>
 36 | 	</cffunction>
 37 | 	<cffunction name="call_to_deletekey_on_abstract_cache_should_fail">
 38 | 		<cftry>
 39 | 			<cfset cache.deleteKey("x")>
 40 | 			<cfset fail("Call to deleteKey() of abstract cache should have failed but didn't")>
 41 | 			<cfcatch type="RESTfulCF.AbstractCache.NotImplemented"></cfcatch>
 42 | 		</cftry>
 43 | 	</cffunction>
 44 | 
 45 | 	<cffunction name="get_call_to_uncached_request_should_return_a_failed_lookup">
 46 | 		<cfset var response = "">
 47 | 		<cfset injectMethod(cache, this, "return_nothing", "getKey")>
 48 | 		<cfset response = cache.get(createobject("component", "restfulcf.framework.core.Request"))>
 49 | 		<cfset assertFalse(response.found)>
 50 | 	</cffunction>
 51 | 	<cffunction name="get_call_to_cached_request_should_return_response_object">
 52 | 		<cfset var response = "">
 53 | 		<cfset injectMethod(cache, this, "return_serialised_response", "getKey")>
 54 | 		<cfset response = cache.get(createobject("component", "restfulcf.framework.core.Request"))>
 55 | 		<cfset assertTrue(response.found, "Cache miss")>
 56 | 		<cfset assertIsTypeOf(response.response, "restfulcf.framework.core.Response")>
 57 | 		<cfset assertEquals(200, response.response.getStatusCode())>
 58 | 		<cfset assertEquals("text/xml", response.response.getResponseType())>
 59 | 		<cfset assertEquals("<fake></fake>", response.response.getResponseBody())>
 60 | 	</cffunction>
 61 | 
 62 | 	<cffunction name="set_should_call_setkey_with_the_correct_serialised_arguments">
 63 | 		<cfset var args = {}>
 64 | 		<cfset var vo   = {}>
 65 | 		<cfset var key  = "">
 66 | 		<cfset var kvp  = "">
 67 | 		<cfset injectMethod(cache, this, "setkey_that_throws_exception_with_arguments", "setKey")>
 68 | 		<cftry>
 69 | 			<!--- use raw, non-init'd objects to get around dependencies --->
 70 | 			<cfset cache.set(
 71 | 				createobject("component", "restfulcf.framework.core.Request"),
 72 | 				createobject("component", "restfulcf.framework.core.Response")
 73 | 			)>
 74 | 			<cfset fail("Should have received an exception from the mock setKey() function")>
 75 | 			<cfcatch type="RESTfulCF.AbstractCacheTest.SetKeyTest">
 76 | 				<cfset args = deserializejson(cfcatch.message)>
 77 | 				<cfset assertEquals("_type=&_uri=/x-invalid-route&_verb=INVALID", args.key, "Cache key not as expected")>
 78 | 				<cfset assertTrue(isdate(args.expires), "Expiry not a date")>
 79 | 				<cfset assertTrue(args.expires GT now(), "Expiry not in the future")>
 80 | 				<cfset vo = deserializejson(args.value)>
 81 | 				<cfset assertIsStruct(vo, "Value not a JSON-encoded structure")>
 82 | 				<cfloop list="status_text,response_type|application/xml,response_file,status_code|200,response_body,response_uri" index="key">
 83 | 					<cfset kvp = listtoarray(key, "|")>
 84 | 					<cfset assertTrue(structkeyexists(vo, kvp[1]), "Value key #kvp[1]# was expected but doesn't exist")>
 85 | 					<cfif arraylen(kvp) EQ 1><cfset arrayappend(kvp, "")></cfif>
 86 | 					<cfset assertEquals(kvp[2], vo[kvp[1]], "Value for key #kvp[1]# was incorrect")>
 87 | 				</cfloop>
 88 | 			</cfcatch>
 89 | 		</cftry>
 90 | 	</cffunction>
 91 | 
 92 | 	<!--- injected functions used for mocking --->
 93 | 	<cffunction name="return_nothing" access="private">
 94 | 		<cfreturn "">
 95 | 	</cffunction>
 96 | 	<cffunction name="return_serialised_response" access="private">
 97 | 		<cfset var response = {
 98 | 			status_code   = 200,
 99 | 			status_text   = "",
100 | 			response_type = "text/xml",
101 | 			response_uri  = "",
102 | 			response_body = "<fake></fake>",
103 | 			response_file = ""
104 | 		}>
105 | 		<cfreturn serializejson(response)>
106 | 	</cffunction>
107 | 	<cffunction name="setkey_that_throws_exception_with_arguments" access="private">
108 | 		<cfthrow type="RESTfulCF.AbstractCacheTest.SetKeyTest" message="#serializejson(arguments)#">
109 | 	</cffunction>
110 | 
111 | </cfcomponent>
112 | 


--------------------------------------------------------------------------------
/restfulcf/framework/core/ResourceCollection.cfc:
--------------------------------------------------------------------------------
  1 | <!--- -->
  2 | <fusedoc fuse="restfulcf/framework/core/ResourceCollection.cfc" language="ColdFusion" specification="2.0">
  3 | 	<responsibilities>
  4 | 		I am a resource that contains other resources (effectively an array of resources)
  5 | 	</responsibilities>
  6 | </fusedoc>
  7 | --->
  8 | 
  9 | <cfcomponent extends="restfulcf.framework.core.Resource" output="no">
 10 | 
 11 | 	<cfset variables.instance.type = "">
 12 | 	<cfset variables.instance.resources = []>
 13 | 
 14 | 	<cffunction name="init" access="public" returntype="restfulcf.framework.core.ResourceCollection" output="no" hint="I initialise the component">
 15 | 		<cfargument name="type" type="string" required="yes" hint="The type of resource that the collection holds">
 16 | 		<cfargument name="resources" type="array" required="no" hint="An optional array of resources which which to populate this collection">
 17 | 		<cfset variables.instance.type = arguments.type>
 18 | 		<cfif structkeyexists(arguments, "resources")><cfset variables.instance.resources = arguments.resources></cfif>
 19 | 		<cfreturn this>
 20 | 	</cffunction>
 21 | 
 22 | 	<cffunction name="add" access="public" returntype="void" output="no" hint="Adds a resource to the collection">
 23 | 		<cfargument name="resource" type="restfulcf.framework.core.Resource" required="yes" hint="The resource to add to the collection">
 24 | 		<cfset arrayappend(variables.instance.resources, arguments.resource)>
 25 | 	</cffunction>
 26 | 
 27 | 	<cffunction name="peek" access="public" returntype="restfulcf.framework.core.Resource" output="no" hint="Retrieves a single resource from the collection">
 28 | 		<cfargument name="position" type="numeric" required="no" hint="The index of the resource to retrieve (default is first)">
 29 | 		<cfif structkeyexists(arguments, "position")>
 30 | 			<cfif NOT (arguments.position GTE 1 AND arguments.position LTE arraylen(variables.instance.resources))>
 31 | 				<cfthrow type="coldfusion.runtime.InvalidArgumentException" message="position" detail="Invalid resource position (no resource exists with this index)">
 32 | 			</cfif>
 33 | 		<cfelse>
 34 | 			<cfset arguments.position = 1>
 35 | 			<cfif NOT arraylen(variables.instance.resources)>
 36 | 				<cfthrow type="coldfusion.runtime.InvalidArgumentException" detail="Collection is empty">
 37 | 			</cfif>
 38 | 		</cfif>
 39 | 		<cfreturn variables.instance.resources[arguments.position]>
 40 | 	</cffunction>
 41 | 
 42 | 	<cffunction name="size" access="public" returntype="numeric" output="no" hint="Returns the number of resources in the collection">
 43 | 		<cfreturn arraylen(variables.instance.resources)>
 44 | 	</cffunction>
 45 | 
 46 | 	<cffunction name="getResources" access="public" returntype="array" output="no" hint="Returns the internal array of resources">
 47 | 		<cfreturn variables.instance.resources>
 48 | 	</cffunction>
 49 | 
 50 | 	<cffunction name="sort" access="public" returntype="void" output="no" hint="Sorts the collection based on the given key">
 51 | 		<cfargument name="by" type="string" required="yes" hint="What to sort by: can be a structure key or function name">
 52 | 		<cfargument name="order" type="string" required="no" default="asc" hint="Sort order: asc/desc">
 53 | 		<cfset var arrays = createobject("component", "restfulcf.framework.util.Arrays")>
 54 | 		<cfset variables.instance.resources = arrays.mergeSort(variables.instance.resources, arguments.by)>
 55 | 		<cfif lcase(arguments.order) EQ "desc"><cfset variables.instance.resources = arrays.switch(variables.instance.resources)></cfif>
 56 | 	</cffunction>
 57 | 
 58 | 	<cffunction name="toXML" access="public" returntype="xml" output="no" hint="Returns this resource in XML format">
 59 | 		<cfset var xml = []>
 60 | 		<cfset var resource = "">
 61 | 		<cfloop array="#variables.instance.resources#" index="resource">
 62 | 			<cfset arrayappend(xml, resource.toXML())>
 63 | 		</cfloop>
 64 | 		<cfreturn '<#variables.instance.type# type="array">' & arraytolist(xml, chr(10)) & '</#variables.instance.type#>'>
 65 | 	</cffunction>
 66 | 
 67 | 	<cffunction name="toHTML" access="public" returntype="string" output="no" hint="Returns this resource in HTML format">
 68 | 		<cfset var html = []>
 69 | 		<cfset var resource = "">
 70 | 		<cfloop array="#variables.instance.resources#" index="resource">
 71 | 			<cfset arrayappend(html, resource.toHTML())>
 72 | 		</cfloop>
 73 | 		<cfreturn arraytolist(html, chr(10) & "<hr>")>
 74 | 	</cffunction>
 75 | 
 76 | 	<cffunction name="toTXT" access="public" returntype="string" output="no" hint="Returns this resource in plain text format">
 77 | 		<cfset var text = []>
 78 | 		<cfset var resource = "">
 79 | 		<cfloop array="#variables.instance.resources#" index="resource">
 80 | 			<cfset arrayappend(text, resource.toTXT())>
 81 | 		</cfloop>
 82 | 		<cfreturn arraytolist(text, chr(10))>
 83 | 	</cffunction>
 84 | 
 85 | 	<cffunction name="toJSON" access="public" returntype="string" output="no" hint="Returns this resource in plain text format">
 86 | 		<cfset var json = []>
 87 | 		<cfset var resource = "">
 88 | 		<cfloop array="#variables.instance.resources#" index="resource">
 89 | 			<cfset arrayappend(json, resource.toJSON())>
 90 | 		</cfloop>
 91 | 		<cfreturn "[" & arraytolist(json, ",#chr(10)#") & "]">
 92 | 	</cffunction>
 93 | 
 94 | 	<cffunction name="toCSV" access="public" returntype="string" output="no" hint="Returns this resource in CSV format">
 95 | 		<cfargument name="include_header" type="boolean" required="no" default="TRUE" hint="Should the resource properties be included as the first line?">
 96 | 		<cfset var csv = []>
 97 | 		<cfset var resource = "">
 98 | 		<cfloop array="#variables.instance.resources#" index="resource">
 99 | 			<cfset arrayappend(csv, resource.toCSV(arguments.include_header))>
100 | 			<cfset arguments.include_header = FALSE>
101 | 		</cfloop>
102 | 		<cfreturn arraytolist(csv, chr(10))>
103 | 	</cffunction>
104 | 
105 | </cfcomponent>
106 | 


--------------------------------------------------------------------------------
/restfulcf/framework/util/Arrays.cfc:
--------------------------------------------------------------------------------
  1 | <!--- -->
  2 | <fusedoc fuse="restfulcf/framework/util/Arrays.cfc" language="ColdFusion" specification="2.0">
  3 | 	<responsibilities>
  4 | 		I am a collection of functions which provide generic CF array manipulation methods.
  5 | 	</responsibilities>
  6 | </fusedoc>
  7 | --->
  8 | 
  9 | <cfcomponent displayname="Arrays" output="no" hint="This is a collection of functions which provide generic CF array functions.">
 10 | 
 11 | 	<cffunction name="join" access="public" returntype="array" output="no" hint="Joins two arrays together">
 12 | 		<cfargument name="first" type="array" required="yes" hint="The first array to join">
 13 | 		<cfargument name="second" type="array" required="yes" hint="The second array join">
 14 | 		<cfset var i = 0>
 15 | 		<cfloop from="1" to="#arraylen(arguments.second)#" index="i">
 16 | 			<cfset arrayappend(arguments.first, arguments.second[i])>
 17 | 		</cfloop>
 18 | 		<cfreturn arguments.first>
 19 | 	</cffunction>
 20 | 
 21 | 	<cffunction name="split" access="public" returntype="array" output="no" hint="Splits a single array in two based on the number of elements required in the first.">
 22 | 		<cfargument name="arr" type="array" required="yes" hint="The array to split">
 23 | 		<cfargument name="cnt" type="numeric" required="yes" hint="The number of elements required in the first result array">
 24 | 		<cfset var res = [[], []]>
 25 | 		<cfset var i = 0>
 26 | 		<cfloop from="1" to="#arguments.cnt#" index="i">
 27 | 			<cfif arraylen(arguments.arr)>
 28 | 				<cfset arrayappend(res[1], arguments.arr[1])>
 29 | 				<cfset arraydeleteat(arguments.arr, 1)>
 30 | 			</cfif>
 31 | 		</cfloop>
 32 | 		<cfset res[2] = arguments.arr>
 33 | 		<cfreturn res>
 34 | 	</cffunction>
 35 | 
 36 | 	<cffunction name="merge" access="public" returntype="array" output="no" hint="Merges two arrays of structures together based on the value of a given key (lower value = earlier in the array).">
 37 | 		<cfargument name="left" type="array" required="yes" hint="The first array to merge">
 38 | 		<cfargument name="right" type="array" required="yes" hint="The second array merge">
 39 | 		<cfargument name="key" type="string" required="yes" hint="The structure key to use for ordering - can be a function name to call if the array data items are component instances">
 40 | 		<cfset var res = []>
 41 | 		<cfset var dir = "">
 42 | 		<cfset var l_key = "">
 43 | 		<cfset var r_key = "">
 44 | 		<!--- loop over both arrays, adding to the results based on the lower of the two array HEADs --->
 45 | 		<cfloop condition="arraylen(arguments.left) AND arraylen(arguments.right)">
 46 | 			<!--- default merge direction --->
 47 | 			<cfset dir = "left">
 48 | 			<!--- check for a structure item or a custom function for the left-hand node --->
 49 | 			<cfif structkeyexists(arguments.left[1], arguments.key) AND NOT iscustomfunction(arguments.left[1][arguments.key])>
 50 | 				<cfset l_key = arguments.left[1][arguments.key]>
 51 | 			<cfelse><cfinvoke component="#arguments.left[1]#" method="#arguments.key#" returnvariable="l_key"></cfif>
 52 | 			<!--- check for a structure item or a custom function for the right-hand node --->
 53 | 			<cfif structkeyexists(arguments.right[1], arguments.key) AND NOT iscustomfunction(arguments.right[1][arguments.key])>
 54 | 				<cfset r_key = arguments.right[1][arguments.key]>
 55 | 			<cfelse><cfinvoke component="#arguments.right[1]#" method="#arguments.key#" returnvariable="r_key"></cfif>
 56 | 			<!--- change the merge order if need be --->
 57 | 			<cfif l_key GT r_key><cfset dir = "right"></cfif>
 58 | 			<cfset arrayappend(res, arguments[dir][1])>
 59 | 			<cfset arraydeleteat(arguments[dir], 1)>
 60 | 		</cfloop>
 61 | 		<!--- if there are any items left in either array, just stick them on the end --->
 62 | 		<cfif arraylen(arguments.left)><cfset res = join(res, arguments.left)></cfif>
 63 | 		<cfif arraylen(arguments.right)><cfset res = join(res, arguments.right)></cfif>
 64 | 		<cfreturn res>
 65 | 	</cffunction>
 66 | 
 67 | 	<cffunction name="mergeSort" access="public" returntype="array" output="no" hint="Performs a merge sort on an array of structures based on the value of a given key (lower value = earlier in the array).">
 68 | 		<cfargument name="arr" type="array" required="yes" hint="The array of structures to merge sort">
 69 | 		<cfargument name="key" type="string" required="yes" hint="The structure key to use for ordering">
 70 | 		<cfset var lft = []>
 71 | 		<cfset var rgt = []>
 72 | 		<cfset var spl = []>
 73 | 		<!--- if we've less than two elements then there's nothing to sort --->
 74 | 		<cfif arraylen(arguments.arr) LTE 1><cfreturn arguments.arr></cfif>
 75 | 		<!--- split the array in two and recursively merge sort those bits --->
 76 | 		<cfset spl = split(arguments.arr, ceiling(arraylen(arguments.arr)/2))>
 77 | 		<cfset lft = mergeSort(spl[1], arguments.key)>
 78 | 		<cfset rgt = mergeSort(spl[2], arguments.key)>
 79 | 		<!--- merge the two parts back together in order and return --->
 80 | 		<cfreturn merge(lft, rgt, arguments.key)>
 81 | 	</cffunction>
 82 | 
 83 | 	<cffunction name="slice" access="public" returntype="array" output="no" hint="Slices an array (returns a sub-section of the array).  Kinda like the LIMIT clause of a SQL statement.">
 84 | 		<cfargument name="arr" type="array" required="yes" hint="The array to slice">
 85 | 		<cfargument name="start" type="numeric" required="no" default="1" hint="The first result to return">
 86 | 		<cfargument name="limit" type="numeric" required="no" default="#arraylen(arguments.arr)#" hint="The max number of results to return">
 87 | 		<cfset var slice = []>
 88 | 		<cfset var i = 0>
 89 | 		<cfloop from="#arguments.start#" to="#arguments.start + arguments.limit - 1#" index="i">
 90 | 			<cfif i GT arraylen(arguments.arr)><cfbreak></cfif>
 91 | 			<cfif i GTE 1><cfset arrayappend(slice, arguments.arr[i])></cfif>
 92 | 		</cfloop>
 93 | 		<cfreturn slice>
 94 | 	</cffunction>
 95 | 
 96 | 	<cffunction name="switch" access="public" returntype="array" output="no" hint="Reverses an array">
 97 | 		<cfargument name="arr" type="array" required="yes" hint="The array to reverse">
 98 | 		<cfset var rev = []>
 99 | 		<cfset var i = "">
100 | 		<cfloop from="#arraylen(arguments.arr)#" to="1" step="-1" index="i">
101 | 			<cfset arrayappend(rev, arguments.arr[i])>
102 | 		</cfloop>
103 | 		<cfreturn rev>
104 | 	</cffunction>
105 | 
106 | </cfcomponent>
107 | 


--------------------------------------------------------------------------------
/restfulcf/test/tests/core/ResourceCollectionTest.cfc:
--------------------------------------------------------------------------------
  1 | <!--- -->
  2 | <fusedoc fuse="restfulcf/test/tests/core/ResourceCollectionTest.cfc" language="ColdFusion" specification="2.0">
  3 | 	<responsibilities>
  4 | 		I test the resource collection component
  5 | 	</responsibilities>
  6 | </fusedoc>
  7 | --->
  8 | 
  9 | <cfcomponent extends="mxunit.framework.TestCase">
 10 | 
 11 | 	<cffunction name="setup">
 12 | 		<cfset collection = createobject("component", "restfulcf.framework.core.ResourceCollection").init("resource_fixtures")>
 13 | 		<cfset collection.add(createobject("component", "ResourceFixture").init(id=1))>
 14 | 		<cfset collection.add(createobject("component", "ResourceFixture").init(id=2))>
 15 | 		<cfset collection.add(createobject("component", "ResourceFixture").init(id=3))>
 16 | 	</cffunction>
 17 | 
 18 | 	<cffunction name="adding_an_invalid_resource_should_raise_exception">
 19 | 		<cftry>
 20 | 			<cfset collection.add("invalid")>
 21 | 			<cfset fail("Adding an invalid resource should have raised an exception")>
 22 | 			<cfcatch type="any"></cfcatch>
 23 | 		</cftry>
 24 | 	</cffunction>
 25 | 
 26 | 	<cffunction name="getting_the_resources_should_return_an_array_of_resources">
 27 | 		<cfset var resources = collection.getResources()>
 28 | 		<cfset var i = 0>
 29 | 		<cfset assertIsArray(resources, "Result is not an array")>
 30 | 		<cfset assertEquals(3, arraylen(resources), "Resource array length was not as expected")>
 31 | 		<cfloop from="1" to="3" index="i">
 32 | 			<cfset assertEquals(i, resources[i].getID(), "Resource #i# has unexpected ID")>
 33 | 		</cfloop>
 34 | 	</cffunction>
 35 | 
 36 | 	<cffunction name="getting_the_size_of_an_empty_collection_should_return_zero">
 37 | 		<cfset assertEquals(0, createobject("component", "restfulcf.framework.core.ResourceCollection").size())>
 38 | 	</cffunction>
 39 | 	<cffunction name="getting_the_size_of_a_populated_collection_should_return_the_number_of_resources">
 40 | 		<cfset assertEquals(3, collection.size())>
 41 | 	</cffunction>
 42 | 	<cffunction name="adding_a_resource_to_the_collection_should_increase_the_size">
 43 | 		<cfset collection.add(createobject("component", "ResourceFixture").init(id=4))>
 44 | 		<cfset assertEquals(4, collection.size())>
 45 | 	</cffunction>
 46 | 
 47 | 	<cffunction name="peeking_at_a_populated_collection_should_return_the_first_resource">
 48 | 		<cfset assertEquals(1, collection.peek().getID())>
 49 | 	</cffunction>
 50 | 	<cffunction name="peeking_at_the_end_populated_collection_should_return_the_last_resource">
 51 | 		<cfset assertEquals(3, collection.peek(collection.size()).getID())>
 52 | 	</cffunction>
 53 | 	<cffunction name="peeking_at_an_empty_collection_should_throw_an_exception">
 54 | 		<cftry>
 55 | 			<cfset createobject("component", "restfulcf.framework.core.ResourceCollection").peek()>
 56 | 			<cfset fail("Exception wasn't raised")>
 57 | 			<cfcatch type="coldfusion.runtime.InvalidArgumentException"></cfcatch>
 58 | 		</cftry>
 59 | 	</cffunction>
 60 | 	<cffunction name="peeking_at_an_invalid_index_of_a_collection_should_throw_an_exception">
 61 | 		<cftry>
 62 | 			<cfset collection.peek(999)>
 63 | 			<cfset fail("Exception wasn't raised")>
 64 | 			<cfcatch type="coldfusion.runtime.InvalidArgumentException"></cfcatch>
 65 | 		</cftry>
 66 | 	</cffunction>
 67 | 
 68 | 	<cffunction name="sorting_a_collection_should_reorder_resources">
 69 | 		<cfset var resources = []>
 70 | 		<cfset var i = 0>
 71 | 		<cfset collection.add(createobject("component", "ResourceFixture").init(id=0))>
 72 | 		<cfset collection.sort("getID")>
 73 | 		<cfset resources = collection.getResources()>
 74 | 		<cfloop from="1" to="4" index="i">
 75 | 			<cfset assertEquals(i-1, resources[i].getID(), "Resource #i# has unexpected ID")>
 76 | 		</cfloop>
 77 | 	</cffunction>
 78 | 	<cffunction name="sorting_a_collection_in_descending_order_should_reorder_resources">
 79 | 		<cfset var resources = []>
 80 | 		<cfset var i = 0>
 81 | 		<cfset collection.add(createobject("component", "ResourceFixture").init(id=0))>
 82 | 		<cfset collection.sort("getID", "desc")>
 83 | 		<cfset resources = collection.getResources()>
 84 | 		<cfloop from="1" to="4" index="i">
 85 | 			<cfset assertEquals((4-i), resources[i].getID(), "Resource #i# has unexpected ID")>
 86 | 		</cfloop>
 87 | 	</cffunction>
 88 | 
 89 | 	<cffunction name="to_xml_should_return_a_valid_xml_packet">
 90 | 		<cfset assertTrue(isxml(collection.toXML()))>
 91 | 	</cffunction>
 92 | 	<cffunction name="to_xml_should_return_a_root_node_of_type_array">
 93 | 		<cfset assertXpath("/resource_fixtures[@type='array']", xmlparse(collection.toXML()))>
 94 | 	</cffunction>
 95 | 	<cffunction name="to_xml_should_return_a_node_for_each_resource">
 96 | 		<cfset var xml = xmlparse(collection.toXML())>
 97 | 		<cfset var nodes = xmlsearch(xml, "/resource_fixtures[@type='array']/resource_fixture")>
 98 | 		<cfset assertEquals(3, arraylen(nodes))>
 99 | 	</cffunction>
100 | 	<cffunction name="to_xml_on_empty_collection_should_return_an_empty_xml_packet">
101 | 		<cfset var empty = createobject("component", "restfulcf.framework.core.ResourceCollection").init("resource_fixtures")>
102 | 		<cfset var xml = xmlparse(empty.toXML())>
103 | 		<cfset var nodes = xmlsearch(xml, "/resource_fixtures[@type='array']/*")>
104 | 		<cfset assertEquals(0, arraylen(nodes))>
105 | 	</cffunction>
106 | 
107 | 	<cffunction name="to_html_should_return_a_block_for_each_resource">
108 | 		<cfset var html = collection.toHTML()>
109 | 		<cfset var resources = html.split("<hr>")>
110 | 		<cfset assertEquals(3, arraylen(resources))>
111 | 	</cffunction>
112 | 	<cffunction name="to_html_on_empty_collection_should_return_an_empty_string">
113 | 		<cfset var empty = createobject("component", "restfulcf.framework.core.ResourceCollection").init("resource_fixtures")>
114 | 		<cfset assertEquals(0, len(empty.toHTML()))>
115 | 	</cffunction>
116 | 
117 | 	<cffunction name="to_csv_should_return_a_line_for_each_resource_plus_one_header">
118 | 		<cfset var csv = collection.toCSV()>
119 | 		<cfset var resources = csv.split(chr(10))>
120 | 		<cfset assertEquals(4, arraylen(resources))>
121 | 	</cffunction>
122 | 	<cffunction name="to_csv_should_return_a_line_for_each_resource_without_header">
123 | 		<cfset var csv = collection.toCSV(FALSE)>
124 | 		<cfset var resources = csv.split(chr(10))>
125 | 		<cfset assertEquals(3, arraylen(resources))>
126 | 	</cffunction>
127 | 	<cffunction name="to_csv_on_empty_collection_should_return_an_empty_string">
128 | 		<cfset var empty = createobject("component", "restfulcf.framework.core.ResourceCollection").init("resource_fixtures")>
129 | 		<cfset assertEquals(0, len(empty.toCSV()))>
130 | 	</cffunction>
131 | 
132 | </cfcomponent>
133 | 


--------------------------------------------------------------------------------
/restfulcf/framework/core/cache/AbstractCache.cfc:
--------------------------------------------------------------------------------
  1 | <!--- -->
  2 | <fusedoc fuse="restfulcf/framework/core/cache/AbstractCache.cfc" language="ColdFusion" specification="2.0">
  3 | 	<responsibilities>
  4 | 		I am the base of all response caches
  5 | 	</responsibilities>
  6 | </fusedoc>
  7 | --->
  8 | 
  9 | <cfcomponent output="no">
 10 | 
 11 | 	<cfset variables.default_timeout = createtimespan(0,0,30,0)>
 12 | 
 13 | 	<cffunction name="init" access="public" returntype="restfulcf.framework.core.cache.AbstractCache" output="no" hint="Initialises this cache">
 14 | 		<cfargument name="timeout" type="numeric" required="no" hint="The timespan to use as a default timeout">
 15 | 		<!--- the base component is an 'abstract' cache and cannot be used as an actual implementation --->
 16 | 		<cfif getmetadata(this).name EQ "restfulcf.framework.core.cache.AbstractCache">
 17 | 			<cfthrow type="RESTfulCF.AbstractCache.CannotInitAbstractCache" message="The #getmetadata(this).name# component must be extended to provide a concrete cache implementation." detail="Extend this component and override the getKey, setKey and deleteKey functions.">
 18 | 		</cfif>
 19 | 		<cfif structkeyexists(arguments, "timeout")><cfset variables.default_timeout = arguments.timeout></cfif>
 20 | 		<cfreturn this>
 21 | 	</cffunction>
 22 | 
 23 | 	<cffunction name="get" access="public" returntype="struct" output="no" hint="Get a response from the cache.  Returns a struct with up to two keys: `found` = true|false; `response` = the response object (will only exist if key is found)">
 24 | 		<cfargument name="request" type="restfulcf.framework.core.Request" required="yes" hint="The request object to get a response for">
 25 | 		<cfset var resp = { found = FALSE }>
 26 | 		<cfset var cache_key = serialiseRequest(arguments.request)>
 27 | 		<cfset var cache_data = getKey(cache_key)>
 28 | 		<cfif len(cache_data)>
 29 | 			<cfset resp.found = TRUE>
 30 | 			<cfset resp.response = deserialiseResponse(cache_data, arguments.request)>
 31 | 			<cfset resp.response.setCacheHit(TRUE)>
 32 | 			<cfset resp.response.setCacheKey(cache_key)>
 33 | 		</cfif>
 34 | 		<cfreturn resp>
 35 | 	</cffunction>
 36 | 	<cffunction name="set" access="public" returntype="void" output="no" hint="Sets a key in the cache">
 37 | 		<cfargument name="request" type="restfulcf.framework.core.Request" required="yes" hint="The request object to set a response for">
 38 | 		<cfargument name="response" type="restfulcf.framework.core.Response" required="yes" hint="The response object to set">
 39 | 		<!--- if the cache expiry stamp in the response is zero, use the default --->
 40 | 		<cfset var exp = arguments.response.getCacheExpiry()>
 41 | 		<cfif NOT exp><cfset exp = variables.default_timeout></cfif>
 42 | 		<cfset setKey(
 43 | 			key     = serialiseRequest(arguments.request),
 44 | 			value   = serialiseResponse(arguments.response),
 45 | 			expires = dateadd('s', round(exp * 86400), now())
 46 | 		)>
 47 | 	</cffunction>
 48 | 	<cffunction name="delete" access="public" returntype="void" output="no" hint="Deletes a key from the cache">
 49 | 		<cfargument name="request" type="restfulcf.framework.core.Request" required="yes" hint="The request object to delete the cached response for">
 50 | 		<cfset deleteKey(serialiseRequest(arguments.request))>
 51 | 	</cffunction>
 52 | 
 53 | 	<cffunction name="serialiseRequest" access="private" returntype="string" output="no" hint="Builds a key from a request object">
 54 | 		<cfargument name="request" type="restfulcf.framework.core.Request" required="yes" hint="The request object to build the cache key for">
 55 | 		<cfset var args = []>
 56 | 		<cfset var key  = []>
 57 | 		<cfset var arg  = "">
 58 | 		<!--- build the structure that will represent this request --->
 59 | 		<cfset var params = {}>
 60 | 		<cfset params['_verb'] = arguments.request.getRoute().getVerb()>
 61 | 		<cfset params['_uri']  = arguments.request.getRoute().getURI()>
 62 | 		<cfset params['_type'] = arguments.request.getResponseType()>
 63 | 		<cfset structappend(params, arguments.request.getArguments())>
 64 | 		<!--- build what is effectively an alpha-ordered query string of all params --->
 65 | 		<cfset args = structkeyarray(params)>
 66 | 		<cfset arraysort(args, "textnocase")>
 67 | 		<cfloop array="#args#" index="arg"><cfset arrayappend(key, lcase(arg) & "=" & params[arg])></cfloop>
 68 | 		<cfreturn arraytolist(key, "&")>
 69 | 	</cffunction>
 70 | 
 71 | 	<cffunction name="serialiseResponse" access="private" returntype="string" output="no" hint="Builds a cached response string from a response object">
 72 | 		<cfargument name="response" type="restfulcf.framework.core.Response" required="yes" hint="The response object for serialisation">
 73 | 		<cfset var resp = {
 74 | 			status_code   = arguments.response.getStatusCode(),
 75 | 			status_text   = arguments.response.getStatusText(),
 76 | 			response_type = arguments.response.getResponseType(),
 77 | 			response_uri  = arguments.response.getResponseURI(),
 78 | 			response_body = arguments.response.getResponseBody(),
 79 | 			response_file = arguments.response.getResponseFile()
 80 | 		}>
 81 | 		<cfreturn serializejson(resp)>
 82 | 	</cffunction>
 83 | 	<cffunction name="deserialiseResponse" access="private" returntype="restfulcf.framework.core.Response" output="no" hint="Builds a response object from a cached response string">
 84 | 		<cfargument name="data" type="string" required="yes" hint="The string representation of the reponse to build in to a complete response object">
 85 | 		<cfargument name="request" type="restfulcf.framework.core.Request" required="yes" hint="The request object that requested this cached response">
 86 | 		<cfset var response = createobject("component", "restfulcf.framework.core.Response").init(arguments.request)>
 87 | 		<cfset var resp = deserializejson(arguments.data)>
 88 | 		<cfset response.setStatusCode(resp.status_code)>
 89 | 		<cfset response.setStatusText(resp.status_text)>
 90 | 		<cfset response.setResponseType(resp.response_type)>
 91 | 		<cfset response.setResponseURI(resp.response_uri)>
 92 | 		<cfset response.setResponseBody(resp.response_body)>
 93 | 		<cfset response.setResponseFile(resp.response_file)>
 94 | 		<cfset response.setCacheHit(TRUE)>
 95 | 		<cfreturn response>
 96 | 	</cffunction>
 97 | 
 98 | 
 99 | 	<!--- THESE FUNCTIONS MUST BE IMPLEMENTED IN THE CONCRETE CACHE --->
100 | 
101 | 	<cffunction name="getKey" access="public" returntype="string" output="no" hint="Gets the value for a given key from the cache">
102 | 		<cfargument name="key" type="string" required="yes" hint="The key to retrieve">
103 | 		<cfthrow type="RESTfulCF.AbstractCache.NotImplemented" message="The getKey() function must be implemented by #getmetadata(this).name#">
104 | 	</cffunction>
105 | 	<cffunction name="setKey" access="public" returntype="void" output="no" hint="Sets a given value for a given key in the cache">
106 | 		<cfargument name="key" type="string" required="yes" hint="The key to set">
107 | 		<cfargument name="value" type="string" required="yes" hint="The value to store">
108 | 		<cfargument name="expires" type="numeric" required="yes" hint="The cache expiry date time">
109 | 		<cfthrow type="RESTfulCF.AbstractCache.NotImplemented" message="The setKey() function must be implemented by #getmetadata(this).name#">
110 | 	</cffunction>
111 | 	<cffunction name="deleteKey" access="public" returntype="void" output="no" hint="Deletes a given key from the cache">
112 | 		<cfargument name="key" type="string" required="yes" hint="The key to delete">
113 | 		<cfthrow type="RESTfulCF.AbstractCache.NotImplemented" message="The deleteKey() function must be implemented by #getmetadata(this).name#">
114 | 	</cffunction>
115 | 
116 | </cfcomponent>
117 | 


--------------------------------------------------------------------------------
/restfulcf/framework/core/Response.cfc:
--------------------------------------------------------------------------------
  1 | <!--- -->
  2 | <fusedoc fuse="restfulcf/framework/core/Response.cfc" language="ColdFusion" specification="2.0">
  3 | 	<responsibilities>
  4 | 		I am a response object that gets passed to and updated by controller methods
  5 | 	</responsibilities>
  6 | </fusedoc>
  7 | --->
  8 | 
  9 | <cfcomponent output="no">
 10 | 
 11 | 	<cfset variables.instance = {
 12 | 		status_code   = 200,
 13 | 		status_text   = "",
 14 | 		response_type = "application/xml",
 15 | 		response_body = "",
 16 | 		response_file = "",
 17 | 		response_uri  = "",
 18 | 		errors        = [],
 19 | 		request       = createobject("component", "restfulcf.framework.core.Request"),
 20 | 		cache         = {
 21 | 			active    = FALSE,
 22 | 			expiry    = 0,
 23 | 			hit       = FALSE,
 24 | 			key       = ""
 25 | 		}
 26 | 	}>
 27 | 
 28 | 	<cffunction name="init" access="public" returntype="restfulcf.framework.core.Response" output="no" hint="I am the encapsulation of a request response">
 29 | 		<cfargument name="request" type="restfulcf.framework.core.Request" required="no" hint="The request object that resulted in this response">
 30 | 		<cfif structkeyexists(arguments, "request")><cfset variables.instance.request = arguments.request></cfif>
 31 | 		<cfreturn this>
 32 | 	</cffunction>
 33 | 
 34 | 	<cffunction name="getStatusCode" access="public" returntype="numeric" output="no" hint="Get the response status code for this request">
 35 | 		<cfreturn variables.instance.status_code>
 36 | 	</cffunction>
 37 | 	<cffunction name="setStatusCode" access="public" returntype="void" output="no" hint="Set the response status code for this request">
 38 | 		<cfargument name="code" type="numeric" required="yes" hint="The response status code for this request">
 39 | 		<cfset variables.instance.status_code = arguments.code>
 40 | 	</cffunction>
 41 | 
 42 | 	<cffunction name="getStatusText" access="public" returntype="string" output="no" hint="Get the response status text for this request">
 43 | 		<cfreturn variables.instance.status_text>
 44 | 	</cffunction>
 45 | 	<cffunction name="setStatusText" access="public" returntype="void" output="no" hint="Set the response status text for this request.">
 46 | 		<cfargument name="text" type="string" required="yes" hint="The response status message for this request">
 47 | 		<cfset variables.instance.status_text = arguments.text>
 48 | 	</cffunction>
 49 | 
 50 | 	<cffunction name="getResponseType" access="public" returntype="string" output="no" hint="Get the response type for this request">
 51 | 		<cfreturn variables.instance.response_type>
 52 | 	</cffunction>
 53 | 	<cffunction name="setResponseType" access="public" returntype="void" output="no" hint="Set the response type for this request">
 54 | 		<cfargument name="type" type="string" required="yes" hint="The response type for this request">
 55 | 		<cfset variables.instance.response_type = arguments.type>
 56 | 	</cffunction>
 57 | 
 58 | 	<cffunction name="getResponseURI" access="public" returntype="string" output="no" hint="Get the response URI for this request">
 59 | 		<cfreturn variables.instance.response_uri>
 60 | 	</cffunction>
 61 | 	<cffunction name="setResponseURI" access="public" returntype="void" output="no" hint="Set the response URI for this request (will be set as the Location: header)">
 62 | 		<cfargument name="uri" type="string" required="yes" hint="The response URI for this request">
 63 | 		<cfset variables.instance.response_uri = arguments.uri>
 64 | 	</cffunction>
 65 | 
 66 | 	<cffunction name="getResponseBody" access="public" returntype="any" output="no" hint="Get the response data for this request">
 67 | 		<cfreturn variables.instance.response_body>
 68 | 	</cffunction>
 69 | 	<cffunction name="setResponseBody" access="public" returntype="void" output="no" hint="Set the response data for this request">
 70 | 		<cfargument name="data" type="any" required="yes" hint="The response data for this request">
 71 | 		<cfset variables.instance.response_body = arguments.data>
 72 | 	</cffunction>
 73 | 
 74 | 	<cffunction name="getResponseFile" access="public" returntype="any" output="no" hint="Get the response file for this request">
 75 | 		<cfreturn variables.instance.response_file>
 76 | 	</cffunction>
 77 | 	<cffunction name="setResponseFile" access="public" returntype="void" output="no" hint="Set the response file for this request (send this file instead of the body content if provided)">
 78 | 		<cfargument name="filepath" type="any" required="yes" hint="The full file path for the file">
 79 | 		<cfset variables.instance.response_file = arguments.filepath>
 80 | 	</cffunction>
 81 | 
 82 | 	<cffunction name="addError" access="public" returntype="void" output="no" hint="Adds an error to the error list">
 83 | 		<cfargument name="error" type="string" required="yes" hint="The error text">
 84 | 		<cfset arrayappend(variables.instance.errors, arguments.error)>
 85 | 	</cffunction>
 86 | 	<cffunction name="hasErrors" access="public" returntype="boolean" output="no" hint="Are there any errors associated with this response">
 87 | 		<cfreturn NOT(NOT(arraylen(variables.instance.errors)))>
 88 | 	</cffunction>
 89 | 	<cffunction name="getErrorCollection" access="public" returntype="restfulcf.framework.core.ErrorCollection" output="no" hint="Returns the error list">
 90 | 		<cfreturn createobject("component", "restfulcf.framework.core.ErrorCollection").init(variables.instance.errors)>
 91 | 	</cffunction>
 92 | 
 93 | 	<cffunction name="getCacheStatus" access="public" returntype="boolean" output="no" hint="Gets if this response should be cached">
 94 | 		<cfreturn variables.instance.cache.active>
 95 | 	</cffunction>
 96 | 	<cffunction name="setCacheStatus" access="public" returntype="void" output="no" hint="Sets if this response should be cached">
 97 | 		<cfargument name="cache" type="boolean" required="yes" hint="Should we cache this response?">
 98 | 		<cfset variables.instance.cache.active = arguments.cache>
 99 | 	</cffunction>
100 | 	<cffunction name="getCacheExpiry" access="public" returntype="boolean" output="no" hint="Gets how long this response should be cached for">
101 | 		<cfreturn variables.instance.cache.expiry>
102 | 	</cffunction>
103 | 	<cffunction name="setCacheExpiry" access="public" returntype="void" output="no" hint="Sets how long this response should be cached for">
104 | 		<cfargument name="timespan" type="numeric" required="yes" hint="The time in days to cache the data for (use `createtimespan`)">
105 | 		<cfset variables.instance.cache.expiry = arguments.timespan>
106 | 	</cffunction>
107 | 	<cffunction name="getCacheHit" access="public" returntype="boolean" output="no" hint="Gets if this response was returned from the cache">
108 | 		<cfreturn variables.instance.cache.hit>
109 | 	</cffunction>
110 | 	<cffunction name="setCacheHit" access="public" returntype="void" output="no" hint="Sets if this response was returned from the cache">
111 | 		<cfargument name="hit" type="boolean" required="yes" hint="Was this a cached response?">
112 | 		<cfset variables.instance.cache.hit = arguments.hit>
113 | 	</cffunction>
114 | 	<cffunction name="getCacheKey" access="public" returntype="string" output="no" hint="Returns the cache key used for this response">
115 | 		<cfreturn variables.instance.cache.key>
116 | 	</cffunction>
117 | 	<cffunction name="setCacheKey" access="public" returntype="void" output="no" hint="Sets the cache key used for this response">
118 | 		<cfargument name="key" type="string" required="yes" hint="The cache key">
119 | 		<cfset variables.instance.cache.key = arguments.key>
120 | 	</cffunction>
121 | 
122 | 	<cffunction name="getRequest" access="public" returntype="restfulcf.framework.core.Request" output="no" hint="Returns the request object that resulted in this response">
123 | 		<cfreturn variables.instance.request>
124 | 	</cffunction>
125 | 
126 | </cfcomponent>
127 | 


--------------------------------------------------------------------------------
/restfulcf/sample/helloworld/rest/controllers/Worlds.cfc:
--------------------------------------------------------------------------------
  1 | <!--- -->
  2 | <fusedoc fuse="restfulcf/sample/helloworld/rest/controllers/Worlds.cfc" language="ColdFusion" specification="2.0">
  3 | 	<responsibilities>
  4 | 		I am the controller for World resources for the "Hello World" sample app
  5 | 	</responsibilities>
  6 | </fusedoc>
  7 | --->
  8 | 
  9 | <cfcomponent extends="restfulcf.framework.core.Controller" output="no">
 10 | 
 11 | 	<cffunction name="index" access="public" returntype="restfulcf.framework.core.ResourceCollection" output="no" hint="Index method (GET)">
 12 | 		<cfargument name="order" type="string"  required="no" default="name" hint="The order to return results in (id, name, created_at)">
 13 | 		<!--- create a collection to group all the matching worlds together in --->
 14 | 		<cfset var collection = createobject("component", "restfulcf.framework.core.ResourceCollection").init("worlds")>
 15 | 		<cfset var world = "">
 16 | 		<!--- simply loop through all worlds, create a resource for each one and add it to the collection --->
 17 | 		<cfloop array="#application.worlds#" index="world">
 18 | 			<!--- we'll use our internal function defined at the bottom of
 19 | 			      this component to convert the structure to a resource --->
 20 | 			<cfset collection.add(toResource(world))>
 21 | 		</cfloop>
 22 | 		<!--- internal sorting based on the provided field (explicit sorting of a collection
 23 | 		      instead of using DB ORDER BY clause because we're not using a DB here) --->
 24 | 		<cfif collection.size() GT 1>
 25 | 			<!--- have a peek inside the first item in the collection and get the list of "sortable" fields --->
 26 | 			<cfif NOT listfind(structkeylist(collection.peek().getProperties()), listfirst(arguments.order, " "))>
 27 | 				<!--- default the order to something we know we have if an unsuitable order has been provided --->
 28 | 				<cfset arguments.order = "name">
 29 | 			</cfif>
 30 | 			<!--- sort based on the given field (using the getter for the property) --->
 31 | 			<cfset collection.sort("get" & arguments.order)>
 32 | 		</cfif>
 33 | 		<!--- cache the response --->
 34 | 		<cfset arguments['_response'].setCacheStatus(TRUE)>
 35 | 		<!--- return the sorted collection --->
 36 | 		<cfreturn collection>
 37 | 	</cffunction>
 38 | 
 39 | 	<cffunction name="count" access="public" returntype="any" output="no" hint="Returns a count of worlds">
 40 | 		<!--- create a ResourceCount instance and populate it with the number of worlds --->
 41 | 		<cfreturn createobject("component", "restfulcf.framework.core.ResourceCount").init("worlds", arraylen(application.worlds))>
 42 | 	</cffunction>
 43 | 
 44 | 	<cffunction name="read" access="public" returntype="any" output="no" hint="Read method (GET)">
 45 | 		<cfargument name="id" type="numeric" required="yes" hint="The world ID to read">
 46 | 		<cfset var world = "">
 47 | 		<!--- find the world --->
 48 | 		<cfset var pos = findPosition(arguments.id)>
 49 | 		<cfif pos>
 50 | 			<!--- get the world as a resource --->
 51 | 			<cfset world = toResource(application.worlds[pos])>
 52 | 		<cfelse>
 53 | 			<!--- we can't find the word: set the response status appropriately --->
 54 | 			<cfset arguments['_response'].setStatusCode(this.HTTP_STATUS_CODES['not_found'])>
 55 | 		</cfif>
 56 | 		<cfreturn world>
 57 | 	</cffunction>
 58 | 
 59 | 	<cffunction name="create" access="public" returntype="any" output="yes" hint="Create method (POST)">
 60 | 		<cfargument name="name" type="string" required="yes" hint="The world name">
 61 | 		<cfset var world = {}>
 62 | 		<!--- validate the name --->
 63 | 		<cfif NOT len(arguments.name)>
 64 | 			<!--- add an error if there's a problem --->
 65 | 			<cfset arguments['_response'].addError("Name must not be empty")>
 66 | 		</cfif>
 67 | 		<!--- if there are any errors, set a fail status and return --->
 68 | 		<cfif arguments['_response'].hasErrors()>
 69 | 			<cfset arguments['_response'].setStatusCode(this.HTTP_STATUS_CODES['unprocessable_entity'])>
 70 | 			<cfreturn>
 71 | 		</cfif>
 72 | 		<!--- still here, so create the new world --->
 73 | 		<cfset world = {
 74 | 			id         = getMaxWorldID() + 1,
 75 | 			name       = arguments.name,
 76 | 			created_at = NOW(),
 77 | 			updated_at = NOW()
 78 | 		}>
 79 | 		<!--- store the new world in our 'database' --->
 80 | 		<cfset arrayappend(application.worlds, world)>
 81 | 		<!--- set the proper response status and URI --->
 82 | 		<cfset arguments['_response'].setStatusCode(this.HTTP_STATUS_CODES['created'])>
 83 | 		<cfset arguments['_response'].setResponseURI("/worlds/" & world.id)>
 84 | 		<!--- and return the resource-ified world --->
 85 | 		<cfreturn toResource(world)>
 86 | 	</cffunction>
 87 | 
 88 | 	<cffunction name="update" access="public" returntype="any" output="no" hint="Update method (PUT)">
 89 | 		<cfargument name="id" type="numeric" required="yes" hint="The world ID to update">
 90 | 		<cfargument name="name" type="string" required="yes" hint="The world name">
 91 | 		<cfset var world = {}>
 92 | 		<!--- find the world to update --->
 93 | 		<cfset var pos = findPosition(arguments.id)>
 94 | 		<cfif pos>
 95 | 			<cfset world = application.worlds[pos]>
 96 | 		<cfelse>
 97 | 			<!--- we can't find the word: set the response status appropriately and return --->
 98 | 			<cfset arguments['_response'].setStatusCode(this.HTTP_STATUS_CODES['not_found'])>
 99 | 			<cfreturn>
100 | 		</cfif>
101 | 		<!--- validate the name --->
102 | 		<cfif NOT len(arguments.name)>
103 | 			<cfset arguments['_response'].addError("Name must not be empty")>
104 | 		</cfif>
105 | 		<!--- if there are any errors, set a fail status and return --->
106 | 		<cfif arguments['_response'].hasErrors()>
107 | 			<cfset arguments['_response'].setStatusCode(this.HTTP_STATUS_CODES['unprocessable_entity'])>
108 | 			<cfreturn>
109 | 		</cfif>
110 | 		<!--- still here, update the world --->
111 | 		<cfset world.name = arguments.name>
112 | 		<cfset world.updated_at = NOW()>
113 | 		<!--- store the new world in our 'database' --->
114 | 		<cfset application.worlds[pos] = world>
115 | 		<!--- set the proper response status --->
116 | 		<cfset arguments['_response'].setStatusCode(this.HTTP_STATUS_CODES['ok'])>
117 | 		<!--- and return the resource-ified world --->
118 | 		<cfreturn toResource(world)>
119 | 	</cffunction>
120 | 
121 | 	<cffunction name="delete" access="public" returntype="any" output="no" hint="Delete method (DELETE)">
122 | 		<cfargument name="id" type="numeric" required="yes" hint="The world ID to delete">
123 | 		<cfset var world = {}>
124 | 		<!--- find the world to update --->
125 | 		<cfset var pos = findPosition(arguments.id)>
126 | 		<cfif NOT pos>
127 | 			<!--- we can't find the word: set the response status appropriately and return --->
128 | 			<cfset arguments['_response'].setStatusCode(this.HTTP_STATUS_CODES['not_found'])>
129 | 			<cfreturn>
130 | 		</cfif>
131 | 		<cfset arraydeleteat(application.worlds, pos)>
132 | 		<cfset arguments['_response'].setStatusCode(this.HTTP_STATUS_CODES['ok'])>
133 | 	</cffunction>
134 | 
135 | 	<!--- *** (NON-CRUD) HELPER AND UTILITY FUNCTIONS --->
136 | 
137 | 	<cffunction name="toResource" access="private" returntype="restfulcf.framework.core.Resource" output="no" hint="Converts an internally-stored world stucture to a World resource">
138 | 		<cfargument name="world" type="struct" required="yes" hint="The structure to convert to a World resource">
139 | 		<cfreturn createobject("component", "restfulcf.sample.helloworld.rest.resources.World").init(
140 | 			id         = world.id,
141 | 			name       = world.name,
142 | 			created_at = world.created_at,
143 | 			updated_at = world.updated_at
144 | 		)>
145 | 	</cffunction>
146 | 
147 | 	<cffunction name="findPosition" access="private" returntype="numeric" output="no" hint="Find the array position of the given world ID">
148 | 		<cfargument name="id" type="numeric" required="yes" hint="The world ID">
149 | 		<cfset var pos = 0>
150 | 		<cfset var i = 0>
151 | 		<cfloop from="1" to="#arraylen(application.worlds)#" index="i">
152 | 			<cfif application.worlds[i].id EQ arguments.id>
153 | 				<cfset pos = i>
154 | 				<cfbreak>
155 | 			</cfif>
156 | 		</cfloop>
157 | 		<cfreturn pos>
158 | 	</cffunction>
159 | 
160 | 	<cffunction name="getMaxWorldID" access="private" returntype="numeric" output="no" hint="Find the maximum world ID">
161 | 		<cfset var max_id = 0>
162 | 		<cfset var world = "">
163 | 		<cfloop array="#application.worlds#" index="world">
164 | 			<cfif world.id GT max_id>
165 | 				<cfset max_id = world.id>
166 | 			</cfif>
167 | 		</cfloop>
168 | 		<cfreturn max_id>
169 | 	</cffunction>
170 | 
171 | </cfcomponent>
172 | 


--------------------------------------------------------------------------------
/restfulcf/sample/helloworld/README.markdown:
--------------------------------------------------------------------------------
  1 | # RESTfulCF Sample App: Hello World
  2 | 
  3 | The staple introductory or sample application for any language or framework, we present: RESTfulCF Hello World.
  4 | 
  5 | ## Setup and Requirements
  6 | 
  7 | The assumed setup is:
  8 | 
  9 | * ColdFusion 8;
 10 | * Apache with `mod_rewrite` enabled and allowed for per-directory settings (e.g. using `.htaccess`);
 11 | * That the `restfulcf` directory is in your local web root.
 12 | 
 13 | The sample application uses an `application`-scoped "database" for storing `World` instances, so no database is required.
 14 | 
 15 | To make non-`GET` requests to a RESTfulCF implementation (i.e. for creating, updating or deleting resources), you'll need something other than your browser.  `cURL` is good enough for you command-line people, or if you're a Firefox fan try the [Poster](https://addons.mozilla.org/en-US/firefox/addon/2691) plugin.
 16 | 
 17 | > **Note**: if you are not using Apache with `mod_rewrite` enabled within an `.htaccess` file, you'll need to add `rest.cfm` to each of the URLs listed below, for example: `...public/worlds` should become `...public/rest.cfm/worlds`.
 18 | 
 19 | ## Files
 20 | 
 21 | This sample application is structured as follows (all within `restfulcf/sample/helloworld`):
 22 | 
 23 |     README.markdown        – this file
 24 |     public                 – the "webroot" of this application
 25 |         .htaccess          – Apache rewrite (to remove /rest.cfm/ from URLs)
 26 |         rest.cfm           – public interface to the REST implementation
 27 |         Application.cfc    – basic setup of application vars etc
 28 |     rest                   – the location of the controllers, resource descriptors etc
 29 |         Dispatcher.cfc     – Dispatcher definition (extends restfulcf.framework.core.Dispatcher)
 30 |         controllers        – all the controllers for the sample app
 31 |             Worlds.cfc     – controller (extends restfulcf.framework.core.Controller)
 32 |         resources          – all resources for the sample app
 33 |             World.cfc      – resource definition (extends restfulcf.framework.core.Resource)
 34 | 
 35 | The controller file name should be pluralised and CamelCased (although this can be overridden); the resource file name can anything, but should be singular and CamelCased for consistency.
 36 | 
 37 | ## Controller Actions
 38 | 
 39 | The sample controller (`rest/controllers/Worlds.cfc`) gives an example of the six default actions.  The actions available, including an example of the HTTP request required to call that action, are as follows:
 40 | 
 41 | * `index`   -- list/index of all worlds (`GET /worlds`)
 42 | * `create`: -- create a new world (`POST /worlds`)
 43 | * `read`:   -- read a single world (`GET /worlds/:id`)
 44 | * `update`: -- update a single world (`PUT /worlds/:id`)
 45 | * `delete`: -- delete a single world (`DELETE /worlds/:id`)
 46 | * `count`:  -- simple count, instead of listing all and counting (`GET /worlds/count`)
 47 | 
 48 | ### `index`, `read` and `count` (via the HTTP `GET` method)
 49 | 
 50 | The simplest calls that can be made are `GET` requests, as these can be made directly through your browser.  Assuming the setup as described above, you can retrieve a list of all pre-defined `World`s (also known as a "collection" or resources) by simply putting the following into your browser:
 51 | 
 52 |     http://localhost/restfulcf/sample/helloworld/public/worlds
 53 | 
 54 | This should return you an XML packet similar to the following:
 55 | 
 56 |     <?xml version="1.0" encoding="UTF-8"?>
 57 |     <worlds type="array">
 58 |         <world>
 59 |             <created_at type="datetime">{ts '2009-07-13 08:31:45'}</created_at>
 60 |             <id type="integer">2</id>
 61 |             <name>Goodbye</name>
 62 |             <updated_at type="datetime">{ts '2009-07-13 08:31:45'}</updated_at>
 63 |         </world>
 64 |         <world>
 65 |             <created_at type="datetime">{ts '1978-09-22 12:34:56'}</created_at>
 66 |             <id type="integer">1</id>
 67 |             <name>Hello</name>
 68 |             <updated_at type="datetime">{ts '2009-07-13 08:31:45'}</updated_at>
 69 |         </world>
 70 |     </worlds>
 71 | 
 72 | By default, the worlds are returned in alphabetical order by name; to change this, try the following:
 73 | 
 74 |     http://localhost/restfulcf/sample/helloworld/public/worlds?order=id
 75 | 
 76 | The `index` function in `restfulcf/sample/helloworld/rest/controllers/Worlds.cfc` is setup to use the `sort` function of the `ResourceCollection` that's returned, based on the order given, which means you can sort based on any of the fields.
 77 | 
 78 | To read just a single `World` resource, you just add the ID of the world to the end of the `index` URL as follows:
 79 | 
 80 |     http://localhost/restfulcf/sample/helloworld/public/worlds/1
 81 | 
 82 | You'll then just get the single resource back:
 83 | 
 84 |     <world>
 85 |         <created_at type="datetime">{ts '1978-09-22 12:34:56'}</created_at>
 86 |         <id type="integer">1</id>
 87 |         <name>Hello</name>
 88 |         <updated_at type="datetime">{ts '2009-07-13 08:31:45'}</updated_at>
 89 |     </world>
 90 | 
 91 | The default representation of each resource is XML, but you can change this by simple adding the appropriate type of the end of the URL, as follows:
 92 | 
 93 |     http://localhost/restfulcf/sample/helloworld/public/worlds/1.txt
 94 |     http://localhost/restfulcf/sample/helloworld/public/worlds/1.html
 95 |     http://localhost/restfulcf/sample/helloworld/public/worlds/1.pdf
 96 | 
 97 | If you request a representation that's not supported by the given resource, the HTTP response status will be `415 Unsupported Media Type`.
 98 | 
 99 | If you simply wish to get a count of how many `World`s there are, you can append `/count` to the collection URI:
100 | 
101 |     http://localhost/restfulcf/sample/helloworld/public/worlds/count
102 | 
103 | An XML representation of a count will look like the following:
104 | 
105 |     <worlds>
106 |         <count type="integer">2</count>
107 |     </worlds>
108 | 
109 | This method is not a standard RESTful, but has been added though the need to perform counts on resources, but not wanting to retrieve thousands of resources via the `index` method, simply to count how many there are.
110 | 
111 | ### `create` (via the HTTP `POST` method)
112 | 
113 | Creating a new resource is slightly more complicated, in that it requires an HTTP `POST` method.  The example here is using `cURL` to create a new `World` resource:
114 | 
115 |     curl -d 'name=Another' http://localhost/restfulcf/sample/helloworld/public/worlds
116 | 
117 | You can provide the properties for new resources either as `GET` or `POST` arguments (using the ColdFusion `URL` or `FORM` scopes), or by sending an XML representation of the resource as the `POST` body.
118 | 
119 | Assuming that the new `World` was created successfully, the HTTP response status will be `201 Created`; the `Location` headed will include the unique URI to the newly created `World` resource, and the body will be the representation of the resource as if you had `read` it.
120 | 
121 | If there is a validation error and the resource cannot be created, the response status will be `422 Unprocessable Entity`, and the body will be an array of error messages such as the following (if we provided an empty `name` property when trying to create a new `World`):
122 | 
123 |     <errors type="array">
124 |         <error>Name must not be empty</error>
125 |     </errors>
126 | 
127 | ### `update` (via the HTTP `PUT` method)
128 | 
129 | Updating an existing resource is very similar to creating a new one: the properties for the resource are provided in the same way, and on a successful request the appropriate representation of the updated resource is returned as the response body.
130 | 
131 | An `update` request differs from a `create` in that you must use the HTTP `PUT` method, and use the full URI to the resource, for example:
132 | 
133 |     curl -X PUT -d 'name=A Different' http://localhost/restfulcf/sample/helloworld/public/worlds/1
134 | 
135 | If a resource cannot be found, the response status will be `404 Not Found`; on a successful update, the response will be `200 OK`.  Validation errors are handled in the same way as for a `create` request.
136 | 
137 | ### `delete` (via the HTTP `DELETE` method)
138 | 
139 | The final request type is a `delete`; this is simply an HTTP `DELETE` request to a resource URI:
140 | 
141 |     curl -X DELETE http://localhost/restfulcf/sample/helloworld/public/worlds/1
142 | 
143 | The response statuses are the same as for an `update` request (`200 OK` or `404 Not Found` as appropriate).
144 | 


--------------------------------------------------------------------------------
/restfulcf/test/tests/util/InflectorTest.cfc:
--------------------------------------------------------------------------------
  1 | <!--- -->
  2 | <fusedoc fuse="restfulcf/test/tests/util/InflectorTest.cfc" language="ColdFusion" specification="2.0">
  3 | 	<responsibilities>
  4 | 		I test the inflector to make sure it inflects things correctly
  5 | 	</responsibilities>
  6 | </fusedoc>
  7 | --->
  8 | 
  9 | <cfcomponent extends="mxunit.framework.TestCase">
 10 | 
 11 | 	<!--- case-sensitive asserts are currently only available in SVN for MXUnit (not standard release) --->
 12 | 	<cfif NOT (structkeyexists(variables, "assertEqualsCase") AND iscustomfunction(variables.assertEqualsCase))>
 13 | 		<cfset variables.assertEqualsCase = variables.assertEquals>
 14 | 	</cfif>
 15 | 
 16 | 	<cffunction name="setup">
 17 | 		<cfset inflector = createObject("component", "restfulcf.framework.util.Inflector")>
 18 | 	</cffunction>
 19 | 
 20 | 	<!--- Capitalising --->
 21 | 	<cffunction name="capitalise_should_capitalise_first_letter">
 22 | 		<cfset assertEqualsCase("The big dog", inflector.capitalise("the big dog"))>
 23 | 	</cffunction>
 24 | 	<cffunction name="capitalise_should_not_change_already_capitalised_first_letter">
 25 | 		<cfset assertEqualsCase("The big dog", inflector.capitalise("The big dog"))>
 26 | 	</cffunction>
 27 | 	<cffunction name="capitalise_should_capitalise_single_character">
 28 | 		<cfset assertEqualsCase("X", inflector.capitalise("x"))>
 29 | 	</cffunction>
 30 | 	<cffunction name="is_capital_should_be_true_for_all_capital_letters">
 31 | 		<cfset var i = 0>
 32 | 		<cfloop from="65" to="90" index="i">
 33 | 			<cfset assertTrue(inflector.isCapital(chr(i)))>
 34 | 		</cfloop>
 35 | 	</cffunction>
 36 | 	<cffunction name="is_capital_should_be_false_for_all_non_capital_letters">
 37 | 		<cfset var i = 0>
 38 | 		<cfloop from="141" to="172" index="i">
 39 | 			<cfset assertFalse(inflector.isCapital(chr(i)))>
 40 | 		</cfloop>
 41 | 	</cffunction>
 42 | 	<cffunction name="is_capital_should_be_false_for_all_non_alpha_characters">
 43 | 		<cfset var i = "">
 44 | 		<cfloop list="1,2,6,7,8,@,£,$,^,),(,*,{,},_,<,>,?,*,[,],@,?" index="i">
 45 | 			<cfset assertFalse(inflector.isCapital(i))>
 46 | 		</cfloop>
 47 | 	</cffunction>
 48 | 
 49 | 	<!--- CamelCasing --->
 50 | 	<cffunction name="camel_case_should_camel_case_spaced_string">
 51 | 		<cfset assertEqualsCase("TheBigDog", inflector.CamelCase("the big dog"))>
 52 | 	</cffunction>
 53 | 	<cffunction name="camel_case_should_camel_case_underscored_string">
 54 | 		<cfset assertEqualsCase("TheBigDog", inflector.CamelCase("the_big_dog"))>
 55 | 	</cffunction>
 56 | 	<cffunction name="camel_case_should_camel_case_string_with_non_alpha_chars">
 57 | 		<cfset assertEqualsCase("TheBigDog", inflector.CamelCase("the{}{big^!*dog"))>
 58 | 	</cffunction>
 59 | 	<cffunction name="camel_case_should_not_change_an_already_camel_cased_string">
 60 | 		<cfset assertEqualsCase("TheBigDog", inflector.CamelCase("TheBigDog"))>
 61 | 	</cffunction>
 62 | 
 63 | 	<!--- variablising --->
 64 | 	<cffunction name="variablise_should_variablise_camel_cased_string">
 65 | 		<cfset assertEqualsCase("the_big_dog", inflector.variablise("TheBigDog"))>
 66 | 	</cffunction>
 67 | 	<cffunction name="variablise_should_variablise_spaced_string">
 68 | 		<cfset assertEqualsCase("the_big_dog", inflector.variablise("The big dog"))>
 69 | 	</cffunction>
 70 | 	<cffunction name="variablise_should_variablise_string_with_numbers">
 71 | 		<cfset assertEqualsCase("area51_controller", inflector.variablise("area51Controller"))>
 72 | 	</cffunction>
 73 | 	<cffunction name="variablise_should_not_change_an_already_variablised_string">
 74 | 		<cfset assertEqualsCase("the_big_dog", inflector.variablise("the_big_dog"))>
 75 | 	</cffunction>
 76 | 	<cffunction name="variablise_should_variablise_string_with_non_alpha_chars">
 77 | 		<cfset assertEqualsCase("the_big_dog", inflector.variablise("^%*%^ The^%*%^ BigDog %^%*"))>
 78 | 	</cffunction>
 79 | 	<cffunction name="variablise_should_variablise_string_with_multiple_upcased_chars">
 80 | 		<cfset assertEqualsCase("the_css_and_html_people", inflector.variablise("TheCSSAndHTMLPeople"))>
 81 | 	</cffunction>
 82 | 
 83 | 	<!--- humanising --->
 84 | 	<cffunction name="humanise_should_humanise_camel_cased_string">
 85 | 		<cfset assertEqualsCase("The Big Dog", inflector.humanise("TheBigDog"))>
 86 | 	</cffunction>
 87 | 	<cffunction name="humanise_should_humanise_variablise_string">
 88 | 		<cfset assertEqualsCase("the big dog", inflector.humanise("the_big_dog"))>
 89 | 	</cffunction>
 90 | 	<cffunction name="humanise_should_not_change_already_humanised_string">
 91 | 		<cfset assertEqualsCase("the big dog", inflector.humanise("the big dog"))>
 92 | 	</cffunction>
 93 | 	<cffunction name="humanise_should_humanise_string_with_non_alpha_chars">
 94 | 		<cfset assertEqualsCase("The Big Dog", inflector.humanise("^%*%^ The^%*%^ BigDog %^%*"))>
 95 | 	</cffunction>
 96 | 	<cffunction name="humanise_should_humanise_string_with_multiple_upcased_chars">
 97 | 		<cfset assertEqualsCase("The CSS And HTML People", inflector.humanise("TheCSSAndHTMLPeople"))>
 98 | 	</cffunction>
 99 | 	<cffunction name="humanise_string_ending_with_id_should_remove_id">
100 | 		<cfset assertEqualsCase("another test", inflector.humanise("another_test_id"))>
101 | 	</cffunction>
102 | 
103 | 	<!--- string padding --->
104 | 	<cffunction name="pad_should_pad_string_to_max_length">
105 | 		<cfset assertEquals(20, len(inflector.pad(repeatstring("x", 10), 20)))>
106 | 	</cffunction>
107 | 	<cffunction name="pad_should_return_string_if_length_greater_than_max_pad_length">
108 | 		<cfset assertEquals(30, len(inflector.pad(repeatstring("x", 30), 20)))>
109 | 	</cffunction>
110 | 
111 | 	<!--- pluralisation and singularisation --->
112 | 	<cfset singular_to_plural = {
113 | 		search       = "searches",
114 | 		switch       = "switches",
115 | 		fix          = "fixes",
116 | 		box          = "boxes",
117 | 		process      = "processes",
118 | 		address      = "addresses",
119 | 		case         = "cases",
120 | 		stack        = "stacks",
121 | 		wish         = "wishes",
122 | 		fish         = "fish",
123 | 		jeans        = "jeans",
124 | 		category     = "categories",
125 | 		query        = "queries",
126 | 		ability      = "abilities",
127 | 		agency       = "agencies",
128 | 		movie        = "movies",
129 | 		archive      = "archives",
130 | 		index        = "indices",
131 | 		wife         = "wives",
132 | 		safe         = "saves",
133 | 		half         = "halves",
134 | 		move         = "moves",
135 | 		salesperson  = "salespeople",
136 | 		person       = "people",
137 | 		spokesman    = "spokesmen",
138 | 		man          = "men",
139 | 		woman        = "women",
140 | 		basis        = "bases",
141 | 		diagnosis    = "diagnoses",
142 | 		diagnosis_a  = "diagnosis_as",
143 | 		datum        = "data",
144 | 		medium       = "media",
145 | 		analysis     = "analyses",
146 | 		node_child   = "node_children",
147 | 		child        = "children",
148 | 		experience   = "experiences",
149 | 		day          = "days",
150 | 		comment      = "comments",
151 | 		foobar       = "foobars",
152 | 		newsletter   = "newsletters",
153 | 		old_news     = "old_news",
154 | 		news         = "news",
155 | 		series       = "series",
156 | 		species      = "species",
157 | 		quiz         = "quizzes",
158 | 		perspective  = "perspectives",
159 | 		ox           = "oxen",
160 | 		photo        = "photos",
161 | 		buffalo      = "buffaloes",
162 | 		tomato       = "tomatoes",
163 | 		dwarf        = "dwarves",
164 | 		elf          = "elves",
165 | 		information  = "information",
166 | 		equipment    = "equipment",
167 | 		bus          = "buses",
168 | 		status       = "statuses",
169 | 		status_code  = "status_codes",
170 | 		mouse        = "mice",
171 | 		louse        = "lice",
172 | 		house        = "houses",
173 | 		octopus      = "octopi",
174 | 		virus        = "viri",
175 | 		alias        = "aliases",
176 | 		portfolio    = "portfolios",
177 | 		vertex       = "vertices",
178 | 		matrix       = "matrices",
179 | 		matrix_fu    = "matrix_fus",
180 | 		axis         = "axes",
181 | 		testis       = "testes",
182 | 		crisis       = "crises",
183 | 		rice         = "rice",
184 | 		shoe         = "shoes",
185 | 		horse        = "horses",
186 | 		prize        = "prizes",
187 | 		edge         = "edges",
188 | 		database     = "databases",
189 | 		stadium      = "stadia",
190 | 		zombie       = "zombies"
191 | 	}>
192 | 	<cffunction name="pluralise_should_pluralise_simple_and_complex_words">
193 | 		<cfset var word = "">
194 | 		<cfloop collection="#singular_to_plural#" item="word">
195 | 			<cfset assertEquals(singular_to_plural[word], inflector.pluralise(word))>
196 | 		</cfloop>
197 | 	</cffunction>
198 | 	<cffunction name="singularise_should_singularise_simple_and_complex_words">
199 | 		<cfset var word = "">
200 | 		<cfloop collection="#singular_to_plural#" item="word">
201 | 			<cfset assertEquals(word, inflector.singularise(singular_to_plural[word]))>
202 | 		</cfloop>
203 | 	</cffunction>
204 | 	<cffunction name="pluralise_should_not_repluralise_already_plural_words">
205 | 		<cfset var word = "">
206 | 		<cfloop collection="#singular_to_plural#" item="word">
207 | 			<cfset assertEquals(singular_to_plural[word], inflector.pluralise(singular_to_plural[word]))>
208 | 		</cfloop>
209 | 	</cffunction>
210 | 	<cffunction name="singularise_should_not_resingularise_already_singular_words">
211 | 		<cfset var word = "">
212 | 		<cfloop collection="#singular_to_plural#" item="word">
213 | 			<cfset assertEquals(word, inflector.singularise(word))>
214 | 		</cfloop>
215 | 	</cffunction>
216 | 
217 | </cfcomponent>
218 | 


--------------------------------------------------------------------------------
/restfulcf/framework/util/Inflector.cfc:
--------------------------------------------------------------------------------
  1 | <!---  -->
  2 | <fusedoc fuse="restfulcf/framework/util/Inflector.cfc" language="ColdFusion" specification="2.0">
  3 | 	<responsibilities>
  4 | 		I am a CF version of portions of the Ruby on Rails Inflector class, specifically the
  5 | 		functions which provide the ability to generate singulars/plurals of given words,
  6 | 		plus some translation functions.
  7 | 	</responsibilities>
  8 | </fusedoc>
  9 | --->
 10 | 
 11 | <cfcomponent displayname="Inflector" output="no">
 12 | 
 13 | 	<!--- SETUP --->
 14 | 
 15 | 	<cfset variables.plurals      = arraynew(1)>
 16 | 	<cfset variables.singulars    = arraynew(1)>
 17 | 	<cfset variables.irregulars   = arraynew(1)>
 18 | 	<cfset variables.uncountables = "">
 19 | 
 20 | 	<cfscript>
 21 | 		// singular -> plural rules (most generic first)
 22 | 		plural('$', 's');
 23 | 		plural('s$', 's');
 24 | 		plural('(ax|test)is$', '\1es');
 25 | 		plural('(octop|vir)us$', '\1i');
 26 | 		plural('(octop|vir)i$', '\1i');
 27 | 		plural('(alias|status)$', '\1es');
 28 | 		plural('(bu)s$', '\1ses');
 29 | 		plural('(buffal|tomat)o$', '\1oes');
 30 | 		plural('([ti])um$', '\1a');
 31 | 		plural('([ti])a$', '\1a');
 32 | 		plural('s[ei]s$', 'ses');
 33 | 		plural('(?:([^f])fe|([lr])f)$', '\1\2ves');
 34 | 		plural('(hive)$', '\1s');
 35 | 		plural('([^aeiouy]|qu)y$', '\1ies');
 36 | 		plural('(x|ch|ss|sh)$', '\1es');
 37 | 		plural('(matr|vert|ind)(?:ix|ex)$', '\1ices');
 38 | 		plural('([m|l])ouse$', '\1ice');
 39 | 		plural('([m|l])ice$', '\1ice');
 40 | 		plural('^(ox)(en)?$', '\1en');
 41 | 		plural('(quiz)$', '\1zes');
 42 | 		plural('(r|m|wom)en$', '\1en');
 43 | 		plural('(people)$', '\1');
 44 | 		// plural -> singular rules (most generic first)
 45 | 		singular('s$', '');
 46 | 		singular('(n)ews$', '\1ews');
 47 | 		singular('([ti])a$', '\1um');
 48 | 		singular('((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)s[ei]s$', '\1\2sis');
 49 | 		singular('(^analy)s[ei]s$', '\1sis');
 50 | 		singular('([^f])ves$', '\1fe');
 51 | 		singular('([ht]ive)s$', '\1');
 52 | 		singular('([lr])ves$', '\1f');
 53 | 		singular('([^aeiouy]|qu)ies$', '\1y');
 54 | 		singular('(s)eries$', '\1eries');
 55 | 		singular('(m)ovies$', '\1ovie');
 56 | 		singular('(x|ch|ss|sh)es$', '\1');
 57 | 		singular('([m|l])ice$', '\1ouse');
 58 | 		singular('(bus)(es)?$', '\1');
 59 | 		singular('(o)es$', '\1');
 60 | 		singular('(shoe)s$', '\1');
 61 | 		singular('(cris|ax|test)[ei]s$', '\1is');
 62 | 		singular('(octop|vir)(i|us)$', '\1us');
 63 | 		singular('(alias|status)(es)?$', '\1');
 64 | 		singular('^(ox)en', '\1');
 65 | 		singular('(vert|ind)ices$', '\1ex');
 66 | 		singular('(matr)ices$', '\1ix');
 67 | 		singular('(quiz)zes$', '\1');
 68 | 		singular('(database)s$', '\1');
 69 | 		singular('(ess)$', '\1');
 70 | 		// irregulars (singular, plural)
 71 | 		irregular('person', 'people');
 72 | 		irregular('man', 'men');
 73 | 		irregular('child', 'children');
 74 | 		irregular('sex', 'sexes');
 75 | 		irregular('move', 'moves');
 76 | 		irregular('zombie', 'zombies');
 77 | 		// uncountables (words that don't change)
 78 | 		uncountable('equipment');
 79 | 		uncountable('information');
 80 | 		uncountable('rice');
 81 | 		uncountable('money');
 82 | 		uncountable('species');
 83 | 		uncountable('series');
 84 | 		uncountable('fish');
 85 | 		uncountable('sheep');
 86 | 		uncountable('jeans');
 87 | 	</cfscript>
 88 | 
 89 | 	<!--- PUBLIC callable functions --->
 90 | 
 91 | 	<!--- function for returning the plural form of a word --->
 92 | 	<cffunction name="pluralise" access="public" returntype="string" output="no" hint="Returns the plural form of a word">
 93 | 		<cfargument name="word" type="string" required="yes" hint="The word to get the plural for">
 94 | 		<cfset var i = 0>
 95 | 		<cfif NOT listfind(variables.uncountables, lcase(arguments.word))>
 96 | 			<cfloop from="1" to="#arraylen(variables.plurals)#" index="i">
 97 | 				<cfif refindnocase(variables.plurals[i]['rule'], arguments.word)>
 98 | 					<cfset arguments.word = rereplacenocase(arguments.word, variables.plurals[i]['rule'], variables.plurals[i]['replacement'])>
 99 | 					<cfbreak>
100 | 				</cfif>
101 | 			</cfloop>
102 | 		</cfif>
103 | 		<cfreturn arguments.word>
104 | 	</cffunction>
105 | 
106 | 	<!--- function for returning the singular form of a word --->
107 | 	<cffunction name="singularise" access="public" returntype="string" output="no" hint="Returns the singular form of a word">
108 | 		<cfargument name="word" type="string" required="yes" hint="The word to get the singular for">
109 | 		<cfset var i = 0>
110 | 		<cfif NOT listfind(variables.uncountables, lcase(arguments.word))>
111 | 			<cfloop from="1" to="#arraylen(variables.singulars)#" index="i">
112 | 				<cfif refindnocase(variables.singulars[i]['rule'], arguments.word)>
113 | 					<cfset arguments.word = rereplacenocase(arguments.word, variables.singulars[i]['rule'], variables.singulars[i]['replacement'])>
114 | 					<cfbreak>
115 | 				</cfif>
116 | 			</cfloop>
117 | 		</cfif>
118 | 		<cfreturn arguments.word>
119 | 	</cffunction>
120 | 
121 | 
122 | 	<!--- function for capitalising the first character of a string --->
123 | 	<cffunction name="capitalise" access="public" returntype="string" output="no" hint="Capitalises the first character in a string">
124 | 		<cfargument name="string" type="string" required="yes" hint="The string to capitalise">
125 | 		<cfif len(arguments.string) LT 2><cfreturn ucase(arguments.string)></cfif>
126 | 		<cfreturn ucase(left(arguments.string, 1)) & right(arguments.string, len(arguments.string)-1)>
127 | 	</cffunction>
128 | 
129 | 	<!--- function for CamelCasing a string --->
130 | 	<cffunction name="CamelCase" access="public" returntype="string" output="no" hint="Returns a given string, converted to CamelCase.  All non-alphanum characters are stripped.">
131 | 		<cfargument name="string" type="string" required="yes" hint="The string to CamelCase">
132 | 		<cfset var str = "">
133 | 		<cfset var i = 0>
134 | 		<!--- split the string into tokens based on non-alphanum characters --->
135 | 		<cfset var tokens = trim(arguments.string).split("[^a-zA-Z0-9]")>
136 | 		<cfloop from="1" to="#arraylen(tokens)#" index="i">
137 | 			<!--- loop through each token and capitalise it --->
138 | 			<cfif len(tokens[i])><cfset str = str & capitalise(tokens[i])></cfif>
139 | 		</cfloop>
140 | 		<cfreturn str>
141 | 	</cffunction>
142 | 
143 | 	<!--- function for variablising a string --->
144 | 	<cffunction name="variablise" access="public" returntype="string" output="no" hint="Converts a string to a variable name, e.g. CamelCase becomes camel_case, 'big CSSDogThing' becomes big_css_dog_thing etc.">
145 | 		<cfargument name="string" type="string" required="yes" hint="The string to variablise">
146 | 		<cfset arguments.string = replace(trim(rereplace(arguments.string, "([^[:alnum:]_-]+)", " ", "ALL")), " ", "-", "ALL")>
147 | 		<cfset arguments.string = rereplace(arguments.string, "([A-Z]+)([A-Z][a-z])", "\1_\2", "ALL")>
148 | 		<cfset arguments.string = rereplace(arguments.string, "([a-z\d])([A-Z])", "\1_\2", "ALL")>
149 | 		<cfreturn lcase(replace(arguments.string, "-", "_", "ALL"))>
150 | 	</cffunction>
151 | 
152 | 	<!--- function for humanising a string --->
153 | 	<cffunction name="humanise" access="public" returntype="string" output="no" hint="Converts a string to a human-readable string, e.g. CamelCase becomes Camel Case, my_field_id becomes my_field etc.">
154 | 		<cfargument name="string" type="string" required="yes" hint="The string to humanise">
155 | 		<cfset arguments.string = replace(trim(rereplace(rereplace(arguments.string, "_id$", ""), "([^[:alnum:]_-]+)", " ", "ALL")), "_", " ", "ALL")>
156 | 		<cfset arguments.string = rereplace(arguments.string, "([A-Z]+)([A-Z][a-z])", "\1 \2", "ALL")>
157 | 		<cfreturn rereplace(arguments.string, "([a-z\d])([A-Z])", "\1 \2", "ALL")>
158 | 	</cffunction>
159 | 
160 | 	<!--- function for working out if a given character is upper-case --->
161 | 	<cffunction name="isCapital" access="public" returntype="boolean" output="no" hint="Is a given character upper-case?">
162 | 		<cfargument name="char" type="string" required="yes" hint="">
163 | 		<cfreturn asc(char) GTE 65 AND asc(char) LTE 90>
164 | 	</cffunction>
165 | 
166 | 	<!--- function to pad a string with spaces --->
167 | 	<cffunction name="pad" access="public" returntype="string" output="no" hint="Pads a string with spaces up to a given length">
168 | 		<cfargument name="str" type="string" required="yes" hint="The string to pad">
169 | 		<cfargument name="minlen" type="numeric" required="yes" hint="The length to pad to">
170 | 		<cfif len(str) GTE arguments.minlen><cfreturn arguments.str></cfif>
171 | 		<cfreturn str & repeatstring(" ", arguments.minlen-len(arguments.str))>
172 | 	</cffunction>
173 | 
174 | 	<!--- PRIVATE functions for component setup --->
175 | 
176 | 	<!--- function for specifying a new pluralisation rule and its replacement --->
177 | 	<cffunction name="plural" access="private" returntype="void" output="no" hint="Specifies a new pluralisation rule and its replacement">
178 | 		<cfargument name="rule" type="string" required="yes" hint="The regex rule to match">
179 | 		<cfargument name="replacement" type="string" required="yes" hint="The replacement value to use for this rule">
180 | 		<cfset var pl = structnew()>
181 | 		<cfset pl.rule = arguments.rule>
182 | 		<cfset pl.replacement = arguments.replacement>
183 | 		<cfset arrayprepend(variables.plurals, pl)>
184 | 	</cffunction>
185 | 
186 | 	<!--- function for specifying a new singularisation rule and its replacement --->
187 | 	<cffunction name="singular" access="private" returntype="void" output="no" hint="Specifies a new singularisation rule and its replacement">
188 | 		<cfargument name="rule" type="string" required="yes" hint="The regex rule to match">
189 | 		<cfargument name="replacement" type="string" required="yes" hint="The replacement value to use for this rule">
190 | 		<cfset var pl = structnew()>
191 | 		<cfset pl.rule = arguments.rule>
192 | 		<cfset pl.replacement = arguments.replacement>
193 | 		<cfset arrayprepend(variables.singulars, pl)>
194 | 	</cffunction>
195 | 
196 | 	<!--- function for adding irregular words that don't fit any norms --->
197 | 	<cffunction name="irregular" access="private" returntype="void" output="no" hint="Adds irregular words to the inflector that don't conform to any norms">
198 | 		<cfargument name="sin" type="string" required="yes" hint="The singular form of the word">
199 | 		<cfargument name="plu" type="string" required="yes" hint="The plrual form of the word">
200 | 		<cfset plural('(#left(arguments.sin, 1)#)#right(arguments.sin, len(arguments.sin) - 1)#$', '\1' & right(arguments.plu, len(arguments.plu) - 1))>
201 | 		<cfset singular('(#left(arguments.plu, 1)#)#right(arguments.plu, len(arguments.plu) - 1)#$', '\1' & right(arguments.sin, len(arguments.sin) - 1))>
202 | 	</cffunction>
203 | 
204 | 	<!--- function for adding uncountable words that shouldn't be inflected --->
205 | 	<cffunction name="uncountable" access="private" returntype="void" output="no" hint="Adds uncountable words that shouldn't be inflected">
206 | 		<cfargument name="word" type="string" required="yes" hint="The word to add to the uncountable list">
207 | 		<cfset variables.uncountables = listappend(variables.uncountables, arguments.word)>
208 | 	</cffunction>
209 | 
210 | </cfcomponent>
211 | 


--------------------------------------------------------------------------------
/restfulcf/framework/core/Request.cfc:
--------------------------------------------------------------------------------
  1 | <!--- -->
  2 | <fusedoc fuse="restfulcf/framework/core/Request.cfc" language="ColdFusion" specification="2.0">
  3 | 	<responsibilities>
  4 | 		I represent an individual request for a resource
  5 | 	</responsibilities>
  6 | </fusedoc>
  7 | --->
  8 | 
  9 | <cfcomponent output="no">
 10 | 
 11 | 	<cfset variables.instance = {
 12 | 		dispatcher = "",
 13 | 		route      = createobject("component", "restfulcf.framework.core.Route"),
 14 | 		uri        = "",
 15 | 		type       = "",
 16 | 		mime       = "",
 17 | 		arguments  = {},
 18 | 		fn_args    = {},
 19 | 		arg_trans  = FALSE,
 20 | 		options    = {}
 21 | 	}>
 22 | 
 23 | 	<cffunction name="init" access="public" returntype="restfulcf.framework.core.Request" output="no" hint="I initialise this instance">
 24 | 		<cfargument name="dispatcher" type="restfulcf.framework.core.Dispatcher" required="yes" hint="A reference to the calling dispatcher">
 25 | 		<cfargument name="route" type="restfulcf.framework.core.Route" required="yes" hint="The route that can handle this request">
 26 | 		<cfargument name="uri" type="string" required="yes" hint="The resource URI (excluding requested response type)">
 27 | 		<cfargument name="type" type="string" required="yes" hint="The requested response type">
 28 | 		<cfargument name="mime" type="string" required="yes" hint="The mime type of the request (not the response)">
 29 | 		<cfargument name="arg_trans" type="boolean" required="no" hint="Should we be converting dashes in argument names in to underscores?">
 30 | 		<cfset var arg = "">
 31 | 		<cfset var controller = "">
 32 | 		<cfloop collection="#arguments#" item="arg">
 33 | 			<cfif structkeyexists(variables.instance, arg)>
 34 | 				<cfset variables.instance[arg] = arguments[arg]>
 35 | 			</cfif>
 36 | 		</cfloop>
 37 | 		<cfset controller = variables.instance.dispatcher.getController(variables.instance.route.getController())>
 38 | 		<cfloop array="#getmetadata(controller[variables.instance.route.getMethod()]).parameters#" index="arg">
 39 | 			<cfparam name="arg.type" default="any">
 40 | 			<cfset variables.instance.fn_args[arg.name] = arg.type>
 41 | 		</cfloop>
 42 | 		<cfset arg = buildArgs()>
 43 | 		<cfset variables.instance.arguments = arg.args>
 44 | 		<cfset variables.instance.options = arg.opts>
 45 | 		<cfreturn this>
 46 | 	</cffunction>
 47 | 
 48 | 	<cffunction name="run" access="public" returntype="restfulcf.framework.core.Response" output="no" hint="Runs this request and responds with an encapsulated Response">
 49 | 		<cfset var response = createobject("component", "restfulcf.framework.core.Response").init(this)>
 50 | 		<cfset var controller = variables.instance.dispatcher.getController(variables.instance.route.getController())>
 51 | 		<cfset var vo        = "">
 52 | 		<cfset var resp      = "">
 53 | 		<cfset var args      = duplicate(variables.instance.arguments)>
 54 | 		<cfset var cache_data = {}>
 55 | 
 56 | 		<!--- check for any previously cached results (GET requests only) --->
 57 | 		<cfif variables.instance.dispatcher.isCacheEnabled() AND variables.instance.route.getVerb() EQ "GET">
 58 | 			<!--- if we've been passed a "__refresh" option in the args, freshen the cache --->
 59 | 			<cfif structkeyexists(variables.instance.options, "refresh")>
 60 | 				<cfset variables.instance.dispatcher.getCache().delete(this)>
 61 | 			<cfelse>
 62 | 				<cfset cache_data = variables.instance.dispatcher.getCache().get(this)>
 63 | 				<cfif cache_data.found><cfreturn cache_data.response></cfif>
 64 | 			</cfif>
 65 | 		</cfif>
 66 | 
 67 | 		<!--- add the request and response objects in whatever --->
 68 | 		<cfset args['_request'] = this>
 69 | 		<cfset args['_response'] = response>
 70 | 
 71 | 		<!--- call the appropriate request method, then get the representation for the returned object --->
 72 | 		<cftry>
 73 | 			<cfinvoke component          = "#controller#"
 74 | 			          method             = "#variables.instance.route.getMethod()#"
 75 | 			          returnvariable     = "vo"
 76 | 			          argumentcollection = "#args#">
 77 | 			<!--- any missing arguments are treated as a bad request --->
 78 | 			<cfcatch type="coldfusion.runtime.MissingArgumentException">
 79 | 				<!--- anything that does originate from this file is a bigger problem --->
 80 | 				<cfif cfcatch.tagcontext[1].template NEQ getcurrenttemplatepath()><cfrethrow></cfif>
 81 | 				<cfset response.setStatusCode(controller.HTTP_STATUS_CODES['unprocessable_entity'])>
 82 | 				<cfset response.addError("#cfcatch.paramname# is required")>
 83 | 			</cfcatch>
 84 | 			<cfcatch type="any">
 85 | 				<cfif find("coldfusion.runtime.UDFMethod$InvalidArgumentTypeException", trim(cfcatch.stacktrace)) EQ 1>
 86 | 					<cfif cfcatch.tagcontext[2].template NEQ getcurrenttemplatepath()><cfrethrow></cfif>
 87 | 					<cfset response.setStatusCode(controller.HTTP_STATUS_CODES['unprocessable_entity'])>
 88 | 					<cfset response.addError("#cfcatch.arg# is of the incorrect type (expected #cfcatch.type#)")>
 89 | 				<cfelse>
 90 | 					<cfrethrow>
 91 | 				</cfif>
 92 | 			</cfcatch>
 93 | 		</cftry>
 94 | 
 95 | 		<!--- if there are any errors, use the error object as the response instead --->
 96 | 		<cfif response.hasErrors()><cfset vo = response.getErrorCollection()></cfif>
 97 | 
 98 | 		<!--- only set the response if we've got back an object that responds to the correct to* type --->
 99 | 		<cfif isdefined("vo") AND isobject(vo)>
100 | 			<cfif structkeyexists(vo, "to#variables.instance.type#") AND iscustomfunction(vo["to#variables.instance.type#"])>
101 | 				<cfinvoke component="#vo#" method="to#variables.instance.type#" _response="#response#" returnvariable="resp">
102 | 				<cfif isdefined("resp") AND len(resp)><cfset response.setResponseBody(resp)></cfif>
103 | 			<cfelse>
104 | 				<cfset response.setStatusCode(controller.HTTP_STATUS_CODES['unsupported_media_type'])>
105 | 			</cfif>
106 | 		</cfif>
107 | 
108 | 		<!--- cache the response if required (we only care about successful GETs) --->
109 | 		<cfif variables.instance.dispatcher.isCacheEnabled()>
110 | 			<cfif variables.instance.route.getVerb() EQ "GET" AND response.getCacheStatus()
111 | 			  AND response.getStatusCode() EQ controller.HTTP_STATUS_CODES['ok']>
112 | 				<cfset variables.instance.dispatcher.getCache().set(this, response)>
113 | 			</cfif>
114 | 		</cfif>
115 | 
116 | 		<!--- return the response object --->
117 | 		<cfreturn response>
118 | 	</cffunction>
119 | 
120 | 	<cffunction name="buildArgs" access="private" returntype="struct" output="no" hint="Collects the arguments for this request from various sources">
121 | 		<cfset var post_body = "">
122 | 		<cfset var xml       = {}>
123 | 		<cfset var key       = "">
124 | 		<cfset var cond      = "">
125 | 		<cfset var arg_keys  = "">
126 | 		<cfset var arg       = "">
127 | 		<cfset var arg_name  = "">
128 | 		<cfset var opts      = {}>
129 | 		<!---
130 | 			build the arguments to send to the appropriate function, including refs to the request
131 | 			and response objects.  Argument precedence is:
132 | 
133 | 			1. path vars (e.g. the ID from /resource/:id)
134 | 			2. decoded XML data from the body of a POST or PUT
135 | 			3. anything from the FORM scope
136 | 			4. anything from the URL scope, including decoded "structured" conditions
137 | 
138 | 			The request and response objects always get thrown in as well (as _request and _response)
139 | 		--->
140 | 		<cfset var args = variables.instance.route.getPathVars(variables.instance.uri)>
141 | 
142 | 		<!--- POST/PUT might be sending data as encoded XML in the POST body: assume that all data is top-level --->
143 | 		<!--- just check for the sub-type, as we might be using text/xml or application/xml --->
144 | 		<cfif listfind("POST,PUT", variables.instance.route.getVerb()) AND listlast(variables.instance.mime, "/") EQ "xml">
145 | 			<cfset post_body = gethttprequestdata().content>
146 | 			<cfif isbinary(post_body)><cfset post_body = tostring(tobinary(post_body))></cfif>
147 | 			<cfif isxml(trim(post_body))>
148 | 				<cfset xml = createobject("component", "restfulcf.framework.util.XML").toStruct(xml=post_body, include_root=FALSE)>
149 | 				<!--- remove any 'nil' attributes (thanks, rails...) --->
150 | 				<cfloop collection="#xml#" item="key">
151 | 					<cfif structkeyexists(xml, key & "::attributes")
152 | 					  AND structkeyexists(xml[key & "::attributes"], "nil")
153 | 					  AND isboolean(xml[key & "::attributes"]['nil'])
154 | 					  AND xml[key & "::attributes"]['nil']>
155 | 						<cfset arg_name = key>
156 | 						<cfif variables.instance.arg_trans><cfset arg_name = replace(key, "-", "_", "ALL")></cfif>
157 | 						<!--- is this nil arg an argument of the route function --->
158 | 						<cfif structkeyexists(variables.instance.fn_args, arg_name)>
159 | 							<!--- is it a string or something we'll treat as a string? --->
160 | 							<cfif listfind("string,any", variables.instance.fn_args[arg_name])>
161 | 								<cfset xml[key] = "">
162 | 							<!--- is it an _id field --->
163 | 							<cfelseif len(arg_name) GTE 4 AND right(arg_name, 3) EQ "_id">
164 | 								<cfset xml[key] = 0>
165 | 							<!--- neither of the above, so ignore it --->
166 | 							<cfelse><cfset structdelete(xml, key)></cfif>
167 | 						<!--- if it's nil and not an argument to this function, ignore it completely --->
168 | 						<cfelse><cfset structdelete(xml, key)></cfif>
169 | 					</cfif>
170 | 				</cfloop>
171 | 				<!--- we're only accepting single-level vars, so anything that's not a simple value should be removed --->
172 | 				<cfloop collection="#xml#" item="key">
173 | 					<cfif NOT issimplevalue(xml[key])><cfset structdelete(xml, key)></cfif>
174 | 				</cfloop>
175 | 				<cfset structappend(args, xml, FALSE)>
176 | 			</cfif>
177 | 		</cfif>
178 | 
179 | 		<!--- add any form and url vars to the arguments --->
180 | 		<cfset structappend(args, form, FALSE)>
181 | 		<cfloop collection="#url#" item="key">
182 | 			<!--- we may have "structured" conditions in the URL scope, e.g. "conditions[name]=x&conditions[id]=1" --->
183 | 			<cfif lcase(listfirst(key, "[")) EQ "conditions" AND right(key, 1) EQ "]">
184 | 				<cfset cond = listlast(left(key, len(key)-1), "[")>
185 | 				<cfif NOT structkeyexists(args, cond)><cfset args[cond] = url[key]></cfif>
186 | 			<cfelseif NOT structkeyexists(args, key)><cfset args[key] = url[key]></cfif>
187 | 		</cfloop>
188 | 
189 | 		<!--- do any parameter name translation --->
190 | 		<cfset arg_keys = structkeylist(args)>
191 | 		<cfif variables.instance.arg_trans>
192 | 			<cfloop list="#arg_keys#" index="arg">
193 | 				<cfif find("-", arg)>
194 | 					<cfset args[replace(arg, "-", "_", "ALL")] = args[arg]>
195 | 					<cfset structdelete(args, arg)>
196 | 				</cfif>
197 | 			</cfloop>
198 | 		</cfif>
199 | 
200 | 		<!--- separate any request options (non-argument params such as cache-busting, included fields etc) --->
201 | 		<cfset arg_keys = structkeylist(args)>
202 | 		<cfloop list="#arg_keys#" index="arg">
203 | 			<cfif len(arg) GT 2 AND left(arg, 2) EQ "__">
204 | 				<cfset opts[right(arg, len(arg)-2)] = args[arg]>
205 | 				<cfset structdelete(args, arg)>
206 | 			</cfif>
207 | 		</cfloop>
208 | 
209 | 		<cfset arg_keys = { args = args, opts = opts }>
210 | 		<cfreturn arg_keys>
211 | 	</cffunction>
212 | 
213 | 	<!--- general getters to allow controllers to inspect where the request has come from --->
214 | 	<cffunction name="getDispatcher" access="public" returntype="restfulcf.framework.core.Dispatcher" output="no" hint="The calling dispatcher">
215 | 		<cfreturn variables.instance.dispatcher>
216 | 	</cffunction>
217 | 	<cffunction name="getRoute" access="public" returntype="restfulcf.framework.core.Route" output="no" hint="The route that matches the given URI">
218 | 		<cfreturn variables.instance.route>
219 | 	</cffunction>
220 | 	<cffunction name="getURI" access="public" returntype="string" output="no" hint="The requested URI">
221 | 		<cfreturn variables.instance.uri>
222 | 	</cffunction>
223 | 	<cffunction name="getResponseType" access="public" returntype="string" output="no" hint="The requested response type">
224 | 		<cfreturn variables.instance.type>
225 | 	</cffunction>
226 | 	<cffunction name="getArguments" access="public" returntype="struct" output="no" hint="The arguments for this request">
227 | 		<cfreturn variables.instance.arguments>
228 | 	</cffunction>
229 | 	<cffunction name="getOptions" access="public" returntype="struct" output="no" hint="The options (non-argument params) for this request">
230 | 		<cfreturn variables.instance.options>
231 | 	</cffunction>
232 | 
233 | </cfcomponent>
234 | 


--------------------------------------------------------------------------------
/restfulcf/framework/core/Resource.cfc:
--------------------------------------------------------------------------------
  1 | <!--- -->
  2 | <fusedoc fuse="restfulcf/framework/core/Resource.cfc" language="ColdFusion" specification="2.0">
  3 | 	<responsibilities>
  4 | 		I am the base class for resources
  5 | 	</responsibilities>
  6 | </fusedoc>
  7 | --->
  8 | 
  9 | <cfcomponent output="no">
 10 | 
 11 | 	<!--- what's the data type here: auto-built from component name if not provided --->
 12 | 	<cfset variables.type = "">
 13 | 	<!--- properties for this component: auto-filled on init() by any <cfproperty>s --->
 14 | 	<cfset variables.properties = {}>
 15 | 	<!--- all instance vars are stored here --->
 16 | 	<cfset variables.instance = {}>
 17 | 
 18 | 	<cffunction name="init" access="public" returntype="restfulcf.framework.core.Resource" output="no" hint="I am a general initialiser for this resource">
 19 | 		<cfset var local = {}>
 20 | 		<cfset local.meta = getmetadata(this)>
 21 | 		<!--- load properties --->
 22 | 		<cfif structkeyexists(local.meta, "properties")>
 23 | 			<cfloop array="#local.meta.properties#" index="local.prop">
 24 | 				<!--- build up the local metadata for this property --->
 25 | 				<cfset local.prop_data = {}>
 26 | 				<cfloop collection="#local.prop#" item="local.prop_param">
 27 | 					<cfif local.prop_param NEQ "name"><cfset local.prop_data[lcase(local.prop_param)] = local.prop[local.prop_param]></cfif>
 28 | 				</cfloop>
 29 | 				<!--- any id or _id field should default to an integer --->
 30 | 				<cfif local.prop.name EQ "id" OR (len(local.prop.name) GTE 4 AND right(local.prop.name, 3) EQ "_id")>
 31 | 					<cfparam name="local.prop_data.type" default="numeric">
 32 | 					<cfif local.prop_data.type EQ "numeric"><cfparam name="local.prop_data.precision" default="integer"></cfif>
 33 | 				</cfif>
 34 | 				<!--- anything else should at least allow any type --->
 35 | 				<cfparam name="local.prop_data.type" default="any">
 36 | 				<!--- default precision of numeric and date properties (integer and datetime respectively) --->
 37 | 				<cfif local.prop_data.type EQ "numeric" AND NOT structkeyexists(local.prop_data, "precision")><cfset local.prop_data.precision = "any"></cfif>
 38 | 				<cfif local.prop_data.type EQ "date" AND NOT structkeyexists(local.prop_data, "precision")><cfset local.prop_data.precision = "datetime"></cfif>
 39 | 				<!--- store the property and set the default value where appropriate --->
 40 | 				<cfset variables.properties[local.prop.name] = local.prop_data>
 41 | 				<cfif structkeyexists(local.prop, "default")>
 42 | 					<cfset set(local.prop.name, local.prop.default)>
 43 | 				</cfif>
 44 | 			</cfloop>
 45 | 		</cfif>
 46 | 		<!--- work out the type if necessary --->
 47 | 		<cfif NOT len(variables.type)>
 48 | 			<cfset local.inflector = createobject("component", "restfulcf.framework.util.Inflector")>
 49 | 			<cfset variables.type = local.inflector.variablise(local.inflector.singularise(listlast(local.meta.name, ".")))>
 50 | 		</cfif>
 51 | 		<!--- initialise any provided instance vars --->
 52 | 		<cfloop collection="#arguments#" item="local.arg">
 53 | 			<cfif structkeyexists(variables.properties, local.arg)>
 54 | 				<cfset set(local.arg, arguments[local.arg])>
 55 | 			</cfif>
 56 | 		</cfloop>
 57 | 		<cfreturn this>
 58 | 	</cffunction>
 59 | 
 60 | 	<!--- to provide a representation of a given resource, create the appropriate to* function to return the data --->
 61 | 	<cffunction name="toXML" access="public" returntype="xml" output="no">
 62 | 		<cfset var xml = []>
 63 | 		<cfset var type = "">
 64 | 		<cfset var value = "">
 65 | 		<cfset var key = "">
 66 | 		<cfset var keys = structkeyarray(variables.instance)>
 67 | 		<cfset arraysort(keys, 'textnocase', 'asc')>
 68 | 		<cfloop array="#keys#" index="key">
 69 | 			<cfset value = variables.instance[key]>
 70 | 			<!--- handle nested resources --->
 71 | 			<cfif NOT issimplevalue(value)>
 72 | 				<cfif isstruct(value) AND structkeyexists(value, "toXML")>
 73 | 					<cfset arrayappend(xml, value.toXML())>
 74 | 				<cfelse>
 75 | 					<cfset arrayappend(xml, "<#lcase(key)#>" & xmlformat(value.toString()) & "</#lcase(key)#>")>
 76 | 				</cfif>
 77 | 			<!--- blank empty non-numeric or zero'd ID fields --->
 78 | 			<cfelseif (NOT isnumeric(value) AND NOT len(value)) OR ((key EQ "id" OR (len(key) GTE 4 AND right(key, 3) EQ "_id")) AND isnumeric(value) AND value EQ 0)>
 79 | 				<cfset arrayappend(xml, "<#lcase(key)# nil=""true"" />")>
 80 | 			<!--- anything else --->
 81 | 			<cfelse>
 82 | 				<cfset type = "">
 83 | 				<cfswitch expression="#variables.properties[key].type#">
 84 | 					<!--- numeric values may have a precision --->
 85 | 					<cfcase value="numeric">
 86 | 						<cfswitch expression="#variables.properties[key].precision#">
 87 | 							<cfcase value="float"><cfset type = "float"></cfcase>
 88 | 							<cfcase value="decimal"><cfset type = "decimal"></cfcase>
 89 | 							<cfcase value="integer"><cfset type = "integer"></cfcase>
 90 | 						</cfswitch>
 91 | 					</cfcase>
 92 | 					<!--- booleans should just be 0/1 --->
 93 | 					<cfcase value="boolean"><cfset type = "boolean"></cfcase>
 94 | 					<!--- dates should be ODBC dates, times or datetimes --->
 95 | 					<cfcase value="date">
 96 | 						<cfswitch expression="#variables.properties[key].precision#">
 97 | 							<cfcase value="date"><cfset type = "date"></cfcase>
 98 | 							<cfcase value="time"><cfset type = "time"></cfcase>
 99 | 							<cfdefaultcase><cfset type = "datetime"></cfdefaultcase>
100 | 						</cfswitch>
101 | 					</cfcase>
102 | 				</cfswitch>
103 | 				<!--- build the item XML string, including type if necessary --->
104 | 				<cfif len(type)><cfset type = ' type="#type#"'></cfif>
105 | 				<cfset arrayappend(xml, "<#lcase(key)##type#>" & xmlformat(value) & "</#lcase(key)#>")>
106 | 			</cfif>
107 | 		</cfloop>
108 | 		<cfreturn "<#variables.type#>" & arraytolist(xml, chr(10)) & "</#variables.type#>">
109 | 	</cffunction>
110 | 
111 | 	<cffunction name="toHTML" access="public" returntype="string" output="no">
112 | 		<cfset var html = []>
113 | 		<cfset var val = "">
114 | 		<cfset var key = "">
115 | 		<cfset var keys = structkeyarray(variables.instance)>
116 | 		<cfset arraysort(keys, 'textnocase', 'asc')>
117 | 		<cfloop array="#keys#" index="key">
118 | 			<cfset val = variables.instance[key]>
119 | 			<!--- handle nested resources --->
120 | 			<cfif NOT issimplevalue(val)>
121 | 				<cfif isstruct(val) AND structkeyexists(val, "toHTML")>
122 | 					<cfset arrayappend(html, "<dt>#htmleditformat(lcase(key))#</dt><dd>" & val.toHTML() & "</dd>")>
123 | 				<cfelse>
124 | 					<cfset arrayappend(html, "<dt>#htmleditformat(lcase(key))#</dt><dd>" & val.toString() & "</dd>")>
125 | 				</cfif>
126 | 			<cfelse>
127 | 				<cfset arrayappend(html, "<dt>#htmleditformat(lcase(key))#</dt><dd>" & htmleditformat(val) & "</dd>")>
128 | 			</cfif>
129 | 		</cfloop>
130 | 		<cfreturn "<dl class=""#variables.type#"">" & arraytolist(html, chr(10)) & "</dl>">
131 | 	</cffunction>
132 | 
133 | 	<cffunction name="toTXT" access="public" returntype="string" output="no">
134 | 		<cfreturn serializejson(variables.instance)>
135 | 	</cffunction>
136 | 	<cffunction name="toJSON" access="public" returntype="string" output="no">
137 | 		<cfreturn serializejson(variables.instance)>
138 | 	</cffunction>
139 | 
140 | 	<cffunction name="toCSV" access="public" returntype="string" output="no">
141 | 		<cfargument name="include_header" type="boolean" required="no" default="TRUE" hint="Should the resource properties be included as the first line?">
142 | 		<cfset var csv = []>
143 | 		<cfset var val = "">
144 | 		<cfset var key = "">
145 | 		<cfset var hed = "">
146 | 		<cfset var keys = structkeyarray(variables.instance)>
147 | 		<cfset arraysort(keys, 'textnocase', 'asc')>
148 | 		<cfloop array="#keys#" index="key">
149 | 			<cfset val = variables.instance[key]>
150 | 			<!--- handle nested resources by embedding simple strings (can't nest CSVs) --->
151 | 			<cfif NOT issimplevalue(val)><cfset val = val.toString()></cfif>
152 | 			<!--- escape commas and double-quotes --->
153 | 			<cfset val = replace(val, '"', '""', 'ALL')>
154 | 			<cfif findoneof('",', val)><cfset val = '"#val#"'></cfif>
155 | 			<cfset arrayappend(csv, val)>
156 | 		</cfloop>
157 | 		<cfif arguments.include_header><cfset hed = arraytolist(keys) & chr(10)></cfif>
158 | 		<cfreturn hed & arraytolist(csv)>
159 | 	</cffunction>
160 | 
161 | 	<!--- generic getter and setter functions --->
162 | 	<cffunction name="get" access="private" returntype="any" output="no" hint="I am a generic getter method, used internally and for auto-generated onMissingMethod() calls">
163 | 		<cfargument name="key" type="string" required="yes" hint="The key to retrieve">
164 | 		<cfif structkeyexists(variables.instance, arguments.key)>
165 | 			<cfreturn variables.instance[arguments.key]>
166 | 		<cfelse>
167 | 			<cfthrow type="Application" message="The method get#arguments.key# was not found in component #getMetaData(this).path#" detail="Ensure that the method is defined, and that it is spelled correctly.">
168 | 		</cfif>
169 | 	</cffunction>
170 | 	<cffunction name="set" access="private" returntype="void" output="no" hint="I am a generic setter method, used internally and for auto-generated onMissingMethod() calls">
171 | 		<cfargument name="key" type="string" required="yes" hint="The key to set">
172 | 		<cfargument name="value" type="any" required="yes" hint="The value to set">
173 | 		<cfif structkeyexists(variables.properties, arguments.key)>
174 | 			<cfif isvalid(variables.properties[arguments.key].type, arguments.value)>
175 | 				<!--- massage input values into the correct form depending on property type and precision --->
176 | 				<cfswitch expression="#variables.properties[arguments.key].type#">
177 | 					<cfcase value="date">
178 | 						<cfswitch expression="#variables.properties[arguments.key].precision#">
179 | 							<cfcase value="date"><cfset arguments.value = createodbcdate(arguments.value)></cfcase>
180 | 							<cfcase value="time"><cfset arguments.value = createodbctime(arguments.value)></cfcase>
181 | 							<cfdefaultcase><cfset arguments.value = createodbcdatetime(arguments.value)></cfdefaultcase>
182 | 						</cfswitch>
183 | 					</cfcase>
184 | 					<cfcase value="numeric">
185 | 						<cfswitch expression="#variables.properties[arguments.key].precision#">
186 | 							<cfcase value="float"><cfset arguments.value = val(trim(numberformat(arguments.value, "99999999999999.09999999999999")))></cfcase>
187 | 							<cfcase value="decimal"><cfset arguments.value = val(trim(numberformat(arguments.value, "99999999999999.00")))></cfcase>
188 | 							<cfcase value="integer"><cfset arguments.value = int(arguments.value)></cfcase>
189 | 						</cfswitch>
190 | 					</cfcase>
191 | 					<cfcase value="boolean">
192 | 						<cfif arguments.value><cfset arguments.value = 1><cfelse><cfset arguments.value = 0></cfif>
193 | 					</cfcase>
194 | 				</cfswitch>
195 | 				<cfset variables.instance[arguments.key] = arguments.value>
196 | 			<cfelse>
197 | 				<cfthrow type="Application" message="The value to set#arguments.key# must be of type #variables.properties[arguments.key].type#." detail="The value provided was <code>#arguments.value#</code>.">
198 | 			</cfif>
199 | 		<cfelse>
200 | 			<cfthrow type="Application" message="The method set#arguments.key# was not found in component #getMetaData(this).path#" detail="Ensure that the method is defined, and that it is spelled correctly.">
201 | 		</cfif>
202 | 	</cffunction>
203 | 
204 | 	<!--- handle any set/get calls or cases of missing on* methods nicely --->
205 | 	<cffunction name="onMissingMethod" access="public" returntype="any" output="no">
206 | 		<cfargument name="missingMethodName" type="string" required="yes" hint="The method name called">
207 | 		<cfargument name="missingMethodArguments" type="struct" required="yes" hint="Any arguments the method was called with">
208 | 		<cfset var method = lcase(missingMethodName)>
209 | 		<cfif find("get", method) EQ 1>
210 | 			<cfreturn get(right(method, len(method)-3), arguments.missingMethodArguments[1])>
211 | 		<cfelseif find("set", method) EQ 1>
212 | 			<cfset set(right(method, len(method)-3), arguments.missingMethodArguments[1])>
213 | 		<cfelse>
214 | 			<cfthrow type="Application" message="The method #arguments.missingMethodName# was not found in component #getMetaData(this).path#" detail="Ensure that the method is defined, and that it is spelled correctly.">
215 | 		</cfif>
216 | 	</cffunction>
217 | 
218 | 	<cffunction name="getProperties" access="public" returntype="struct" output="no" hint="Returns a copy of the properties listed for this object">
219 | 		<cfreturn structcopy(variables.properties)>
220 | 	</cffunction>
221 | 
222 | </cfcomponent>
223 | 


--------------------------------------------------------------------------------
/restfulcf/test/tests/util/ArraysTest.cfc:
--------------------------------------------------------------------------------
  1 | <!--- -->
  2 | <fusedoc fuse="restfulcf/test/tests/util/ArraysTest.cfc" language="ColdFusion" specification="2.0">
  3 | 	<responsibilities>
  4 | 		I test the array helper functions
  5 | 	</responsibilities>
  6 | </fusedoc>
  7 | --->
  8 | 
  9 | <cfcomponent extends="mxunit.framework.TestCase">
 10 | 
 11 | 	<cffunction name="setup">
 12 | 		<cfset arrays = createObject("component", "restfulcf.framework.util.Arrays")>
 13 | 	</cffunction>
 14 | 
 15 | 	<!---
 16 | 		Functions to test:
 17 | 			join      - joins two arrays together
 18 | 			split     - splits an array in to two parts
 19 | 			slice     - returns a sub-set of a given array
 20 | 			switch    - reverses an array
 21 | 			merge     - merge two arrays of structures based on key value
 22 | 			mergeSort - recursively merges and sorts an array of structures based on key value
 23 | 	--->
 24 | 
 25 | 	<!--- JOIN --->
 26 | 	<cffunction name="join_of_two_empty_arrays_should_result_in_an_empty_array">
 27 | 		<cfset var a = []>
 28 | 		<cfset var b = []>
 29 | 		<cfset var r = arrays.join(a, b)>
 30 | 		<cfset assertEquals(0, arraylen(r))>
 31 | 	</cffunction>
 32 | 	<cffunction name="join_of_two_arrays_should_result_in_summed_array_length">
 33 | 		<cfset var a = [1,2,3]>
 34 | 		<cfset var b = [4,5]>
 35 | 		<cfset var r = arrays.join(a, b)>
 36 | 		<cfset assertEquals(arraylen(a) + arraylen(b), arraylen(r))>
 37 | 	</cffunction>
 38 | 	<cffunction name="join_of_two_arrays_should_order_resulting_array_a_then_b">
 39 | 		<cfset var a = [1]>
 40 | 		<cfset var b = [2]>
 41 | 		<cfset var r = arrays.join(a, b)>
 42 | 		<cfset assertEquals(1, r[1], "The first element of the joined array was not as expected")>
 43 | 		<cfset assertEquals(2, r[2], "The second element of the joined array was not as expected")>
 44 | 	</cffunction>
 45 | 
 46 | 	<!--- SPLIT --->
 47 | 	<cffunction name="split_should_return_an_array_containing_two_arrays">
 48 | 		<cfset var a = []>
 49 | 		<cfset var r = arrays.split(a, 1)>
 50 | 		<cfset assertTrue(isArray(r), "Value returned from split was not an array")>
 51 | 		<cfset assertEquals(2, arraylen(r), "Array returned from split did not have two elements")>
 52 | 		<cfset assertTrue(isArray(r[1]), "First element returned from split was not an array")>
 53 | 		<cfset assertTrue(isArray(r[2]), "Second element returned from split was not an array")>
 54 | 	</cffunction>
 55 | 	<cffunction name="split_of_empty_array_should_result_in_two_empty_arrays">
 56 | 		<cfset var a = []>
 57 | 		<cfset var r = arrays.split(a, 1)>
 58 | 		<cfset assertEquals(0, arraylen(r[1]), "The first element of the joined array was not as expected")>
 59 | 		<cfset assertEquals(0, arraylen(r[2]), "The second element of the joined array was not as expected")>
 60 | 	</cffunction>
 61 | 	<cffunction name="split_of_short_array_should_result_in_empty_second_array">
 62 | 		<cfset var a = [1,2,3]>
 63 | 		<cfset var r = arrays.split(a, 10)>
 64 | 		<cfset assertEquals(3, arraylen(r[1]), "The first element of the joined array was not as expected")>
 65 | 		<cfset assertEquals(0, arraylen(r[2]), "The second element of the joined array was not as expected")>
 66 | 	</cffunction>
 67 | 	<cffunction name="split_on_zero_should_result_in_empty_first_array">
 68 | 		<cfset var a = [1,2,3]>
 69 | 		<cfset var r = arrays.split(a, 0)>
 70 | 		<cfset assertEquals(0, arraylen(r[1]), "The first element of the joined array was not as expected")>
 71 | 		<cfset assertEquals(3, arraylen(r[2]), "The second element of the joined array was not as expected")>
 72 | 	</cffunction>
 73 | 	<cffunction name="result_of_split_should_have_correct_number_of_elements_in_total">
 74 | 		<cfset var a = [1,2,3,4,5]>
 75 | 		<cfset var r = arrays.split(a, 3)>
 76 | 		<cfset assertEquals(arraylen(a), arraylen(r[1]) + arraylen(r[2]))>
 77 | 	</cffunction>
 78 | 	<cffunction name="result_of_split_should_have_correct_number_of_elements_in_each">
 79 | 		<cfset var a = [1,2,3,4,5]>
 80 | 		<cfset var r = arrays.split(a, 3)>
 81 | 		<cfset assertEquals(3, arraylen(r[1]), "The first element of the joined array was not as expected")>
 82 | 		<cfset assertEquals(2, arraylen(r[2]), "The second element of the joined array was not as expected")>
 83 | 	</cffunction>
 84 | 	<cffunction name="result_of_split_should_have_correct_ordering_of_elements">
 85 | 		<cfset var a = [1,2,3,4,5]>
 86 | 		<cfset var r = arrays.split(a, 3)>
 87 | 		<cfset assertEquals(1, r[1][1], "The first element of the joined array was not as expected")>
 88 | 		<cfset assertEquals(4, r[2][1], "The second element of the joined array was not as expected")>
 89 | 	</cffunction>
 90 | 
 91 | 	<!--- SLICE --->
 92 | 	<cffunction name="slice_of_an_empty_array_should_return_an_empty_array">
 93 | 		<cfset var a = []>
 94 | 		<cfset var r = arrays.slice(a, 1, 1)>
 95 | 		<cfset assertEquals(0, arraylen(r))>
 96 | 	</cffunction>
 97 | 	<cffunction name="slice_starting_past_the_end_should_return_an_empty_array">
 98 | 		<cfset var a = [1,2,3]>
 99 | 		<cfset var r = arrays.slice(a, 5, 1)>
100 | 		<cfset assertEquals(0, arraylen(r))>
101 | 	</cffunction>
102 | 	<cffunction name="slice_with_negative_offset_and_small_limit_should_return_an_empty_array">
103 | 		<cfset var a = [1,2,3]>
104 | 		<cfset var r = arrays.slice(a, -5, 1)>
105 | 		<cfset assertEquals(0, arraylen(r))>
106 | 	</cffunction>
107 | 	<cffunction name="slice_from_the_start_should_return_the_correct_number_of_results">
108 | 		<cfset var a = [1,2,3,4,5]>
109 | 		<cfset var r = arrays.slice(a, 1, 3)>
110 | 		<cfset assertEquals(3, arraylen(r))>
111 | 	</cffunction>
112 | 	<cffunction name="slice_from_the_middle_should_return_the_correct_number_of_results">
113 | 		<cfset var a = [1,2,3,4,5]>
114 | 		<cfset var r = arrays.slice(a, 2, 3)>
115 | 		<cfset assertEquals(3, arraylen(r))>
116 | 	</cffunction>
117 | 	<cffunction name="slice_from_the_end_should_return_the_correct_number_of_results">
118 | 		<cfset var a = [1,2,3,4,5]>
119 | 		<cfset var r = arrays.slice(a, 3, 3)>
120 | 		<cfset assertEquals(3, arraylen(r))>
121 | 	</cffunction>
122 | 	<cffunction name="slice_passing_end_of_array_should_only_return_to_the_end">
123 | 		<cfset var a = [1,2,3,4,5]>
124 | 		<cfset var r = arrays.slice(a, 3, 5)>
125 | 		<cfset assertEquals(3, arraylen(r))>
126 | 	</cffunction>
127 | 	<cffunction name="slice_with_a_zero_offset_should_return_one_less_than_the_limit">
128 | 		<cfset var a = [1,2,3,4,5]>
129 | 		<cfset var r = arrays.slice(a, 0, 5)>
130 | 		<cfset assertEquals(4, arraylen(r))>
131 | 	</cffunction>
132 | 	<cffunction name="slice_with_a_negative_offset_should_return_correct_number_of_results">
133 | 		<cfset var a = [1,2,3,4,5]>
134 | 		<cfset var r = arrays.slice(a, -2, 5)>
135 | 		<cfset assertEquals(2, arraylen(r))>
136 | 	</cffunction>
137 | 
138 | 	<!--- SWITCH --->
139 | 	<cffunction name="switch_of_empty_array_should_return_empty_array">
140 | 		<cfset var a = []>
141 | 		<cfset var r = arrays.switch(a)>
142 | 		<cfset assertEquals(0, arraylen(r))>
143 | 	</cffunction>
144 | 	<cffunction name="switch_on_array_with_one_element_should_not_change">
145 | 		<cfset var a = [1]>
146 | 		<cfset var r = arrays.switch(a)>
147 | 		<cfset assertEquals(1, arraylen(r), "Resulting array length was different than expected")>
148 | 		<cfset assertEquals(1, r[1], "Resulting array value was different than expected")>
149 | 	</cffunction>
150 | 	<cffunction name="switch_on_array_with_two_elements_should_reverse_them">
151 | 		<cfset var a = [1,2]>
152 | 		<cfset var r = arrays.switch(a)>
153 | 		<cfset assertEquals(2, r[1], "First element in reversed array was different than expected")>
154 | 		<cfset assertEquals(1, r[2], "First element in reversed array was different than expected")>
155 | 	</cffunction>
156 | 	<cffunction name="switch_on_array_with_lots_of_elements_should_reverse_them">
157 | 		<cfset var a = [1,2,3,4,5,6,7,8,9]>
158 | 		<cfset var r = arrays.switch(a)>
159 | 		<cfset assertEquals(reverse(arraytolist(a)), arraytolist(r))>
160 | 	</cffunction>
161 | 
162 | 	<!--- MERGE --->
163 | 	<cffunction name="merge_of_two_empty_arrays_return_an_empty_array">
164 | 		<cfset var a = []>
165 | 		<cfset var b = []>
166 | 		<cfset var r = arrays.merge(a, b, "x")>
167 | 		<cfset assertEquals(0, arraylen(r))>
168 | 	</cffunction>
169 | 	<cffunction name="merge_with_empty_second_array_should_just_return_first_array">
170 | 		<cfset var a = [ {id=1}, {id=3}, {id=5} ]>
171 | 		<cfset var b = []>
172 | 		<cfset var r = arrays.merge(a, b, "id")>
173 | 		<cfset assertEquals(3, arraylen(r), "Returned array has unexpected length")>
174 | 		<cfset assertEquals(1, r[1].id, "First element has unexpected ID")>
175 | 		<cfset assertEquals(5, r[3].id, "Last element has unexpected ID")>
176 | 	</cffunction>
177 | 	<cffunction name="merge_with_empty_first_array_should_just_return_second_array">
178 | 		<cfset var a = []>
179 | 		<cfset var b = [ {id=1}, {id=3}, {id=5} ]>
180 | 		<cfset var r = arrays.merge(a, b, "id")>
181 | 		<cfset assertEquals(3, arraylen(r), "Returned array has unexpected length")>
182 | 		<cfset assertEquals(1, r[1].id, "First element has unexpected ID")>
183 | 		<cfset assertEquals(5, r[3].id, "Last element has unexpected ID")>
184 | 	</cffunction>
185 | 	<cffunction name="merge_where_arrays_are_separate_should_not_shuffle_arrays_together">
186 | 		<cfset var a = [ {id=1}, {id=3}, {id=5} ]>
187 | 		<cfset var b = [ {id="a"}, {id="b"}, {id="c"} ]>
188 | 		<cfset var r = arrays.merge(a, b, "id")>
189 | 		<cfset assertEquals(6, arraylen(r), "Returned array has unexpected length")>
190 | 		<cfset assertEquals(1, r[1].id, "First element has unexpected ID")>
191 | 		<cfset assertEquals(5, r[3].id, "Last element has unexpected ID")>
192 | 		<cfset assertEquals("a", r[4].id, "Fourth element has unexpected ID")>
193 | 		<cfset assertEquals("c", r[6].id, "Sixth element has unexpected ID")>
194 | 	</cffunction>
195 | 	<cffunction name="merge_where_arrays_are_ordered_should_shuffle_arrays_together">
196 | 		<cfset var a = [ {id=1}, {id=3}, {id=5} ]>
197 | 		<cfset var b = [ {id=2}, {id=4}, {id=6} ]>
198 | 		<cfset var r = arrays.merge(a, b, "id")>
199 | 		<cfset var i = 0>
200 | 		<cfset assertEquals(6, arraylen(r), "Returned array has unexpected length")>
201 | 		<cfloop from="1" to="#arraylen(r)#" index="i">
202 | 			<cfset assertEquals(i, r[i].id, "Element #i# has unexpected ID")>
203 | 		</cfloop>
204 | 	</cffunction>
205 | 	<cffunction name="merge_of_component_arrays_should_work_with_properties_as_keys">
206 | 		<cfset var a = [ [], [] ]>
207 | 		<cfset var r = []>
208 | 		<cfset var i = 0>
209 | 		<cfloop from="1" to="6" index="i">
210 | 			<cfset arrayappend(a[(i MOD 2) + 1], createobject("component", "ArrayMergeFixture").init(i))>
211 | 		</cfloop>
212 | 		<cfset r = arrays.merge(a[2], a[1], "id")>
213 | 		<cfloop from="1" to="#arraylen(r)#" index="i">
214 | 			<cfset assertEquals(i, r[i].id, "Element #i# has unexpected ID")>
215 | 		</cfloop>
216 | 	</cffunction>
217 | 	<cffunction name="merge_of_component_arrays_should_work_with_function_as_keys">
218 | 		<cfset var a = [ [], [] ]>
219 | 		<cfset var r = []>
220 | 		<cfset var i = 0>
221 | 		<cfloop from="1" to="6" index="i">
222 | 			<cfset arrayappend(a[(i MOD 2) + 1], createobject("component", "ArrayMergeFixture").init(i))>
223 | 		</cfloop>
224 | 		<cfset r = arrays.merge(a[2], a[1], "getID")>
225 | 		<cfloop from="1" to="#arraylen(r)#" index="i">
226 | 			<cfset assertEquals(i, r[i].id, "Element #i# has unexpected ID")>
227 | 		</cfloop>
228 | 	</cffunction>
229 | 
230 | 	<!--- MERGE SORT --->
231 | 	<cffunction name="merge_sort_on_simple_structure_should_sort_by_numeric_key">
232 | 		<cfset var a = [ {id=3}, {id=5}, {id=2}, {id=4}, {id=6}, {id=1} ]>
233 | 		<cfset var r = arrays.mergeSort(a, "id")>
234 | 		<cfloop from="1" to="#arraylen(r)#" index="i">
235 | 			<cfset assertEquals(i, r[i].id, "Element #i# has unexpected ID")>
236 | 		</cfloop>
237 | 	</cffunction>
238 | 	<cffunction name="merge_sort_on_simple_structure_should_sort_by_alpha_key">
239 | 		<cfset var a = [ {id="c"}, {id="e"}, {id="b"}, {id="d"}, {id="f"}, {id="a"} ]>
240 | 		<cfset var r = arrays.mergeSort(a, "id")>
241 | 		<cfloop from="1" to="#arraylen(r)#" index="i">
242 | 			<cfset assertEquals(chr(i + 96), r[i].id, "Element #i# has unexpected ID")>
243 | 		</cfloop>
244 | 	</cffunction>
245 | 	<cffunction name="merge_sort_on_component_arrays_should_sort_by_properties_as_keys">
246 | 		<cfset var a = []>
247 | 		<cfset var r = []>
248 | 		<cfloop list="3,5,2,4,6,1" index="i">
249 | 			<cfset arrayappend(a, createobject("component", "ArrayMergeFixture").init(i))>
250 | 		</cfloop>
251 | 		<cfset r = arrays.mergeSort(a, "id")>
252 | 		<cfloop from="1" to="#arraylen(r)#" index="i">
253 | 			<cfset assertEquals(i, r[i].id, "Element #i# has unexpected ID")>
254 | 		</cfloop>
255 | 	</cffunction>
256 | 	<cffunction name="merge_sort_on_component_arrays_should_sort_by_function_as_keys">
257 | 		<cfset var a = []>
258 | 		<cfset var r = []>
259 | 		<cfloop list="3,5,2,4,6,1" index="i">
260 | 			<cfset arrayappend(a, createobject("component", "ArrayMergeFixture").init(i))>
261 | 		</cfloop>
262 | 		<cfset r = arrays.mergeSort(a, "getID")>
263 | 		<cfloop from="1" to="#arraylen(r)#" index="i">
264 | 			<cfset assertEquals(i, r[i].id, "Element #i# has unexpected ID")>
265 | 		</cfloop>
266 | 	</cffunction>
267 | 
268 | </cfcomponent>
269 | 


--------------------------------------------------------------------------------
/restfulcf/framework/core/Dispatcher.cfc:
--------------------------------------------------------------------------------
  1 | <!--- -->
  2 | <fusedoc fuse="restfulcf/framework/core/Dispatcher.cfc" language="ColdFusion" specification="2.0">
  3 | 	<responsibilities>
  4 | 		I am the core dispatcher / engine for the RESTful application
  5 | 	</responsibilities>
  6 | </fusedoc>
  7 | --->
  8 | 
  9 | <cfcomponent output="no">
 10 | 
 11 | 	<cfset variables.controllers = {}>
 12 | 	<cfset variables.routes      = createobject("component", "restfulcf.framework.core.RouteCollection")>
 13 | 	<cfset variables.inflector   = createobject("component", "restfulcf.framework.util.Inflector")>
 14 | 	<!--- the controller path should be overridden in the concrete dispatcher --->
 15 | 	<cfset variables.controller_path = "">
 16 | 	<!--- default authenticator is empty --->
 17 | 	<cfset variables.authenticator = createobject("component", "restfulcf.framework.core.Authenticator")>
 18 | 	<!--- as is the default cache --->
 19 | 	<cfset variables.cache_enabled = FALSE>
 20 | 	<cfset variables.cache = createobject("component", "restfulcf.framework.core.cache.EmptyCache")>
 21 | 	<!--- the default response type, should nothing be specified --->
 22 | 	<cfset variables.response_type = "xml">
 23 | 	<!--- response type / MIME type mappings --->
 24 | 	<cfset variables.response_types = {
 25 | 		xml  = "application/xml",
 26 | 		txt  = "text/plain",
 27 | 		html = "text/html",
 28 | 		json = "text/javascript",
 29 | 		pdf  = "application/pdf",
 30 | 		csv  = "text/csv"
 31 | 	}>
 32 | 	<!--- do we want to translate hyphens to underscores in incoming arguments? --->
 33 | 	<cfset variables.argument_translation = FALSE>
 34 | 
 35 | 	<cffunction name="init" access="public" returntype="restfulcf.framework.core.Dispatcher" output="no" hint="I initialise this instance of the dispatcher.  Should be overridden to define resources.">
 36 | 		<cfif len(variables.controller_path) AND right(variables.controller_path, 1) NEQ ".">
 37 | 			<cfset variables.controller_path = variables.controller_path & ".">
 38 | 		</cfif>
 39 | 		<cfreturn this>
 40 | 	</cffunction>
 41 | 
 42 | 	<cffunction name="dispatch" access="public" returntype="restfulcf.framework.core.Response" output="no" hint="I am the dispatcher for working out which resource we need and in what representation, and going and getting it.">
 43 | 		<cfargument name="method" type="string" required="yes" hint="The request method (e.g. GET, POST etc)">
 44 | 		<cfargument name="uri" type="string" required="yes" hint="The resource path (e.g. /users/1)">
 45 | 
 46 | 		<cfset var route         = "">
 47 | 		<cfset var request_args  = {}>
 48 | 		<cfset var response_type = variables.response_type>
 49 | 		<cfset var resource_path = arguments.uri>
 50 | 		<cfset var request       = "">
 51 | 		<cfset var response      = "">
 52 | 		<cfset var auth_creds = { user = "", pass = "" }>
 53 | 		<cfset var auth_string = getPageContext().getRequest().getHeader("Authorization")>
 54 | 
 55 | 		<!--- grab the response format from the resource path --->
 56 | 		<cfif listlen(resource_path, ".") GT 1>
 57 | 			<cfset response_type = listlast(resource_path, ".")>
 58 | 			<cfset resource_path = reverse(listrest(reverse(resource_path), "."))>
 59 | 		</cfif>
 60 | 
 61 | 		<!--- find the route that matches the resource path and run the request --->
 62 | 		<cfset route = variables.routes.findRoute(arguments.method, resource_path)>
 63 | 		<cfif route.getVerb() EQ "INVALID">
 64 | 			<cfset response = createobject("component", "restfulcf.framework.core.Response")>
 65 | 			<cfset response.setStatusCode("404")>
 66 | 		<cfelseif NOT structkeyexists(variables.response_types, response_type)>
 67 | 			<cfset response = createobject("component", "restfulcf.framework.core.Response")>
 68 | 			<cfset response.setStatusCode(getController(route.getController()).HTTP_STATUS_CODES['unsupported_media_type'])>
 69 | 		<cfelse>
 70 | 			<cfset request = createobject("component", "restfulcf.framework.core.Request").init(
 71 | 				dispatcher = this,
 72 | 				route      = route,
 73 | 				uri        = resource_path,
 74 | 				type       = response_type,
 75 | 				mime       = listfirst(cgi.content_type, ";"),
 76 | 				arg_trans  = variables.argument_translation
 77 | 			)>
 78 | 
 79 | 			<!--- authenticate now after request parsing has been done --->
 80 | 			<cfif isdefined("auth_string")>
 81 | 				<cfset auth_string = tostring(tobinary(listlast(auth_string, " ")))>
 82 | 				<cfif listlen(auth_string, ":") EQ 2>
 83 | 					<cfset auth_creds.user = listfirst(auth_string, ":")>
 84 | 					<cfset auth_creds.pass = listlast(auth_string, ":")>
 85 | 				</cfif>
 86 | 			</cfif>
 87 | 			<cfset auth_creds.request = request>
 88 | 			<cfif NOT variables.authenticator.isAuthenticated(argumentcollection=auth_creds)>
 89 | 				<cfset response = createobject("component", "restfulcf.framework.core.Response")>
 90 | 				<cfset response.setStatusCode("401")>
 91 | 				<cfheader name="WWW-Authenticate" value='Basic realm="#variables.authenticator.getRealm()#"'>
 92 | 				<cfreturn response>
 93 | 			</cfif>
 94 | 
 95 | 			<cfset response = request.run()>
 96 | 			<cfset response.setResponseType(variables.response_types[response_type])>
 97 | 		</cfif>
 98 | 		<cfreturn response>
 99 | 	</cffunction>
100 | 
101 | 	<cffunction name="addResource" access="private" returntype="restfulcf.framework.core.Controller" output="no" hint="I add a controller to the pool">
102 | 		<cfargument name="resource" type="string" required="yes" hint="The (unique) name of the resource">
103 | 		<cfargument name="nesting" type="any" required="no" hint="If this is a nested resource, specify parent resource names as either a comma-delimited list or an array.  Only relevant if create_default_routes is TRUE.">
104 | 		<cfargument name="route_alias" type="string" required="no" hint="The name given to the resource in the route.  Allows for one route like /payments=>Payments, and one /sites/:site_id/payments=>SitePayments">
105 | 		<cfargument name="controller" type="string" required="no" hint="An optional controller name to use, if not the default, generated from the resource name">
106 | 		<cfargument name="create_default_routes" type="boolean" required="no" default="TRUE" hint="Should default routes be created for this resource">
107 | 		<cfargument name="methods" type="string" required="no" hint="A list of methods to include when creating default routes">
108 | 		<!--- normalise naming for the resource, and create the controller --->
109 | 		<cfset var local = {}>
110 | 		<cfset local.resource_name = variables.inflector.variablise(variables.inflector.pluralise(arguments.resource))>
111 | 		<!--- make sure we've not already got a resource with this name --->
112 | 		<cfif structkeyexists(variables.controllers, local.resource_name)>
113 | 			<cfthrow type="restfulcf.framework.Dispatcher.DuplicateResourceException" message="A resource already exists with the name #arguments.resource# (which was normalised to #local.resource_name#).">
114 | 		</cfif>
115 | 		<!--- allow overriding of the default naming behaviour for controllers --->
116 | 		<cfif structkeyexists(arguments, "controller")>
117 | 			<cfset local.controller_name = arguments.controller>
118 | 		<cfelse>
119 | 			<cfset local.controller_name = variables.inflector.CamelCase(variables.inflector.pluralise(arguments.resource))>
120 | 		</cfif>
121 | 		<cfset local.controller = createobject("component", variables.controller_path & local.controller_name)>
122 | 		<!--- cache a reference to the controller --->
123 | 		<cfset variables.controllers[local.resource_name] = local.controller>
124 | 		<!--- add default routes for this controller --->
125 | 		<cfif arguments.create_default_routes>
126 | 			<!--- normalise naming for the routing --->
127 | 			<cfset local.route_alias = local.resource_name>
128 | 			<cfif structkeyexists(arguments, "route_alias")><cfset local.route_alias = variables.inflector.variablise(variables.inflector.pluralise(arguments.route_alias))></cfif>
129 | 			<cfset local.route_path = "/" & local.route_alias>
130 | 			<!--- work out any nesting (can be provided as an array or a comma-delimited list) --->
131 | 			<cfif structkeyexists(arguments, "nesting")>
132 | 				<cfif isarray(arguments.nesting)><cfset local.nesting = arguments.nesting><cfelse><cfset local.nesting = arguments.nesting.split(",")></cfif>
133 | 				<cfset local.nesting_path = "">
134 | 				<cfloop array="#local.nesting#" index="local.nested_resource">
135 | 					<cfset local.nested_resource = variables.inflector.variablise(local.nested_resource)>
136 | 					<cfset local.nesting_path = local.nesting_path & "/" & variables.inflector.pluralise(local.nested_resource) & "/:" & variables.inflector.singularise(local.nested_resource) & "_id">
137 | 				</cfloop>
138 | 				<cfset local.route_path = local.nesting_path & local.route_path>
139 | 			</cfif>
140 | 			<!--- define the route templates --->
141 | 			<cfset local.route_templates = [
142 | 				{ verb = "GET",    route = "",       method = "index"  },
143 | 				{ verb = "POST",   route = "",       method = "create" },
144 | 				{ verb = "GET",    route = "/count", method = "count"  },
145 | 				{ verb = "GET",    route = "/:id",   method = "read"   },
146 | 				{ verb = "PUT",    route = "/:id",   method = "update" },
147 | 				{ verb = "DELETE", route = "/:id",   method = "delete" }
148 | 			]>
149 | 			<!--- create the routes from the template --->
150 | 			<cfloop array="#local.route_templates#" index="local.route">
151 | 				<!--- only create routes that are specified (unless none are provided), and only build those that have the appropriate methods defined --->
152 | 				<cfif (NOT structkeyexists(arguments, "methods") OR listfind(arguments.methods, local.route['method'])) AND structkeyexists(local.controller, local.route['method']) AND iscustomfunction(local.controller[local.route['method']] )>
153 | 					<cfset variables.routes.addRoute(createobject("component", "restfulcf.framework.core.Route").init(local.route['verb'], local.route_path & local.route['route'], local.resource_name, local.route['method']))>
154 | 				</cfif>
155 | 			</cfloop>
156 | 		</cfif>
157 | 		<cfreturn local.controller>
158 | 	</cffunction>
159 | 
160 | 	<cffunction name="addResponseType" access="public" returntype="void" output="no" hint="Adds the possibility of a response type to the dispatcher (e.g. permits resources to respond to a given type)">
161 | 		<cfargument name="name" type="string" required="yes" hint="The name of the response type (used to match the request format from the request, e.g. /resources/1.[doc])">
162 | 		<cfargument name="mime_type" type="string" required="yes" hint="The MIME type string to serve this response up as">
163 | 		<cfset variables.response_types[arguments.name] = arguments.mime_type>
164 | 	</cffunction>
165 | 	<cffunction name="getResponseTypes" access="public" returntype="struct" output="no" hint="Returns a copy of the structure of permitted response types">
166 | 		<cfreturn duplicate(variables.response_types)>
167 | 	</cffunction>
168 | 
169 | 	<cffunction name="setAuthenticator" access="private" returntype="void" output="no" hint="Sets the authenticator component to use when auth'ing requests">
170 | 		<cfargument name="authenticator" type="restfulcf.framework.core.Authenticator" required="yes" hint="The authenticator instance">
171 | 		<cfset variables.authenticator = arguments.authenticator>
172 | 	</cffunction>
173 | 
174 | 	<cffunction name="setCache" access="private" returntype="void" output="no" hint="Sets the cache component to use when caching responses.  Automatically sets cache_enabled flag to TRUE.">
175 | 		<cfargument name="cache" type="restfulcf.framework.core.cache.AbstractCache" required="yes" hint="The cache isntance">
176 | 		<cfset variables.cache = arguments.cache>
177 | 		<cfset variables.cache_enabled = TRUE>
178 | 	</cffunction>
179 | 	<cffunction name="getCache" access="public" returntype="restfulcf.framework.core.cache.AbstractCache" output="no" hint="Gets the cache component to use when caching responses">
180 | 		<cfreturn variables.cache>
181 | 	</cffunction>
182 | 	<cffunction name="setCacheEnabled" access="public" returntype="boolean" output="no" hint="Sets if response caching is enabled">
183 | 		<cfargument name="enabled" type="boolean" required="no" default="TRUE" hint="Should the cache be enabled?">
184 | 		<cfset variables.cache_enabled = NOT(NOT(arguments.enabled))>
185 | 	</cffunction>
186 | 	<cffunction name="isCacheEnabled" access="public" returntype="boolean" output="no" hint="Is response caching enabled?">
187 | 		<cfreturn variables.cache_enabled>
188 | 	</cffunction>
189 | 
190 | 	<cffunction name="getController" access="public" returntype="restfulcf.framework.core.Controller" output="no" hint="Returns the controller instance for a given name">
191 | 		<cfargument name="name" type="string" required="yes" hint="The controller name to return">
192 | 		<cfif structkeyexists(variables.controllers, arguments.name)>
193 | 			<cfreturn variables.controllers[arguments.name]>
194 | 		</cfif>
195 | 		<cfthrow type="ControllerNotFound" message="The controller for resource type #arguments.name# is not registered." detail="Make sure you addResource() from the dispatcher.  The resource name should be pluralised (e.g. users, not user.)">
196 | 	</cffunction>
197 | 	<cffunction name="getRouteCollection" access="public" returntype="restfulcf.framework.core.RouteCollection" output="no" hint="Returns the routes collection">
198 | 		<cfreturn variables.routes>
199 | 	</cffunction>
200 | 
201 | </cfcomponent>
202 | 


--------------------------------------------------------------------------------
/restfulcf/test/tests/core/ResourceTest.cfc:
--------------------------------------------------------------------------------
  1 | <!--- -->
  2 | <fusedoc fuse="restfulcf/test/tests/core/ResourceTest.cfc" language="ColdFusion" specification="2.0">
  3 | 	<responsibilities>
  4 | 		I test the resource component
  5 | 	</responsibilities>
  6 | </fusedoc>
  7 | --->
  8 | 
  9 | <cfcomponent extends="mxunit.framework.TestCase">
 10 | 
 11 | 	<cffunction name="setup">
 12 | 		<cfset base = createobject("component", "restfulcf.framework.core.Resource").init()>
 13 | 		<cfset resource = createobject("component", "ResourceFixture").init()>
 14 | 		<cfset params = {
 15 | 			id            = 1,
 16 | 			name          = "Default",
 17 | 			email         = "test@test.com",
 18 | 			created_at    = "{ts '1978-09-22 00:00:00'}",
 19 | 			updated_at    = "{ts '1978-09-22 00:00:00'}",
 20 | 			remote_id     = 2,
 21 | 			numeric_id    = 3,
 22 | 			decimal_id    = 3.45,
 23 | 			string_id     = "x",
 24 | 			numeric       = 0.2e3,
 25 | 			integer       = 3,
 26 | 			decimal       = 4.56,
 27 | 			float         = 7.8,
 28 | 			date_only     = "{d '1978-09-22'}",
 29 | 			time_only     = "{t '12:34:56'}",
 30 | 			date_and_time = "{ts '1978-09-22 12:34:56'}",
 31 | 			boolean       = 1
 32 | 		}>
 33 | 		<cfset all_properties = listappend(lcase(structkeylist(params)), "location")>
 34 | 	</cffunction>
 35 | 
 36 | 	<cffunction name="base_init_should_return_instance_of_resource">
 37 | 		<cfset assertIsTypeOf(base, "restfulcf.framework.core.Resource")>
 38 | 	</cffunction>
 39 | 	<cffunction name="extended_init_should_return_instance_of_resource">
 40 | 		<cfset assertIsTypeOf(resource, "restfulcf.framework.core.Resource")>
 41 | 	</cffunction>
 42 | 
 43 | 	<!--- SETTERS AND GETTERS --->
 44 | 
 45 | 	<cffunction name="get_on_base_should_raise_exception">
 46 | 		<cftry>
 47 | 			<cfset base.getInvalidProperty()>
 48 | 			<cfset fail("get() on base component should have raised an exception")>
 49 | 			<cfcatch type="Application"></cfcatch>
 50 | 		</cftry>
 51 | 	</cffunction>
 52 | 	<cffunction name="set_on_base_should_raise_exception">
 53 | 		<cftry>
 54 | 			<cfset base.setInvalidProperty("x")>
 55 | 			<cfset fail("set() on base component should have raised an exception")>
 56 | 			<cfcatch type="Application"></cfcatch>
 57 | 		</cftry>
 58 | 	</cffunction>
 59 | 
 60 | 	<cffunction name="get_invalid_property_should_raise_exception">
 61 | 		<cftry>
 62 | 			<cfset resource.getInvalidProperty()>
 63 | 			<cfset fail("get() on invalid property should have raised an exception")>
 64 | 			<cfcatch type="Application"></cfcatch>
 65 | 		</cftry>
 66 | 	</cffunction>
 67 | 	<cffunction name="set_invalid_property_should_raise_exception">
 68 | 		<cftry>
 69 | 			<cfset resource.setInvalidProperty("x")>
 70 | 			<cfset fail("set() on invalid property should have raised an exception")>
 71 | 			<cfcatch type="Application"></cfcatch>
 72 | 		</cftry>
 73 | 	</cffunction>
 74 | 
 75 | 	<cffunction name="get_valid_property_should_return_default_property_value">
 76 | 		<cfset assertEquals(params['id'], resource.getID())>
 77 | 		<cfset assertEquals(params['name'], resource.getName())>
 78 | 		<cfset assertEquals(params['email'], resource.getEmail())>
 79 | 	</cffunction>
 80 | 	<cffunction name="set_valid_property_with_valid_value_should_succeed">
 81 | 		<cftry>
 82 | 			<cfset resource.setName("Test Name")>
 83 | 			<cfcatch type="Application"><cfset fail(cfcatch.message)></cfcatch>
 84 | 		</cftry>
 85 | 		<cfset assertEquals("Test Name", resource.getName())>
 86 | 	</cffunction>
 87 | 	<cffunction name="set_valid_property_with_invalid_value_should_raise_exception">
 88 | 		<cftry>
 89 | 			<cfset resource.setID("x")>
 90 | 			<cfset fail("set() on valid property with invalid data should have raised an exception")>
 91 | 			<cfcatch type="Application"></cfcatch>
 92 | 		</cftry>
 93 | 		<cfset assertEquals(params['id'], resource.getID())>
 94 | 	</cffunction>
 95 | 
 96 | 	<cffunction name="get_property_with_no_default_value_before_set_should_raise_exception">
 97 | 		<cftry>
 98 | 			<cfset resource.getLocation()>
 99 | 			<cfset fail("get() on valid property with no default should have raised an exception")>
100 | 			<cfcatch type="any"></cfcatch>
101 | 		</cftry>
102 | 	</cffunction>
103 | 	<cffunction name="get_property_with_no_default_value_after_set_should_succeed">
104 | 		<cftry>
105 | 			<cfset resource.setLocation("here")>
106 | 			<cfcatch type="any"><cfset fail(cfcatch.message)></cfcatch>
107 | 		</cftry>
108 | 		<cfset assertEquals("here", resource.getLocation())>
109 | 	</cffunction>
110 | 
111 | 	<cffunction name="no_properties_should_be_available_via_accessors_on_base_resource">
112 | 		<cfset assertEquals(0, arraylen(structkeyarray(base.getProperties())))>
113 | 	</cffunction>
114 | 	<cffunction name="all_properties_should_be_available_via_accessors">
115 | 		<cfset var props = resource.getProperties()>
116 | 		<cfset var prop = "">
117 | 		<cfloop collection="#props#" item="prop">
118 | 			<cfif NOT listfind(all_properties, prop)><cfset fail("Found unexpected property: #prop#")></cfif>
119 | 		</cfloop>
120 | 		<cfloop list="#all_properties#" index="prop">
121 | 			<cfif NOT structkeyexists(props, prop)><cfset fail("Expected property not found: #prop#")></cfif>
122 | 		</cfloop>
123 | 	</cffunction>
124 | 
125 | 	<cffunction name="setting_a_numeric_field_with_no_precision_should_not_coerce">
126 | 		<cfset resource.setNumeric(0.2e-3)>
127 | 		<cfset assertEquals(0.2e-3, resource.getNumeric())>
128 | 	</cffunction>
129 | 	<cffunction name="setting_an_int_should_coerce_value_if_non_integer">
130 | 		<cfset resource.setInteger(123.456)>
131 | 		<cfset assertEquals(123, resource.getInteger())>
132 | 	</cffunction>
133 | 	<cffunction name="setting_a_decimal_should_coerce_value_if_non_decimal">
134 | 		<cfset resource.setDecimal(123)>
135 | 		<cfset assertEquals("123.00", resource.getDecimal(), "trying to set a decimal with no decimal points")>
136 | 		<cfset resource.setDecimal(123.123)>
137 | 		<cfset assertEquals("123.12", resource.getDecimal(), "trying to set a decimal with too many decimal points")>
138 | 	</cffunction>
139 | 	<cffunction name="decimal_coercion_should_be_via_rounding">
140 | 		<cfset resource.setDecimal(1.234)>
141 | 		<cfset assertEquals("1.23", resource.getDecimal(), "should have rounded down")>
142 | 		<cfset resource.setDecimal(1.235)>
143 | 		<cfset assertEquals("1.24", resource.getDecimal(), "should have rounded up")>
144 | 	</cffunction>
145 | 	<cffunction name="setting_a_float_should_coerce_value_if_non_float">
146 | 		<cfset resource.setFloat(123)>
147 | 		<cfset assertEquals("123.0", resource.getFloat())>
148 | 		<cfset resource.setFloat(123.123)>
149 | 		<cfset assertEquals("123.123", resource.getFloat())>
150 | 	</cffunction>
151 | 
152 | 	<cffunction name="setting_a_date_should_coerce_value_if_non_date">
153 | 		<cfset resource.setDate_Only("{ts '1978-09-22 12:34:56'}")>
154 | 		<cfset assertEquals("{d '1978-09-22'}", resource.getDate_Only())>
155 | 	</cffunction>
156 | 	<cffunction name="setting_a_time_should_coerce_value_if_non_time">
157 | 		<cfset resource.setTime_Only("{ts '1978-09-22 12:34:56'}")>
158 | 		<cfset assertEquals("{t '12:34:56'}", resource.getTime_Only())>
159 | 	</cffunction>
160 | 	<cffunction name="setting_a_datetime_should_coerce_value_if_non_datetime">
161 | 		<cfset resource.setDate_and_Time("1978-09-22 12:34:56")>
162 | 		<cfset assertEquals("{ts '1978-09-22 12:34:56'}", resource.getDate_and_Time())>
163 | 	</cffunction>
164 | 
165 | 	<cffunction name="setting_a_boolean_should_coerce_to_numeric_form">
166 | 		<cfset resource.setBoolean(FALSE)>
167 | 		<cfset assertEquals(0, resource.getBoolean(), "trying to set a boolean to FALSE")>
168 | 		<cfset resource.setBoolean(TRUE)>
169 | 		<cfset assertEquals(1, resource.getBoolean(), "trying to set a boolean to TRUE")>
170 | 	</cffunction>
171 | 
172 | 	<cffunction name="property_with_id_but_no_type_should_default_to_int_and_coerce">
173 | 		<cfset resource.setRemote_ID(12.345)>
174 | 		<cfset assertEquals(12, resource.getRemote_ID())>
175 | 	</cffunction>
176 | 	<cffunction name="property_with_id_and_numeric_type_should_default_to_int_and_coerce">
177 | 		<cfset resource.setNumeric_ID(12.345)>
178 | 		<cfset assertEquals(12, resource.getNumeric_ID())>
179 | 	</cffunction>
180 | 	<cffunction name="property_with_id_and_numeric_type_and_precision_should_coerce">
181 | 		<cfset resource.setDecimal_ID(1.234)>
182 | 		<cfset assertEquals(1.23, resource.getDecimal_ID())>
183 | 	</cffunction>
184 | 	<cffunction name="property_with_id_and_string_type_should_not_coerce">
185 | 		<cfset resource.setString_ID("qwerty")>
186 | 		<cfset assertEquals("qwerty", resource.getString_ID())>
187 | 	</cffunction>
188 | 
189 | 	<!--- TRANSFORMATIONS --->
190 | 
191 | 	<cffunction name="transform_to_xml_should_return_valid_xml">
192 | 		<cfset assertTrue(isxml(resource.toXML()))>
193 | 	</cffunction>
194 | 	<cffunction name="transform_to_xml_should_have_correctly_named_root_node">
195 | 		<cfset assertXpath("/resource_fixture", xmlparse(resource.toXML()))>
196 | 	</cffunction>
197 | 	<cffunction name="transform_to_xml_should_contain_all_properties_with_defaults">
198 | 		<cfset var xml = xmlparse(resource.toXML())>
199 | 		<cfset var param = "">
200 | 		<cfloop collection="#params#" item="param">
201 | 			<cfset assertXpath("/resource_fixture/#lcase(param)#", xml, params[param], "'#param#' property is missing or incorrect in generated XML")>
202 | 		</cfloop>
203 | 	</cffunction>
204 | 	<cffunction name="transform_to_xml_should_contain_all_properties_with_correct_types">
205 | 		<cfset var xml = xmlparse(resource.toXML())>
206 | 		<cfset var param = "">
207 | 		<cfloop collection="#params#" item="param">
208 | 			<cfset assertXpath("/resource_fixture/#lcase(param)#", xml, params[param], "'#param#' property is missing or incorrect in generated XML")>
209 | 		</cfloop>
210 | 	</cffunction>
211 | 	<cffunction name="transform_to_xml_should_set_correct_type_on_all_nodes">
212 | 		<cfset var xml = xmlparse(resource.toXML())>
213 | 		<cfset var props = resource.getProperties()>
214 | 		<cfset var type = "">
215 | 		<cfset var node = "">
216 | 		<cfset var param = "">
217 | 		<cfloop collection="#params#" item="param">
218 | 			<cfset node = xmlsearch(xml, '/resource_fixture/#lcase(param)#')>
219 | 			<cfif arraylen(node) NEQ 1>
220 | 				<cfset fail("Unexpected number of nodes returned for property #lcase(param)#: got #arraylen(node)#, expected 1")>
221 | 			</cfif>
222 | 			<cfset node = node[1]>
223 | 			<cfswitch expression="#props[param].type#">
224 | 				<cfcase value="numeric">
225 | 					<cfswitch expression="#props[param].precision#">
226 | 						<cfcase value="integer,decimal,float"><cfset type = props[param].precision></cfcase>
227 | 						<cfcase value="any"><cfset type = ""></cfcase>
228 | 						<cfdefaultcase><cfset fail("Invalid precision found for numeric property #lcase(param)#: #props[param].precision#")></cfdefaultcase>
229 | 					</cfswitch>
230 | 				</cfcase>
231 | 				<cfcase value="date">
232 | 					<cfswitch expression="#props[param].precision#">
233 | 						<cfcase value="date,time,datetime"><cfset type = props[param].precision></cfcase>
234 | 						<cfdefaultcase><cfset fail("Invalid precision found for date property #lcase(param)#: #props[param].precision#")></cfdefaultcase>
235 | 					</cfswitch>
236 | 				</cfcase>
237 | 				<cfcase value="boolean"><cfset type = "boolean"></cfcase>
238 | 				<cfdefaultcase><cfset type = ""></cfdefaultcase>
239 | 			</cfswitch>
240 | 			<cfif len(type)>
241 | 				<cfif NOT structkeyexists(node.xmlattributes, "type")>
242 | 					<cfset fail("No type found for property #lcase(param)#: expected #type#")>
243 | 				<cfelseif node.xmlattributes.type NEQ type>
244 | 					<cfset fail("Unexpected type found for property #lcase(param)#: found #node.xmlattributes.type# but expected #type#")>
245 | 				</cfif>
246 | 			<cfelse>
247 | 				<cfif structkeyexists(node.xmlattributes, "type")>
248 | 					<cfset fail("Found type for property #lcase(param)# when one was not expected: #node.xmlattributes.type#")>
249 | 				</cfif>
250 | 			</cfif>
251 | 			<cfset assertXpath("/resource_fixture/#lcase(param)#", xml, params[param], "'#param#' property is missing or incorrect in generated XML")>
252 | 		</cfloop>
253 | 	</cffunction>
254 | 
255 | 	<cffunction name="transform_to_html_should_have_correctly_named_root_node">
256 | 		<cfset assertXpath("/dl[@class='resource_fixture']", xmlparse(resource.toHTML()))>
257 | 	</cffunction>
258 | 	<cffunction name="transform_to_html_should_contain_all_properties_with_defaults">
259 | 		<cfset var xml = resource.toHTML()>
260 | 		<cfset var term = xmlsearch(xml, "/dl/dt")>
261 | 		<cfset var data = xmlsearch(xml, "/dl/dd")>
262 | 		<cfset var i = 0>
263 | 		<cfset var f = 0>
264 | 		<cfloop from="1" to="#arraylen(term)#" index="i">
265 | 			<cfif NOT structkeyexists(params, term[i].xmltext)><cfset fail("Found unexpected node '#term[i].xmltext#'")></cfif>
266 | 			<cfset assertEquals(params[term[i].xmltext], data[i].xmltext, "Unexpected data for node '#term[i].xmltext#'")>
267 | 		</cfloop>
268 | 	</cffunction>
269 | 
270 | 	<cffunction name="default_transform_to_csv_should_return_correct_data_with_header">
271 | 		<cfset var csv = resource.toCSV()>
272 | 		<cfset assertEquals(2, listlen(csv, chr(10)), "Returned CSV should have two lines")>
273 | 		<cfset assertEquals("boolean,created_at,date_and_time,date_only,decimal,decimal_id,email,float,id,integer,name,numeric,numeric_id,remote_id,string_id,time_only,updated_at", listgetat(csv, 1, chr(10)), "Header line is incorrect")>
274 | 		<cfset assertEquals("1,{ts '1978-09-22 00:00:00'},{ts '1978-09-22 12:34:56'},{d '1978-09-22'},4.56,3.45,test@test.com,7.8,1,3,Default,0.2e3,3,2,x,{t '12:34:56'},{ts '1978-09-22 00:00:00'}", listgetat(csv, 2, chr(10)), "Data line is incorrect")>
275 | 	</cffunction>
276 | 	<cffunction name="transform_to_csv_should_not_include_header_if_told_not_to">
277 | 		<cfset var csv = resource.toCSV(FALSE)>
278 | 		<cfset assertEquals(1, listlen(csv, chr(10)), "Returned CSV should have one line")>
279 | 		<cfset assertEquals("1,{ts '1978-09-22 00:00:00'},{ts '1978-09-22 12:34:56'},{d '1978-09-22'},4.56,3.45,test@test.com,7.8,1,3,Default,0.2e3,3,2,x,{t '12:34:56'},{ts '1978-09-22 00:00:00'}", csv, "Data line is incorrect")>
280 | 	</cffunction>
281 | 	<cffunction name="transform_to_csv_should_escape_commas_and_quotes">
282 | 		<cfset var csv = "">
283 | 		<cfset resource.setName('Billy "Bob" Brannigan')>
284 | 		<cfset resource.setEmail("Fake email, with a comma")>
285 | 		<cfset csv = resource.toCSV(FALSE)>
286 | 		<cfset assertEquals("1,{ts '1978-09-22 00:00:00'},{ts '1978-09-22 12:34:56'},{d '1978-09-22'},4.56,3.45,""Fake email, with a comma"",7.8,1,3,""Billy """"Bob"""" Brannigan"",0.2e3,3,2,x,{t '12:34:56'},{ts '1978-09-22 00:00:00'}", csv, "Data line is incorrect")>
287 | 	</cffunction>
288 | 
289 | </cfcomponent>
290 | 


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