Resources are set when you return something out of your _init<MethodName>. For example when you use the following source code and return the $_logger, Zend_Application stores the returned value in a registry inside the application.

// place in your bootstrap file.
public function _initLogger()
{
    $writer = new Zend_Log_Writer_Firebug();
    $_logger = new Zend_Log($writer);
    return $_logger;
}

Now the way you get access to the logger is by doing the following inside your controller or controller helper:

class IndexController extends Zend_Controller_Action
{
    public function indexAction()
    {
        // action body
        $logger = $this->getInvokeArg('bootstrap')
                        ->getResource('logger');
    }
}

The key is the getResource() method. You pass in the part following the _init from your method name. This will return the instance of what ever object was returned in the _init method.

Where I got stuck, was since I’m using the Module Bootstrap for my modules and I only want the logger on specific modules and not the whole application when I used the above code it returned null. The reason for null was because it was not in the global bootstrap file. To get access to the resources from the module bootstrap you need to use the following code:

class Admin_IndexController extends Zend_Controller_Action
{
    public function indexAction()
    {
        // action body
        $logger = $this->getInvokeArg('bootstrap')
                        ->getResource('modules')
                        ->offsetGet($this->getRequest()->getModuleName())
                        ->getResource('logger');
    }
}

I hope this helps someone else out there as it was an eye opener to me when I was told about it via the ZF mailing list.

I’ve come up with the following Zend_Filer_Interface so that way you can plug it into anything that has the ability to use Zend_Filter.

Read More for the source code.

Updated on 12/10/09 to include more characters and remove the html version

Updated again on 12/10/09 to make it work with UTF-8 Submitted Forms. I’ve spent half the day validaing this and testing it with a HEX editor

<?php

class Util_Filter_WordChars implements Zend_Filter_Interface
{
    /**
     * Filter out the invalid characters that word puts in.
     * @param string $value
     * @return string
     */
    public function filter($value)
    {

        $search = array(chr(0xe2) . chr(0x80) . chr(0x98),  // '
            chr(0xe2) . chr(0x80) . chr(0x99),  // '
            chr(0xe2) . chr(0x80) . chr(0x9c),  // "
            chr(0xe2) . chr(0x80) . chr(0x9d),  // "
            chr(0xe2) . chr(0x80) . chr(0x93),  // em dash
            chr(0xe2) . chr(0x80) . chr(0x94),  // en dash
            chr(0xe2) . chr(0x80) . chr(0xa6)); // ...

        $replace = array(
            '\'',
            '\'',
            '"',
            '"',
            '-',
            '-',
            '...');

        return str_replace($search, $replace, $value);
    }
}

This could be changed to put them in the html ascii code to display them but I like the standard single quote and double quote online.

It was fun writing it and learning more that I ever wanted to know about the Ec2 API’s but all it all it was a great expierice and I’m glad that I got the chance to do it.

Other notable items in the 1.8 release are:

• Zend_Application
• Zend_Tool
• Zend_Crypt
• Zend_Service_Amazon_S3
• and so much more

I do have to say I learned a lot while doing the inital work and I’m happy that Wil pinged me to do it. If you want to check out the code currently it lives on github but it is on track to make the 1.8 release of Zend Framework.

Please leave a commet here or on the proposal for anything that I may have over looked or if you have any ideas on how I could make it better.

While I was a little hesitant at first about this in my testing on my dev server it seems to have improved page performance in the form of reduced bandwidth coming off the server which is always a good thing.

All that is required is to create and register a new front controller plugin. Click here for the most up to date code.

I personally think it’s worth checking out if you run a zend framework based site as it’s only about ~35 lines of code at the time of writing.

1. All of the class files have the closing php tag (?>) on them followed by white space.
2. Lack of a modules directory in the default project
3. The Initializer Plug-in does not do some very basic things that should be done.

1. Closing php Tag

According to the PHP Coding Standard that is on the Zend Framework Wiki:

For files that contain only PHP code, the closing tag (“?>”) is to be omitted. It is not required by PHP, and omitting it prevents trailing whitespace from being accidentally injected into the output.

2. Lack of a modules direcory

I know this is easy to add if you know what you are doing with ZF but someone who is new to the framework they might find it hard to understand how to add support for the modules directory. It’s part of the proposed project structure in the ZF wiki.

3. Initializer Plug-in

This is where I have the biggest problem with the default project that is generated.

1. The basic layout of the file is fine except for all the init*() methods return void where they should return the class object so that you can chain requests together in the routeStartup() method.
2. It sets the controller directory last so if something throws an exception before before the controller path is set you end up seeing the exception about how ZF can not find the error controller instead of the actually exception thrown.

