ColdFusion on Wheels Bloggers

Make an RSS Feed for Your Splash Site

Sat, 06 Mar 2010 07:38:35 -0800

Using the new Splash Tags for the Splash CMS, you can easily make an RSS feed or an XML sitemap.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
<cfcontent type="text/xml" reset="Yes"><?xml version="1.0" encoding="UTF-8"?>

<rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/"

    xmlns:atom="http://www.w3.org/2005/Atom">

<channel>

  <atom:link href="http://www.YourSite.com/index.cfm/feed"

    rel="self" type="application/rss+xml" />

  <title>YourSite.comtitle>

  <link>http://www.YourSite.comlink>

  <description>Your Description Goes Heredescription>

  <cfoutput>

    <pubDate>#HTMLEditFormat(DateFormat(now(), 'ddd, dd mmm yyyy'))#

      #HTMLEditFormat(TimeFormat(now(), 'HH:mm:ss'))# ESTpubDate>

  <language>en-uslanguage>

  <ttl>40ttl>

  <s:find slug="blog">

  <s:children-each order="publishedAt desc" where="status='published'">

    <item>

      <cfset thisChild = request.tags.currentChild>

      <title>#HTMLEditFormat(thisChild.title)#title>

      <description><![CDATA[<s:content part="body" page="#thisChild#"/>]]>description>

      <pubDate>#HTMLEditFormat(DateFormat(thisChild.publishedAt, 'ddd, dd mmm yyyy'))#

         #HTMLEditFormat(TimeFormat(thisChild.publishedAt, 'HH:mm:ss'))# ESTpubDate>

      <guid isPermaLink="true">http://www.yoursite.com/index.cfm/#thisChild.slug#guid>

      <link>http://www.yoursite.com/index.cfm/#thisChild.slug#link>

    item>

  s:children-each>

  s:find>

channel>cfoutput>

rss>cfcontent><cfabort>

Most of this code is the required RSS XML. Just drop in your site-specific domain name, description, etc.

The tag finds the blog, and then loops over all the children that are under the blog page. I used thisChild as a convenience variable instead of having to type request.tags.currentChild every time. The at the end keeps Splash from adding extra HTML tags at the end of the file.

You could also create an easy XML site map using a similar approach. Just change out the XML wrapper.

New Splash Tags for the Splash CMS

Fri, 05 Mar 2010 13:10:56 -0800

I recently added several new Splash Tags for the Splash content management system. If you don’t know about Splash, read my Introduction to Splash article.

There’s a complete list of tags and documentation over on the GitHub Wiki. But, I’ll give you an overview and show you how to use these tags for a blog.

This tag looks up a page and stores the page object so that subsequent tags can use that page object.

The tag finds all the children of a page and loops over them.

and finds the first or last child page.

The rest of the tags are all used inside of a tag. They check to see if the current child page is the first one, last one, or whatever.

Making a Blog page with Splash Tags

Let’s say you have a page named Blog, that has several posts that are child pages of Blog. Then, in the body for the blog page, put something like this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<h3>Articlesh3>

<s:find slug="blog">

  <s:children-each

   order="publishedAt desc"

   where="status='published'">

    <cfset thisChild = request.tags.currentChild>

    <cfoutput>

      <dt class="blogList">

         <a href="#thisChild.slug#">#thisChild.title#a>

            | #DateFormat(thisChild.publishedAt, 'long')#dt>

      <dd class="blogDesc">#thisChild.description#dd>

    cfoutput>

  s:children-each>

s:find>

finds the blog page, and then loops over all the pages. By the way, uses the CFWheels findAll model method, so all of the cool CFWheels parameters are available in !

If you want to see an example of what this looks like, visit the DonorUp blog page.

All in all, that’s a lot of output for very little programming effort. That’s what I call the secret to programmer happiness!

Content Management and the Splash CMS — Introduction

Fri, 05 Mar 2010 12:02:46 -0800

Splash CMS is an open source content management system that runs on top of CFWheels. It’s designed to be a simple, but elegant content management solutions for websites that are managed by small teams.

CFWheels is an open source ColdFusion framework that is inspired by Ruby on Rails. Besides being easy to use and learn, using CFWheels lets you adapt great ideas from Ruby on Rails (RoR) applications. RoR has the Radiant CMS, and Splash is the ColdFusion/CFWheels adaptation!

You can easily download Splash from http://wiki.github.com/russjohnson/SplashCMS/. The documentation for Splash is still kind of sparse, but the Radiant documentation is mostly applicable, and you can easily see how most things are supposed to work. Then, if you get stuck, email the Google Group.

Splash Layouts, Snippets, and Pages

Splash uses Layouts, Snippets, and Pages to build a website.

A layout, as you might imagine, is like a skin for an entire website. You can have multiple layouts and use different layouts for different pages.

Pages are specific URLs on a Splash site, and each page has a specific layout specified. A page can have multiple “page parts.” Most pages will have a “Body” part, but some might also have a “Sidebar” or other parts.

Snippets are reusable content chunks. You might have a navigation snippet that displays the main navigation for your site. Headers and Footers are other common snippets.

Splash Tags

There is one other very powerful component to Splash — Splash Tags. These are ColdFusion custom tags that extend ColdFusion and HTML to work with Splash. Here’s a simple example: the <s:title /> tag. This tag just retrieves the page’s title from the page object and inserts it in place of the tag. So, in your layout, you would typically have something like:

<title><s:title />title>

The pages title information from the database is then easily inserted into the HTML title tag!

There are a lot more tags, so see the Wiki.

Splash in Action

I recently completed the DonorUp.com website using Splash. I was really pleased with how easily I was able to get many thing to come together. So, try Splash and leave a comment to let me know how you like it!

Learning CFWheels — Debugging

Wed, 24 Feb 2010 14:06:55 -0800

CFWheels has some great documentation and examples, but there is still a small learning curve. As you are getting going, it helps to have a few debugging tips. So, keep reading …

On the CFWheels Google Group, Cathy recently asked about the sendEmail() function. This is a pretty good example to show you some debugging tips.

sendEmail() wraps the cfmail tag. Here’s some more information:

CFWheels on sending email.

This all looks pretty straightforward, but what do you do if it’s not working?

First, setup a test view page. Go to the Wheels views folder and add a new folder called test. Then create a new file called index.cfm in the test folder. The path should be /views/test/index.cfm.

In the index.cfm file you just create, put the following:

1
2
3
4
5
6
<cfset

  set(functionName="sendEmail",

  server="yourServer",

  username="yourUsername",

  password="yourPassword")

>

This will trigger the sendEmail() function. You can access the test page at http://localhost/index.cfm/test. But, if you go to this page, you’ll get an error because we didn’t create myemailtemplate, yet. So, make another CFM page in /views/test/ called myemailtemplate.cfm. The content can be anything you want. Something like “Test email” is fine.

Wheels knows you are in the Test controller, so it looks for templates in the /views/test folder. Wait a minute! You never said anything about creating a controller. That’s one of the cool things about Wheels. Even without a controller, it will still show you the view page, and things still work!

Now, go back to the test page at http://localhost/index.cfm/test. If everything is working, you should get an email message. If it’s not working, you can put other stuff in your test page. Try these out:

will show you the params structure with your actions, controller, data you’re passing, etc.
will show information on your filters.
will show all the wheels settings, functions, routes — All kinds of cool things.

Now sendEmail() is a little trickier. It uses ColdFusion’s tag. Put this in your /views/test/index.cfm file:

1
2
3
4
5
<cfmail from="me@mydomain.com"

    to="me@mydomain.com"

    subject="Test Message">

  This is a test

cfmail>

If this won’t work, then it’s your server configuration, not Wheels. You may have to specify your server name or login information. That’s pretty easy, too. Just put the following in your config/settings:

1
2
3
4
5
6
<cfset

  set(functionName="sendEmail",

  server="yourServer",

  username="yourUsername",

  password="yourPassword")

>

I hope this helps!

CF Wheels ORM Fun!!!

Sun, 21 Feb 2010 18:21:56 -0800

Today I wanted to have some fun, so I decided to check out the CF Wheels Framework inspired by Ruby on Rails. I've never used Ruby on Rails before, but this framework is pretty nice. It took me all of about ten minutes to have a default page up and running + diplaying data from my model. I wanted to demonstrate just how easy it is to populate tabular data using the framework.

If you haven't already, you need to download the framework from cfwheels.org, then extract the zipped file into a folder of you're choosing. The first time you run the application, you should see a CF Wheels Intro page. I'm not going to go over any installation or boilerplate stuff; you can find everything you at cfwheels.org; they have some great video tutorials.

The first thing I did was create my database, it just includes a single table for now:

CF Wheels is convention based, so the database name needs to be plural. We need to do this, so Wheels can properly setup mappings between our database and model. (just wanted to point out that this not a requirement, you can override pretty much all the default settings)

Let jump into some code:

Setting up our datasource name (config/settings.cfm)

