Wayne Graham's Blog - ColdFusion

Facebook Developer API

Tue, 18 Mar 2008 08:59:00 -0500

It's been a long while since I posted anything here. Things have been a bit hectic with the launching of a new institutional repository service (using DSpace), taking a computer graphics course (linear algebra, ray tracing, scientific visualization, etc.), and finishing up my book on the Facebook API. This is the first book I've written and I have to admit it was far more of a task than I had first thought it would be. Not that the subject matter was very dense, but there were at least four major changes in the API that required an almost total rewrite of the code base for the examples. There were even a couple of sections that had to get cut because Facebook "fixed" their code because of security and user concerns (plus a lot of folks "abuse" some of the things you could do with the API). There are some great Coldfusion resources for building Facebook applications in ColdFusion. The "un-official" ColdFusion client library for Facebook apps is at nearpersonal. There is also a RIAForge starter project for FBML (FBML is a tag based language for Facebook) named Facebook FBML Starter Kit. So, if you're wanting a short book that highlights some of the more common elements of developing Facebook applications, be sure to check out my book!

SolColdfusion Update

Wed, 31 Oct 2007 13:01:00 -0500

I've been knocked out by a really bad cold the last couple of weeks and I'm just starting to get things back to normal. I did want to send a quick post on the status of the SolColdfusion project. After seeing Ray's Seeker project, it reminded me that I hadn't set up a project at RIAForge yet, so I took care of that last night. You can now access the official project at http://solcoldfusion.riaforge.org/. Since the project site is up-and-running, I also submitted it to the Solr project SOLR-404 (I know it's a coincidence that it's number 404, but it makes me wonder if it's some type of bad omen ;) ...). Anyway, if you think the client should get included in the project, be sure to vote for it! I've also been working on a generic interface, much like Erik Hatcher's Solr Flare. It's been a bit slow coming as I've not had a lot of time to work on these projects, but hopefully things will settle down shortly so I can devote a bit more time to them.

Solr Schema

Fri, 05 Oct 2007 13:27:00 -0500

If you've ever worked on a project that involved Coldfusion's bundled version of Verity, you've no doubt run into the issue of trying to confine your fields into the structure that Verity imposes, and those custom fields are really precious in these instances. About 6 months ago, I ran into an issue with a search project where I had about 125,000 documents to index. Since we also wanted to be able to use the indexes for some other projects, I was a bit nervous to commit almost the entire allotment of indexable objects to one collection. This launched me into writing a custom search engine and indexer using Lucene and slapping Coldfusion around the responses to do things that Verity did. However, once the projects were complete, I never really got around to making it easy to use. It does cool stuff like search across multiple collections, context highlighting, relevancy calculations, term vector calculations, "did you mean", etc. Essentially everything I think all good search engines need to be able to do. Something this system lacked was an easy way to define the fields that you wanted indexed (along with a knowledge of Java to actually make the changes). The ability to create any number of fields to index in different ways (along with faceting) is a real strong point of Solr. Not only can you add fields and choose how that data is analyzed, you can create your own field types that process the information in your index the way you want them to be. This is done in the $SOLR_HOME/config/schema.xml file. The first section (<types>) defines the types of fields that you will be using, and how Solr should process them with Lucene. If you look at some of the fieldtypes, you'll get an idea of what's possible. For instance, the fieldtype for "string" is an untokenized field that doesn't normalize the fields and sorts missing information last.

However, if you need a more robust fieldtype, look at the fieldtype for "text". This uses a whitespace tokenizer (splits words with whitespace) and uses the stopwords defined in the stopwords.txt file. It does some other processing (filters words, converts them to lowercase, runs a porter stemmer, and then removes duplicates). This fieldtype also defines what to do when a query is passed to it (uses the same filters). This is slightly different than the defined "textTight" which does not perform any further analysis on the text when being queried. You'll probably find that most of these work for most instances, but if you need to, you can build your own fieldtype that has very specific indexing and query filters. The next section contains the actual fields you want to use in the aptly named "fields" element. This is where you actually define the fields that will be in your index, the type of analysis to perform on the field, if it should be indexed, stored, have term vectors, or be multivalued (have multiple instances of the same field in the index). Let's say you're wanting to develop an indexing schema for books (hey, I work in a library). At a very basic level, you'd want a field for an id, title, author, reviews, and a set of topics (or tags). Your fields element would contain something along the lines of:

