Turns out when PHP was upgraded, the php.ini file was replaced, and in the new version, it has the production value for html_errors which is Off. Once I set html_errors=On in /etc/php5/apache, colourful HTML-formatted output was producted by Xdebug.

For the Curious reader, I’m using the following xdebug configuration file, which I’ve located in /etc/php5/conf.d/xdebug.ini to prevent any php.ini changes from overwriting my Xdebug directives. Please note that this is a slightly modified version of the default xdebug configuration included in wamp, which I find to be quite nice:

zend_extension="/usr/lib/php5/20090626/xdebug.so"
xdebug.remote_enable=1
xdebug.remote_host="127.0.0.1"
xdebug.remote_port=9000
xdebug.remote_handler="dbgp"
xdebug.remote_mode=req
xdebug.profiler_enable=1
xdebug.profiler_output_dir="/tmp/xprofile/"
xdebug.collect_params=On
xdebug.show_local_vars=On

Before I continue, I should mention that, not only is it impolite, but quite possibly illegal to take the content of a third party site without the owners permission or knowledge.

To accomplish our task we need some open-source tools:

• Zend Framework (Required)
• Quix (Recommended)
• Dojo Toolkit (Recommended)

Our basic strategy is this:

1. Find a target page with some cool content
2. Find the CSS Selector (or X-path) of the element we want to scrape
3. Verify the selector using Dojo
4. Build a Zend_Service object to fetch the cool content to PHP

Step 1: Finding the cool page

Say I am a developer and I really want to get the outward facing IP of the machine that my PHP script is running on. If there is a router or proxy in between my machine and the Internet, this can be non trivial. As a solution I decide to use the service http://www.whatismyip.com/

Step 2: Finding the CSS3 Selector for the element

Its pretty obvious which element we want to get the selector for. If you are feeling clever you can simply read the code or use a DOM inspector to figure out what the query is on your own. However, selectorgaget.com provides a cool tool that will allow you to point and click to determine the appropraite selector. You can get a bookmarklet directly from their site, or you can get the much more powerful Quix bookmarklet which includes the selectorgaget and a bunch of other cool tools.

If you decided on Quix (I know I did), click on the bookmarklet and enter “sg” in the command box. The selectorgaget should load up and as you move your mouse around the screen it should highlight different DOM nodes. We want the top one, so click on the text “Your IP…” and, checking out the path, we see that it is a rather boring h1.

Step 3: Validation via Dojo

I like to validate the path before taking it over to Zend. I use a Dojo and firebug lite bookmarklet which injects a debugging version of dojo into any page via the AOL CDN. To add this bookmarket drag Inject Dojo into your bookmarks toolbar. In the debugging console that pops up, enter dojo.query(‘h1′); and you should see the h1 DOM element being returned.

Step 4: Moving it all to PHP

Now that we have successfully found our CSS3 selector path, we can move over to PHP and come up with a new Zend_Service component. Our approach will be to extend Zend_Service_Abstract, and implement some custom methods to preform the screen scrape.

The finished class looks like this:

class WhatsMyIpService extends Zend_Service_Abstract
{
	/**
	 * The service endpoint.
	 * This is where Zend_Http_Client will navigate
	 * to fill service requests
	 * @var string
	 */
	protected $_endpoint = 'http://whatismyip.com';
 
	/**
	 * handle to the client
	 * @var Zend_Http_Client
	 */
	protected $_client;
 
	public function __construct()
	{
		$this->_client = self::getHttpClient();
	}
 
	/**
	 * Method to get the external IP of the computer / server
	 * script is running on
	 * @return string
	 */
	public function getMyIp()
	{
		//reset the client parameters, set the URL to whatismyip.com
		//and actually preform the request
		$result = $this->_client
			->resetParameters()
			->setUri($this->_endpoint)
			->request(Zend_Http_Client::GET);
 
		//check to make sure that the result isnt a HTTP error
		if($result->isError()){
			throw new Exception('Client returned error: ' . $result->getMessage());
		}
 
		try{
			//setup the query object with the result body (HTML page)
			$query = new Zend_Dom_Query($result->getBody());
 
			$domCollection = $query->query('h1');
		}catch(Zend_Dom_Exception $e){
			throw new Exception('Error Loading Document: ' . $e);
		}
 
		//check to make sure the query return a result
		if($domCollection->count() == 0){
			throw new Exception('Cannot find DOM Element');
		}
 
		//get the titlestring from the nodevalue
		$titleString = (string) $domCollection->current()->nodeValue;
 
		//now we should have the content of h1 stored in the titleString
		//it should read something like "Your IP Address Is: xxx.xxx.xxx.xxx"
 
		//Now we will parse out the IP address using regular expressions
		if (preg_match('/([\d]{1,3}\.[\d]{1,3}\.[\d]{1,3}\.[\d]{1,3})/', $titleString, $matches)) {
			return $matches[1];
		}else{
			throw new Exception('Unable to parse IP from page');
		}
	}
}

