#Adam.Blog# » ColdFusion

My Resume on ColdFusion + FW/1 + CouchDB

Adam Presley — Wed, 01 Sep 2010 00:29:58 +0000

The last few days I decided I wanted to play around with Apache’s CouchDB, one of the more popular database engines in the No-SQL movement. For those who have never heard of it CouchDB is a database engine written in Erlang, and is an Apache Foundation project. One of the neatest things about CouchDB is that the API is based entirely on RESTful JSON services, so all command to it are HTTP commands like PUT, GET, POST, and DELETE. All data is stored as JSON objects known as “documents”. When you have a chance take a look at it.

For me the project I always fall back to when I want to try something new is my Resume project. I’ve kept my resume online for several years now. My first version of it was to proof-of-concept my PHP framework, and this worked well for a long time. I then modified it to work with ColdFusion, Groovy, and Hibernate with MySQL as the persistence layer. That was fun too. Now I set out to redo this in ColdFusion with CouchDB as the persistence layer.

The result is a ColdFusion application using Sean Corfield’s excellent FW/1 framework, my CouchDB4CF Java facade, and Apache CouchDB. Check it out at http://resume.adampresley.com. I’ll post more soon about how it is built.

No related posts.

Adding Namespaces to HTML Tag Using Regular Expressions

Adam Presley — Wed, 25 Aug 2010 23:37:44 +0000

My friend, Mr. Steve Good, approached me about a problem he was having where he needed to add a namespace to an HTML tag at runtime. Essentially he was parsing some dynamic HTML and wished to inject an additional namespace into the HTML declaration. Regular expressions to the rescue! The first test I ran was with a blank tag. For this example I will be injecting the SVG, or Scalable Vector Graphics namespace. To accomplish this in ColdFusion we simply are using the replaceAll method against the String class in Java.

1
2
3

<cfset old = "" />
<cfset new = old.replaceAll("(?i)(?<=", "$1 xmlns:svg=""http://www.w3.org/2000/svg"">") />
<cfdump var="#new#" />

When you run that you will get something that looks like this.

The next task was to ensure that if the HTML tag already had a namespace our regex won’t erase it, but will instead append the new namespace to it. Let’s see that code.

1
2
3

<cfset old = ""http://www.w3.org/1999/xhtml"">" />
<cfset new = old.replaceAll("(?i)(?<=", "$1 xmlns:svg=""http://www.w3.org/2000/svg"">") />
<cfdump var="#new#" />

Yup, as we can see by the above screenshot it seems to work! I love me some regular expressions. Happy coding!

Finding Specific Text in a String using ColdFusion and Java

Code for my Dallas TechFest 2010 Presentation Available

Adam Presley — Thu, 05 Aug 2010 15:45:08 +0000

Finally, as requested, my code and slides for my Dallas TechFest 2010 presentation are available for download. If you missed it I presented on taking an existing ColdFusion application (could be anything, PHP, JSP, Groovy + Grails) and incrementally spicing it up with jQuery. Click here to download the code and instructions on getting setup!

Merging Two ColdFusion Structs

Adam Presley — Tue, 03 Aug 2010 17:19:47 +0000

Here’s a quick little tidbit. My coworker Steve Good asked me if I knew of a quick way to merge two ColdFusion structures together, kind of like how jQuery has the $.extend() method. Well there is in fact a way to do this! And it’s super easy.

Let’s say you have structure one that has two keys, firstName and lastName.

<cfset struct1 = { firstName = "Adam", lastName = "Presley" } />

And now we have structure two that has two keys, firstName and age.

<cfset struct2 = { firstName = "Michael", age = 33 } />

Using a nifty ColdFusion method we can mash the two together in a single line of code.

<cfset structAppend(struct1, struct2) />

Woah, that was easy! The end result will be a structure that would look like this.

<cfset struct1 = { firstName = "Michael", lastName = "Presley", age = 33 } />

Notice the commented out version. That is the underlying method to do the same thing as StructAppend. The benefit? Nothing I can think of.

Enjoy, and happy coding!

No related posts.

Adobe Community Professional Pins Are In!

Adam Presley — Mon, 26 Jul 2010 21:53:53 +0000

Sweeeet. I got home and on my keyboard is sitting a letter from Liz Frederick at Adobe. I open it up and discover that my nifty magnetic ACP pin is in there, as well as stickers! I love stickers!

No related posts.

Thoughts on the Demise of the CFML Advisory Committee

Adam Presley — Thu, 22 Jul 2010 21:50:08 +0000