You'll notice that I have a couple of extra fields for title, author, and topic, these are for the faceting info and are just untokenized fields to make the calculations for facets a little more efficient. Now, we're almost done with creating the schema. We just need to declare a unique key, default search field, and default search operator.


id
title

Remember when I made the fields with the "Str" suffix? We can use a really cool feature of Solr called a "copyField" that literally copies the information from one field to another.

It's worth mentioning here that Solr indexes are not databases! While there are some similarities in the way that Solr allows you to add, update, select, store, and delete information from the index, Solr isn't an RDBMS. I've seen a few discussions where there is some confusion as to why Solr can't do the equivalent of a stored procedure, or some other function of a database. Now, your index server is ready to receive documents to search against. The server, in with the above example as the schema, will expect information to be in the following format:



	1
	Solr Rocks!
	Barr, Foo
	This book rocks!
	This book is horrible!
	information retrieval systems
	xml
	search
	apache foundation

Next week when I get some time, I'll write about creating facet queries...

Solr and Coldfusion -- Setting Up

Fri, 05 Oct 2007 12:22:00 -0500

To get up and running with Solr, you'll need some type of Servlet container. Typically when folks start talking about servlet containers, they're talking about Tomcat or Jetty. In fact, Solr comes with Jetty 6.1.3 (they haven't upgraded to 6.1.5 yet in the distribution). You may also hear about Resin, but in my experience, it runs a bit slower than Jetty and Tomcat. As a small note, servlet containers are different than J2EE application servers like JRun, Geronimo, GlassFish, and JBoss (which use servlet containers like Tomcat and Jetty, but also have EJB containers and can handle other types of logic). If you have a J2EE application server running, you can easily use Solr, and if not, consider using Jetty or Tomcat as your container server. Since your environment can be as varied as there are IT departments, I won't try to cover everything. Essentially you need to have at least the Java 1.5 JRE. However, I would strongly suggest the most current Java JDK (and not the JRE) as it has performance enhancements to run in server mode (with -server). If you don't already have this Java version installed on your server (assuming this is the same server running CF), don't worry, ColdFusion will still work if you install the required Java runtime. Essentially the process for deploying Solr, once you have a servlet container up-and-running is to drop the solr.war file into the webapps directory on the server. It won't do anything at this point as you need to set the configuration files for Solr. The easiest way to do this is copy the files from example/solr into a new directory (which I will refer to now as solr_home). You can tell Java about the home directory by setting the solr.solr.home (-Dsolr.sol.home), set the JNDI lookup ("java:comp/env/solr/home"), or just throw it into the JVM's working directory (the default path is ./solr). Now you just need to make sure everything is running. Just point your browser to http://<server>:<port>/solr/admin. You should then see the administration interface (you may need to restart your servlet container to get everything working properly), but it's not an administrative interface like you get in CFAdmin. This is more of an informational administration panel. You can make sure everything is running, that there are documents in your index is set up properly, check out the schema and configuration files, and thread information. Really the only thing you can administer here is the log level. For some more specific notes on intalling Solr in Tomcat and Jetty, check out Solr's wiki. In particular, if you're going to need multiple instances of Solr to run, pay attention to the sections on Multipe Solr apps on those wiki pages.

Coldfusion Solr Client - SolColdfusion

Thu, 04 Oct 2007 15:19:00 -0500

As I hinted at yesterday, I was close to having some code in the pipeline to abstract using Solr. I've finished the initial code with the following built in. Here's a brief setup guide to start playing with the code. First, you're going to need to grab the latest release version of Solr (currently 1.2). The only real requirement to run this software is that you have a JRE of 1.5 or higher. Untar/zip the file somewhere convenient and open a command prompt. Get to the example directory in the apache-solr.1.2.x folder (cd /example). To start up the sample server running Jetty, just issue the following command:


java -jar start.jar

This will start a new instance of the Solr server on your computer on port 8983. You can make sure this is running by navigating to http://localhost:8983/solr (NOTE: this is a link to your computer. If you get an error, it's because your computer isn't running an instance of Solr on port 8983). At this point, it's probably good to send you over to the Solr website to take a look at their tutorial. Go ahead. I'll wait... ... Great, you're back. You've seen some basic inserting, deleting, and querying of Solr index data. You may have also noticed that there are clients for PHP, Ruby, Python, and Java...no ColdFusion. I want to do a little more testing on this before I submit the patch, but I've added the initial code as an encosure here to do updating, deleting, and searching in Coldfusion. The CFC SolColdfusion should be in the path org/apache/client (at least that's where I'm putting in for the purposes of this initial demonstration). The initialization takes one required parameter (the Solr host) and then has two optional parameters (port and path). To set this up, create an instance with

Now, there are a lot of different parameters you can send to Solr to perform different queries. And, since some of these key names can repeat, I chose to implement sending these parameters as an array. So, let's set this up.

These parameters are basically what are the defaults that Solr will return back to you. If you want highlighting, you would need to add two additional row vectors with 'hl = on' and 'hl.fl = '. Searching is straight forward, taking a query, the start row, number of rows to return, and the array of parameters:

This searches all fields and all content and returns back an XML document with the search results in it.

In the result node, you'll see that Solr returns an xmlAttribute of numFound of 0 (assuming you don't have anything in the index). Let's add an example document from the documents that come with Solr.





  F8V7067-APL-KIT
  Belkin Mobile Power Cord for iPod w/ Dock
  Belkin
  electronics
  connector
  car power adapter, white
  4
  19.95
  1
  false