I hope that the script is sufficiently commented, but to summarize:

In the constructor, we get an local instance of a Zend_Http_Client object. Clone() is used to prevent any other Zend_Service objects from polluting our client with their own requests.

In the getMyIp() method, we first setup and preform the request (using the fluid interface provided by Zend_Http_Client). Notice how we reset the parameters: In this case its not actually necessary as we aren’t passing any parameters, but it is good habit to get into in case in the future we expand this class to include GET or POST parameter passing.

Next, we examine what the HTTP client has passed back to us. Hopefully, if nothing has gone wrong, it is a HTML string representation of the page at whatismyip.com. Some basic checks are preformed to ensure that no HTTP errors have occurred, and then we instantiate a Zend_Dom_Query object which provides both CSS and Xpath selectors.

Finally, after running the CSS selector query, we check to ensure we got a DOM element back, get its value and parse out the IP using Regular expressions. Its pretty impressive what can be done in <70 lines of code with the Zend Framework.

To run this class, we could create a directory structure as follows:
library <- Includes Zend framework
WhatsMyIpService.php <- The above class
getIp.php <- php file including the following:

set_include_path(implode(PATH_SEPARATOR, array(
    realpath(dirname(__FILE__) . '/library'),
    get_include_path(),
)));
 
/** Zend_Loader_Autoload **/
require_once 'Zend/Loader/Autoloader.php';
Zend_Loader_Autoloader::getInstance()->setFallbackAutoloader(true);
 
$service = new WhatsMyIpService();
echo $service->getMyIp();

The first couple of lines gets the library on the include path, the second block sets up autoloading so we don’t have to manually include files, and the final lines instantiates the class and calls the method.

Of course, this is going to pose problems when creating non-dijit objects, as they will all be created on the page-level scope. The work-around is likely constructing clever eval() strings, and then accessing the objects using unsafeWindow. If anyone comes up with a more elegant solution, let me know about it in the comments.

The following can be used to overwrite the previous version of the user-script, restoring the broken functionality as well as making use of some of the newly introduced Dojo features.

// ==UserScript==
// @name           Dojo Integration Test
// @namespace      test
// @description    Proof Of Concept To Integrate Dojo And Greasemonkey
// @include        *
// ==/UserScript==
 
function startup(){
	dojo = unsafeWindow["dojo"];
	dijit = unsafeWindow["dijit"];
 
	dojo.addClass(dojo.body(), 'tundra');
	dojo.require("dijit.Dialog");
 
	//Don't do anything until "Dijit.Dialog" has been loaded
	dojo.addOnLoad(function(){
		//Actually Create The Dialog
		new dijit.Dialog({
			id: 'test',
			title: "Dojo Integration Test",
			content: 'Dojo lives... In Greasemonkey'
		});
 
		dijit.byId('test').show();
	});
};
 
//include flags to djConfig to tell dojo its being used after its been loaded
unsafeWindow.djConfig = {
	afterOnLoad: true,
	addOnLoad: startup
};
 
//Include Dojo from the AOL CDN
var script = document.createElement('script');
script.src="http://o.aolcdn.com/dojo/1.4/dojo/dojo.xd.js.uncompressed.js";
document.getElementsByTagName('head')[0].appendChild(script);
 
//Include the Tundra Theme CSS file
var link = document.createElement('link');
link.rel = "stylesheet";
link.type= "text/css";
link.href="http://o.aolcdn.com/dojo/1.4/dijit/themes/tundra/tundra.css";
document.getElementsByTagName('head')[0].appendChild(link);

Sudoku consists of a 9×9 grid, with each grid cell having a possible 9 different values. If we ignore all the constraints, this gives a possible 9^81 boards (1.9662705 × 10^77). Say we can check one-hundred trillion boards a second (100,000,000,000), it would still take ((9^81)/100000000000)/(31556926) = 6.23 × 10^58 years to iterate over all possible combinations! Clearly randomly generating boards and checking if the constraints are fulfilled is not a realistic solution.

Instead, we will implement a backtracking algorithm. In a nutshell, backtracking incrementally builds a solution, buy iteratively assigning possible values and then checking the validity of the assignment against the constraints. If a constraint doesn’t hold, the algorithm immediately backtracks, pruning any other possible (wrong) solution that involved that illegal value.

For efficiency’s sake, we want to prune an incorrect solution as early as possible – that is to say, we want to assign values to a maximally constrained cell. To do this, we want to be assigning values to a maximally constrained cell.