Setting up our model (model/[YourCFC.cfc])

As you can see in the example below, I didn't follow all of the conventions for Wheels, so I had to override the default properties for my table name . I also set a property for my column name, just to show you that you can override default settings. If you had more than one table and some relationships, you would also define those in here using associations.

Connecting you're model to you're controller (controllers/[YourController.cfc])

So to get all the records back from my model, we would call model("schedule").findAll(). There are a ton of built in functions for displaying records anyway you like. You can find those methods here. I also would like to point out that you should have a controller for each folder inside of you're views directory. Mine is setup like so; views/external/home.cfm. So I have a controller named External with a home function inside of it. Everything that I set in my controller + method home will be available inside the home view:

Connecting our view to our controller (views/[YourView.cfm])

In our view we would want to make sure to cfparam the query being passed to it, and then just output those records in a cfloop.

<dl class="schedule">
<dt>Giants Schedule</dt>
<cfloop query="scheduleClass">
<cfoutput>
<cfif #scheduleRow# mod 2>
<dd class="even"><a href="">#scheduleQry.gameNames#</a><span>#lsDateFormat(scheduleQry.startDates,'dd mmm yyyy')#</span></dd>
<cfelse>
<dd><a href="">#scheduleQry.gameNames#</a><span>#lsDateFormat(scheduleQry.startDates,'dd mmm yyyy')#</span></dd>
</cfif>
<cfset scheduleRow = #scheduleRow# + 1 />
</cfoutput>
</cfloop>
</dl>

Final Result:

Using Partials In CFWheels To Keep DRY

Wed, 17 Feb 2010 15:02:52 -0800

One of the things I like about CFWheels is that its based on sensible conventions. If you follow these conventions, they can really save you a ton of time writing boiler-plate code as well as configuration. Working synergistically with these conventions are a lot of helper methods that will also reduce the amount of code you have to write as well as keeping your application DRY (Dont Repeat Yourself).

I am working on some new features for SplashCMS and ran into a situation that helped clean up quite a bit of code in some of my views and I thought it warranted a little example to show how nice this feature really is.

I have several places where I want to display a list of snippets in this application. Normally you would just write this code in each of the views that display the listing:

Snippets.cfc (controller)

 <cffunction name="index"> <cfset snippets = model('snippet').findAll(order="name")> </cffunction>

index.cfm

 <table> <cfoutput query="snippets"> <tr> <td>#linkTo(text="#name#", route="edit_snippet_path", key="#id#", class="snippet")#</td> <td>#linkTo(text='#imageTag("remove.png")#', route='delete_snippet_path', key="#id#", confirm='Are you sure?')#</td> </tr> </cfoutput> </table>

Not really a big deal I know. Pretty simple code to display a small list in a table. But consider this, if you do this 2 or 3 times for each different type of list you have, that could really start to get unruly in a hurry. So to help us keep our views as DRY as possible, we can leverage a feature in CFWheels called partials.

Partials can best be described as CFINCLUDE on steroids. They work exactly like a CFINCLUDE in their simplest form but, are pretty cool in the fact that they can be as simple or complex in functionality as you need. In order to keep things as simple as possible for this post we will simply look at how using a Wheels Partial over a CFINCLUDE is beneficial for our situation and will delve further into some of their more powerful features in another post.

So, in order to keep from repeating ourselves and having as little code as possible in our app, lets look at how we can simplify this. Since we know we are outputting a list of snippets thats returned in our query, we can strip out the code thats used in each view and place it into a partial named the same as our query. By doing this, we are going to take advantage of one of the features of partials that allows us to automatically handle data being passed into it.

First lets look at the code that makes this happen and then I will explain it further.

index.cfm

 <table:cf> <cfoutput> #includePartial(snippets)# </cfoutput> </table>

_snippet.cfm

 <cfoutput> <tr> <td>#linkTo(text="#name#", route="edit_snippet_path", key="#id#", class="snippet")#</td> <td>#linkTo(text='#imageTag("remove.png")#', route='delete_snippet_path', key="#id#", confirm='Are you sure?')#</td> </tr> </cfoutput>

Notice in the view file (index.cfm) how we are calling the partial and instead of passing a file name, we are passing the actual query into the includePartial() method. By doing this, we are telling Wheels that we want it to find our partial named _snippet and loop over it once for each record in the query. Pretty nice, right? We are letting Wheels handle looping over the query and including our display code for us. This is much more portable now. Any place we want to display this list, we can simply call the partial and we have only one file with display code to manage the list. This helps to DRY up our code.

One thing to note. You will notice that Im passing a query named "snippets" plural. However the file Wheels will look for is "_snippet.cfm" singular. Partials are always named starting with an underscore "_" and when Wheels evaluates the query passed into it, it knows we are dealing with a Snippet model and our models are always singular, so the convention is to use singular names for the partials as well. Just think of it like this, the partial is always dealing with only one record at a time, thus its singular.

I hope this helps explain this really cool feature of partials a bit. In my next post we will expand on this example by demonstrating how CFWheels helps you to use grouping in this same partial.

Buggy curly braces

Mon, 08 Feb 2010 06:35:00 -0800

Due to my habit of leaving out curly braces on simple if/else statements a ColdFusion 9 bug hit me today. Have a look at the following code:

if (0==1) tmp; else aStruct = {};

There's no reason that code should fail, right? But it does. When you run it you get an error message saying that "Variable ASTRUCT is undefined".

It looks like ColdFusion is misinterpreting the curly braces that declares the struct as being the end of the if/else statement. This is also proven by the fact that you can make the code run by adding proper curly braces to the if/else statement or using StructNew to declare the struct instead of the implicit declaration.

To make matters worse, this used to work in ColdFusion 8.

Anyway, off to Adobe to report it...

Permalink | Leave a comment »

Does exactly what it says on the tin

Sat, 06 Feb 2010 10:39:57 -0800

“Does exactly what it says on the tin.”

I love it. All of our method and function names should do exactly the same.

During a discussion with the ColdFusion on Wheels core team about the valid() and beforeValidation() methods, Andy Bellenie made this remark:

My point is that a callback called beforeValidation should run, well, before validation – not during it. This seems self-evident to me and I’d have a hard time explaining to anyone why it should work differently.

Then he pointed to “the Ronseal test, the holy grail of method naming.”

Thanks Andy for the inspiration.

Technorati Tags: best practices, cfwheels, chris peters, clear crystal media, ColdFusion, coldfusion on wheels, development, polymorphism, Programming, web development

onError Handling for CFWheels and Splash CMS

Thu, 04 Feb 2010 14:55:48 -0800

For most websites it’s usually a good idea to have error pages that have user-friendly error messages that are styled to look like the rest of the site. Also, you may want to send yourself an eMail when an error happens. Read on to see how to make this work.

For the DonorUp website, I used CFWheels and the Splash CMS. Once I knew the tricks, it turned out to be really easy to make this work. So, I decided to write a post to explain what you need to know.

Typically, in ColdFusion, you add an onError() method to your Application.cfc file. Wheels gives you various hooks into Application.cfc, but Wheels already has an onError() method. So, you can’t add another one! Fortunately, Wheels has an easy way to handle most errors.

How to send error messages from CFWheels

All you have to do to get Wheels to send error message emails is add the following into your /config/settings.cfm file:

Now, whenever there’s an error, you’ll get a really nice email with all the troubleshooting info you’ll need. Easy!

How to setup a custom error page in CFWheels or Splash

As part of its built-in error handling, Wheels runs the file at /events/onerror.cfm. Just put a redirect to your error page at the top of onerror.cfm and you’re done:

In my case, I went into the Splash CMS admin and added a page called Error Page. This way, the page is automatically styled to match the rest of the site. The error page apologizes to the user for the error, and let’s them know I am going to fix it!

When Wheels does its error handling, it will run /events/onerror.cfm, and the redirectTo() will send them to my error page! If you aren’t running Splash, you could just use the other arguments of redirectTo() to send them to any controller and action.

You can also put your own HTML or CFML code in onerror.cfm, but I like doing it this way better as it uses all the layouts and styling of my site!

Please leave me a comment if you like this approach or have other ideas!

YM_Gravatar 0.2

Wed, 20 Jan 2010 07:34:52 -0800

I just now found an email that Chris Peters sent me about my Gravatar plugin back on 12/15/2009. He said the main thing holding him back from using the plugin was he couldn’t pass additional arguments to the tag. Based on his input and suggestions, I have modified the Gravatar plugin where you can do just that.

Thanks Chris!

http://gaclabs.com/projects/wheels-plugins/ym_gravatar

DefaultScope 0.6.2 released

Sat, 19 Dec 2009 14:14:11 -0800

DefaultScope plugin 0.6.2 has been released!

* <http://cfwheels.org/plugins/listing/23>
* <http://github.com/illuminerdi/DefaultScope>

The DefaultScope plugin adds the ability to set defaults for the findAll() method on a per-Model basis.

Changes:

### 0.6.2 / 2009.12.19