You'll notice I used a commit and optmize statement. Neither of these statements are necessary every time you add a document, but be aware that Solr caches documents and won't flush the new documents to disk unless you either commit the documents or the mergefactor setting you used in your solrconfig.xml file has been reached. Now, let's delete this document...

Don't forget to commit deletions to the index! There'll be more soon (add multiple documents, delete by queries). In the mean time, try it out. If you have any comments, questions, concerns, whatever, let me know.

ColdFusion and Solr

Wed, 03 Oct 2007 15:38:00 -0500

I've spent the last few months working on some projects that didn't really have anything to do with ColdFusion (lots of Java and PHP). One of the projects I've been working with (Vufind.org) uses Solr as it's indexing/search engine. That's starting to get picked up by some pretty big companies (Netflix just relaunched their search using Solr this week). I've been working with Solr in Java for a bit now, and I wanted to start to build an interface for using it as a search engine (my Lucene code is stuck in open source limbo) in Coldfusion. One of the cool things about Solr is that it returns results back through HTTP (in XML, JSON, or ruby). As soon as I get the code finished, I'll post it as a patch in Solr.

ColdFusion and Lucene

Tue, 08 May 2007 11:27:00 -0500

It seems that every couple of years someone has need for some aspect of an information retrieval (IR) system with features that ColdFusion's bundled Verity IR doesn't have (see cflucene and Aaron Johnson's blog). I too ran into a situation that called for investigating alternatives to Verity. Our Special Collections Research Center has used 3x5 index cards to catalog their archives and manuscript collections. There are myriad problems with a hard-copy index catalog (that's why we use computers right?), so we started a process of scanning the cards and running them through OCR software (we're using ABBYY). My original thought was just to dump these all in a location and index them with Verity. All was going well until I realized we had a little more than 110,000 of these individual files which was pushing the 150,000 document limit for our version of ColdFusion. I also knew that there were some other projects to digitize back-issues of student newspapers that would push this document count higher. We had a few choices to make, upgrade our current license to the Enterprise Edition which has a 250,000 document limit, purchase a Google Search Appliance, or find a relatively easy-to-implement IR engine. Each had its own pros and cons, and we initially leaned toward purchasing the Enterprise license. I also have a forthcoming project (hopefully) that will take traditional structured data and pair it with unstructured data reports. For that, I need something that is capable of indexing pretty much anything. However, as funding in academic libraries is challenging at times, I started poking around with Lucene. I remembered that a few years ago, Macromedia had released some code called lindex in its DRK 3. I found the CD and tried it out. I noticed that it was built on the 1.2 release of Lucene and used an old version of PDFBox to extract text from PDFs. Since there have been some significant improvements to Lucene since version 1.2 (the most current version is 2.1), I thought I would try replacing the lucene-core jar file with the more recent one, but that just led to a heap of problems. I kept looking around, but most of the projects out there haven't kept their code up to date with Lucene, so I figured I'd start playing around with it. I'll be doing a series of posts on indexing, implementing different parts of not only Lucene and some of its contributed modules, but some third party software to help create thematic categories in the search results (http://demo.carrot2.org/demo-stable/main) and index management using ColdFusion. For the time being, here's a demo of the search engine I'm working on. It is an index of William and Mary's student newspaper, The Flat Hat, from 1939 to 1950.

Her Royal Majesty

Mon, 30 Apr 2007 08:30:00 -0500

Ok, it's been a while. I've been working on some non-ColdFusion projects so I've been a bit remiss in keeping things up-to-date here. But big news (at least for William and Mary). Her Royal Majesty, Queen Elizabeth II will be visiting William and Mary this Friday as part Jamestown's 400th anniversary. Normally this wouldn't be related to ColdFusion at all, but last week it was announced that she would be coming here and thus ensued a mad rush to get an online exhibit of the Queen's 1957 visit up that would make available pretty much everything we have stored in our Special Collections from her previous visit. I got to use Model-Glue after a long time of not looking at it. I had almost forgotten how painless Model-Glue makes putting projects like this together. I just wanted to give a big thanks to Joe Rinehart and Doug Hughes for bringing the "rapid" back into rapid application development!

Adding COinS for BlogCFC

Wed, 07 Mar 2007 08:24:00 -0500

A few months ago, I was up at George Mason's Center for History and New Media talking to them about how they were approaching their online projects. One of the things they introduced me to was Zotero, a Firefox extension to "collect, manage, and cite your research sources." While it was mostly developed to help researchers manage citations online, I started using it to start organize blog entries, adding my own notes, tags, and relating them to other blog entries. Unfortunately, I've been adding these pages manually. And, with about two lines of code, you can add meta-data to not only open your entries in BlogCFC up to Zotero, but other harvesters. First, a quick note about COinS. COinS is an acronymn for ContextObjects in Spans), it's basically a micro-format for embedding bibliographic information in HTML for the NISO OpenURL Standard Z39.88-2004. What makes this really nice is that you no longer have to hunt down how to cite information for your specific format (Chicago, APA, etc.), the information is embedded in the HTML and software then properly formats the citations for you. A blog entry is a reasonably straight-forward citation. You want the URL, title of the entry, the author, and date. So, to add to BlogCFC, open the index.cfm page and where the loop for the categories is located (around line 82), simply add a new String of the categories:


	
		
		#categories[currentRow][catid]#,

Now, you just need to add the span. I added mine directly under the close of the above loop.

You'll notice there's nothing in the span, so it doesn't actually display on the screen, but is there for OpenURL aware programs like Zotero. If you refresh your cache, you'll then see a button in the address bar (assuming Zotero is installed) that will then add the blog entry to your collection. Not using BlogCFC? There's a few WordPress plugins too, though I've not seen anything for Blogger yet.

MS Access via JDBC

Fri, 02 Feb 2007 15:23:00 -0500

We recently made the move from an IIS Windows web server to an Apache *nix based web server as part of our efforts to consolidate our library's server infrastructure. And for reasons I won't expound upon, we had one MS Access DSN that didn't get migrated to MSSQL and that needed to be used still. Since ColdFusion uses a Windows only driver for MS Access, I needed to figure out a way around this. I found a couple of JDBC drivers for Access (Easysoft's JDBC-ODBC Bridge and HXTT's Access Pure Java JDBC Drivers), but these seemed to be a bit on the expensive side for the short amount of time that I'd need to keep Access in production. I did notice on Easysoft's website that they were using the JdbcOdbc bridge, so after a little bit more digging, I found the syntax to use configure ColdFusion to use MS Access through the JdbcOdbc Bridge; the JDBC URL is


	jdbc:odbc:Driver={Microsoft Access Driver (*.mdb)};DBQ=/path/to/datasource.mdb;DriverID22;

and the Driver Class


	sun.jdbc.odbc.JdbcOdbcDriver

For the very basic inserting of data from a seldom-used web form into a single table, this band aid fix has been doing pretty good!

Form Validation

Thu, 21 Sep 2006 09:17:00 -0500

I've been playing with some form validation stuff for CF. I had been usign , but I wanted the HTML interface to act a bit more like the Flash interface, but I don't really want to use Flash. I've also been doing a lot more work with some of the DHTML libraries that AJAX has made popular, so I figured there had to be a relatively elegent way to do form validations with something like Ajaxian about easy form validation and decided to give it a try. The article on Dexagogo shows how they created a library to handle form-validations that doesn't require any other work than creating a form. This was just what I was looking for! Basically, you just need the latest files from script.aclo.us with the latest prototype version (the 1.5 release candidate is included in the latest script.aculo.us lib folder), and the validation library. Convienently, they're all included in the demo file on the site. To use this, you really only need prototype and the validation library (script.aculo.us adds a nice effect – much like the Flash format in cfform). For me, I made these calls:

This is slightly different than the example on their page; they load the effects.js file directly, I'm calling the library via script.aculo.us with the load parameter. This isn't really a big deal for one library, but it is convenient when you want to use several, but not all, of the libraries (e.g. scriptaculous.js?load=effects,dragdrop,slider). Anyway, to actually use this, you need to create a form with an id attribute:

...

Now, we add some fields and use the class attribute to call the validator:


Name: 

Email:

There are 11 options for use in the validation library (this is directly off their page):

required (not blank)
validate-number (a valid number)
validate-digits (digits only)
validate-alpha (letters only)
validate-alphanum (only letters and numbers)
validate-date (a valid date value)
validate-email (a valid email address)
validate-url (a valid URL)
validate-date-au (a date formatted as; dd/mm/yyyy)
validate-currency-dollar (a valid dollar value)
validate-one-required (At least one textbox/radio element must be selected in a group)

This is really nice, because if you want to allow an optional field, but validate it, you can do:

There's one more piece of the pie...to call the validation library. At the bottom of your page add:

The first argument is the id attribute of the form you're wanting to validate. The second tells the Validator object what to do. This particular example enables validation on each field as you leave it (which I find useful). Some of the other options are:

stopOnFirst (boolean): Stop on the first validation failure; default: false
onSubmit (boolean): Override the default behavior of adding an even listener to the onsubmit event (set to false if you want to make sure your onsubmit method gets called no matter what); default: true
immediate (boolean): validate when the cursor leaves the field; default: false
focusOnError (boolean): place the focus on the first field with an error; default: true
useTitles (boolean): make field validators use form element title attributes as error advice message; default: false
onFormValidate (string function): call a function when the form is validated
onElementValidate (string function): call a function when an element is validated

What I thought was really cool was the ability to add custom validation types via an API. Say you only want folks to use capital letters for their names, you simply add a new validation type like:

Want to add several? You can do that too:

This should be all of the normal items included in (plus a couple extra for good measure). Now the only thing left is to make it look pretty. One of the nice things about the Flash format in is that it color codes required fields with the different halo effects. To obtain a similar effect in the forms, we'll use style sheets instead. This is a rather light stylesheet, but it'll give you something to start with (based on the default haloGreen skin):


 input.required, textarea.required {
	border: 1px solid #ffbf2b;
 }
 input.validation-failed, textarea.validation-failed{
	border: 1px solid #ff3300;
	color: #ff3300;
 }
 input.validation-passed, textarea.validation-passed{
	border: 1px solid #00cc00;
	color: #000;
 }
 .validation-advice {
	margin: 5px 0;
	padding: 5px;
	background-color: #FF3300;
	color: #fff;
	font-weight: bold;
}
.custom-advice {
	margin: 5px 0;
	padding: 5px;
	background-color: #c8aa00;
	color: #fff;
	font-weight:bold;
}

I made a short example of some of the validations at http://swem.wm.edu/blogs/waynegraham/examples/validation/. I have to say that I've found this to be a bit better solution (at least for my needs) than using !

Real Life XSLT 2.0 transformations

Wed, 23 Aug 2006 11:56:00 -0500

I ran into a bit of a situation that was really blowing my mind. I have a rather large XML file (around 20,000+ lines) marked up in TEI that I wanted to do some transformations on (a day book and ledger from the 1850s). Essentially the code follows the format


...

	Page 12
	



	Williamsburg,
	1850,



		
			OctrOctober 3th 1850
		
		
			Doctr S S Griffin
		 
		  
	
	...

	

...

What I wanted to accomplish was group all this together in separate divs for HTML output (ok, I actually need to write each page to its own file, but this is pretty much just one more step). I just could not find a way to group this info this way using XSLT 1 without wrapping each page within its own div structure. I didn't really want to go back and do this, so I asked the TEI-L list. David Sewell pinged me back with some XQuery code that recursively recalls the document structure for a given node. He also mentioned that it would be pretty easy to write an XSLT 2 transformation that groups these nodes together. I did a little bit of digging and came up with

This transformed the pages to what I was wanting



	
	
	Williamsburg, 1850,
	
	
		
			
			Oct^rOctober 3^th 1850
		
		
			
	...



The XSLT processor for ColdFusion doesn't support XSLT 2.0 (it's still a draft spec). However, Saxon does (specifically Saxon 8). For more on doing XSLT transformations, see XSLT 2.0 in ColdFusion.