For example, in Sudoku, if we are examining 3 cells in a single row: C1, C2 and C3 and C1 has one legal value (3), C2 has 4 legal values (1,5,3,2) and C3 has 2 legal values (4,3). Obviously we will want to assign the value 3 to C1 (C1=3) first, then 4 to C3 (C3=4), and then figure out C2 down the line.

What if we didn’t assign the value 3 to C1 first, and instead assigned 3 to C2 (C2=3)? Then we would have C3=4, and when we come to assign C1, there are no legal values left, so we have wasted traversing this entire branch!

With Backtracking, and early pruning in mind we can develop the following algorithm:

 Let c(j,k) be the cell in column j and row k.
 Let V(j,k) be the number of valid values on cell c(j,k).
 Let v(j,k,i) be a valid value for a cell.

 1. Calculate the possible values for every cell c(j,k) that doesnt have a value v(j,k,i) assigned
   if every cell has a value, done.
 2. Find the cell cxy, such that for all a, b, V(x,y) < V(a,b). That is to say, find the cell with the least number of possible values.
   if V(x,y) = 1 (only one possible value)
   	assign c(x,y) = v(x,y,1)
   	goto 1
   else
    foreach value m in v(x,y)
    	assign c(x,y) = m
    	goto 1

To summarize, find the cell that is most constrained (least valid assignments). If there is a single valid assignment, make the assignment and recurse, otherwise, foreach valid assignment, assign the value, and recurse.

In JavaScript, step 1 will look like:

/**
* Gets the values in a given row (meaning iterate through all the columns),
* across all te blocks
*
* @param	int	row			The row to get the column values for
* @param	int	blockRow	The row the block is in (1, 2, 3)
*/
getRowValues: function(row, blockRow){
	var values = [];
 
	for(var bcol=1; bcol<=3; bcol++){
		for( var col=1; col<=3; col++){
			var value = this._boardState[blockRow][bcol][row][col].value;
			if(is_numeric(value)){
				values[values.length] = value;
			}
		}
	}
 
	return values;
},
 
/**
* Gets all the values in a given column (meaning iterate through all rows),
* accross all the blocks
*
* @param	int	column		The column to get the row values for
* @param	int	columnRow	The column the block is in (1, 2, 3)
*/
getColumnValues: function(col, blockCol){
	var values = [];
 
	for(var brow=1; brow<=3; brow++){
		for( var row=1; row<=3; row++){
			var value = this._boardState[brow][blockCol][row][col].value;
			if(is_numeric(value)){
				values[values.length] = value;
			}
		}
	}
 
	return values;
},
 
getBlockValues: function(blockRow, blockCol){
	var values = [];
 
	for(var row=1; row<=3; row++){
		for(var col=1; col<=3; col++){
			var value = this._boardState[blockRow][blockCol][row][col].value;
			if(is_numeric(value)){
				values[values.length] = value;
			}
		}
	}
 
	return values;
},
 
/**
* Gets all possible legal values a cell may possess
*/
getValidCellValues: function(blockRow, blockCol, row, col){
	var possibleValues = [1,2,3,4,5,6,7,8,9];
 
	possibleValues = array_diff(possibleValues, this.getRowValues(row, blockRow));
	possibleValues = array_diff(possibleValues, this.getColumnValues(col, blockCol));
	possibleValues = array_diff(possibleValues, this.getBlockValues(blockRow, blockCol));
 
	return possibleValues;
}

We get all the values that appear in the current row, the current column, and the local block (3x3 section the cell is in).
Starting with all the possible assignments, we subtract off any values that appear in the current row, column, or block.

Step 2 is written as:

calculateAllValidCellValues: function(){
 
var unsolvedCells = false;
 
//Value of current Minimum
var currentMin = {
	brow: 0,
	bcol: 0,
	row: 0,
	col: 0,
	count: 10
};
 
//loop through all values
for(var brow=1; brow<=3; brow++){
	for(var bcol=1; bcol<=3; bcol++){
		for(var row=1; row<=3; row++){
			for(var col=1; col<=3; col++){
				if(empty(this._boardState[brow][bcol][row][col].value)){
					unsolvedCells = true;
 
					var validCellValues = this.getValidCellValues(brow, bcol, row, col);
					this._boardState[brow][bcol][row][col].validValues = validCellValues;
 
					//we want to find a maximally constrained cell
					var valueCount = count(validCellValues);
					if(valueCount < currentMin.count){
						currentMin.brow = brow;
						currentMin.bcol = bcol;
						currentMin.row = row;
						currentMin.col = col;
						currentMin.count = valueCount;
					}
 
					//special break-early case because if we find a value count of 1 we can just go ahead
					//and assign it!
					if(valueCount == 1){
							return this._boardState[currentMin.brow][currentMin.bcol][currentMin.row][currentMin.col];
					}
				}
			}
		}
	}
}
 
if(unsolvedCells){
	//return the maximally constrained cell
	return this._boardState[currentMin.brow][currentMin.bcol][currentMin.row][currentMin.col];
}else{
	//We have solved all the cells
	return false;
}
},