* 1 minor enhancement:

* fix for DefaultScope causing issues with the calculations methods (andybellenie)

Big thanks to Andy for identifying this issue and supplying patches for it.

CFWheels and ORM

Mon, 14 Dec 2009 21:28:00 -0800

Object Relation mapping is one of the key feature in CFWheels. CFWheels makes things easier to start using ORM in your applications. The ORM configuration in CFWheels is implemented by creating a mapping between a database table and ColdFusion compon... [More]

DefaultScope plugin 0.5 released

Mon, 07 Dec 2009 22:25:23 -0800

The DefaultScope plugin 0.5 has been released!

http://cfwheels.org/plugins/listing/23
http://github.com/illuminerdi/DefaultScope

The DefaultScope plugin adds the same functionality to Wheels found in Rails’ ActiveRecord::Base#default_scope. Go ahead and check the documentation on either the Github or CFWheels plugin pages.

Features:
* defaultScope() takes all of the same options as findAll() and stores them for a specific model
* findAll() now pulls in defaultScope values and uses them if not manually overridden

This is my first plugin and I probably did something wrong somewhere. Thanks to James Gibson for helping me tackle a particularly odd issue with CF8. Please try it out, and let me know if you have any problems or suggestions. It’s pretty bare-bones, but it does what it says.

Also, in an odd twist, my first plugin is the 23rd listed on CFWheels, which happens to be my favorite number. Weird.

My first cfwheels plugin - ioc interface

Mon, 07 Dec 2009 07:24:48 -0800

I decided to play around with cfwheels cause I was amazed by some examples I saw around and I have to admit is good fun.

After 1 hr testing I realized that no ioc support is build into cfwheels and ..... I really cannot live with no Ioc container available at any time so I decided to add a plugin for managing a beanFactory into cfwheels.

Probably is not the best cfwheel plugin ever written but was very easy and painless. While I tend to be very OO guy I am amazed by conventions in last period ( I am also playing with Sean Corfield FW1 ). While I am also an happy user of Coldbox and ModelGlue I find that sometimes frameworks added complexity also to easy tasks. From here my desire to look into frameworks that make of conventions their core basement.

In my mind conventions means less code in default situations and about this cfwheels and fw1 at the moment are the best. Btw I also think that for a more complex task Coldbox really has something more to help development of more advanced applications.

You can find the plugin here to play with it and have a look to cfwheels.

Introducing WordArt for ColdFusion

noreply@blogger.com (Sameer Gupta) — Tue, 01 Dec 2009 05:19:00 -0800

Apache Rewrites for Subfolder Install of CFWheels

Mon, 30 Nov 2009 10:36:22 -0800

By default the CFWheels framework and application is installed in the webroot.

But if you want to install it in a subfolder in the webroot, you need to change the rewrites slightly.

I use the following and it works quite well.

In the example below, I have a server called hello.cfwheels.local, and it points to a folder under the webroot called hello.

 ServerName hello.cfwheels.local RewriteEngine On RewriteOptions Inherit RewriteCond %{REQUEST_URI} ^.*/(flashservices|flex2gateway|railo-context|robots.txt)($|/.*$) [NC] RewriteRule ^(.*)$ http://127.0.0.1:8080/$1 [P,L] RewriteCond %{REQUEST_URI} ^.*/(files|images|javascripts|miscellaneous|stylesheets|plugins|sitemap.xml|rewrite.cfm)($|/.*$) [NC] RewriteRule ^(.*)$ http://127.0.0.1:8080/hello$1 [P,L] RewriteRule ^(.*)$ http://127.0.0.1:8080/hello/rewrite.cfm$1 [P,L] RewriteRule ^/(.*)$ http://127.0.0.1:8080/hello/rewrite.cfm/$1 [P,L] ProxyPassReverse / http://127.0.0.1:8080/hello/rewrite.cfm/ ProxyPreserveHost on

If you think there is a better way to accomplish this, please drop in a line.

CfWheels now at version 1.0 – congratulations!

Sun, 29 Nov 2009 14:37:59 -0800

CfWheels – my framework of choice for coldfusion has finally been expunged from release candidate status!

CfWheels is a full-stack framework with some quite strong opinions on code organisation and layout. This is not a bad thing at all, if you do things the wheels way, it makes your life easier.

Built into the concept of the framework are 3 core pieces of ideology that will make your life easier. When i say built in, i really mean baked in as the level of thought these interactions have had is quite surprising. These features are:

ORM – Object Relational Management

URL Rewriting

MVC – the Model View Controller ideology for code separation

Wheels is based on the Ruby on Rails framework, which is widely considered to be a great tool for RAD. Most people who seem to love ruby on rails do so for its speed and ease of use, and there are countless books on this subject. Coldfusion is already a fantastic RAD language, and CfWheels when combined with tools such as Scaffolding can give you a very swift boost into a project.

Scaffolding allows you to generate controller and views for a table that contain all of the basic functionality you will generally require.

A quick and dirty example:

Step 1. Install CfWheels on either Adobe’s own CF8/9, Railo or BlueDragon.

Step 2. install the scaffolding plugin by dropping the zip file into the cfwheels plugin folder

Step 3. Write a simple database table containing the data set you wish to use

Step 4. Click the scaffolding link at the top of the cfwheels debug information panel

Step 5. Enter the name of the table

Step 6. Navigate to the controller (/tablename) and you will see that all the fields are now generated into an input for you, and also basic add/edit/remove functionality exists.

wow, you just built a fully functional application! While clearly this might not suit every project, it can certainly be a good place to start, and a great introduction into cfwheels.

Up and rolling with Git on Snow Leopard

Sat, 28 Nov 2009 07:34:42 -0800

This morning, I set up a GitHub account so that I could have some public repositories for my ColdFusion on Wheels plugins. Feel free to follow me and watch my repositories as I post them up. (Gotta learn how to do that first though!)

Then came the process of installing Git on Snow Leopard so that my computer can talk to the repository. In my opinion, the Git website could do a better job with their Mac OS X installer (or at least the instructions).

Fortunately, Hivelogic has a great step-by-step on installing Git on Snow Leopard. If you’re running Snow Leopard, I highly recommend doing everything that they say in the post. If they ask you to touch your nose while spinning in circles, do it.

Now on to figuring out how to get my reCAPTCHA on Wheels plugin into my new repo.

Technorati Tags: ccm, cfwheels, chris peters, clear crystal media, coldfusion on wheels, Git, github, install, installation, polymorphism, scm, version control, web development

Search CFWheels Documentation

Fri, 27 Nov 2009 13:15:41 -0800

CFWheels has excellent documentation. Well organized, sufficiently detailed, well presented.

Something that is missing at the moment, and is on the list of things to-do for the CFWheels team, is to add a search feature to the docs.

Till the time that feature is implemented, I created a Google custom search for CFWheels docs.

I just find that after one has understood the basics and has started building an application, there is a need to be able to quickly search for information rather than go through listing of topics to figure out where can one find a piece of information.

To that end, a search interface proves very useful.

So, if you want to search CFWheels documentation till the time a formal search is put on the site, you are more than welcome to use the custom search that I use.

You can access the search at: http://nagpals.com/utils/cfwheels/search/

Or use the search box below to search:

CFWheels - Rediscovering beauty in CF Code

Fri, 27 Nov 2009 12:57:30 -0800

I haven't been blogging much of late. Lots of traveling and work kept me away.

During this time, however, I have somehow managed to find time to play with CFWheels. And I must say it has been a pleasure working with it.

I've dabbled with Ruby on Rails and Grails in the past and have always lamented about the fact that the frameworks in CF do not possess the same beauty and elegance.

Well, CFWheels changes all that.

If you ask me, I'd say that all CF developers should at least try it out to once to see all that it has to offer.

Personally, I like they way the MVC architecture is implemented in CFWheels -- pretty much like Rails/Grails. Plus domain modeling and URL rewriting using routes -- leading to very nice, readable URL. And not to mention time-saver features like view helpers that let you build nice views and forms and add validation to them. And also the plugins... And also the provision for different environment like design/development/test/production.

I've tried it on Railo and it is blazing fast. I'm sure it would be as quick on CF9.

I could go on and on. But it is simpler for you to simply head over CFWheels to discover the magic.

Installing CFWheels 1.0

Tue, 24 Nov 2009 16:32:00 -0800

ColdFusion on Wheels 1.0 a production ready version hits the web today. To be frank I haven't tried it before and just want to understand its specific features over the other frameworks available for ColdFusion. So I have downloaded and installed it ... [More]

Go get it…. CFWheels hits 1.0!!!!

Tue, 24 Nov 2009 04:48:45 -0800

After many long months and some great dedication from all those involved, today CFWheels hit the 1.0 milestone.

Using extra CFC attributes for documentation

Thu, 12 Nov 2009 13:57:02 -0800

For the ColdFusion on Wheels API documentation, we chose to do something a little unconventional (but pretty cool). Instead of trying to write or use a comment parser for our documentation, we just added additional attributes to our CFC s’ tags.