Getting XML from MSSQL Server
Mon, 21 Aug 2006 11:49:00 -0500
I've been playing with all the AJAX stuff that's been coming out lately. I suppose that like a lot of folks, I was creating a query, then having a generic function that created the XML in a proxy file for the JavaScript (Ray Camden has a really nice function for transforming a query to XML). 

Last week I was doing some research to find a way to do some XML searching and stumbled upon the FOR XML statement. I knew that most RDBMSs were capable of dealing with XML record sets, but it's been years since I've even looked at any of the XML stuff for MSSQL. 

The FOR XML statement returns a query result and transforms rows into XML elements. There are three arguments that this can take:


	RAW: Transforms each row into an element with a generic identifier (<row/>) as the element tag.
	AUTO: Returns the results in a simple nested XML tree
	EXPLICIT: Allows you to define the XML tree returned

				 [More]


MG Unity
Fri, 23 Jun 2006 14:27:00 -0500
It's been a while since I've written on this blog...I'm attempting to keep this one on CF. Anyway, MG Unity has come out and I have to admit that I'm REALLY glad it has. 

I've been working on a project with five academics from four different institutions looking at the vernacular architecture of the Colonial Chesapeake to 1720 for an article in the William and Mary Quarterly for the 2007 celebration of Jamestown. The objective was to write an scholarly article that looks at everything that has been excavated and see if the arguments of past scholars still hold. Not only were the scholars looking at individual sites as an aggregate, but wanted to track changes to the structures over time (additions, fireplaces, cellars, etc.). 