In this step all the possible values are calulated and tallied, and the maximally constrained cell is returned.

Finally, we have the sub-parts of step 2 where the assignment and recurive calls are implemented:

/**
* if DieOnError is true, will throw an exception if
* and halt execution if an error is thrown. (This should be set to true, for the
* primary board, but not for any "cloned" sub-boards
*/
solveBoard: function(dieOnError){
 
	try{
		do{
			console.log('iteration ' + (++this.iteration));
 
			//get a maximally constrained cell
			var cell = this.calculateAllValidCellValues();
 
			if(cell === false){
				console.log('Solved all cells');
				break;	//we solved all the cells
			}
 
			if(count(cell.validValues) == 0){
				throw 'Cant find a solution';
			}else if(count(cell.validValues) == 1){
				//Assign the value and go to the next step
				var value = reset(cell.validValues);
 
				console.log('setting [' + cell.brow + '][' + cell.bcol +']['+ cell.row +']['+ cell.col + ']: ' + value);
 
				this.setCellValue(value, cell.brow, cell.bcol, cell.row, cell.col);
			}else{
				//There is more than one possible value
				console.log("More than one possible outcome. Creating Sub-boards");
				for(i in cell.validValues){
					var board = dojo.clone(this);
 
					var value = cell.validValues[i];
 
					console.log('setting [' + cell.brow + '][' + cell.bcol +']['+ cell.row +']['+ cell.col + ']: ' + value);
					board.setCellValue(value, cell.brow, cell.bcol, cell.row, cell.col);
 
					var subBoardResult = board.solveBoard(false);
					if(subBoardResult !== false){
						//We got a board solution
						console.log('Sub-board solved all cells');
						return subBoardResult;
					}
				}
 
				throw 'Cant find a solution';
			}
 
		}while(true);
	}catch(e){
		if(dieOnError){
			alert(e);
			console.debug(e);
		}
		return false;
	}
 
	return this;
},

Note how we check to see if there is a single valid value, and if not, a sub-board is spawned where each possible value for the maximally constrained cell is explored.

Finally, see it in action for yourself:

Javascript Sudoku Solver

Shell In A Box implements a web server that can export arbitrary command line tools to a web based terminal emulator. This emulator is accessible to any JavaScript and CSS enabled web browser and does not require any additional browser plugins.

So basically it gives you a shell to your local system wherever you go (as long as you have a browser that was released since the turn of the century). This can be especially handy if you are on a public machine without permissions to install software (such as putty). The only dis-advantage is that the remote machine has to be running shellinabox, so this will not work for shared hosting environments. However, if you setup a shellinabox machine, you can then SSH into other boxes that aren’t running the daemon.

I’m running Gentoo Linux on my utility machine, and shellinabox doesn’t ship with a gentoo init script. Please enjoy the one I have written below. Basically, you install shellinabox normally, then I copied its generated certs to /var/lib/shellingabox to be used for ssh connections.

Corrections and improvements are appreciated.

/etc/init.d/shellinaboxd:

#!/sbin/runscript
# Copyright 1999-2009 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
# $Header: $
 
CMD=/usr/local/bin/shellinaboxd
CERT_DIR=/var/lib/shellinabox
PIDFILE=/var/run/shellinabox.pid
 
depend() {
        need net
}
 
start() {
        ebegin "Starting Shellinabox"
        start-stop-daemon --start --pidfile $PIDFILE --exec $CMD -- --cert $CERT_DIR -b=$PIDFILE
        eend $?
}

Use drag this link into your bookmarks and have Dojo at your fingertips no matter where your browser takes you:
Inject Dojo v.1.3.2

App_Model_Person:
 tableName: T_person
 columns:
  id: integer
  name: string(64)

People have addresses. One person may have more than one address (billing, mailing, physical, for example). Therefore, we need a second, person address table similar to the following:

App_Model_Person_Address:
 tableName: T_person_address
 package: Person
 columns:
  person_id: integer
  address: string

Notice that the App_Model_Person_Addres model is in the Person package. This is done to ensure that it will be placed in the person subfolder, so the final path of this class will be App/Model/Person/App_Model_Person_Address.php