Look at this example for the autoLink() view helper:

<cffunction name="autoLink" returntype="string" access="public" output="false" hint="Turns all URLs and e-mail addresses into clickable links."
 examples=
 '
 ##autoLink("Download Wheels from http://cfwheels.org/download")##
 -> Download Wheels from http://cfwheels.org/download
 
 ##autoLink("Email us at info@cfwheels.org")##
 -> Email us at info@cfwheels.org
 '
 categories="view-helper,text" functions="excerpt,highlight,simpleFormat,titleize,truncate"
> <cfargument name="text" type="string" required="true" hint="The text to create links in."> <cfargument name="link" type="string" required="false" default="all" hint="Whether to link URLs, email addresses or both. Possible values are: `all` (default), `URLs` and `emailAddresses`.">
  <cfscript> var loc = {}; loc.urlRegex = "(?ix)([^(url=)|(href=)'""])(((https?)://([^:]+\:[^@]*@)?)([\d\w\-]+\.)?[\w\d\-\.]+\.(com|net|org|info|biz|tv|co\.uk|de|ro|it)(( / [\w\d\.\-@%\\\/:]* )+)?(\?[\w\d\?%,\.\/\##!@:=\+~_\-&]*(?<![\.]))?)";
 loc.mailRegex = "(([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,}))";
 loc.returnValue = arguments.text;
 if (arguments.link != "emailAddresses")
 loc.returnValue = loc.returnValue.ReplaceAll(loc.urlRegex, "$1<a href=""$2"">$2a>"); if (arguments.link != "URLs") loc.returnValue = REReplaceNoCase(loc.returnValue, loc.mailRegex, "<a href=""mailto:\1"">\1a>", "all"); cfscript> <cfreturn loc.returnValue>
 
cffunction>

It makes the function declarations a little beefier, but the documentation is right there with the code. As you can see, we added examples, categories, and functions attributes to the declaration.

Writing a parser took a little over a week, but it was fairly simple with CFML ’s GetMetaData() function and some extra business rules.

Here’s a link to the autoLink() documentation on CFWheels.org so you can see what the output looks like. Everything on that page is generated based on the code above.

Technorati Tags: adobe, ccm, cfml, cfwheels, chris peters, clear crystal media, ColdFusion, coldfusion on wheels, polymorphism, railo, web development

CFWheels and Git: Ignoring unpacked plugin directories

Mon, 02 Nov 2009 13:48:06 -0800

Just a quick little git and Wheels tip. Most of the time, you might only want to track your plugins .zip file in your repo and ignore the plugin’s unpacked directory since it’s pretty much redundant to track both. In order to do this, create a .gitignore file where your .git directory lives. In it add the following:

plugins/**/*

What that does is essentially tells git to ignore any subdirectories off the main plugin directory.

Wheels spotted in the wild…

Thu, 22 Oct 2009 13:32:54 -0700

UPDATE: CFML syntax highlighting has been add to Pygments as of version 1.3. You can see the closed ticket information here.

If there was one thing that always bugged me about github is the lack of support of CFML syntax highlighting. It seems that CFML never gets any love, but that is about to change! The Pygments project is an open source generic syntax highlighter written in python that has support for a ton of different languages. Now it seems the Pygments is working on CFML syntax highlighting for their next release!

What does this all have to do with Wheels you might ask? Well it seems that the CFML code they are using as a test bed for the highlighting is none other then the Wheels repo!

Script-based controllers and models, tag-based views

Thu, 22 Oct 2009 12:41:48 -0700

I’m looking forward to playing around with ColdFusion 9 when I get some more time here in a month or so. One of the areas that interests me in particular is the ability to write full CFC s in CFScript syntax.

Think about this scenario in ColdFusion on Wheels:

Controllers in script syntax
Models in script syntax
Views in tag syntax

I like the idea of this, though I’ll admit that I haven’t tried it yet. The more data- and logic-heavy parts of the app can be script-driven, while the tag-based syntax can be used with HTML .

Imagine this scenario for a Wheels model class:

component extends="Model" {
  /** @hint Initializes associations and validations */ public function init() { // Associations hasMany("chirps"); // Validations validatesPresenceOf("firstName,lastName,email,gender,urlId"); validatesUniquenessOf("email,urlId"); validatesLengthOf(properties="firstName,lastName", maximum=50); }
 
}

And this for a Wheels controller:

component extends="Controller" {
  /** @hint Shows form for registering for social network. */ public function register() { user = model("user").new(); }
  /** @hint Saves registration submission. */ public function create() { user = model("user").new(params.user); user.save();
  if(user.hasErrors()) { renderPage(action="register"); } else { flashInsert(success="Thank you for registering for Social Network."); redirectTo(controller="home"); } }
 
}

And then any view logic can be mixed in via tags with all the other HTML tags (right where it belongs).

<cfsetting enablecfoutputonly="true">
 
<cfparam name="user">
 
<cfoutput>
 
<h1>Register for Social Networkh1>
 
#startFormTag(action="create")#
 
#textField(label="First Name", objectName="user", property="firstName")#
#textField(label="Last Name", objectName="user", property="lastName")#
#textField(label="Email", objectName="user", property="email")#
 
<fieldset> <legend>Genderlegend> #radioButton(label="Male", objectName="user", property="gender", tagValue="M")# #radioButton(label="Female", objectName="user", property="gender", tagValue="F")#
fieldset>
 
<fieldset> <legend>Profile Addresslegend> #textField(label="http://#cgi.script_name#/profile/", objectName="user", property="urlId")#
fieldset>
 
<div> #submitTag(value="Register Now")#
div>
 
#endFormTag()#
 
cfoutput>
 
<cfsetting enablecfoutputonly="false">

This makes me excited for Railo adoption of script-based CFC s and for time to warp 5 years into the future when script-based CFC s are more widely used in general.

Technorati Tags: ccm, cf, cf9, cfc, cfml, cfscript, cfwheels, chris peters, clear crystal media, ColdFusion, coldfusion 9, coldfusion on wheels, mvc, polymorphism, railo

Shouldn’t be long now…

Tue, 20 Oct 2009 13:48:34 -0700

http://code.google.com/p/cfwheels/source/detail?r=3243

Wheels is only a hammer

Thu, 08 Oct 2009 03:49:23 -0700

My posting this is a seriously delayed reaction. But I must admit that I was using Wheels as a hammer and trying to treat a problem like a nail when I wrote about creating a Wheels partial for setting form focus.

Stephen came up with a much nicer jQuery-only solution for setting form focus:

$(document).ready(function(){ $(”.focus”).focus();
});

So now you can set form focus on load by setting that element’s class to focus. No need to create a Wheels partial and set a variable in your CFML .

In my newbness, I wasn’t thinking that you could have that $(".focus") hanging there without it applying to something on every page. Now I am schooled.

Thanks Stephen!

Technorati Tags: cfml, cfwheels, ColdFusion, coldfusion on wheels, html, javascript, jQuery

Interesting Railo mapping bug

Tue, 29 Sep 2009 09:51:00 -0700

During a Wheels debug session with Tony we discovered a bug in Railo 3.1.1 related to mappings.

Normally when you create an object in Railo it is slow the first time but then lightning fast on subsequent creations of the same object. This applies both to the page request (e.g. if you create multiple objects on the same page it is only slow on the first one) and to the life span of the application (e.g. if you create an object on a page, creating that same object is faster on the second page called).

When testing the latest version of Wheels on Railo we noticed however that the initial slowness would remain the same across page requests, even though the object had already been created in a previous request. It was like Railo was not able to cache the object information internally and thus had to recreate the object from scratch on every page request (excuse the non-technical lingo here but I have no idea how Railo handles this under the hood).

After messing around with our test code for a bit we came to the conclusion that this bug appears when you have a CFC that extends another CFC via a mapping. When we used a plain folder in the "extends" attribute it would run just fine.

We're currently implementing a work-around for this issue and hope to include it in the next Wheels version. If this is something you have problems with right now you can remove the mapping that is set in the "wheels/functions.cfm" file (only do this if you're running your site off the web root though).

By the way, the Railo team has been informed and they say they will have this fixed (or at least made faster) in an upcoming patch.

Permalink | Leave a comment »

Wheels 1.0 is coming

Tue, 22 Sep 2009 17:49:05 -0700

It’s been the buzz around our community lately that Wheels 1.0 will hopefully be hitting the streets in November 2009. Out of all the open and closed source projects I’ve been involved with over my career, I have to say that Wheels hold a special place in my heart. The entire team (and especially Per) is doing an outstanding job getting the final code base up to par.

Keep up the great work everyone!

Wheels 1.0, when?

Wed, 16 Sep 2009 05:38:00 -0700

Chris Peters totally gave it away in his post on the official Wheels blog:
"We're pretty much locked on features until we release 1.0 in a couple months".

A "couple" usually means "2", right?