Let me know in the comments if you have any suggestions or additions to this.

Here is my updated Initializer.php file

< ?php
<?php
/**
 * My new Zend Framework project
 *
 * $LastChangedDate$
 * $LastChangedRevision$
 */

require_once 'Zend/Controller/Plugin/Abstract.php';
require_once 'Zend/Controller/Front.php';
require_once 'Zend/Controller/Request/Abstract.php';
require_once 'Zend/Controller/Action/HelperBroker.php';

/**
 *
 * Initializes configuration depndeing on the type of environment
 * (test, development, production, etc.)
 *
 * This can be used to configure environment variables, databases,
 * layouts, routers, helpers and more
 *
 */
class Initializer extends Zend_Controller_Plugin_Abstract
{
    /**
     * @var Zend_Config
     */
    protected static $_config;

    /**
     * @var string Current environment
     */
    protected $_env;

    /**
     * @var Zend_Controller_Front
     */
    protected $_front;

    /**
     * @var string Path to application root
     */
    protected $_root;

    /**
     * Constructor
     *
     * Initialize environment, root path, and configuration.
     *
     * @param  string $env
     * @param  string|null $root
     * @return void
     */
    public function __construct($env, $root = null)
    {
        $this->_setEnv($env);
        if (null === $root) {
            $root = realpath(dirname(__FILE__) . '/../');
        }
        $this->_root = $root;

        $this->initPhpConfig();

        $this->_front = Zend_Controller_Front::getInstance();

        // set the test environment parameters
        if ($env == 'test') {
            // Enable all errors so we'll know when something goes wrong.
            error_reporting(E_ALL | E_STRICT);
            ini_set('display_startup_errors', 1);
            ini_set('display_errors', 1);

            $this->_front->throwExceptions(true);
        }
    }

    /**
     * Initialize environment
     *
     * @param  string $env
     * @return void
     */
    protected function _setEnv($env)
    {
        $this->_env = $env;
    }

    /**
     * Initialize Data bases
     *
     * @return Initializer
     */
    public function initPhpConfig()
    {

    }

    /**
     * Route startup
     *
     * @return Initializer
     */
    public function routeStartup(Zend_Controller_Request_Abstract $request)
    {
        $this->initControllers()
            ->initHelpers()
            ->initView()
            ->initDb()
            ->initPlugins()
            ->initRoutes();

        return $this;
    }

    /**
     * Initialize data bases
     *
     * @return Initializer
     */
    public function initDb()
    {
        return $this;
    }

    /**
     * Initialize action helpers
     *
     * @return Initializer
     */
    public function initHelpers()
    {
        // register the default action helpers
        Zend_Controller_Action_HelperBroker::addPath( $this->_root . '/application/default/helpers', 'Zend_Controller_Action_Helper');

        return $this;
    }

    /**
     * Initialize view
     *
     * @return Initializer
     */
    public function initView()
    {
        // Bootstrap layouts
        Zend_Layout::startMvc(array(
            'layoutPath' => $this->_root .  '/application/default/layouts',
            'layout' => 'main'
        ));

        return $this;

    }

    /**
     * Initialize plugins
     *
     * @return Initializer
     */
    public function initPlugins()
    {
        return $this;
    }

    /**
     * Initialize routes
     *
     * @return Initializer
     */
    public function initRoutes()
    {
        return $this;
    }

    /**
     * Initialize Controller and Modules paths
     *
     * @return Initializer
     */
    public function initControllers()
    {
        $this->_front->addControllerDirectory($this->_root . '/application/default/controllers', 'default');
        $this->_front->addModuleDirectory($this->_root . '/application/modules');

        return $this;
    }
}

According to Matthew Weier O’Phinney:

For this particular release, we tried very hard to leverage the community. The majority of new features present in 1.7.0 are from community proposals, or were primarily driven by community contributors. For me, this represents a milestone: ZF is now at a stage where fewer and fewer core components are necessary, and the community is able to build off it and add extra value to the project.

Read More »

I am happy to say that I the Twitter Component was my handy work.  After ZendCon 08 Matthew passed the project off to me as he didn’t have time to complete it.

I also helped closed about 15 of thoes issues and I’m still working hard on closing more.  I also look forward to keep working with the community as it’s one of the strongest framework communities on the web.

Zend_Twitter_Service is currently in the standard trunk for Zend Framework and is scheduled to be released with 1.7.  Please check it out and check back for some examples in the next few days.