Before, using the doctrine command line tool to generate the classes, we must make sure that we are going to generate the models in the appropriate location. Assuming that we have an application library on the include path (eg: library/ is on the include path and it has a folder App in it), then we want Doctrine generating the models in the library/App/Model folder. This can be done by setting the models_path to the proper location. Eg:

new Doctrine_Cli(array(
...,
'models_path'         =>  APPLICATION_PATH . '/library/App/Model',
...
));

The main problem with the auto-generated classes produced by the Doctrine_Cli is the filename of the php file that is generated. For, example, the full path of the generated App_Model_Person class will be library/App/Model/App_Model_Person.php; however, according to Zend conventions it should be library/App/Model/Person.php.

The Doctrine Model Autoloader provided below attempts to solve these problems by detecting when a Doctrine Model is being loaded, and then generating the appropriate path (with the full class name acting as the filename). To complicate matters, there are some special cases for base-classes and package classes as well, specifically that they may have Base or Package prefixing the name of the class. The Model autoloader addresses this by detecting the presence of these terms using regular expressions and tweaking the generation of the paths accordingly.

It is very simple to use the Doctrine Model Autoloader class. Simply instantiate it, passing it the prefix of the Doctrine Model namespace. In this case it would be App_Model_. Don’t forget the trailing underscore (“_”), however the class should detect that its missing and add it in for you if you do.

An example usage for the above case would be simply:

$doctrineAutoloader = new Zext_Loader_Autoloader_DoctrineModel('App_Model_');

Upon instantiation, the autoloader registers itself with the Zend_Loader_Autoloader for the passed namepace, so no further setup is required.

<?php
 
class Zext_Loader_Autoloader_DoctrineModel implements Zend_Loader_Autoloader_Interface
{
	/**
	 * The namespace of the models
	 * @var string
	 */
	protected $_namespace;
 
	/**
	 * Whether or not to suppress file not found warnings
     * @var bool
     */
	protected $_suppressNotFoundWarnings = true;
 
	/**
	 * 
	 * @param string $modelNamespace	The namespace of the model to load. Eg: 'Zext_Model_'
	 * @param boolean $quiet			If this is true, suppresses warnings if the file isn't found
	 */
	public function __construct($modelNamespace, $quiet=true)
	{
		if(strrpos($modelNamespace, '_') + 1 != strlen($modelNamespace)){
			$modelNamespace .= '_';
		}
 
		$this->_namespace = $modelNamespace;
		$this->_suppressNotFoundWarnings = $quiet;
 
		$this->init();
	}
 
	/**
	 * Initializes Zend_Loader_Autoloader, pushing the doctrine autoloader onto the autoloading stack
	 * @return void
	 */
	protected function _init()
	{
		$namespaces = array(
			'Package' . $this->_namespace,
			'Base' . $this->_namespace,
			$this->_namespace
		);
 
		$autoloader = Zend_Loader_Autoloader::getInstance();
 
		foreach($namespaces as $namespace){
			$autoloader->pushAutoloader($this, $namespace);
		}
	}
 
	/**
	 * (non-PHPdoc)
	 * @see tests/library/Zend/Loader/Autoloader/Zend_Loader_Autoloader_Interface#autoload($class)
	 */
	public function autoload($className)
	{
		if (class_exists($className, false) || interface_exists($className, false)) {
            return true;
        }
 
 
        //Check to see if we are loading a package / base
        if (preg_match('/(?P<prefix>.+)' . $this->_namespace  . '(?P<class>.+)/mx', $className, $matches)) {
			$result = $matches['prefix'];
			switch(strtolower($matches['prefix'])){
				case 'package':
					$classPath = $this->_loadPackage($matches['class']);
				break;
 
				case 'base':
					$classPath = $this->_loadBase($matches['class']);
				break;
			}
		}else{
			$classPath = $this->_getPath(
				substr($className, 0, strrpos($className, '_') + 1), 
				$className
			);
		}
 
 
		if($this->_suppressNotFoundWarnings){
        	@Zend_Loader::loadFile($classPath, null, true);
		}else{
			Zend_Loader::loadFile($classPath, null, true);
		}
 
        if(!class_exists($className, false) && !interface_exists($className, false)){
        	return false;
        }
 
        return true;
	}
 
	/**
	 * Gets the correct path for loading packages
	 * 
	 * @param $className
	 * @return string
	 */
	protected function _loadPackage($className)
	{
		$package = substr($className, 0, strpos($className, '_'));
 
		return $this->_getPath(
			$this->_namespace . 'packages_' . $package . '_',
			'Package' . $this->_namespace . $className
		);
	}
 