So, let's do the math in ColdFusion (I could use my brain for the calculation I guess but ColdFusion is already up to version 9 while the last reports from my brain indicate perpetual beta status).

<cfset releaseDate = Month(Now()) + 2> <cfdump var="#MonthAsString(releaseDate)#">

For those of you who don't have the luxury of having a ColdFusion development server to run this complex code on I can tell you that the answer is "November".

I'm looking forward to it, are you?

By the way, the above code was done without any use of a framework!
Yeah, it was painful but I stuck with it.

Permalink | Leave a comment »

CFWheels — Using Layouts and Stylesheets

Sun, 06 Sep 2009 10:50:21 -0700

On Page 73 of Head First Rails, we need to add a design for the meBay site.

Just like Rails, CFWheels supports layouts to create a master template and to avoid repeating yourself.

For our simple app, we could just work with the default layout located at /views/layout.cfm. But, to follow the book, let’s create a controller-specific layout at: /views/ads/layout.cfm. So, this layout.cfm in the /view/ads/ subdirectory will only be used for views associated with the ads controller.

[cf]

Ads: #params.action#
#stylesheetLinkTag("default")#

#contentForLayout()#

[/cf]

Most of this code is HTML boilerplate. #params.action# inserts the name of the current action in the Title tag. The params structure is always passed from the controller to the view. It includes the name of the action, variables, etc. You can always cfdump it out if you want to see what all is in there.

#stylesheetLinkTag(”default”)# uses another CFWheels helper function. By convention, stylesheets are located in the /stylesheets directory. So this function builds the link to our stylesheet named default.css. Download the code for Chapter 2 from the Head First Rails website, and get default.css from the /public/stylesheets/ folder. In CFWheels, put default.css in your /stylesheets folder. If you have trouble with the stylesheet, make sure all the images references are correct. If your web server configuration is different, you might need to adjust the paths.

On line 16, we’ve setup a link to our index action.

On line 22, you see #contentForLayout()#. This is where CFWheels puts the content from the other view pages — show.cfm and index.cfm. It’s the equivalent of <%= yield %> in Rails.

That’s it! Now we have a pretty, styled meBay application. Visit http://localhost/index.cfm/ads/ and see how pretty things look.

Next, it’s on to Chapter 3. In software development, things always change. And, now meBay wants to let people post ads online!

CFWheels — Adding a Custom Index Page

Sun, 06 Sep 2009 08:46:43 -0700

Starting on Page 73 of Head First Rails, we need to add an index page so that people can find the pages they want!

First, let’s add a new route so that http://localhost/index.cfm/ads/ goes to the new index action we’ll add in a minute.

Open up /config/routes.cfm, and change it to:

[cf]

[/cf]

Notice the new route on line 2: . CFWheels checks the routes in order. So, if the URL pattern matches /ads/[key], it will go to the show action. But, if the key isn’t there, it matches the /ads/ pattern and goes to the new index action.

Now, we need to add an index action to the controller and then an index.cfm view. Open up /controllers/Ads.cfc and add the new index function. Leave the show function alone.

[cf]

[/cf]

Notice the that we set ads = model(”Ad”).findAll(). This tells Wheels, to go get the Ad model, and findAll the data — Pretty Powerful! The data comes back as a ColdFusion query object.

For testing, put the line in your controller, and send your browser to: http://localhost/index.cfm/ads/. You’ll see the query dumped out in all its glory! This is a pretty good debugging trick. Add a to your controller to see what variables and data the controller is passing to the view. Remove the line, and let’s go create the view.

Go create /views/ads/index.cfm:

[cf]

All Ads

#linkTo(text="#ads.name#", route="ads", key="#ads.id#")#

[/cf]

Pretty simple! Specifying the query attribute in makes this just like a . You end up with a bunch of List Items (

) — One for each record in the query we got from the controller.

linkTo() is another cool Wheels helper function. You could just use an tag. However, using the linkTo() function is a best practice because it makes your application more portable. We specified the “ads” route in the function. If, later on, we changed our subfolders or URL rewriting, everything would still work.

That’s it. Send your browser to: http://localhost/index.cfm/ads/ and you should see a list of ads. Each ad will have a link that takes you to the show action and displays the ad.

CFWheels — Fixing the Controller and View

Sun, 30 Aug 2009 08:21:04 -0700

Last time, we setup our route, and now if you go to: http://localhost/index.cfm/ads/3, you won’t get an error. But, just like on Page 63 of Head First Rails, the ads are blank and the page is kind of boring — There’s no data.

First, we need to fix our controller at /controllers/Ads.cfc. Make sure your show function looks like:

[cf]

[/cf]

When Wheels created the model, it automatically adds the findByKey method. All we have to do is tell it which key we want, and params.key has the key value!

We still need to fix /views/ads/show.cfm to display the data. Change this file to:

[cf]

Name:#ad.name#

Description:#ad.description#

Price:#ad.price#

Seller Id:#ad.seller_id#

Email:#ad.email#

[/cf]

Pretty neat. Just put the values in the view and wrap it up in a tag! Wheels handles the hard part of getting the data from the database into the model.

Go back to: http://localhost/index.cfm/ads/3, and you’ll see that the data is now being correctly displayed.

CFWheels — How to Setup and Use Routes

Sun, 30 Aug 2009 07:56:07 -0700

Routes offer a way to map web URLs to specific controllers in your application. It’s one place where you might use configuration in CFWheels.

There’s a good section in the CFWheels docs on Using Routes. But, I’m going to continue following along with the examples in Head First Rails, starting on page 56.

If you try a URL like this: http://localhost/index.cfm/ads/3, Wheels will give you an error: Could not find the view page for the ‘3′ action in the ‘ads’ controller. That’s because, Wheels is looking for the Ads controller with the “3″ action. Rails would complain that there is no action (Method in the Ads controller) called ‘3′. But, Wheels is smarter and just goes straight to the view. We don’t have a ‘3′ method in Ads.cfc, but Wheels still tries to load a view from /views/ads/3.cfm. The file isn’t there, so it throws an error.

Setting up a Route will let us fix this! Open up /config/routes.cfm. It defaults to something like:

[cf]

[/cf]

Did you ever wonder how you got to that nice congratulations page when you just go to: http://localhost/? What happens is that our route, the “home” route, says, that if the URL pattern is “” (Blank String), Wheels should go the the wheels controller, and run the action congratulations.

Take a peek at /controllers/Wheels.cfc. Sure enough, there is a congratulations method that loads up info on the current version of Wheels. And, then of course, it looks for the view in /views/wheels/congratulations.cfm. The file is already there as part of the default Wheels installation. If you open it up, you can see the HTML code including the place where it inserts the version information Wheels got from the controller.

The default routes.cfm file is nice, but lets make some changes!

[cf]

[/cf]

It’s important to understand that Wheels goes through the routes in order from top to bottom. As soon as it finds a match, it goes to the appropriate controller. Here’s how you interpret this route.cfm:

Ads. If the URL pattern looks like: http//localhost/index.cfm/ads/3, go to the show action in the ads controller. Did you notice the pattern includes [key]? This tells Wheels to set the key parameter to whatever is in the URL — 3 in this case.
Catchall. If the URL doesn’t match the Ads pattern, Wheels will try the next pattern. This pattern matches [path]. In other words, it matches anything, and puts the value in the path parameter. Actually, it doesn’t put everything in the path paramter — Just the part before the next slash, “/”. http//localhost/index.cfm/xxx/yyy/zzz/3 will only have “xxx” in the path parameter. A route like this is a good one to add to catch any unknown URLs a user might enter — Sort of like a 404 Error page.
Home. If the URL pattern is blank, we’ve got one more route to cover that case. Remember, the pattern is just the stuff that comes after http//localhost/index.cfm/.

Ultimately Routes just offer a convenient way to map a URL to a controller. They are useful for having prettier URLs that make more sense to the users. You can always use query params in your URL and completely bypass routes. This URL, http://localhost/index.cfm?controller=ads&action=show&key=3 directly specifies the controller and action, so there’s no need for Wheels to check the route!

CFWheels — Creating a Custom Controller and View

Thu, 27 Aug 2009 13:47:36 -0700

We’re on Page 52 of Head First Rails, and we need to create a custom Controller and View.

I’m going to keep following the book, but there is a great tutorial that covers the same ideas over on the CFWheels website.

Convention Rules! CFWheels has conventions for almost everything. As long as you follow the conventions, things just work naturally.

For example, look at a URL like this http://localhost/ads/show/5. CFWheels will automatically interpret this to run the show function in the ads controller. The number 5 is passed as a “key”.

Before I keep going, I have to touch on URL rewriting. The URL I just used as an example will only work if your server supports full URL rewriting. I’m using the ColdFusion development server, and it only offers “partial” URL rewriting. So, I have to use a URL like this: http://localhost/index.cfm/ads/show/5. Notice that index.cfm has to be inserted in the URL!