I knew this was going to be a challenging project from the beginning, so I attempted to set the expectations early for the application development cycle. I thought it a fluke that I actually got them all to aggree on a set of important fields and tables before I started coding anything (a first for me). However, as I got into the project a bit more, requests for additional fields here, moving this data to this table, all while attempting to support constant input into the application got to be a bit more than was really feasible for a "spare-time" project. 

I had set out to use as good of coding practices as I could. Each table had its own DAO, gateway, TOs, validators, etc. However, each change to these fields made me keep mucking around in these files and the forms calling the objects. After a while of making constant changes, I fell back on some old "bad" practices and kind of strong-armed some of the solution with spaghetti code...and I hated myself for it because I knew that I would have to come back at a later date to fix it.

About this time Joe started doing some work with Arf! And Doug Hughes started work on Reactor. I continued to code in my bad style, but since I knew what I had done, I just kept doing it.

After the project members presented their paper, I set the project down for a while since my daughter had just been born. Since Joe brought out Unity, I decided now was as good a time as any to pick up the refactoring of the project. 

All I can say is that what I've done in half-a-day with Unity would take me three- to four-times longer my old way. The scaffolds (once I figured out how they were working) have been an absolute godsend for the rather complex relationships between phases of construction and the overall archaeological and architectural record. The Reactor syntax is so easy (especially since ColdSpring seperates all the configuration) that everything just clicks. 