	/**
	 * Gets the correct path for loading bases
	 * 
	 * @param $className
	 * @return string
	 */
	protected function _loadBase($className)
	{
		$package = substr($className, 0, strpos($className, '_'));
 
		return $this->_getPath(
			$this->_namespace . $package . '_generated_',
			'Base' . $this->_namespace . $className
		);
	}
 
	/**
	 * Gets the classpath from an _ separated path and the classname
	 * 
	 * @param string $path
	 * @param string $name
	 * @return string
	 */
	protected function _getPath($path, $name)
	{
		return str_replace('_', DIRECTORY_SEPARATOR, $path) . $name . '.php';
	}
}

I have been building a large application and one of the requirements is to trigger a certain action when an event happens. For example, trigger the sending of an alert email when a database row is updated. Some programmers may be tempted to simply hard-code this functionality into the model class, however this doesn’t give very strict class encapsulation, and can quickly become un-maintainable.

I use the Dojo Javscript toolkit for most of my dynamic front-end functionality. It has implemented a publish/subscribe system using dojo.publish() and dojo.subscribe(). This article will describe the implementation of a similar system using PHP.

Overview

The concept I wanted to implement consists of three parts:

1. The Listener
   This is a class that is interested in the events that are thrown by some other class. Keeping with the above example, tihs class may implement the functionality of sending the alert emails when the database row is updated
2. The Event
   To give the listener some data to act on, an event (message) is passed from the triggering object to the listener. This event may contain information such as the column values for the updated row.
3. The Dispatcher
   The dispatcher is the glue that holds everything together. When an object wants to trigger and event it passes it to the dispatcher (publishes it). When a listener class wants to listen for an event, it will ask the dispatcher to inform it when the event of a specified type is passed (subscribe).

Some other food for thought:

• A listener may only want to subscribe to an event that is published by a certain resource, so there must be a way to track who published the event
• A listener may want to subscribe to all events that are published by a resource or to a specific event independent of the resource, so wildcards should be permitted

Implementation

The Event Object

The event object, in its simplicity, is a very basic class. As mentioned above, it needs to track a minimum of:

1. The resource that published the event
2. The name (/type) of the event
3. Some (optional) data to be passed to the listener

A very simple example of an event object may be the following:

class Event {
	/**
	 * The name of the resource publishing this event
	 * @var string
	 */
	public $resourceName;
 
	/**
	 * The name of this event
	 * @var string
	 */
	public $eventName;
 
	/**
	 * Any data associated with this event
	 * @var mixed
	 */
	public $data;
 
	/**
	 * @param string $resourceName	name of the publisher
	 * @param string $eventName		name of the event
	 * @param mixed $data			[OPTIONAL] Additional event data
	 */
	public function __construct($resourceName, $eventName, $data=null)
	{
		$this->resourceName = $resourceName;
		$this->eventName = $eventName;
		$this->data = $data;
	}
}

Depending on your goals, you may want to make $resourceName, $eventName, and $data private attributes and use getters / setters. Additionally, if you do not wish to pass the eventName and, rather, use object inheritance you could implement the event object in either of the following ways:

Eg 1: Manually set the event name.

class UpdateEvent extends Event
{
	public $eventName = 'Update';
 
	public function __construct($resourceName, $data=null)
	{
		$this->resourceName = $resourceName;
		$this->data = $data;
	}
}

Eg 2: Automatically parse the event name from the class name

class UpdateEvent extends Event
{
	public function __construct($resourceName, $data=null)
	{
		parent::__construct($resourceName, get_class($this), $data);
	}
}

The Listener Object

The Listener object is also has a very simple job. It simply accepts an event object and does something with it. The only catch is that all listener objects should have the same method which accepts the event. Because of this, it makes sense to use an interface.

interface ListenerInterface
{
	/**
	 * Accepts an event and does something with it
	 *
	 * @param Event $event	The event to process
	 */
	public function publish(Event $event);
}

I am going to implement a very simple listener class for the purpose of this demo. This listener outputs a string saying what event was fired, and for which resource. EG: published a .

class EchoListener implements ListenerInterface
{
 
	public function publish(Event $event)
	{
		echo "{$event->resourceName} published a {$event->eventName}";
	}
}

The Dispatch Object

The dispatch object is by far the most complex of all the components. It handles both the subscription of listeners and the dispatching of events. For my actual implementation I needed more than one backend for my dispatch object (Both a hard-coded memory based one, and a user-defined backend based on mysql). For simplicities sake I am going to demonstrate only the memory-based backend here, and leave the implementation of multiple-backends as an exercise to the user.

Without further adeau, here is the class in its entirety. I will discuss each part individually below:

class Dispatcher {
 
