Creating Ruby-Inspired Modules In ColdFusion

<cfscript>

component
	output = false
	hint = "I provide simple publish + subscribe module features."
	{


	// Each event type will have any number of subscriptions associated
	// with it. Each subscription will be characterized as a type and a
	// function callback.
	eventTypes = {};


	// ---
	// PUBLIC METHODS.
	// ---


	// I remove the subscription from the given even type.
	public any function off(
		required string eventType,
		required any eventHandler
		) {

		// If the event type doesn't exist, nothing else to do.
		if ( ! structKeyExists( eventTypes, eventType ) ) {

			return( this );

		}

		var filteredSubscriptions = [];

		// Copy over all of the subscriptions that do not match the
		// given event handler.
		for ( var subscription in eventTypes[ eventType ] ) {

			if ( isSameHandler( subscription.handler, eventHandler ) ) {

				continue;

			}

			arrayAppend( filteredSubscriptions, subscription );

		}

		// Persist the filtered subscription collection.
		eventTypes[ eventType ] = filteredSubscriptions;

		// Return the reference to the consumer of the module.
		return( this );

	}


	// I set up the subscription to the given event type.
	public any function on(
		required string eventType,
		required any eventHandler
		) {

		// Make sure that we have a subscription channel for the given
		// event type. Currently, event types are completely arbitrary.
		if ( ! structKeyExists( eventTypes, eventType ) ) {

			eventTypes[ eventType ] = [];

		}

		// Add the subscription.
		arrayAppend(
			eventTypes[ eventType ],
			{
				type = eventType,
				handler = eventHandler,
				uuid = getEventHandlerID( eventHandler )
			}
		);

		// Return the reference to the consumer of the module.
		return( this );

	}


	// ---
	// PRIVATE METHODS.
	// ---


	// I param a module-based UUID for the event handler meta data
	// such that different handlers can be compared for equality. This
	// data is persisted in the function's meta data.
	private string function getEventHandlerID( required any eventHandler ) {

		var uuidKey = "pubsub-id";
		var metaData = getMetaData( eventHandler );

		if ( ! structKeyExists( metaData, uuidKey ) ) {

			metaData[ uuidKey ] = createUUID();

		}

		return( metaData[ uuidKey ] );

	}


	// I determine if the two event handlers are the same.
	private boolean function isSameHandler(
		required any eventHandlerA,
		required any eventHandlerB
		) {

		var uuidA = getEventHandlerID( eventHandlerA );
		var uuidB = getEventHandlerID( eventHandlerB );

		return( uuidA == uuidB );

	}


	// I trigger the given event on the given channel.
	private void function trigger( required string eventType ) {

		// If there are no bindings on this channel, there is nothing
		// more that we need to do.
		if ( ! structKeyExists( eventTypes, eventType ) ) {

			return;

		}

		// Invoke each handler with same argument collection. This
		// way, the event can be triggered with multiple arguments.
		for ( var subscription in eventTypes[ eventType ] ) {

			subscription.handler( argumentCollection = arguments );

		}

	}


}

</cfscript>

<cfscript>

component
	output = false
	accessors = true
	hint = "I model a Friend with evented setters."
	{


	// Define the properties for accessor generation.
	property name="name" type="string";


	// Include the PubSub behaviors, on(), off(), trigger().
	include "PubSub.cfc";


	// I initialize the component with the given default values.
	public any function init( required string initialName ) {

		name = initialName;

		return( this );

	}


	// ---
	// PUBLIC METHODS.
	// ---


	// Set the new name - triggers "nameChanged" event.
	public any function setName( required string newName ) {

		var oldName = name;

		name = newName;

		// Announce the name-change event to all callback handlers
		// that have asked to subscribe.
		trigger( "nameChanged", newName, oldName );

		return( this );

	}


}

</cfscript>

<cfscript>


	// Define one name-change handler.
	function nameChangeHandler( eventType, newName, oldName ) {

		writeOutput( "[1] Name Changed: " & oldName & " to " & newName );
		writeOutput( "<br />" );

	}


	// Define another name-change handler so that we can test to see
	// if the off() method unbinds the correct handler.
	function anotherNameChangeHandler( eventType, newName, oldName ) {

		writeOutput( "[2] Love your new name: " & newName );
		writeOutput( "<br />" );

	}


	// NOTE: In ColdFusion 9, the above event handlers will NOT have
	// access to this page's variables' scope. ColdFusion 9 does not
	// create closures; however, in ColdFusion 10, you CAN create a
	// closure that does keep the proper variables reference.


	// ------------------------------------------------------ //
	// ------------------------------------------------------ //


	// Create our friend instance - this instance includes the PubSub
	// module and should have publicly exposed methods for on() and
	// off() binding and unbind respectively.
	friend = new Friend( "Sarah" );

	writeOutput( "Initial Name: " & friend.getName() & "<br />" );


	// Bind our two event handlers.
	friend.on( "nameChanged", nameChangeHandler );
	friend.on( "nameChanged", anotherNameChangeHandler );

	// Change the name to see that BOTH event handlers are triggered.
	friend.setName( "Tricia" );

	// Unbind one of the event handlers.
	friend.off( "nameChanged", nameChangeHandler );

	// Change the name again to make sure that only ONE of the event
	// handlers is triggered, ensuring that the other event handler
	// was properly unbound via off().
	friend.setName( "Joanna" );


</cfscript>