The entire framework is just so intuitive (at least compared to my previous experiences with frameworks). The ability to not have to worry any more about building the basic web pages, forms, CRUD, and displays makes Unity a pleasure. Also, changes will be a breeze compared to what they entailed a couple of months ago, which will allow me to do some of the cool stuff I had planned with Google Maps and Google Earth to map out the locations of these archeaological/historical sites!


Copyright and Intellectual Property
Tue, 17 Jan 2006 12:52:00 -0500
Recently there has been a lot of noise about Ray Camden's BlogCFC being re-branded and redistributed without attribution (really the only thing he actually asks for in his documentation). This has been an issue I've been wrestling with on a couple of projects here at the College as we continue to move toward digitizing different collections.

The first issue to deal with is the idea of copyright. There are specific criteria a work must show to qualify for copyright status (taken from http://fairuse.stanford.edu/Copyright_and_Fair_Use_Overview/chapter0/0-a.html#1).


The work must be "fixed in a tangible medium of expression"
The work must be original (e.g. independently created by the author). On this point, "it doesn't matter if an author's creation is similar to existing works, or even if it is arguably lacking in quality, ingenuity or aesthetic merit" 
The work must be the result of at least some creative effort on the part of its author.


An additional point to make is the fact that since 1989, a copyright notice has not been necessary to hold the copyright of pretty much anything you create (called the Berne copyright convention). While you hold copyright as soon as the work is created, you must register the copyright in order to bring suite (http://www.fplc.edu/tfield/copynet.htm#aut). In registering copyright for most websites and software, you would actually apply "literary works" as they are compilations of ideas (see  http://www.copyright.gov/circs/circ1.html#wwp).  

I really like Brad Templeton's explanation in 10 Big Myths about copyright explained  (though there are 11) summarizes copyright issues, it's definitely worth the read. Templeton also points out that the Digital Millennium Rights Act (DMRA) gave some real teeth to copyright law.

Stanford University Libraries has a great guide to Copyright and Faire Use with a lot of great resources, including a very interesting point about automatic copyright. Once someone has copied your work, your copyright is no longer automatic. It's then up to you to convince a Federal Judge that you are the copyright owner.

While the offending party has removed his bundle of software, I think it important to remember what copyrighted material is, and how not to use it when given a reasonably open license to do what you want with the software. So, if you want to show Ray (Camden) some love, check out his Amazon Wish List.