Today was a busy news day for me. Most of it just personal stuff, but the story of the day in the world of ColdFusion is the departure of Adobe, or more specifically Adam Lehman, from the CFML Advisory Committee. I say it’s big news, but it seems to me that it will be the big event in ColdFusion history that no one will really know, or care too much about. Sad? Perhaps.

For those who do not know what the CFML Advisory Committee is allow me a brief detour to give the 60-second rundown. The CFML Advisory Committee, as defined by their own website is to “…define what is ‘core’ to the ColdFusion Markup Language, how that core should behave and what is considered ‘extended core’ – what language features useful CFML processors should implement – as well as offering guidelines for vendors to provide extensions to CFML in a consistent manner.” It seems like a noble goal for certain.

For those who might wonder why such a concept would even matter, consider the C++ language. Originally created by one guy in 1979 it gained an enormous amount of popularity. With this popularity and general acceptance by the development community, as well as the growing software industry, comes vendors, developers, and businesses clamoring to get in on the action. Libraries are built, custom extensions to the language, with each one trying to be the next “standard”. Over time you had various flavors or the language, extensions that cause portability issues, all which violated the original intent of the language.

Then in 1998 the ISO standards group (and a few others who’s acronyms I cannot name) finalized a standards document detailing how the language should behave, the semantics of code, and what libraries would come standard with the language.

This is the idea behind CFML Advisory Committee. Standardize the CFML language. Ensure that regardless of the vendor certain behaviors and language elements will be present and accounted for. An idea that, from the day I heard about it, I have agreed with. This is good for ColdFusion.

It would seem that the committee will not be able to achieve its goal. Blame politics, corporate agenda, or even personality conflicts, the end result remains the same. We are back to Adobe defining how the language will work, and the other vendors follow suit.

This is not necessarily a bad thing entirely. I won’t go on the record and state it’s a good thing entirely either. But it does raise some interesting questions in my mind, especially for me.

In his post Adam Lehman states “…the ColdFusion ACPs will be the CFML Advisory Panel for ColdFusion X and beyond.” As I am an Adobe ColdFusion ACP I certainly appreciate being able to provide my feedback to Adobe regarding the direction of the language.

Being in the ACP program, however, presents an interesting challenge. Adobe generally does not see fit to share information about the direction of the ColdFusion language to the general populous, and as an ACP I am under NDA for a good number of things. If Adobe were to formalize our role in the feedback process I wonder how much tighter the NDA becomes. Should that happen how limiting will my discussions with individuals involved in open source CFML be? Is that good for the ColdFusion language, such restrictions, or is it better perhaps to encourage open communication and solicit valuable feedback from the very community that supports your product?

Whatever the case I will continue supporting the ColdFusion community, it’s members, the language, and my desire to spread the nerdy love. To all I say happy coding!

No related posts.

SES URLs With Mura on Tomcat

Adam Presley — Fri, 02 Jul 2010 23:08:58 +0000

Tonight as I’m setting up a new server I wanted to make sure I had URL rewrite ability. Normally this is no issue as I use Apache for most anything web server related. However this time I am setting up a Mura site on Railo running on Tomcat. And yes, I’m using Tomcat for both my Java Servlet engine and my web server. As such I wanted to ensure I have “pretty URLs” for my Mura-based application. In this post I will attempt to show you how to set that up.

At this point I am going to assume you have a running Tomcat and Mura application. The first thing we need to do is download Paul Tuckey’s excellent UrlRewriteFilter Java filter. This can be located at http://www.tuckey.org/urlrewrite/. The version I downloaded as of this writing is 3.2.0. Once downloaded you can extract the contents anywhere you wish to keep it. You will notice there isn’t much there… in fact at the top level there is only a folder named WEB-INF. Opening that folder doesn’t reveal much more.

If you have Tomcat running you’ll need to stop it temporarily for this next part. After stopping Tomcat, copy the file /WEB-INF/lib/urlrewrite-3.2.0.jar into your lib folder, found at {TOMCAT}/lib, where {TOMCAT} is the folder where you have placed your Tomcat installation. By copying this JAR file there you are making the URL re-writer filter available to all Java applications running in your Tomcat instance.

The next phase is to setup Railo (yes, you can do this in Adobe CF as well) to use this Java re-writer filter. Where you do this varies based on how you have setup your Railo application, but I have my Railo files extracted in my Mura application’s web root directory. So in my main Mura directory I have a WEB-INF folder containing the entire Railo library.

