Rob Allen has written up a post about creating custom resources for your Zend Framework bootstrap process (for more see Matthew Weier O'Phinney's post here). In Rob's case, he wants to create one for a CouchDb interface.

In my case, I wanted to create a resource for CouchDb that checked that the database was created and if not, create it. Creating your own plugin is easy enough. The obvious place is library/App/Application/Resource

The code is quick and easy - a class that extends the Zend_Application_Resource_ResourceAbstract component and defines a basic init() method that pulls in the settings from the application.ini file for the "resources.couchdb" section. These settings can be used to create the connection or whatever needs to be done to set up the object for future use. You'll also need to add a line in the application.ini to tell the application about the custom resources directory too.

Robert Basic has a quick new tutorial about chaining routes in your Zend Framework applications:

On a forum, there was a question today, about adding language "support" to the routes using Zend Framework. The guy wanted routes like /en/foo/bar or /de/baz. I wrote there an example for that using Zend_Router_Routes_Chain, so just posting that example here, too.

Custom routing allows you to define routes specific to your application without having to change the core libraries. In his example, he shows how to set up the routing objects and how to add them to the request's chain.

Brandon Savage has posted the next part of his series looking at exceptions in PHP. This new article shows how to create a custom exception layer on top of the built-in handling.

One of the things that you can (and should) do with PHP exceptions is extend them to suit your own purposes. While the base Exception class in PHP is neither abstract nor impossible to use on its own, extending exceptions give you a great amount of flexibility and power, particularly in three areas: customization, identification, and abstraction.

He looks at creating custom exception types (for easier handling and customization and how it can help with the abstraction of your applications.

On PHPBuilder.com today there's a new tutorial from Marc Plotz about error handling in PHP apps - what it is and how to capture them to keep them away from your users.

Error reporting is there for a reason and should be used for the purpose it was built. [...] So what is it that we can do to stop errors from first giving out sensitive server information, and second killing our script half-way down the page? Luckily for us PHP has several built-in error handlers for us to use.

He looks at a few different ways to handle errors - additional checking around the operation (like a file_exists before a fopen), working with custom error handlers and the various error levels (like E_ALL or E_ERROR).

Matt Curry has a new post looking at adding additional functionality (custom panels) to his CakePHP status dashboard application.

There are two different ways to add a panel '" using requestAction or Ajax. The general rule is if the panel is pretty fast to load and content is static use requestAction. If the panel takes some time or you want to be able to interact with it then use Ajax. For example, the logs panel uses requestAction since it's pretty quick to grab the log entries and you really don't need to interact with them. The Google Analytics panel, on the other hand, takes a few seconds to query the API and has options to change the timeframe, so it uses Ajax.

New panels can either be made as a part of the application or as plugins and bundled for easy adding and removing. He shows how to write the controller and the element to interface with the CakePHP code. His example grabs the latest users created on his application.

On the Content with Style blog Pascal Opitz looks at creating a custom Zend form element for uploading images.

It really is time to post something, isn't it? Here is a quick way to have an image preview inside of a form based on Zend Form. I am using the auto include mechanism for this one, utilizing the PEAR naming convention, and all my files will sit underneath a Shared folder within the library folder.

Their custom element is created in a two pieces - the form element itself and a custom view helper to define how the form element is displayed. An example of its use is also included.

Wenbert Del Rosario has a recent post to his blog today about using custom plugins in a Zend Framework application.

A few days ago, I managed to setup a project using the new command line tools. My project now had models, views and all the controllers that I needed. But then came the time when I had to setup my own custom plugins. [...] To register your own custom plugin in the new Zend Framework 1.8 release, go to you application.ini file found in the configs directory and add this [code to register the plugin on the front controller instance].

He includes an example of the settings needed for the application.ini, the location to put the plugin file in and a simple example of how the plugin would be coded.

In a new post to his blog Sameer takes a look at streams and filters in PHP applications, specifically how to set up a custom filter to attach to any stream.

In this post we will see how to create a custom stream filter. Streams, first introduced in PHP 4.3, provide an abstration layer for file access. A number of different resources besides files - like network connections, compression protocols etc. can be regarded as "streams" of data which can be serially read and written to.

Streams are the method "behind the scenes" for several of the PHP functions you already use (like fsockopen and file_get_contents). His example shows you how you can manually create a stream and attach a filter to it to replace URLs in the contents of the stream with the "[---URL---]" string and push it back to the standard output.

Raphael Stolt has a new post looking at a technique to ensure that your Phing buildfile is how it should be via unit testing it.

While transforming some of the Ant buildfile refactorings described in Julian Simpson's seminal essay into a Phing context, it felt plainly wrong that I didn't have any tests for the buildfile to back me up on obtaining the pristine behaviour throughout the process. While Ant users can rely on an Apache project called AntUnit there are currently no tailor-made tools available for testing or verifying Phing buildfiles.

He includes an sample build file that will be tested and some PHPUnit code to execute the build and run several tests on the results like githubCloneAdhocTaskShouldBeDefined, targetLogBuildShouldBeAPrivateOne, propertyGithubReposDirShouldBeSet and more.

On The Web Squeeze blog there's a recent post looking at a PHP framework that doesn't get mentioned that often (at least these days) - Prado. The post looks briefly at the framework at getting it set up for development.

This [word game] project was going to be slightly larger, and writing everything myself from scratch would have taken far too long. So I decided to use a PHP framework. PHP frameworks are a collection of code, meant to make your life easier and to aid you in the rapid development of dynamic websites. My choice fell on the Prado framework (see www.pradosoft.com).

He walks you through a first example script with both sides - controller to create/gather the content and the custom tag markup for it to inject the content into. He also includes a look at some of the Ajax support included with the framework. His example is the user clicking on a "Add to Cart" button to call the backend "onToCartClicked" method.