    /**
     * Associative array of listeners.
     * Indicies are: [resourceName][event][listener hash]
     *
     * @var array
     */
    protected $_listeners = array();
 
    /**
     * Subscribes the listener to the resource's events.
     * If $resourceName is *, then the listener will be dispatched when the specified event is fired
     * If $event is *, then the listener will be dispatched for any dispatched event of the specified resource
     * If $resourceName and $event is *, the listener will be dispatched for any dispatched event for any resource
     *
     * @param Listener $listener
     * @param String $resourceName
     * @param Mixed $event
     * @return Dispatcher
     */
    public function subscribe(Listener $listener, $resourceName='*', $event='*'){
    	$this->_listeners[$resourceName][$event][spl_object_hash($listener)] = $listener;
    	return $this;
    }
 
    /**
     * Unsubscribes the listener from the resource's events
     *
     * @param Listener $listener
     * @param String $resourceName
     * @param Mixed $event
     * @return Dispatcher
     */
    public function unsubscribe(Listener $listener, $resourceName='*', $event='*'){
    	unset($this->_listeners[$resourceName][$event][spl_object_hash($listener)]);
    	return $this;
    }
 
    /**
     * Publishes an event to all the listeners listening to the specified event for the specified resource
     *
     * @param Event $event
     * @return Dispatcher
     */
    public function publish(Event $event ){
    	$resourceName = $event->resourceName;
    	$eventName = $event->eventName;
 
    	//Loop through all the wildcard handlers
    	if(isset($this->_listeners['*']['*'])){
	    	foreach($this->_listeners['*']['*'] as $listener){
	    		$listener->publish($event);
	    	}
    	}
 
    	//Dispatch wildcard Resources
    	//These are events that are published no matter what the resource
    	if(isset($this->_listeners['*'])){
	    	foreach($this->_listeners['*'] as $event =>; $listeners){
	    		if($event == $eventName){
	    			foreach($listeners as $listener){
	    				$listener->publish($event);
	    			}
	    		}
	    	}
    	}
 
    	//Dispatch wildcard Events
    	//these are listeners that are dispatched for a certain resource, despite the event
    	if(isset($this->_listeners[$resourceName]['*'])){
    		foreach($this->_listeners[$resourceName]['*'] as $listener){
   				$handler->publish($event);
    		}
    	}
 
    	//Dispatch to a certain resource event
    	if(isset($this->_listeners[$resourceName][$eventName])){
    		foreach($this->_handlers[$resourceName][$eventName] as $listener){
    			$handler->publish($event);
    		}
    	}
 
    	return $this;
    }
}

Listeners Attribute

This associative array tracks all the listeners that are subscribed to events. It supports wildcard resources and wildcard events, allowing for a listener to be subscribed to a certain event and resource, all events of a certain resource, all events of a certain type, or all events across all resources. By having an object hash as the final key, well permit multiple listeners to be subscribed to a single event, while still maintaining the unsubscribe functionality (assuming the original object is still present).

Subscribe Function

The subscribe function subscribes a listener to either a specific event for a specific resource and event pairing, or some combination of wildcards.

Unsubscribe Function

Unsubscribes a listener from a resource’s event or wildcard.

Publish Function

The publish function is the workhorse of the Dispatcher class. Every time an event is pubished, the dispatcher searches through the listener array, looking first for any global wildcards (listeners that should be informed on any event), then resource wildcards (listeners that are subscribed to a certain event across all resources), then event wildcards (listeners that are subcribed to all events of a certain resource), and finally events that are subscribed to only one resource’s event.

Putting It Together

Now that we have our three components built, it is time to put it all together. First setup the dispatcher and subscribe some listeners to a resource’s event. Next, publish the event to the dispatcher and, fingers crossed, the event should be propogated to your listeners.

$dispatcher = new Dispatcher();
$echoListener = new EchoListener();
$dispatcher->subscribe($echoListener, 'fooResource', 'barEvent');
 
//Should output "fooResource published a barEvent"
$dispatcher->publish(new Event('fooResource', 'barEvent'));

Well that was a lot of writing. There are several ways to extend this model to make it a bit more elegant and efficient (such as having the publisher of an event pass an instance of itself – this is especially useful for database models, having the subscribe rules dynamically loaded based on the resource name via, say, Zend_Plugin_Loader, having the resource name automatically filled in in much the same way that the event name can be populated); however, I hope this has given you a starting point from which to implement events in your application.

If you have any questions / find spelling, grammar or coding mistakes please mention them in the comments.

Assuming that you have the standard zend directory structure, you will have something like this:

/application
  /admin
    /controllers
    /layouts
    /views
  /default
    /controllers
    /layouts
    /views
  /feeds
    /controllers
    /views