You can also specify the Controller and Action like this: http://localhost/index.cfm?controller=ads&action=show&key=5. Doing it this way will always work. It bypasses routes and any server URL rewriting problems. You might want to just use this form of URL while you are learning or if you are debugging a problem.

In any case, the idea is to run the show function in the ads controller. CFWheels will look for Ads.cfc in the controller folder, and will look for the show function inside Ads.cfc.

Then, it will run the show function and load the view. It will expect there to be a view file in /views/ads named show.cfm to match the function you called.

But, guess what? If you don’t create the Ads.cfc controller, CFWheels, will still try to run the view. Normally, you’ll want the controller to get some data for you, but if not, you could skip the controller altogether.

Here’s my controller code for /controllers/Ads.cfc:

[cf]

[/cf]

Later, we’ll add some functionality to the controller, but I’m following the book. And, for now, the only two actions we need are index and show.

At this point, you could try to go to http://localhost/index.cfm?controller=ads&action=show&key=5. But, you’d get a Wheels error because there is no view file.

Here’s my view code for /views/ads/show.cfm:

[cf]

Name:

Description:

Price:

Seller Id:

Email:

[/cf]

I know, this doesn’t do much either, but we’ll add on. Be Patient!

Now, if you go to http://localhost/index.cfm?controller=ads&action=show&key=5, you’ll see the lovely static view file you just created.

Next time, we’ll look at routes some more, and eventually, we’ll actually make this app work.

CFWheels — Creating a Custom Model

Tue, 25 Aug 2009 08:36:55 -0700

Continuing the series on using Head First Rails to learn CFWheels, lets move on to Chapter 2 — Beyond Scaffolding. We are going to create the MeBay application!

Starting on Page 45 in Head First Rails …

Whether we use scaffolding or not, we still have to create the database. In Rails, you do this with the script/generate model command and then running rake. But, in CFWheels, it’s easiest to just use SQL and create the database directly. Here is some mySQL code to create the needed ads table.

[sql]

CREATE TABLE `ads` (
`id` INTEGER PRIMARY KEY NOT NULL auto_increment,
`name` varchar(255),
`description` text,
`price` decimal,
`seller_id` integer,
`email` varchar(255),
`img_url` varchar(255),
`created_at` datetime,
`updated_at` datetime
);
[/sql]

Later on, we’ll want to populate the table with some sample data, so let me go ahead and show the full SQL that creates the table and adds the test data:

[sql]
DROP TABLE IF EXISTS `ads` ;
CREATE TABLE `ads` (
`id` INTEGER PRIMARY KEY NOT NULL auto_increment,
`name` varchar(255),
`description` text,
`price` decimal,
`seller_id` integer,
`email` varchar(255),
`img_url` varchar(255),
`created_at` datetime,
`updated_at` datetime
);
INSERT INTO `ads` VALUES(1,’Typewriter’,'Old manual typewriter. Many years useful service. Works best with a bottle next to it.’,71.95,54,’dhammett@email.com’,'http://homepage.mac.com/david_griffiths/typewriter.png’,”,”);
INSERT INTO `ads` VALUES(2,’Football’,'Some strings frayed.’,74.02,45,’marty@googlemail.com’,'http://www.freefever.com/freeclipart/clipart/football2.gif’,”,”);
INSERT INTO `ads` VALUES(3,’Moosehead’,'Slightly moth-eaten. One of the antlers is broken and there’’s a strange buzzing sound behind the eyes…’,2978.25,56,’kathy@hotmail.com’,'http://saloon.javaranch.com/ubb/moosefly.gif’,”,”);
INSERT INTO `ads` VALUES(4,’Desk’,'Milk desk - go…’,4800,123,’andy@allmail….’,'http://picasaweb.goog…’,”,”);
INSERT INTO `ads` VALUES(5,’Door curtain’,'Beaded door cu…’,11,773,’dawn@hotmail….’,'http://www.freewebsit…’,”,”);
INSERT INTO `ads` VALUES(6,’Apple Newton’,'Still works! M…’,25,2,’ahertz@differ…’,'http://www.differnet….’,”,”);
INSERT INTO `ads` VALUES(7,’Sinclair C5′,’Battery flat t…’,372.06,346,’clive@sinclai…’,'http://www.ebay.com/w…’,”,”);
INSERT INTO `ads` VALUES(8,’Edsel’,'Never used aut…’,355,755,’bing@badabing…’,'http://pages.google.c…’,”,”);
INSERT INTO `ads` VALUES(37,’Diamond’,'203.4 carats, grade D pear cut diamond. Low price for quick sale. Owner leaving the country.’,1000000,5234,’pink@panther.com’,'http://’,”,”);
[/sql]

It’s easy enough to manually create the Model, but for convenience, let’s use the scaffolding plugin anyway.

Click the Scaffold link at the bottom of any CFWHeels page – In the debug section, next to Plugins. Then, on the scaffold page, enter ad as the Object name, select Model from the Type drop down, and click Generate. Remember, the table is named ads (plural with an “s”), but the the model is named ad (singular).

Now, open /models/Ad.cfc. You’ll see something that looks like:

[cf]

[/cf]

That’s all it takes to create a model! Your model must extend Model.cfc — That’s where all the CFWheels goodness happens. Other than that, all you need is an init function. Later on, you can use the init function to add extra capabilities, but for now, all that’s needed is a blank init function!

CFWheels — Adding a new table with model, view, and controller

Sun, 16 Aug 2009 11:34:16 -0700

In Part 2, we looked at Editing the View in CFWheels.

We thought we were done, but now the boss wants to record events along with ticket sales. Remember we are following along in Head First Rails, and converting everything to CFWheels!

Fortunately, with scaffolding, all we need to do is create the new database table and run the scaffolding plugin.

Here’s the create table SQL query:

CREATE TABLE `events` (
`id` int(11) NOT NULL auto_increment,
`artist` varchar(255) NOT NULL,
`description` text,
`price_low` decimal NOT NULL,
`price_high` decimal NOT NULL,
`event_date` date NOT NULL,
PRIMARY KEY (`id`)
)

I got the idea from a Rails app to create a “spec” directory to hold application specification information. And, I created a database sub-directory to hold all my table creation SQL. So the query is stored in /spec/database/events.sql.

Next, click the Scaffold link. Look in the debug information at the bottom of each page, next to Plugins. Then, on the scaffold page, enter event as the Object name, and click Generate. Remember, the table is named events (plural with an “s”), but the the object is named event (singular).

All that’s left is to open /views/events/ and edit the labels in edit.cfm, index.cfm, new.cfm and show.cfm. This last step isn’t really needed to make things work, but the boss is kind of picky.

Great — We’ve finished with Chapter 1 of Head First Rails. You now know how to:

Create a new CFWheels application
Install the scaffolding plugin to CFWheels
Setup a database table and use scaffolding to automatically generate the Model, View, and Controller code.
Edit HTML in the View
Add fields and new tables to the database

Next time, we’ll start Chapter 2, and build an application from scratch — Without using scaffolding.

Editing the View in CFWheels

Wed, 12 Aug 2009 08:55:29 -0700

In Part 1, we looked at Scaffolding Basics in CFWheels.

Now, I’ll continue working through the exercises in Head First Rails and converting things to CFWheels.

Page 27: Edit the HTML in the View

When you use scaffolding, the labels will be the same as the field names in the database. This may be OK, but if you need to change them to make them more readable by humans, it’s easy enough to edit the HTML in the views.

Look at the directory for webroot/views/tickets. You’ll see four files named edit.cfm, index.cfm, new.cfm, and show.cfm. These are the four files that you need to edit.
Open up edit.cfm, and you’ll see the code like: Seat_id_seq. Seat_id_seq isn’t a very human-friendly label, so let’s change it to Seat #.
Change the code to Seat ##. Remember this is inside a block, so you have to escape the # symbol by typing it twice.
Open index.cfm and change the appropriate line to .
Now make similar changes to new.cfm and show.cfm.
Save everything, then go to http://localhost/tickets/index.cfm?controller=tickets&action=index to see your beautiful new labels!

I made one other change to the code to make things work correctly! At the bottom of the show.cfm file, there’s a line that starts out with
#linkTo(text=”Return to the listing”, action=”action”)#. This may be a bug in scaffolding, or maybe I did something wrong. This line should really say:
#linkTo(text=”Return to the listing”, action=”index“)#. This way, the link will go back to the index view.

Page 31: Adding a new data field

The Boss forgot that we need a phone number field, so now we have to add it!

In Rails, you have to do > script/generate migration … and then run > rake db:migrate. In CFWheels, we’ll just run an Alter Table query on the database. Here’s the query I ran:

ALTER TABLE tickets
ADD phone varchar(255)

But, just like with Rails, changing the database isn’t enough (Page 36). We still have to update the code in the View files to handle the new field. Here’s the code I added to edit.cfm and new.cfm:

Phone

#textField(objectName=’ticket’, property=’phone’)#

Notice the textField() function. This is the CFWheels equivalent of <%= f.text_field :phone %>. Rails also has the f.label function. I’m not sure of the advantages of using a helper function for labels. But, this doesn’t seem to be available in CFWheels — At least not yet!

By the way, you can get details on any helper function like the textField tag at:

http://code.google.com/p/cfwheels/wiki/textFieldTag

The changes to show.cfm and index.cfm are similar. If you have any trouble, leave me a comment!

I heard a rumor that the Boss wants to add event information to our application. We’ll look at this next time!

CFWheels Scaffolding Basics

Tue, 11 Aug 2009 05:09:27 -0700

I choose CFWheels as my first ColdFusion framework to learn. I was going to learn ColdBox, but quickly discovered that I would really have to learn Transfer or Reactor and Coldspring at the same time. These may be good tools, but I wanted to focus mostly on mastering the Model View Controller pattern.

I’ve been really pleased with CFWheels. It’s the ColdFusion answer to Ruby on Rails, and it just makes sense to me!

The documentation is good. Still, for a new learner, some things are missing. So, I thought maybe I can leverage some Rails resources. I found a great book — Head First Rails. I’m going to do some posts on translating the book to CFML and to CFWheels. I think this will help my learning and may help others.

From here, I’m assuming that you know something about web development, CFML, and already have a ColdFusion server running on your computer. If not, this information may be too advanced for you. CFWheels runs great on the development edition of ColdFusion that’s available from Adobe. Railo is also supported. You can learn more about the requirements at: http://cfwheels.org/docs/chapter/requirements.

Now on to Head First Rails, Chapter 1: Really Rapid CFWheels

Page 7: Creating a New Application

In Rails, you open a command prompt and type > rails tickets. This sets up the folder structure for your app.

In CFWheels, you do the same thing by downloading the CFWheels files and just unzipping them to a folder named tickets in your webroot. The name of the folder is very important. CFWheels and Rails both rely on convention instead of configuration. Things have to be named consistently!

Page 14: Creating Tables (Migration)

In Rails, you create tables in the database by going to a command prompt and typing > ruby script/generate scaffold tickets … Then, you have to run a migration by typing > rake db.migrate. These two commands also write code for your application! Rails will automatically create Model, View, and Controller files for your new table.

CFWheels handles this a little differently, but you can quickly get to the same place. First, you have to install the Scaffolding plugin.

Download the scaffolding plugin
Save the .zip file in your wwwroot/tickets/plugins folder.
Reload CFWheels by running this URL in your browser: http://localhost/tickets/?reload=true
CFWheels will automatically unzip and install the file! You’ll see Scaffold listed as a plugin at the bottom of the page along with other debugging information.
NOTE: Apparently there’s a problem with the Plugin Manager right now. I had to delete the Plugin Manager files from the plugins directory. Then, this process worked for me. I discovered the problem was with my ColdFusion server configuration. I had added a Dump() method to Component.cfc. When Wheels tried to load multiple plug-ins, it saw the duplicated method, and threw an error as a result of the naming conflict.

You’ll only need to do the steps above once. Now, lets use scaffolding to create an app in CFWheels. Instead of using the script/generate syntax, CFWheels expects you to just create your table via a SQL query or whatever database tools you like to use. Most developers know how to do this, and I like this approach better than learning a new syntax in Rails!

Here’s my Create Table SQL script. This is essentially the same command you type into Rails via script/generate.

CREATE TABLE `tickets` (
`id` int(11) NOT NULL auto_increment,
`name` varchar(255) NOT NULL,
`seat_id_seq` varchar(255) NOT NULL,
`address` text NOT NULL,
`price_paid` decimal NOT NULL,
`email_address` varchar(255) DEFAULT NULL,
PRIMARY KEY (`id`)
)

Now, it get’s really easy. Either click the Scaffold link on the bottom of your browser screen, or point your browser to http://localhost/tickets/index.cfm?controller=wheels&action=plugins&name=scaffold. This will display the scaffolding plugin screen.

Just enter the name of the table and click Generate. That’s it! Instant Application. Go to http://localhost/tickets/index.cfm?controller=tickets&action=index to see your new application. Rails automatically creates a route, so their URL is simpler, and you can easily do the same thing if you want. For me, when learning, I’d rather see the controller and action clearly shown in the URL. There’s always time to switch to pretty URL’s later on.

Next we’ll edit the HTML in the view. But, that’s another post. Please leave a comment if I got something wrong or you like my approach!

Announcing WorkingWithCFML.com

Fri, 07 Aug 2009 11:30:24 -0700

Although there are many downsides to being unemployed, there are a few upsides to it as well. One of which is that you have a TON of time to play with code and learn new things. After almost 3 months between projects now, I started getting the fever to launch something. So I was playing around with CFWheels at that time and decided to throw something together.

The result is WorkingWithCFML.com. Its not nearly feature complete, but I wanted to get something out there and start playing around. Its basically a site that allows CFML developers to create profiles, recommend other developers, etc. The idea is not mine, Most of the functionality is heavily "borrowed" from the Rails site workingwithrails.com. I just thought it would be a cool project and wanted to see how much i could get done with Wheels.

Currently I have around 45 man hours in the site, that includes bug-fixing the last couple days. Its running on the latest version of Railo 3.1.0.026 and was written with version 0.9.3 of CFWheels.

If you are so inclined, create profile and share. If you happen to run into any issues, or if you can think of a feature that you would like added, please let me know. Afterall, I dont have much else to do right now. ;)

Handling Nested Resources in CFWheels

Wed, 15 Jul 2009 14:24:49 -0700

Several frameworks these days are including a routing system to make it easy to implement user friendly urls, or as some like to call them, search engine safe urls. These routing systems can also make refactoring much simpler as well if you use them properly.

I have been playing around with CFWheels lately and was wondering how I could take advantage of nested resources in this framework. Nested resources is something I picked up while working on some Rails projects, its a way to automatically handle related objects in your forms. Let me show you a quick example.

Say we are building a bug tracker. We have 2 objects, a Projects object and a Ticket object. Here is how the associations are setup.

Project.cfc

and now our Ticket.cfc

Now normally if you were adding a ticket, you could use a URL like this:

localhost/tickets/new

And you could pass in the projectID as a hidden field or something like that to handle the association.

But, there is a much easier way to handle this. First lets take advantage of the routing system and create a few routes. I like named routes in my applications much better than the defaults. If I ever refactor a controller and rename an action, etc. I can change the route and every link in my site that points to that route is automatically updated for me. Hows that for a time saver?

These 3 routes handle the nesting for us. Notice how the project part of the url is always first? Then the nested resource since tickets belong to projects. This URL structure will ensure that our projectID is always available in the params scope. Our URl will now look like this if we are adding a ticket to a project.

localhost/project/1/tickets/new

Heres a typical link that would point to our form to create a new ticket.

#linkTo(text="New Ticket", route="new_project_ticket", projectid=params.projectid)

To setup our form for the new ticket an automatically populate the projectID hidden field, we can write our controller action like this.

That takes advantage of the built-in associations in Wheels and builds the new ticket object through the project object for us. You form would be a standard Wheels form but will automatically have the projectID set in the hidden field for you.

Geek Week: Day 5

Wed, 13 May 2009 20:17:16 -0700

Well Day3 and 4 ended up with me having to do client work and some work for my day job. Those two days were a bust and I should of ended the days with doing some more coding, but afterwards my mind just wasn’t into it. I’m learning that this wasn’t the smartest idea. I now see why it takes a long time to get things done.

On top of all that, while I was just sitting down to type this out, I saw that the two commits to trunk that I made today weren’t the smartest changes either and I was asked to revert them, which I did.

I think I’m going to take a break tomorrow from testing and trying to find bugs since I basically creating my own

Wheels was donated some migration code quite a while ago from Ryan. One of my goals this weeks was to try to get migrations working. I figured tomorrow I fork the my local repo and see what I can do to get this in.

Geek Week Update: Day 2

Sun, 10 May 2009 19:33:21 -0700

Today was WAAAAY more productive then yesterday, way more, even though I went to bed at 6:30am this morning. I had to finish a project for a client and decided that I better get it out of the way before it started to haunt me and dip into my Wheels time.

The entire day was spent revamping the testing framework for the last time (I hope) as I think I finally got it to where I want it to be. I did a bunch of optimizations to the testrunner and the output display. In doing so I discover the beauty of getComponentMetaData().

When running the tests, I had some logic in place that basically would inspect the meta data of the component you wanted to test to see if it is extending the wheels.test base component. There’s no reason to even waste the time searching for tests to run if the component won’t even have any and the only way it’s going to have tests is if it extends the wheels.test base component.

In order to do the check I would use createobject to create an instance of the component and then use getMetaData() to inspect the meta data. To me this seemed kinda dumb and it bothered me that I knew there had to be a better way and that’s when I found getCompoentMetaData(). Basically this does the same thing as getMetaData() but you don’t have to waste your time instantiating the component. All you have to do is pass the component path to getComponentMetaData() and it does the work for you and returns the exact same meta data that getMetaData() would. Very handy function indeed.

The other thing that was bothering me was the hackery way I was altering the application.wheels.modelPath and the application.wheels.modelComponentPath so that I could call test models with the model() function. Before I was performing my half ass hack inside the test cases themselves in the setup(), but I knew that this was going to get messy. It finally dawned on me to just add them into the testing framework itself for now. Later on we’ll think of a better way to pass a component path to model(), but as for right now this prevents me from having to do the hack manually and even though it’s still a hack, it’s a bit cleaner.

After finally getting the testing framework ironed out, I moved on to refactoring all the tests to get more output and separate the multiple calls to assert() I was doing in each test. All and all, Wheels not has 61 tests in 19 cases. Not bad for a start. It’s definitely NOT where I wanted to be at this point, but there’s no sense in rushing either.

Tonight I ‘m going to do some research into designing a testing database that I can use to properly test the model layer. I’m sure I’ll be totally OCD about the way it’s designed and will spend most of the day second guessing myself over and over. One of the ideas to get around this was was to look at maybe using the blogCFC database since it’s already been ported to like EVERY RDBMS engine out there (go Ray!). We’ll have to see.

Will update again tomorrow.

Geek Week Update: Day 1

Sat, 09 May 2009 18:27:58 -0700

So how is it going so far? HORRIBLE!

Well first off, I updated my cygwin install with the latest version of git and subervion-perl a couple of weeks ago and when I went to rebase with the CFWheels repo, it would die. Only one commit at a time would be pulled down and then errors all over the place. After searching on google I found out that this is a known problem with the latest subversion-perl so I had to downgrade. That took me about an hour to figure out. I could have applied a patch to the version that I had already installed, but I wasn’t in the mood to be jerking around like that and I figured I’d leave that stuff to the experts.

After that I was finally able to sync with the svn repo and get everything up and running.

With my confidence in the toliet, I started writing tests and finding bugs that needed to be fixed. When I found my first bug, I decided to use trusty old tortoisesvn to write the patch and get it into trunk since I had local checkout already. That went well, but it wasn’t the best way to do it. I should be using git and git-svn to do this stuff and by using tortise I had to litterally duplicate the patch that I already had in git. NOT SMART!

Anyhow, I continued coding and soon found another bug that needed some attention. “WHAT LUCK!” I thought because now I could submit the patch through git-svn like I should have been doing all along. BIG MISTAKE! Let’s just say that I fought with this for almost two hours, because I kept screwing up the workflow left and right and having to git reset –hard. Thank God that stackoverflow.com exists and after reading carefully, the solution that I found, and some playing around, I finally got the workflow down and was able to commit the patch.

All and all, I’m having a rough time. Maybe I’m just off my game today since I have a lot of other things in my head right now and my mental state isn’t in sync. No matter, tomorrow is another day and more coding.

Tomorrow I’m planning on completing the creation of a test database so that I can test out all the functions that depend on models and cleanning up the tests.

About the tests. Right now, the way I’m writing tests, I’ll have more then one assert in each test. From what I’ve seen and researched how other people write tests, this is the wrong way. You should have one assert for each test. After writing a bunch of them, this makes sense. Reason being is because if you have 5 asserts in one test and one of the asserts fails, the whole test fails. Now currently this isn’t a problem because I know it’s the last assert I wrote that failed. However, down the road I can see this becoming a problem when we’re trying to figure out where the test is failing. It’s not like I want the rest of the team to be commenting out asserts until they find the one thats failing. I come to the conclusion at this point that I’m going to have to rewrite all the tests I’ve created into this new format. Oh well it’s what learning is all about and the reason I love doing open source stuff.

I’ll update again tomorrow.

CFWheels Geek Week scheduled

Mon, 27 Apr 2009 07:59:58 -0700

I finally got the dates to take off and GEEK OUT ON WHEELS (I like the way that sounds)! I’ll be officially off from May 9th – May 17th.

Again, if you want to help in anyway, either use google code or github to check out the code.

CFWheels: 0.9.1 now available

Mon, 27 Apr 2009 07:47:25 -0700

Quick annoucement that we have just released version 0.9.1 of CFWheels!

Railo really is fast!

Thu, 02 Apr 2009 12:52:00 -0700

I've had a few hours spare so thought I'd see for myself if Railo is as fast as I've heard. Well, after running a few of my own mini applications I can backup the claims.

Cfwheels Sample application

Tue, 23 Sep 2008 06:29:00 -0700

This is a really simple example of getting and displaying data from a database using the ColdFusion of Wheels framework. I should point out that I am not an expert, this is just me learning!

Dynamic Sub-Domain Redirect

Jordan M — Sat, 06 Sep 2008 09:09:00 -0700

Ever wanted an easy to implement, dynamic sub-domain redirect built into your Coldfusion project? Well, here's something I've done using Coldfusion on Wheels' easy-to-append Application.cfc functions, along with a Controller that handles the business logic for the handed-in sub-domain.

Edit the events's onrequeststart.cfm to have the following:

A variable to store the current CGI.SERVER_NAME
A regex (provided below) to parse the data
An if-test to evaluate the results after parsing
A redirect/cflocation to the action of choice

It could look something like this:

</cfif>

That's it! Just make sure you have a controller that actually does something (like display certain data based on the handed-in dynamic sub-domain) and you're good to go.

Thanks to Matthew over at the Denver Dev blog for the help on the regex.

Simplified Scope with CFW

Jordan M — Sat, 06 Sep 2008 08:55:00 -0700

So as of the start of my entries here, I've really been focused on CFW (Coldfusion Wheels). As I've continued to review and play with some application scenarios, I'm finding a number of really handy simplifications CFW has introduced that trump the standard approach of non-framework based Coldfusion deployments.

The one that got my attention today was the param struct. Rather than having a URL "scope" and a "form" scope and some CGI variables (for identifying pathing domain, etc.), everything's tossed into the param for CFW.

Not only does this brain damage of persisting variables from different structures, it just really cleans up code.

Go ahead, check it out: The Params Struct in CFW

CFWheels Starters

Jordan M — Fri, 05 Sep 2008 09:05:00 -0700

The most important aspect of the Coldfusion on Wheels (CFW) framework is the MVC--model view controller--architecture and the highly extendable aspects that CFW offers. Binding views and controls is as easy as implementing a Coldfusion Component (CFC) within the "controllers" folder (as of version 0.8.1) and a matching CFM page in the "views" folder.

Where things really get interesting is the flexibility of Coldfusion's Application.cfc as implemented by CFW and how this can affect the view's content and rendering. Whereas a usual implementation of the Application.cfc would include a verbose document defining functions for the onApplicationStart, onError, onRequestStart, and so on, deployment of the CFW's Application.cfc is left alone.

As I've discovered, rather then messing with the CFW core files (in case of a necessary upgrade), you can simply drop in a Application.cfc corresponding function-named CFC within the CFW's "events" directory and the code will be called along with the same-named function of the Application.cfc.

Documentation on this can be found here

Now that rocks!

Coldfusion on Wheels

Jordan M — Fri, 05 Sep 2008 07:43:00 -0700

I recently was searching for a quick, easy to implement Coldfusion framework, and came across CF on Wheels.

Although it's not in a 1.0 release yet, the framework looks extremely promising. I've been working with it this week and from initial download to "hello world" tests of the deployment, I'm impressed.

Whether you're running on a dedicated (Apache or IIS) server or a shared environment, the tidy URL writing and SEO-friendly pathing is a real clincher.

More to come.

What it's all about

Jordan M — Fri, 05 Sep 2008 07:38:00 -0700

Welcome to the RIA Haiku blog. From here on out I'll be posting about the ins, and outs, of RIA development, the technologies I'm currently exploring, and tips I've come across which have helped in my software development career.

As for the name, posts will focus on being concise and in three piece aspects.

Look forward to the first post soon.

ColdFusion on Wheels - table relationships

Wed, 28 May 2008 08:04:00 -0700

If you have two tables in your database that have a one to many relationship then you need to set up the relationship between the two in ColdFusion on Wheels.For example if you have a posts table and a comments table (Note that ColdFusion on Wheels&hellip

Coldfusion on wheels

Wed, 23 Apr 2008 15:56:00 -0700

As Mr Forta has pointed out over on his blog the CFWheels chaps have released an update to their framework. This framework has been quite for a while so im looking forward to checking it out again.

ColdFusion on Wheels provides fast application development, a great organization system for your code, and is just plain fun to use. One of our biggest goals is for you to be able to get up and running with Wheels quickly. We want for you to be able to learn it as rapidly as it is to write applications with it.

Chris has blogged here whats new

ColdFusion on Wheels 0.7 released

Wed, 23 Apr 2008 10:46:00 -0700

CFWheels, the ColdFusion framework inspired by Ruby on Wheels has just reached version 0.7. I've just been reading the docs and really like some of the features it has. It is an MVC framework and as with all frameworks it has it's strengths and weakn&hellip