If you open up that WEB-INF folder there should be a web.xml file. Open this file in your favorite text editor. Near the top, after the node and before the nodes paste the following XML.

	
	>
		>UrlRewriteFilter>
		>org.tuckey.web.filters.urlrewrite.UrlRewriteFilter>
		>
			 >logLevel>
			 >WARN>
		>
	>
	>
		>UrlRewriteFilter>
		>CFMLServlet>
	>

This block of XML tells Tomcat, when loading your application, to install this URL re-write filter, and to map any requests that come through the CFMLServlet to it. Basically that means that any CFM or CFC requests will go through the filter.

The next part of this same file that must be altered is the servlet mappings to allow paths after “index.cfm”. This allows Mura to execute requests like “/index.cfm/contact-us/”. To do this find the following block of XML:

	>
		>CFMLServlet>
		>*.cfm>
	>

Once you find this, you want to insert this next block of XML right after it.

	>
		>CFMLServlet>
		>/index.cfm/*>
	>

Now we are ready to configure the re-writer filter to forward our “pretty” SES URLs to index.cfm! In the extracted files there is a file named urlrewrite.xml. Copy this file into the same folder as your Railo web.xml file that we just got done modifying. Now open it up. Fortunately this file is pretty well documented, and the online docs have even more information! For the moment, though, we just want to make sure that all of our SES URLs go to the right place. The other concern here is to also ensure that when we go to Mura’s administrator, the URLs DO NOT get forwarded to index.cfm. So, with a little bit of regular expression magic, we can make UrlRewriteFilter do this.

 version="1.0" encoding="utf-8"?>

 

>
	>
		>
			Makes all requests forward to /index.cfm/whatever-came-next
			Ignores admin URLs so the admin still works correctly for Mura.
		>
		>^/(?!admin|plugins|js|css|assets|images|tasks|railo-context|flex2gateway|wysiwyg)(.*)$>
		>/index.cfm/$1>
	>
>

Ok, super. The final phase is to tell Mura that we wish to make our URL’s pretty! To do this, start Tomcat back up, then log into your Mura administrator and browse to File Manager -> Application Root and click on the folder config. In this folder there is a file named settings.ini.cfm. Click on the pencil icon to the right of the file name to edit it. Once inside we are looking for two settings: siteidinurls and indexfileinurls. These settings should both be set to zero (0). Once you save those changes make sure to click on Reload Application.

And with that you should be able to browse to your Mura site without the crazy question marks or index.cfm in the URL. But if you are in the administrator you should still have all the question marks so it behaves as expected.

I hope this helped somebody out there. Cheers, and happy coding!

No related posts.

How To Get the Server Name Running Your ColdFusion Page

Adam Presley — Wed, 05 May 2010 16:46:44 +0000

ColdFusion is a great language in its own right. What makes it even more awesome? The fact that it is a Java application. Why is this cool? Because you can dig into Java to do all the dirty stuff ColdFusion shields you from, should you desire to do so.

While writing this profiling code this last week I had the need to get information specific to the server executing my ColdFusion code. The first bit of information I need is the host name, or the proper name of the server running ColdFusion. Java to the rescue! The Java package java.net contains what we need to do this.

<cfset inet = createObject("java", "java.net.InetAddress") />
<cfset hostName = inet.getLocalHost().getHostName() />
 
<cfoutput>This computer's name is #hostName#cfoutput>

The other piece of information I needed was something to identify the instance of ColdFusion I was running on in a multi-instance environment. I’m betting the way I did this could be done better, but for now it is doing the job. By default ColdFusion installs JRun as the J2EE server that runs ColdFusion as a Java application. As such I was able to delve into the Java classes provided by JRun to get the JNDI port number, which is of course unique per instance.

The code below shows how to do that. Also note I have a try/catch around that code, and in the catch I am trying to create a different object of type org.apache.catalina.ServerFactory. This is because my co-workers are running JRun, and I am running Tomcat, and that object is what get’s me a server class from Tomcat, which in turn can give me the port Tomcat listens on for the shutdown command.


<cftry>
	<cfset j2eeService = createObject("java", "jrun.naming.NamingService") />
 
<cfcatch>
	<cfset j2eeService = createObject("java", "org.apache.catalina.ServerFactory").getServer() />
cfcatch>
cftry>
 
<cfset port = j2eeService.getPort() />
 
<cfoutput>This instance is running against port #port#cfoutput>

And this, ladies and gentlemen, is why ColdFusion rocks! Happy coding!