Or something of the sort. When the user is in the admin section we want to use the layout folder from /admin, and when they are in the default section or in the feeds section of the site we would like to use the layout folder from /default.

We could simply go through all the controllers in the admin section and set the layout path in the init or preDisptach function:

public function preDispatch(){
	Zend_Layout::getMvcInstance()->setLayoutPath('../application/admin/layouts');
}

This may work well for this simple example. However, every time we wish to add a controller to the admin section it would be necessary to setup the layout path and if ever we want to change the layout path for the admin module, there would be a lot of search-replacing.

A Much better solution is to write a plugin for the Zend Front controller. This plugin extends the Zend_Controller_Plugin_Abstract type and will be run each time the front controller is invoked, before anything is rendered.

Our plugin must have some very basic functionality:

1. Ability to register a layout for use with a specified module
2. Ability to fall back to the default layout if there is no layout registered for the current module

The Layout Plugin is as follows:

class Module_LayoutPlugin extends Zend_Controller_Plugin_Abstract {
 
	/**
	 * Array of layout paths associating modules with layouts
	 */
	protected $_moduleLayouts;
 
	/**
	 * Registers a module layout.
	 * This layout will be rendered when the specified module is called.
	 * If there is no layout registered for the current module, the default layout as specified
	 * in Zend_Layout will be rendered
	 * 
	 * @param String $module		The name of the module
	 * @param String $layoutPath	The path to the layout
	 * @param String $layout		The name of the layout to render
	 */
	public function registerModuleLayout($module, $layoutPath, $layout=null){
		$this->_moduleLayouts[$module] = array(
			'layoutPath' => $layoutPath,
			'layout' => $layout
		);
	}
 
	public function preDispatch(Zend_Controller_Request_Abstract $request){
		if(isset($this->_moduleLayouts[$request->getModuleName()])){
			$config = $this->_moduleLayouts[$request->getModuleName()];
 
			$layout = Zend_Layout::getMvcInstance();
			if($layout->getMvcEnabled()){
				$layout->setLayoutPath($config['layoutPath']);
 
				if($config['layout'] !== null){
					$layout->setLayout($config['layout']);
				}
			}
		}
	}
}

The $_moduleLayouts property maintains the mapping between modules and layouts.

The registerModuleLayout function allows us to register a layoutpath and an (optional) layout name for a module.

The actual magic happens in the preDispatch function (which is called by the front controller before dispatching the request). The function checks to see if there is a layout set for the current module; if there is, it switches the layout path to use the module-specific path. Next it checks to see if there is a layout name associated with the layout registered for this module. If there is, it uses it, otherwise it falls back to the default layout name.

In our bootstrapper file (html/index.php) we must setup the default layout and module layout paths and then register the plugin with the front controller. The following code snippit is only a sliver of the bootstrapper and assumes that $controller is an instance of Zend_Controller_Front (eg: $controller = Zend_Controller_Front::getInstance();)

//setup the layout
Zend_Layout::startMvc(array(
    'layoutPath' => '../application/default/layouts',
    'layout' => 'main'
));
 
$layoutModulePlugin = new Module_LayoutPlugin();
$layoutModulePlugin->registerModuleLayout('admin','../application/admin/layouts');
 
$controller->registerPlugin($layoutModulePlugin);

It is important to setup the default layout so the plugin has a layout to fall back to if no module-specific layout is registered.

I hope that this tutorial has served as a quick and easy introduction to Zend Front Controller plugins and module-specific layouts.

<IfModule mod_expires.c>
     Header set Cache-Control "max-age=3600, public"
</IfModule>

The above checks to ensure the mod_expires module is loaded in apache, and if it is the Cache is set to expire 3600 seconds from now: 1 hour. Furthermore, the page can be cached in a publicly accessible (shared) cache.

Getting caching working with Zend was a little more challenging. By default Zend (or PHP) writes caching information to headers disabling caching. However, the code snippit below (to be placed inside an Action Controller) blanks out the expires header, sets the cache-control header so that the page expires in one hour, and blanks out the Pragma header.

The expires header allows the server to specify a date when the cache expires (Rather than setting the max-age offset) and the Pragma indicates if the page can be cached in a proxy. I found, with Firefox 3, if Expires and Pragma weren’t blanked out, they would take preference over the Cache-Control header, disabling caching of the page.

$this->getResponse()->setHeader('Expires', '', true);
$this->getResponse()->setHeader('Cache-Control', 'public', true);
$this->getResponse()->setHeader('Cache-Control', 'max-age=3800');
$this->getResponse()->setHeader('Pragma', '', true);

After the addition of caching, the page load was reduced to 8Kb of data pulled down over 9 requests: about a 90% optimization.