<?php
class Sozfo_Log_Writer_Twitter extends Zend_Log_Writer_Abstract
{
    protected $_username;
    protected $_password;
    protected $_twitter;

    public function __construct ($username, $password)
    {
        $this->_username = $username;
        $this->_password = $password;

        $this->_formatter = new Zend_Log_Formatter_Simple();
    }

    protected function _getTwitter ()
    {
        if (null === $this->_twitter) {
            $this->_twitter = new Zend_Service_Twitter($this->_username, $this->_password);
            $response = $this->_twitter->account->verifyCredentials();
            if ($response->isError()) {
                throw new Zend_Log_Exception('Provided credentials for Twitter log writer are wrong');
            }
        }
        return $this->_twitter;
    }

    public function _write ($event)
    {
        $line = $this->_formatter->format($event);
        $this->_getTwitter()->status->update($line);
    }
}

<?php
class Model_Row_Abstract extends Zend_Db_Table_Row {
	
	protected $_dataTypes = array(
		'bit' => 'int',
		'tinyint' => 'int',
		'bool' => 'bool',
		'boolean' => 'bool',
		'smallint' => 'int',
		'mediumint' => 'int',
		'int' => 'int',
		'integer' => 'int',
		'bigint' => 'float',
		'serial' => 'int',
		'float' => 'float',
		'real' => 'float',
		'numeric' => 'float',
		'money' => 'float',
		'double' => 'float',
		'double precision' => 'float',
		'decimal' => 'float',
		'dec' => 'float',
		'fixed' => 'float',
		'year' => 'int'
	);
	
	/**
	 * Initialize object
	 *
	 * Called from {@link __construct()} as final step of object instantiation.
	 *
	 * @return void
	 */
	public function init() {
		$table = $this->getTable();
		if ($table) {
			$cols = $table->info(Zend_Db_Table_Abstract::METADATA);
			foreach ($cols as $name => $col) {
				$dataType = strtolower($col['DATA_TYPE']);
				if (array_key_exists($dataType, $this->_dataTypes)) {
					settype($this->_data[$name], $this->_dataTypes[$dataType]);
				}
			}
		}
	}
}
?>

<?php
/**
 * Front Controller Application Resources
 *
 * You can use this is resource in your application.ini
 * <code>
 * ; set classname (0 is order for loader)
 * resources.frontController.plugins.0.classname = "Core_Controller_Plugin_Acl"
 * ; set some options
 * resources.frontController.plugins.0.options.denied.controller = error
 * resources.frontController.plugins.0.options.denied.action = denied
 * resources.frontController.plugins.0.options.role = guest
 * </code>
 *
 * @category   Core
 * @package    Core_Application
 * @subpackage Resource
 * 
 * @version  $Id: Frontcontroller.php 1560 2009-10-16 13:22:35Z dark $
 */
class Core_Application_Resource_Frontcontroller 
    extends Zend_Application_Resource_ResourceAbstract
{
    /**
     * @var Zend_Controller_Front
     */
    protected $_front;

    /**
     * Initialize Front Controller
     * 
     * @return Zend_Controller_Front
     */
    public function init()
    {
        $front = $this->getFrontController();
        
        foreach ($this->getOptions() as $key => $value) {
            switch (strtolower($key)) {
                case 'controllerdirectory':
                    if (is_string($value)) {
                        $front->setControllerDirectory($value);
                    } elseif (is_array($value)) {
                        foreach ($value as $module => $directory) {
                            $front->addControllerDirectory($directory, 
                                                           $module);
                        }
                    }
                    break;
                    
                case 'modulecontrollerdirectoryname':
                    $front->setModuleControllerDirectoryName($value);
                    break;
                    
                case 'moduledirectory':
                    $front->addModuleDirectory($value);
                    break;
                    
                case 'defaultcontrollername':
                    $front->setDefaultControllerName($value);
                    break;
                    
                case 'defaultaction':
                    $front->setDefaultAction($value);
                    break;
                    
                case 'defaultmodule':
                    $front->setDefaultModule($value);
                    break;
                    
                case 'baseurl':
                    $front->setBaseUrl($value);
                    break;
                    
                case 'params':
                    $front->setParams($value);
                    break;
                    
                case 'plugins':
                    ksort($value);
                    foreach ((array) $value as $index => $pluginClass) {
                        if (is_array($pluginClass)) {
                            if (!isset($pluginClass['options'])) {
                                $pluginClass['options'] = array();
                            }
                            $plugin = new $pluginClass['classname']($pluginClass['options']);
                        } else {
                            $plugin = new $pluginClass();
                        }
                        $front->registerPlugin($plugin, $index);
                    }
                    break;

                case 'throwexceptions':
                    $front->throwExceptions((bool) $value);
                    break;

                case 'actionhelperpaths':
                    if (is_array($value)) {
                        foreach ($value as $helperPrefix => $helperPath) {
                            Zend_Controller_Action_HelperBroker::addPath($helperPath, $helperPrefix);
                        }
                    }
                    break;

                default:
                    $front->setParam($key, $value);
                    break;
            }
        }

        if (null !== ($bootstrap = $this->getBootstrap())) {
            $this->getBootstrap()->frontController = $front;
        }

        return $front;
    }

    /**
     * Retrieve front controller instance
     * 
     * @return Zend_Controller_Front
     */
    public function getFrontController()
    {
        if (null === $this->_front) {
            $this->_front = Zend_Controller_Front::getInstance();
        }
        return $this->_front;
    }
}

$config = Zend_Registry::get('config');
        $dbUsername = $config->database->params->username;
        $dbPassword = $config->database->params->password;
        $dbName = $config->database->params->dbname;
        $file = APPLICATION_PATH . '/data/backup/' . time() . '.sql';
        $command = sprintf("
            mysqldump -u %s --password=%s -d %s --skip-no-data > %s",
            escapeshellcmd($dbUsername),
            escapeshellcmd($dbPassword),
            escapeshellcmd($dbName),
            escapeshellcmd($file)
        );
        exec($command);

<?php
/**
 * NotModifiedCache.php
 *
 * @category   BaseZF_Framework
 * @package    BaseZF
 * @copyright  Copyright (c) 2008 BaseZF
 * @author     Harold Thetiot (hthetiot)
 */

class BaseZF_Framework_Controller_Plugin_NotModifiedCache extends Zend_Controller_Plugin_Abstract
{
    /**
     * Defined by Zend_Controller_Plugin_Abstract
     */
    public function dispatchLoopShutdown()
    {
        $response = $this->getResponse();

        // no cache if error found or if response
        // is not a Zend_Controller_Response_Http instance
        if (!($response instanceOf Zend_Controller_Response_Http) || $response->isException()) {
            return;
        }

        // Generate unique Hash-ID by using MD5
        $hashID = md5($response->getBody());

        // Specify the time when the page has
        // been changed. For example this date
        // can come from the database or any
        // file. Here we define a fixed date value:
        $lastChangeTime = 1144055759;

        // Define the proxy or cache expire time
        $expireTime = 3600; // seconds (= one hour)

        // Get request headers:
        $headers = apache_request_headers();
        // you could also use getallheaders() or $_SERVER
        // or HTTP_SERVER_VARS

        // Set cache/proxy informations:
        $response->setHeader('Cache-Control', 'max-age=' . $expireTime); // must-revalidate
        $response->setHeader('Expires', gmdate('D, d M Y H:i:s', time() + $expireTime) . ' GMT');

        // Set last modified (this helps search engines
        // and other web tools to determine if a page has
        // been updated)
        $response->setHeader('Last-Modified', gmdate('D, d M Y H:i:s', $lastChangeTime) . ' GMT');

        // Send a "ETag" which represents the content
        // (this helps browsers to determine if the page
        // has been changed or if it can be loaded from
        // the cache - this will speed up the page loading)
        $response->setHeader('ETag', $hashID);

        // The browser "asks" us if the requested page has
        // been changed and sends the last modified date he
        // has in it's internal cache. So now we can check
        // if the submitted time equals our internal time value.
        // If yes then the page did not get updated
        $PageWasUpdated = !(isset($headers['If-Modified-Since']) && strtotime($headers['If-Modified-Since']) == $lastChangeTime);

        // The second possibility is that the browser sends us
        // the last Hash-ID he has. If he does we can determine
        // if he has the latest version by comparing both IDs.
        // Warning: If-None-Match header can have a value like "hash0, hash1"
        $DoIDsMatch = (isset($headers['If-None-Match']) && strpos($headers['If-None-Match'], $hashID) !== false);

        // Does one of the two ways apply?
        if (!$PageWasUpdated or $DoIDsMatch){

            // Okay, the browser already has the
            // latest version of our page in his
            // cache. So just tell him that
            // the page was not modified and DON'T
            // send the content -> this saves bandwith and
            // speeds up the loading for the visitor
            $response->setHttpResponseCode(304);

            // That's all, now close the connection:
            $response->setHeader('Connection', 'close');

            // The magical part:
            // No content here ;-)
            $front = Zend_Controller_Front::getInstance();
            $front->returnResponse(false);

            // Just the headers
            $response->sendHeaders();

        } else {

            // Okay, the browser does not have the
            // latest version or does not have any
            // version cached. So we have to send him
            // the full page.
            $response->setHttpResponseCode(200);

            // Tell the browser which size the content
            $response->setHeader('Content-Length', mb_strlen($response));
        }
    }
}

<?php
/**
 * SM's code library
 * 
 * 
 * @category    Smapp     
 * @package     Smapp_Paginator
 * @copyright   Copyright (c) 2009 Pavel V Egorov
 * @author      Pavel V Egorov
 * @link        http://epavel.ru/
 * @since       14.08.2009
 */


/**
 * @see Zend_Paginator_Adapter_Interface
 */
require_once 'Zend/Paginator/Adapter/Interface.php';

/**
 * @category    Smapp     
 * @package     Smapp_Paginator
 * @copyright   Copyright (c) 2009 Pavel V Egorov
 * @author      Pavel V Egorov
 * @link        http://epavel.ru/
 * @since       14.08.2009
 */
class Smapp_Paginator_Adapter_DoctrineQuery implements Zend_Paginator_Adapter_Interface
{
    /**
     * Database query
     *
     * @var Doctrine_Query
     */
    protected $_query = null;

    /**
     * Total item count
     *
     * @var integer
     */
    protected $_rowCount = null;

    /**
     * Constructor.
     *
     * @param Doctrine_Query $q The select query
     */
    public function __construct(Doctrine_Query $q)
    {
        $this->_query = $q;
    }

    /**
     * Sets the total row count
     *
     * @param  Doctrine_Query|integer $totalRowCount Total row count integer
     *                                               or query
     * @return Zend_Paginator_Adapter_DbSelect $this
     * @throws Zend_Paginator_Exception
     */
    public function setRowCount($rowCount)
    {
        if ($rowCount instanceof Doctrine_Query) {
            $this->_rowCount = $rowCount->count();
        } else if (is_integer($rowCount)) {
            $this->_rowCount = $rowCount;
        } else {
            /**
             * @see Zend_Paginator_Exception
             */
            require_once 'Zend/Paginator/Exception.php';

            throw new Zend_Paginator_Exception('Invalid row count');
        }

        return $this;
    }

    /**
     * Returns an array of items for a page.
     *
     * @param  integer $offset Page offset
     * @param  integer $itemCountPerPage Number of items per page
     * @return array
     */
    public function getItems($offset, $itemCountPerPage)
    {
        return $this->_query->limit($itemCountPerPage)
                            ->offset($offset)
                            ->execute();
    }

    /**
     * Returns the total number of rows in the result set.
     *
     * @return integer
     */
    public function count()
    {
        if ($this->_rowCount === null) {
            $this->setRowCount(
                $this->_query->count()
            );
        }
        return $this->_rowCount;
    }
}

<?php


//bootstrap.php
require 'CacheAll.php';
....

<?php
 require 'Zend/Cache.php';
    $frontendOptions = array(
               'lifetime' => 108000,
               'debug_header' => false, // for debugging set "true"
               'default_options' => array(
                            'cache' => true,
                            'cache_with_get_variables' => true,
                            'make_id_with_get_variables' => true,
                            'cache_with_cookie_variables' => true,
                            'make_id_with_cookie_variables' => true
              ),
           );
          $backendOptions = array(
                 'cache_dir' => '/path/to/dir',
                 'hashed_directory_level' => 1,
                 'file_name_prefix' => 'npc',
           );
           $c = Zend_Cache::factory('Page', 'File', $frontendOptions, $backendOptions);
           $c -> start();

<?php
/**
 * Zend Framework
 *
 * LICENSE
 *
 * This source file is subject to the new BSD license that is bundled
 * with this package in the file LICENSE.txt.
 * It is also available through the world-wide-web at this URL:
 * http://framework.zend.com/license/new-bsd
 * If you did not receive a copy of the license and are unable to
 * obtain it through the world-wide-web, please send an email
 * to license@zend.com so we can send you a copy immediately.
 *
 * @category   Zend
 * @package    Zend_Mail
 * @copyright  Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
 * @license    http://framework.zend.com/license/new-bsd     New BSD License
 */


/**
 * @see Zend_Mail
 */
require_once 'Zend/Mail.php';

/**
 * Class for sending an email.
 *
 * @category   Zend
 * @package    Zend_Mail
 * @copyright  Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
 * @license    http://framework.zend.com/license/new-bsd     New BSD License
 */
class Techi_Mail extends Zend_Mail
{

	/**
     * Sets the HTML body for the message
     *
     * @param  string    $html
     * @param  string    $charset
     * @param  string    $encoding
     * @return Zend_Mail Provides fluent interface
     */
	public function setBodyHtml($html, $charset = null, $encoding = Zend_Mime::ENCODING_QUOTEDPRINTABLE, $preload_images = true)
	{
		if ($preload_images)
		{
			$this->setType(Zend_Mime::MULTIPART_RELATED);

			$dom = new DOMDocument(null, $this->getCharset());
			@$dom->loadHTML($html);

			$images = $dom->getElementsByTagName('img');

			for ($i = 0; $i < $images->length; $i++)
			{
				$img = $images->item($i);
				$url = $img->getAttribute('src');

				$image_http = new Zend_Http_Client($url);
				$response = $image_http->request();

				if ($response->getStatus() == 200)
				{
					$image_content = $response->getBody();

					$pathinfo = pathinfo($url);
					$mime_type = $response->getHeader('Content-Type');

					$mime = new Zend_Mime_Part($image_content);
					$mime->id          = $url;
					$mime->location    = $url;
					$mime->type        = $mime_type;
					$mime->disposition = Zend_Mime::DISPOSITION_INLINE;
					$mime->encoding    = Zend_Mime::ENCODING_BASE64;
					$mime->filename    = $pathinfo['basename'];

					$this->addAttachment($mime);
				}
			}
		}

		return parent::setBodyHtml($html, $charset, $encoding);
	}
}

<?
class Mhwk_Navigation_Page_Mvc extends Zend_Navigation_Page_Mvc
{
    public function isActive($recursive = false)
    {
        if (!$this->_active) {
            $front = Zend_Controller_Front::getInstance();
			$router = $front->getRouter();
			
			$request = $router->route($front->getRequest());
            $reqParams = $request->getParams();

            if (!array_key_exists('module', $reqParams)) {
                $reqParams['module'] = $front->getDefaultModule();
            }

            $myParams = $this->_params;
			
			$route = $router->getRoute($this->_route);
            $routeDefaults = $route->getDefaults();

            if (null !== $this->_module) {
                $myParams['module'] = $this->_module;
            } else {
                $myParams['module'] = $routeDefaults['module'];
            }

            if (null !== $this->_controller) {
                $myParams['controller'] = $this->_controller;
            } else {
                $myParams['controller'] = $routeDefaults['controller'];
            }

            if (null !== $this->_action) {
                $myParams['action'] = $this->_action;
            } else {
                $myParams['action'] = $routeDefaults['action'];
            }

            if (count(array_intersect_assoc($reqParams, $myParams)) ==
                count($myParams)) {
                $this->_active = true;
                return true;
            }
        }

        return parent::isActive($recursive);
    }
}

<?php
class My_Decorator_AnyMarkup extends Zend_Form_Decorator_Abstract {

    public function render($content) {
        $placement = $this->getPlacement();
        $separator = $this->getSeparator();
        switch ($placement) {
            case self::PREPEND:
                return $this->_options['markup'] . $separator . $content;
            case self::APPEND:
            default:
                return $content . $separator . $this->_options['markup'];
        }
    }

}
?>

<?php

class Vendor_View_Filter_ObfuscateMailto implements Zend_Filter_Interface
{
	/**
	 * Regex to find mailto links
	 * Note that it only finds the links,
	 * it does not care about the validity of the email-address
	 *
	 * @var string
	 */
	protected $_pattern = '/<a(.*)href="mailto:([^"]*)"(.*)>(.*)<\/a>/iu';
	
	/**
	 * Defined in Zend_Filter_Interface
	 *
	 * @param	mixed	$value	Value to filter
	 * @return	mixed			Filtered value
	 */
	public function filter($value)
	{
		return preg_replace_callback($this->_pattern, array($this, '_obfuscate'), $value);
	}
	
	/**
	 * Obfuscates found mailto links to encoded javascript
	 *
	 * @param	array	$matches	Matches from regex
	 * @return	string				Obfuscated mailto link
	 */
	protected function _obfuscate(array $matches)
	{
		// javascript to be executed
		$javascript = "document.write('". $matches[0] ."')";
		
		// empty string that will hold encoded version of javascript 
		$encodedJavascript = '';
		
		// encode each character from $javascript to hex and append it to $encodedJavascript
		for($i = 0; $i < strlen($javascript); $i++) {
			$encodedJavascript .= '%' . bin2hex($javascript[$i]);
		}
		
		// return as html script-tag
		return '<script type="text/javascript">eval(unescape(\''. $encodedJavascript .'\'))</script>';
	}
}

$view->addFilterPath('Vendor/View/Filter', 'Vendor_View_Filter');
$view->addFilter('ObfuscateMailto');

Adapted class

<?php
/**
 * Zend_Queue offline processing hack example
 *
 * @author      Dave Marshall 
 * @version     $Rev: $
 * @since       $Date: $
 * @link        $URL: $
 */
class EmailSender {

    private static $queue = null;

    /**
     * Set Queue
     *
     * @param Zend_Queue $queue
     */
    public static function setQueue($queue)
    {
        self::$queue = $queue;
    }

    /**
     * Takes an array of addresses and sends an email to each one.
     *
     * @see reallySendEmail
     * @see sendQueuedEmails
     * @param array $address
     */
    public static function sendEmail($address)
    {
        if (self::$queue === null) {
            // just send them now if we don't have a queue instance
            return self::reallySendEmail($address);
        }

        self::$queue->send(serialize(func_get_args()));
    }

    /**
     * Takes an array of addresses and sends an email to each one.
     *
     * @see sendEmail
     * @param array $address
     */
    private static function reallySendEmail($address)
    {
        /**
         * Code in here
         */
        echo 'Sending email to ' . implode(', ', $address) . PHP_EOL;
    }

    /**
     * Reads emails from the queue and sends them
     *
     * @param int $count - The number of queued items to process
     */
    public static function sendQueuedEmails($count)
    {
        /**
         * Should really check the queue is good here
         */

        $messages = self::$queue->receive(intval($count));
        foreach($messages as $msg) {
            $args = unserialize($msg->body);
            call_user_func_array(array(__CLASS__, 'reallySendEmail'), $args);
            self::$queue->deleteMessage($msg);
        }
    }
}

Usage in application code

<?php

set_include_path(
    'path/to/zend/framework' . PATH_SEPARATOR
    . 'path/to/zend/framework/incubator' . PATH_SEPARATOR
    . get_include_path()
);

require_once "Zend/Loader.php";
Zend_Loader::registerAutoload();

define('DB_SERVER', 'localhost');
define('DB_PORT', 3306);
define('DB_USER', 'root');
define('DB_PASS', 'password');
define('DB_NAME', 'emailsender');
 
$config = array(
    'name' => 'transmittal',
    'driverOptions' => array(
        'host'     => DB_SERVER,
        'port'     => DB_PORT,
        'username' => DB_USER,
        'password' => DB_PASS,
        'dbname'   => DB_NAME,
        'type'     => 'pdo_mysql'
    )
);

// Create a database queue
$queue = new Zend_Queue('Db', $config);
$queue->createQueue('myqueue'); // called for good measure

EmailSender::setQueue($queue);
EmailSender::sendEmail(array('yourname@gmail.com'));

Usage for crontab script

<?php

set_include_path(
    'path/to/zend/framework' . PATH_SEPARATOR
    . 'path/to/zend/framework/incubator' . PATH_SEPARATOR
    . get_include_path()
);

require_once "Zend/Loader.php";
Zend_Loader::registerAutoload();

define('DB_SERVER', 'localhost');
define('DB_PORT', 3306);
define('DB_USER', 'root');
define('DB_PASS', 'password');
define('DB_NAME', 'emailsender');

$config = array(
    'name' => 'transmittal',
    'driverOptions' => array(
        'host'     => DB_SERVER,
        'port'     => DB_PORT,
        'username' => DB_USER,
        'password' => DB_PASS,
        'dbname'   => DB_NAME,
        'type'     => 'pdo_mysql'
    )
);

// Create a database queue
$queue = new Zend_Queue('Db', $config);
$queue->createQueue('myqueue'); // called for good measure

EmailSender::setQueue($queue);
EmailSender::sendQueuedEmails(5);

class Galahad_View_Helper_Cdn extends Zend_View_Helper_Abstract 
{
	static $_types = array(
		'default' => '',
		'images'  => '/images',
		'styles'  => '/styles',
		'scripts' => '/scripts',
	);
	
	static function setTypes($types)
	{
		self::$_types = $types;
	}
	
	public function cdn($type = 'default')
	{
		if (!isset(self::$_types[$type])) {
			throw new Exception('No CDN set for resource type ' . $type);
		}
		
		return self::$_types[$type];
	}
}

class Core_Application_Resource_Paginator extends Zend_Application_Resource_ResourceAbstract
{
    /**
     * Set the default scrolling style for the Paginator
     *
     * @param  string $scrollingStyle
     * @return Core_Application_Resource_Paginator
     */
    public function setDefaultScrollingStyle($scrollingStyle)
    {
        Zend_Paginator::setDefaultScrollingStyle($scrollingStyle);
        return $this;
    }

    /**
     * Set the default view partial for the Paginator
     *
     * @param  string|array $viewPartial
     * @return Core_Application_Resource_Paginator
     */
    public function setDefaultViewPartial($viewPartial)
    {
        Zend_View_Helper_PaginationControl::setDefaultViewPartial($viewPartial);
        return $this;
    }

    /**
     * Defined by Zend_Application_Resource_Resource
     *
     * @return void
     */
    public function init()
    {
    }
}

// Pass to Zend_Application like so:
resources.paginator.defaultScrollingStyle = "Sliding"
resources.paginator.defaultViewPartial = "paging.phtml"

TUTORIAL
Usage in bootstrap with setters:

// Include PHP file...
// Plugin Manager.
$plugger = new Bolzz_Zend_PluggerPlugin();

// This instance is used by plugger to load
// a plugin on demand.
$oLoaderPlugins = new Zend_Loader_PluginLoader();

// Add all prefix-path-mappings. That's all what plugger needs.
$oLoaderPlugins->addPrefixPath('Tools_Plugin', '../application/modules/tools/plugins/'); // EXAMPLE!

// Now, add the PluginLoader instance to the plugger.
$plugger->setLoader($oLoaderPlugins);

// Set "default plugins". These plugins will be loaded on each request.
// That's the ZF standard.
$plugger->addDefaults('ToolBar');

// Add some arguments for plugin's constructor, if needed.
// Plugger will pass these 3 args in the same order and data type:
// Tools_Plugin_ToolBar - a boolean, an integer and a num array.
$plugger->addArgs('ToolBar', true, 1, array('val1', 'val2'));

// Above, last two calls can be done by one:
// $plugger->addDefaults('ToolBar', true, 1, array('val1', 'val2'));

// Now, first example why it's good to use plugger.
// Tools_Plugin_UserToolBar is only needed if a user wants to edit his options.
// Therefor, a user calls the URL http://www.mydomain.com/settings/someUsername.
// Now, plugger detects "settings" in the URL and loads all plugins,
// which were registered to this request.
$plugger->addSpecials('settings', 'UserToolBar', true, 1, array('val1', 'val2'));
// Tools_Plugin_AdminToolBar is only needed/loaded in an admin panel.
$plugger->addSpecials('admin', 'AdminToolBar');

// plugger handles each request by 3 steps to get known which AREA (settings, admins, etc.)
// should be loaded. This process can be customized.

// Option 1: Searches in URL for a module name and sets it as AREA.
// $plugger->setMode('module');
// Option 2: If the regex matches the URL "settings" is been set as AREA.
$plugger->setRegex('settings', '^settings/[a-z]*');
// Option 3: Searches in URL request string for "settings" and on success "settings" is being set as AREA.
// $plugger->setNeedle('settings', 'settings');

// Now, plugger is working.
$plugger->run();


// Note: plugger could throw an exception Bolzz_Exception_Plugger.

<?php
/**
 * Bolzz Library
 * http://www.bolzz.com - BOLZZ | IT Entwicklung
 *
 * LICENSE
 * 100% Freeware and Open Source
 *
 * @package Bolzz
 * @subpackage Zend
 * @category Plugins
 * @filesource
 */

require_once '../libs/Bolzz_Library/Bolzz/Exception/Plugger.php';

/**
 * Plugger (Plugin Manager)
 * Manages all plugins and loads them only if they are really needed.
 * On each request the Plugger registers plugins, if they are linked
 * to that request and only then.
 *
 * @example Quickstart_PluggerPlugin.php
 * @tutorial http://www.zfforum.de/showpost.php?p=29802&postcount=21
 * @version Version 1.4.2
 */
final class Bolzz_Zend_PluggerPlugin extends Zend_Controller_Plugin_Abstract
{
// data elements #############################################################
// MUST ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	
	/**
	 * Count of members which has to be initialized to use/run Plugger.
	 */
	const MEMBERS_TO_INIT = 2;
	
	/**
	 * Counter flag.
	 *
	 * @var int Default: count of members to initialize.
	 */
	private $_initialized = self::MEMBERS_TO_INIT;
	
	/**
	 * List of initialized members. Setter method as element.
	 *
	 * @var array Num Array.
	 */
	private $_initList = array();
	
	/**
	 * Mode
	 *
	 * @var bool
	 */
	private $_run = false;
	
	/**
	 * Base URL set by front controller.
	 * @var string On init() $baseUrl is set on $this->front->getBaseUrl().
	 */
	private $_baseUrl = '';
	
	/**
	 * Parameters in URL.
	 * If $baseUrl is set, it will be filtered from $urlParams automatically by the _loadAreaBy*()-methods.
	 * @var string On init() $urlParams is set on $_SERVER['REQUEST_URI'].
	 */
	private $_urlParams = '';
	
	/**
	 * Name of Module, Controller, Action or whatever you like. If empty tried to set by loadArea().
	 * This variable represents current website area to register plugins for.
	 * Plugins from $pluginsAreas will be loaded by the Manager, if their associative key is equal with $area.
	 * <code>
	 * <?php
	 * // Define plugins to load in specified areas.
	 * $pluginsAreas = array(
	 * 'areaFoo' => array('Plugin_Class1', 'Plugin_Class2'), // Area 1 ------- * Plugin 
	 * 'areaBar' => 'Plugin_Class3', // Area 1 ------- 1 Plugin
	 * 'areaFooBar' => array('Plugin_Class4')); // Area 1 ------- 1 Plugin
	 * 
	 * // if $area === 'areaFoo'
	 * //    Plugin_Class1 and Plugin_Class2 will be registered.
	 * //    Plugin_Class3 and Plugin_Class4 will NOT be registered.
	 * </code>
	 * @var string
	 */
	private $_area = '';

	/**
	 * If you set $areaMode your project has to use a conventional modular directory struture, like Zend does recommend.
	 * If $areaRegex or $areaNeedle are set, they will be checked first.
 	 * @link http://framework.zend.com/manual/en/zend.controller.modular.html 7.11. Using a Conventional Modular Directory Structure
	 * @var string 'module' | 'controller' | 'action' | ''. By Default: 'module'.
	 */
	private $_areaMode = 'module';
	
	/**
	 * If $areaRegex is set, then Regex will be checked against the URL before $areaMode but after $areaNeedle.
	 * Haystack is URL string.
	 * <code>
	 * <?php
	 * array('area name' => 'REGEX');
	 * </code>	 
	 * @var array Associative Array.
	 */
	private $_areaRegex = array();

	/**
	 * If $areaNeedle is set, then your Regex will be checked against the URL before $areaMode and $areaRegex.
	 * Haystack is URL string.
	 * <code>
	 * <?php
	 * array('area name' => 'needle');
	 * </code>
	 * @var array Associative Array.
	 */
	private $_areaNeedle = array();
	
	/**
	 * Management for prefixes and paths of plugin classes.
	 * @var object Zend_Loader_PluginLoader_Interface
	 */
	private $_loader = null;
	
	/**
	 * Default plugins to load.
	 * <code>
	 * <?php
	 * $pluginsDefaults = array('Plugin_Class1', 'Plugin_Class2', 'Plugin_Class3');
	 * </code>
	 * @var array Numeric Array
	 */
	private $_pluginsDefaults = array();

	/**
	 * Plugins to load in specified areas.
	 * <code>
	 * <?php
	 * // Exammple 1: In each area only one plugin will be loaded.
	 * $pluginsAreas = array(
	 * 'areaFoo' => 'Plugin_Class1', 
	 * 'areaBar' => 'Plugin_Class2', 
	 * 'areaFooBar' => 'Plugin_Class3');
	 * 
	 * // Example 2: In area 'areaFoo' will be more than one plugin loaded.
	 * $pluginsAreas = array(
	 * 'areaFoo' => array('Plugin_Class1', 'Plugin_Class2'), // Area 1 ------- * Plugin 
	 * 'areaBar' => 'Plugin_Class3', // Area 1 ------- 1 Plugin
	 * 'areaFooBar' => array('Plugin_Class4')); // Area 1 ------- 1 Plugin
	 * </code>
	 * @var array Associative Array
	 */
	private $_pluginsAreas = array();
	
	/**
	 * Arguments for constructors of plugins.
	 * <code>
	 * <?php
	 * // Example 1: One argument needed - Given as an string
	 * $arguments = array('classname' => 'param1');
	 * // Example 2: One argument needed - Given as an array
	 * $arguments = array('classname' => array('param1'));
	 * // Example 3: Two or more arguments needed
	 * $arguments = array('classname' => array('param1', 'param2'));
	 * </code>
	 *
	 * @var array Assoziative [multiple] array.
	 */
	private $_arguments = array();
	
	/**
	 * The Singleton Front Controller
	 * Will be set each time when create an object. Flag $_run does not care.
	 * @var object Zend_Controller_Front
	 */
	public $front = null;

// element functions ##########################################################
// MUST +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

	/**
	 * Constructor Bolzz_Zend_PluggerPlugin
	 * 
	 * Initialize members and register plugins.
	 * 
	 * @throws Bolzz_Exception_Plugger Only when $_run is true.
	 * @uses run()
	 * @uses Zend_Controller_Front::getInstance()
	 * @param object $_loader Zend_Loader_PluginLoader_Interface. By Default: null.
	 * @param array $_pluginsDefaults Load these plugins by default - array('Plugin_Name1', 'Plugin_Name2')
	 * @param array $_pluginsAreas Load these plugins in specific areas - array('area' => 'Plugin_Name')
	 * @param array $_arguments Arguments for constructors of plugins.
	 * @param string $_area Current name of Module, Controller or Action. If empty (default), Plugger will set it.
	 * @param string $_areaMode Values: 'module' | 'controller' | 'action' | ''. By Default: 'module'.
	 * @param array $_areaRegex Associative Array. Key is area which will be set if value (regex) matches in URL. Note: Regex must be set in brackets (REGEX).
	 * @param array $_areaNeedle Associative Array. Key is area, which will be set if value (needle) found in URL.
	 * @param bool $_run If true, constructor will try to run Plugger. Default: false.
	 */
	public function __construct($_loader = null, $_pluginsDefaults = array(), $_pluginsAreas = array(),
								$_arguments = array(), $_area = '',
								$_areaMode = 'module', $_areaRegex = array(), $_areaNeedle = array(),
								$_run = false)
	{
		$this->front = Zend_Controller_Front::getInstance();

		$this->_run = $_run;
		
		$this->_init($_loader, $_pluginsDefaults, $_pluginsAreas, $_arguments, $_area, $_areaMode, $_areaRegex, $_areaNeedle);

		if (true === $this->_run) {
			$this->run();
		}
	}

// MUST +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

	/**
	 * Initialize members.
	 * 
	 * Uses $_SERVER['REQUEST_URI'] to get all GET parameters to $_urlParams.
	 * 
	 * @usedby __construct()
	 * @param object $_loader Zend_Loader_PluginLoader_Interface
	 * @param array $_pluginsDefaults
	 * @param array $_pluginsAreas
	 * @param array $_arguments
	 * @param string $_area
	 * @param string $_areaMode
	 * @param array $_areaRegex
	 * @param array $_areaNeedle
	 * @return void
	 */
	private function _init($_loader, $_pluginsDefaults, $_pluginsAreas, $_arguments, $_area,
							$_areaMode,	$_areaRegex, $_areaNeedle)
	{
		if ($_loader instanceof Zend_Loader_PluginLoader_Interface) {
			$this->setLoader($_loader);
		}

		$this->setBaseUrl($this->front->getBaseUrl());
		$this->setUrlParams($_SERVER['REQUEST_URI']);
		$this->setDefaults($_pluginsDefaults);
		$this->setSpecials($_pluginsAreas);
		$this->setArgs($_arguments);
		$this->setMode($_areaMode);
		$this->setRegex($_areaRegex);
		$this->setNeedle($_areaNeedle);

		if (!empty($_area)) {
			$this->setArea($_area);
		}
	}

// MUST +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

	/**
	 * Register plugins for specific areas.
	 * 
	 * @todo exception handling
	 * @usedby __construct()
	 * @uses _runFactory()
	 * @uses $_pluginsAreas
	 * @uses $_area
	 * @return void
	 */
	private function _registerSpecials()
	{
		// identify equal areas
		switch ($this->_area) {
			case 'default':
			case 'index':
				$areaTmp = array('default', 'index');
				break;
			default:
				$areaTmp[0] = $this->_area;
				break;
		}

		if (is_array($areaTmp)) {
			$counts = count($areaTmp);
		} else {
			$counts = 0;
		}

		while ($counts > 0) {
			$countsIndex = --$counts;

			if (isset($areaTmp[$countsIndex])) {
				if (isset($this->_pluginsAreas[$areaTmp[$countsIndex]])) {
					$areaClasses = $this->_pluginsAreas[$areaTmp[$countsIndex]];

					if (!empty($areaClasses)) {
						if (is_array($areaClasses)) {
							foreach ($areaClasses as $key => $name) {
								$this->_runFactory($name);
							}
						} else {
							$this->_runFactory($areaClasses);
						}
					}
				}
			}
		}
	}	

// MUST +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

	/**
	 * Register plugins for all areas of application.
	 * 
	 * @todo exception handling
	 * @usedby __construct()
	 * @uses _runFactory()
	 * @uses $_pluginsDefaults
	 * @return void
	 */
	private function _registerDefaults()
	{
		if (!empty($this->_pluginsDefaults)) {
			foreach ($this->_pluginsDefaults as $key => $name) {
				$this->_runFactory($name);
			}
		}
	}	

// MUST +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

	/**
	 * Factory Method for Plugins. Create an object.
	 * 
	 * @todo throw Exception if could not instantiate class, because of missing arguments, etc.
	 * @uses ReflectionClass
	 * @param string $_sName Filename or Class name
	 * @param string $_sClassName Is definetly a class name
	 * @return bool|object false or instance of $_sClassName
	 */
	private function _factory($_sName, $_sClassName)
	{
		if (isset($_sName) && array_key_exists($_sName, $this->_arguments)) {
			$index = $_sName;
		} elseif (isset($_sClassName) && array_key_exists($_sClassName, $this->_arguments)) {
			$index = $_sClassName;
		} else {
			$index = false;
		}
		
		if ($index !== false
		&& isset($_sClassName)
		&& !empty($_sClassName)
		&& is_string($_sClassName)) {
			if (is_array($this->_arguments[$index])) {
				// array - support constructors with more than one arguments.			

				$refl = new ReflectionClass($_sClassName);

				$obj = $refl->newInstanceArgs($this->_arguments[$index]);
			} else { 
				// string - only one argument given to constructor.

				$obj = new $_sClassName($this->_arguments[$index]);	
			}
		} else {
			if (isset($_sClassName)
			&& !empty($_sClassName)
			&& is_string($_sClassName))
				$obj = new $_sClassName();
			else
				$obj = null;
		}

		return (!is_null($obj) && is_object($obj)) ? $obj : false;
	}

// MUST +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	

	/**
	 * Run Factory Method for Plugins.
	 * 
	 * @throws Zend_Loader_PluginLoader_Exception
	 * @throws Bolzz_Exception_Plugger
	 * @uses _factory()
	 * @uses $front
	 * @uses $_loader
	 * @param string $_sName Filename or Class name
	 * @return void
	 */
	private function _runFactory($_sName)
	{
		if (!is_object($this->_loader)
		|| !($this->_loader instanceof Zend_Loader_PluginLoader_Interface)) {
			include_once 'Zend/Loader/PluginLoader/Exception.php';
			
			throw new Zend_Loader_PluginLoader_Exception(__CLASS__
				. '::$_loader has to be an instance of Zend_Loader_PluginLoader_Interface. Currently given: '
				. gettype($this->_loader));
		}

		// NOTE: If class can not be loaded by name here, an exception
		// Zend_Loader_PluginLoader_Exception will be thrown.
		$this->_loader->load($_sName);

		if ($this->_loader->isLoaded($_sName)) {
			$className = $this->_loader->getClassName($_sName);
		}

		$plugin = $this->_factory($_sName, $className);

		if ($plugin !== false) {
			$this->front->registerPlugin($plugin);
		} else {
			throw new Bolzz_Exception_Plugger('Register plugin "'. $className .'" failed.');
		}
	}

// MUST +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

	/**
	 * Search in array $areaNeedle for parameters of URL. 
	 * 
	 * First parameter found in array will set $area. So the order is: domain.de/p1/p2/p3
	 * If p1 was found in array, return $areaNeedle[p1]. If not, array will be searched
	 * for p2 and after all p3. There is no need to search for more than 3 parameters,
	 * because of URL structure module/controller/action/...
	 * 
	 * <code>
	 * <?php
	 * $areaNeedle = array('foo' => 'bar', 'bla' => 'blubb');
	 * // so when manager calls _loadAreaByNeedle() and parameters are 'blubb' and 'bar' then
	 * // return 'bla', what means that $area is set to 'bla'. Controlled by order of params!
	 * </code>
	 * @usedby _init()
	 * @uses $_urlParams
	 * @uses $_baseUrl
	 * @uses $_areaNeedle
	 * @return string Value for Bolzz_Zend_PluggerPlugin::$area. By Default: empty string.
	 */	
	private function _loadAreaByNeedle()
	{
		$aParams = array();

		if (!empty($this->_urlParams)) {
			$params = str_replace($this->_baseUrl, '', $this->_urlParams);
			
			if ($params{0} === '/') {
				$params = substr($params, 1);
			}
			
			$aParams = explode('/', $params);	
		}

		if (!empty($aParams)) {
			$counts = count($aParams);
			
			// search for first 3 parameters only.
			if ($counts > 3) {
				$counts = 3;
			}

			for ($i = 0; $i < $counts; $i++) {
				if (in_array($aParams[$i], $this->_areaNeedle)) {
					$aFlip = array_flip($this->_areaNeedle);
					
					return $aFlip[$aParams[$i]];
				}
			}
		}
		
		return '';
	}

// MUST +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

	/**
	 * Check Regexes given as VALUES in assoc array $_areaRegex against first 3 parameters in URL.
	 * 
	 * $baseUrl is filtered from URL automatically, before checking. 
	 * A trailing slash also will be filtered.
	 * 
	 * <code>
	 * <?php
	 * $areaRegex = array('foo' => '(^bar.*)', 'bla' => '^blubb.*');
	 * // so when manager calls _loadAreaByRegex() then
	 * // check regex (^bar.*) against parameters, on success return 'foo'.
	 * // Controlled by order of array! Unlike _loadAreaByNeedle().
	 * </code>
	 * @usedby _init()
	 * @uses $_urlParams
	 * @uses $_baseUrl
	 * @uses $_areaRegex
	 * @return string Value of Bolzz_Zend_PluggerPlugin::$area. By Default: empty string.
	 */	
	private function _loadAreaByRegex()
	{
		$params = str_replace($this->_baseUrl, '', $this->_urlParams);
		
		if ($params{0} === '/') {
			$params = substr($params, 1);
		}
		
		$aParams = explode('/', $params);

		if (is_array($aParams)) {
			$counts = count($aParams);
			
			if ($counts > 3) {
				$counts = 3;
			}
			
			$params = '';
			
			for ($i = 0; $i < $counts; $i++) {
				$params .= $aParams[$i] . '/';
			}
		}

		foreach ($this->_areaRegex as $area => $regex) {
			if ($regex{0} !== '(') {
				$regex = '(' . $regex . ')';
			}
			
			if (preg_match($regex, $params) === 1) {
				return $area;
			}
		}

		return '';
	}

// MUST +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

	/**
	 * Read Module, Controller or Action out of url string when $area is empty (default).
	 * If no parameters found in URL or $areaMode is empty, then return 'default'.
	 * Is called last in the chain of the loadAreaBy*()-methods, if one or both of the other arrays are given.
	 * 
	 * <code>
	 * <?php
	 * $areaMode = 'module';
	 * // so when manager calls loadAreaByMode() then
	 * // check if a module exists in parameters, on success return parameter stands for module.
	 * 
	 * // NOTE:
	 * // So this means, URL should be like module/controller/action/key1/value1/... like Zend does recommend.
	 * // Visit link to Zend Documentation for more details about MVC structure of Zend Framework.
	 * </code>
	 * @todo optimize code, create _filterTrailingSlash() for loadAreaBy*()-methods
	 * @link http://framework.zend.com/manual/en/zend.controller.modular.html 7.11. Using a Conventional Modular Directory Structure
	 * @usedby _init()
	 * @uses $_urlParams
	 * @uses $_baseUrl
	 * @uses $_areaMode
	 * @return string Value of Bolzz_Zend_PluggerPlugin::$area. Will never be an empty string like in the other loadAreaBy*-methods. By Default: 'default'.
	 */	
	private function _loadAreaByMode()
	{
		$aParams = array();

		if (!empty($this->_urlParams)) {
			$params = str_replace($this->_baseUrl, '', $this->_urlParams);
			
			if ($params{0} === '/') {
				$params = substr($params, 1);
			}
			
			$aParams = explode('/', $params);	
		}

		if (empty($aParams[0])) {
			return 'default'; // no parameter found in URL.
		} else {
			switch ($this->_areaMode) {
				case 'module':
					return (!empty($aParams[0])) ? $aParams[0] : $aParams[1];

				case 'controller':
					return (!empty($aParams[0])) ? $aParams[1] : $aParams[2];

				case 'action':
					return (!empty($aParams[0])) ? $aParams[2] : $aParams[3];

				default:
					return 'default'; // empty string given in $this->_areaMode (set by __construct)
			}
		}
	}
	
// MUST +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

	/**
	 * Mark members as initialized, which are needed to run Plugger.
	 * 
	 * @param string $_s
	 * @return void
	 */
	private function _initialized($_s)
	{
		if (false === $this->isInitialized()
		&& isset($_s)
		&& false === in_array($_s, $this->_initList, true)) {
			$_s = (string) $_s;

			array_push($this->_initList, $_s);
			
			$this->_initialized--;
		}
	}
	
// MUST +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

	/**
	 * Load area by Needle, Regex or Mode.
	 * 
	 * NOTE: If you use isInitialized() in your code, be sure that Area is set.
	 * Therefor you can use setArea(), loadArea() or constructor argument.
	 * 
	 * @usedby run()
	 * @uses setArea()
	 * @return void
	 */
	public function loadArea()
	{
		if (empty($this->_area)) {
			if (!empty($this->_areaNeedle)) {				
				$this->setArea($this->_loadAreaByNeedle());
			}

			if (empty($this->_area) && !empty($this->_areaRegex)) {				
				$this->setArea($this->_loadAreaByRegex());
			}

			if (empty($this->_area)) {
				$this->setArea($this->_loadAreaByMode());
			}
		}
	}
	
// MUST +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

	/**
	 * Check whether all members are initialized.
	 * 
	 * NOTE: This method would return false, if $_area or $_loader are not set.
	 * @return bool
	 */
	public function isInitialized()
	{		
		if (count($this->_initList) == self::MEMBERS_TO_INIT
		&& 0 === $this->_initialized) {
			return true;
		}
		
		return false;
	}

// MUST +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

	/**
	 * Setter
	 * 
	 * @usedby loadArea()
	 * @param string $_s
	 * @return void
	 */
	public function setArea($_s)
	{
		if (isset($_s) && is_string($_s)) {
			$this->_area = $_s;
			$this->_initialized(__METHOD__);
		} else {
// @todo wrong type
		}
	}
	
// MUST +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

	/**
	 * Setter
	 * 
	 * @param mixed $_m String: Areaname. | $_a assoc Array. Example: array('AREANAME' => 'NEEDLE');
	 * @param string $_needle Needle. Default: ''.
	 * @return void
	 */
	public function setNeedle($_m, $_needle = '')
	{
		if (isset($_m) && is_array($_m)) {
			$this->_areaNeedle = $_m;
		} elseif (isset($_m) && is_string($_m)) {
			 $this->_areaNeedle = array($_m => $_needle);
		} else {
// @todo wrong type
		}
	}
	
// MUST +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

	/**
	 * Setter
	 * 
	 * @param mixed $_m String: Areaname. | assoc Array. Example: array('AREANAME' => '(^REGEX.*)');
	 * @param string $_regex Regex. Default: ''.
	 * @return void
	 */
	public function setRegex($_m, $_regex = '')
	{
		if (isset($_m) && is_array($_m)) {
			$this->_areaRegex = $_m;
		} elseif (isset($_m) && is_string($_m)) {
			 $this->_areaRegex = array($_m => $_regex);
		} else {
// @todo wrong type
		}
	}
	
// MUST +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

	/**
	 * Setter
	 * 
	 * @param string $_s
	 * @return void
	 */
	public function setMode($_s)
	{
		if (isset($_s) && is_string($_s)) {
			$this->_areaMode = $_s;
		} else {
// @todo wrong type
		}
	}
	
// MUST +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

	/**
	 * Setter
	 * 
	 * Overwrite member. If you don't want, use {@see addSpecials()}.
	 * @param array $_a assoc Array. Key: Area (string) Value: Classname (string|num array)
	 * @return void
	 */
	public function setSpecials($_a)
	{
		if (isset($_a) && is_array($_a)) {
			$this->_pluginsAreas = $_a;
		} else {
// @todo wrong type
		}
	}
	
// MUST +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

	/**
	 * Adder
	 * 
	 * NOTE: Value of an existing Key/Area will be overwritten.
	 * Variable count of arguments allowed. They represent the constructor arguments
	 * for the plugin class. Only allowed if first parameter is a string!
	 * If Array, arguments will be ignored!
	 * @varargs
	 * @uses ReflectionMethod
	 * @param mixed $_m String: Area | assoc Array. Key: Area (string) Value: Classname (string|num array)
	 * @param mixed $_mClass String: Classname. Default: null. | Num Array. Values: Classnames
	 * @return void
	 */
	public function addSpecials($_m, $_mClass = null)
	{
		if (isset($_m) && is_array($_m)) {
			foreach ($_m as $area => $mCls) {
				if (is_string($area)
				&& (is_string($mCls) || is_array($mCls))) {
					$this->_pluginsAreas[$area] = $mCls;
				}
			}
		} elseif (isset($_m) && is_string($_m)) {
			if (!empty($_m) && !empty($_mClass)) {
				// Add specials.
				if (is_string($_mClass) || is_array($_mClass)) {
					$this->_pluginsAreas[$_m] = $_mClass;
				}

				// Constructor arguments are given.
				if (func_num_args() > 2) {
					$aArgs = func_get_args();
					
					array_shift($aArgs); // remove AREANAME
					
					$addArgs = new ReflectionMethod(__CLASS__, 'addArgs');
					
					$addArgs->invokeArgs($this, $aArgs);
				}
			}
		}
	}
	
// MUST +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

	/**
	 * Setter
	 * 
	 * Overwrite member. If you don't want, use {@see addArgs()}.
	 * @todo Implement variable arguments - second param needed.
	 * @param array $_a assoc Array. Key: Classname Value: mixed
	 * @return void
	 */
	public function setArgs($_a)
	{
		if (isset($_a) && is_array($_a)) {
			$this->_arguments = $_a;
		} else {
// @todo wrong type
		}
	}

// MUST +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

	/**
	 * Adder
	 * 
	 * Variable count of arguments allowed. They represent the constructor arguments
	 * for the plugin class.
	 * @varargs
	 * @param string $_className
	 * @return void
	 */
	public function addArgs($_className)
	{
		if (isset($_className) && is_string($_className)) {
			$aArgs = null;

			if (func_num_args() > 1) {
				$aArgs = func_get_args();

				if ($aArgs[0] === $_className) {
					array_shift($aArgs);
				}			
			}

			if (is_array($aArgs)) {
				$aArguments = array();
				
				foreach ($aArgs as $key => $mArg) {
					$aArguments[] = $mArg;
				}

				if (!empty($aArguments)) {
					$this->_arguments[$_className] = $aArguments;
				} else {
// @todo Exception: "No arguments given."
				}
			} else {
// @todo Exception: "No arguments given."
			}
		} else {
// @todo wrong type
		}
	}
	
// MUST +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

	/**
	 * Setter
	 * 
	 * Overwrite member. If you don't want, use addDefaults().
	 * @todo Implement usage with variable count of arguments.
	 * @param mixed $_m Num Array or String.
	 * @return void
	 */
	public function setDefaults($_m)
	{
		if (isset($_m) && is_array($_m)) {
			$this->_pluginsDefaults = $_m;
		} elseif (isset($_m) && is_string($_m)) {
			$this->_pluginsDefaults = array($_m);
		} else {
// @todo wrong type
		}
	}
	
// MUST +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

	/**
	 * Adder
	 * 
	 * Variable count of arguments allowed. They represent the constructor arguments
	 * for the plugin class. Only allowed if first parameter is a string!
	 * If Array, arguments will be ignored!
	 * @varargs
	 * @uses ReflectionMethod
	 * @param mixed $_m Num Array or String. Array: Classnames. String: Classname.
	 * @return void
	 */
	public function addDefaults($_m)
	{
		if (isset($_m) && is_array($_m)) {
			foreach ($_m as $key => $className) {
				if (is_string($className)
				&& false === in_array($className, $this->_pluginsDefaults)) {
					$this->_pluginsDefaults[] = $className;
				}
			}
		} elseif (isset($_m) && is_string($_m)) {
			// Add defaults.
			if (false === in_array($_m, $this->_pluginsDefaults)) {
				array_push($this->_pluginsDefaults, $_m);
			}
			
			// Constructor arguments are given.
			if (func_num_args() > 1) {
				$aArgs = func_get_args();
				
				$addArgs = new ReflectionMethod(__CLASS__, 'addArgs');
				
				$addArgs->invokeArgs($this, $aArgs);
			}
		} else {
// @todo wrong type
		}
	}
	
// MUST +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

	/**
	 * Setter
	 * 
	 * By Default: Value of $_SERVER['REQUEST_URI'].
	 * @param string $_s
	 * @return void
	 */
	public function setUrlParams($_s)
	{
		if (isset($_s) && is_string($_s)) {
			$this->_urlParams = $_s;
		}
	}
	
// MUST +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

	/**
	 * Setter
	 * 
	 * BaseUrl comes from Front Controller and is set by constructor. You can
	 * set (overwrite) the BaseUrl by this setter method.
	 * NOTE: This setter will not change the major baseUrl of the front controller!
	 * It is for Plugger use only.
	 * @param string $_s
	 * @return void
	 */
	public function setBaseUrl($_s)
	{
		if (isset($_s) && is_string($_s)) {
			$this->_baseUrl = $_s;
		}
	}
	
// MUST +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

	/**
	 * Setter
	 * 
	 * NOTE: A Loader object has been set before run().
	 * @param object $_o Zend_Loader_PluginLoader_Interface
	 * @return void
	 */
	public function setLoader(Zend_Loader_PluginLoader_Interface $_o)
	{
		$this->_loader = $_o;
		$this->_initialized(__METHOD__);
	}
	
// MUST +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	
	/**
	 * Run Plugger, means register plugins. Plugger has to be initialized otherwise
	 * an exception would be thrown.
	 * 
	 * NOTE: Use only in mode $_run: false (Last argument of constructor - Default: false).
	 * @uses loadArea() 
	 * @throws Bolzz_Exception_Plugger
	 * @return void
	 */
	public function run()
	{
		$this->loadArea();

		if (true === $this->isInitialized()) {
			$this->_registerDefaults();
			
			$this->_registerSpecials();
		} else {
			throw new Bolzz_Exception_Plugger('Plugger is not full initialized and not ready to run or register plugins.');
		}
	}
	
// MUST +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

	/**
	 * Reset initialization. 
	 * 
	 * Members keep their values, only members which are
	 * important for a minimum of initialization will be cleared!
	 * @uses ReflectionClass
	 * @return void
	 */
	public function reset()
	{
		$clsPlugger = new ReflectionClass(__CLASS__);
		
		$defaultProps = $clsPlugger->getDefaultProperties();
		
		$this->_initialized = $defaultProps['_initialized'];
		$this->_initList 	= $defaultProps['_initList'];
		$this->_area 		= $defaultProps['_area'];
		$this->_loader 		= $defaultProps['_loader'];
	}

// MUST +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

	/**
	 * Clear all member values.
	 * 
	 * @uses reset()
	 * @uses ReflectionClass
	 * @return void
	 */
	public function clear()
	{
		$this->reset();

		$clsParent 		= new ReflectionClass(get_parent_class($this));
		$parentProps 	= $clsParent->getDefaultProperties();

		$clsPlugger 	= new ReflectionClass(__CLASS__);
		$selfProps 	= $clsPlugger->getDefaultProperties();
		
		// Do not change parent's members
		$props = array_diff_assoc($selfProps, $parentProps);
		
		if (is_array($props)) {
			foreach ($props as $sMember => $mValue) {
				$this->{$sMember} = $mValue;
			}
		}
	}
}

<?php
/**
 * Bolzz Library
 * http://www.bolzz.com - BOLZZ | IT Entwicklung
 *
 * LICENSE
 * 100% Freeware and Open Source
 *
 * @package Bolzz
 * @subpackage Exception
 */
 
/**
 * Plugin Manager Exception
 *
 * @version Version 0.1.0
 */
class Bolzz_Exception_Plugger extends Exception
{
	public function __construct($_message = '')
	{
		$this->message = $_message;
	}
}

<?php
class Dropper_Auth_Adapter_Config implements Zend_Auth_Adapter_Interface
{
	protected $_credential;
	protected $_identity;
	protected $_credentialField;
	protected $_identityField;
	
	/**
	 * Global config
	 *
	 * @var Zend_Config
	 */
	protected $_config;
	
	public function __construct(Zend_Config $config, $credentialField, $identityField)
	{
		$this->_config = $config;
		$this->setCredentialField($credentialField)
			->setIdentityField($identityField);
	}
	
	/**
	 * Set credential field
	 *
	 * @param string $credentialField
	 * @return Dropper_Auth_Adapter_Config
	 */
	public function setCredentialField($credentialField)
	{
		$this->_credentialField = $credentialField;
		return $this;
	}
	
	/**
	 * Set identity field
	 *
	 * @param string $identityField
	 * @return Dropper_Auth_Adapter_Config
	 */
	public function setIdentityField($identityField)
	{
		$this->_identityField = $identityField;
		return $this;
	}
	
	/**
	 * Set credential value
	 *
	 * @param string $credentia
	 * @return Dropper_Auth_Adapter_Config
	 */
	public function setCredential($credential)
	{
		$this->_credential = $credential;
		return $this;	
	}
	
	/**
	 * Set identity value
	 *
	 * @param string $identity
	 * @return Dropper_Auth_Adapter_Config
	 */
	public function setIdentity($identity)
	{
		$this->_identity = $identity;
		return $this;
	}
	
	/**
	 * Authenticate process
	 *
	 * @return Zend_Auth_Result
	 */
	public function authenticate()
	{
		$crField = explode(".", $this->_credentialField);
		$idField = explode(".", $this->_identityField);
		$tmpConfig = $this->_config;
		foreach($crField as $part) {
			$tmpConfig = $tmpConfig->get($part);
			if (!$tmpConfig instanceof Zend_Config) {
				$credential = $tmpConfig;
			}
		}
		
		
		$tmpConfig = $this->_config;
		foreach($idField as $part) {
			$tmpConfig = $tmpConfig->get($part);
			if (!$tmpConfig instanceof Zend_Config) {
				$identity = $tmpConfig;
			}
		}

		if (!$credential || !$identity) {
			throw new Zend_Auth_Adapter_Exception("Credential and Identity fields shouldn't be empty");
		}
		
		$result = array(
			'code' => Zend_Auth_Result::FAILURE,
			'messages' => array('Invalid identity or credential')
		);
		
		if ($this->_identity == $identity && $this->_credential ==md5($credential)) {
			$result = array(
				'code' => Zend_Auth_Result::SUCCESS,
				'messages' => array('Identity and credential are valid')
			);
		}
		
		return new Zend_Auth_Result($result['code'], $this->_identity, $result['messages']);
	}
}
?>

/**
 *@example
 */
<?php
    try {
					$authAdapter = new Dropper_Auth_Adapter_Config($this->_config, "user.password", "user.login");
					$authAdapter->setIdentity($form->getValue('username'))
								->setCredential($form->getValue('password'));
					$result = Zend_Auth::getInstance()->authenticate($authAdapter);
				} catch (Zend_Auth_Adapter_Exception $e) {
					//exception handling
				}
?>

Create class FormRTE in library/Zend/Form/Element/

/**
 * Zend Framework
 *
 * LICENSE
 *
 * This source file is subject to the new BSD license that is bundled
 * with this package in the file LICENSE.txt.
 * It is also available through the world-wide-web at this URL:
 * http://framework.zend.com/license/new-bsd
 * If you did not receive a copy of the license and are unable to
 * obtain it through the world-wide-web, please send an email
 * to license@zend.com so we can send you a copy immediately.
 *
 * @category   Zend
 * @package    Zend_Form
 * @subpackage Element
 * @copyright  Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
 * @license    http://framework.zend.com/license/new-bsd     New BSD License
 */

/** Zend_Form_Element_Xhtml */
require_once 'Zend/Form/Element/Xhtml.php';

/**
 * Textarea form element
 * 
 * @category   Zend
 * @package    Zend_Form
 * @subpackage Element
 * @copyright  Copyright (c) 2005-2008 Zend Technologies USA Inc. (http://www.zend.com)
 * @license    http://framework.zend.com/license/new-bsd     New BSD License
 * @version    $Id: Textarea.php 8064 2008-02-16 10:58:39Z thomas $
 */
class Zend_Form_Element_FormRTE extends Zend_Form_Element_Xhtml
{
    /**
     * Use formTextarea view helper by default
     * @var string
     */
    public $helper = 'formRTE';
}

create in Zend/View/Helper the class Zend_View_Helper_FormRTE or use an other HelperPath

<?php
$view->setHelperPath(APPLICATION_PATH . '/helpers');
?>

<?php 

/** 
 * Abstract class for extension 
 */ 
require_once 'Zend/View/Helper/FormElement.php'; 

/** 
 * FCKeditor PHP class 
 */ 
require_once 'formRTE/fckeditor/fckeditor.php'; 


/** 
 * Helper to generate a "textarea" element 
 * 
 * @category   Zend 
 * @package    Zend_View 
 * @subpackage Helper 
 * @copyright  Copyright (c) 2005-2009 Zend Technologies USA Inc. (http://www.zend.com) 
 * @license    http://framework.zend.com/license/new-bsd     New BSD License 
 */ 
class Zend_View_Helper_FormRTE extends Zend_View_Helper_FormElement 
{ 
    /** 
     * Generates a richtext element using FCKeditor. 
     * 
     * @access public 
     * 
     * @param string|array $name If a string, the element name.  If an 
     * array, all other parameters are ignored, and the array elements 
     * are extracted in place of added parameters. 
     * 
     * @param mixed $value The element value. 
     * 
     * @param array $attribs Attributes for the element tag. 
     * 
     * @return string The element XHTML. 
     */ 
    public function formRTE($name = null, $value = null, $attribs = null) 
    { 
        if(is_null($name) && is_null($value) && is_null($attribs)) { 
            return $this; 
        } 
         
        $info = $this->_getInfo($name, $value, $attribs); 
        extract($info); // name, value, attribs, options, listsep, disable 

        $editor = new FCKeditor($name); 
         
        // set variables
        $editor->BasePath    = 'http://localhost/xxxx/application/helpers/formRTE/fckeditor/' ; 
        $editor->ToolbarSet = empty($attribs['ToolbarSet']) ? 'Basic' : $attribs['ToolbarSet']; 
        $editor->Width        = empty($attribs['Width']) ? '50%' : $attribs['Width']; 
        $editor->Height        = empty($attribs['Height']) ? 250 : $attribs['Height']; 
        $editor->Value        = $value; 
         
        // set Config  
        $editor->Config['BaseHref'] = $editor->BasePath;
        $editor->Config['CustomConfigurationsPath'] = $editor->BasePath.'editor/fckconfig.js'; 
        $editor->Config['SkinPath'] = $editor->BasePath.'editor/skins/silver/';         
        return $editor->createHtml(); 
         
    } 
         
}

You can add this element to your form like other form elements:


$myForm->addElement('formRTE', 'message', array(
                                                        'label'      => 'formRTE label:',
											            'required'   => true,
											            'value'      => 'Salam, Schalom, Pax vobis <i>this string </i>is the value variable  of the View_Helper,<br/>
											                         but i give this string to <b>form->addElement()</b> ',
                                                        'attribs'    => array('myattribute') 
                                                        )
                         );

<?php

function __autoload($className) {
    require $className = str_replace('_', '/', $className) . '.php';
}

class Bootstrap{

    public static $frontController = null;

    public static $root = '';

    public static $registry = null;

    public static function run(){
        self::prepare();

        $response = self::$frontController->dispatch();
        self::sendResponse($response);
    }


    public static function prepare(){
        self::setupEnvironment();

        self::setupRegistry();
        self::setupConfiguration();

        self::setupFrontController();
        self::setupErrorHandler();

        self::setupController();
        self::setupView();
        self::setupDatabase();
        self::setupSessions();
        self::setupTranslation();
        self::setupRoutes();
        self::setupAcl();
        self::setupDebug();
    }



    public static function setupEnvironment(){
        error_reporting(E_ALL ^ E_NOTICE);
        ini_set('display_errors', true);

        date_default_timezone_set('Europe/Bucharest');

        self::$root = dirname(dirname(__FILE__));

        $configType = (isset($_SERVER['SERVER_NAME']) && ($_SERVER['SERVER_NAME'] == '127.0.0.1' OR $_SERVER['SERVER_NAME'] == 'localhost')) ? 'development' : 'production';
        define('APPLICATION_ENVIRONMENT', $configType);

        define('HTMLPURIFIER_PREFIX', self::$root . '/library');
    }


    public static function setupRegistry() {
        self::$registry = new Zend_Registry(array(), ArrayObject::ARRAY_AS_PROPS);
        Zend_Registry::setInstance(self::$registry);
    }

    public static function setupConfiguration() {

        $config = new Zend_Config_Ini(
            self::$root . '/application/config/main.ini',
            APPLICATION_ENVIRONMENT
        );

        self::$registry->configuration = $config;

        //save $siteRootDir in registry:
        self::$registry->set('siteRootDir', self::$root );
        self::$registry->set('applicationRootDir', self::$root . '/application' );

        self::$registry->set('siteUploadDir', self::$root . '/uploads');

        self::$registry->set('siteRootUrl', 'http://' . $_SERVER['HTTP_HOST'] );
        self::$registry->set('siteUploadUrl', '/uploads' );
    }


    public static function setupFrontController(){
        self::$frontController = Zend_Controller_Front::getInstance();
        self::$frontController->throwExceptions(true);
        self::$frontController->returnResponse(true);

        self::$frontController->addModuleDirectory(self::$root . '/application/modules');

        self::$frontController->setParam('registry', self::$registry);

        self::$frontController->setParam('env', APPLICATION_ENVIRONMENT);


        $response = new Zend_Controller_Response_Http; // Set default Content-Type
        $response->setHeader('Content-Type', 'text/html; charset=UTF-8', true);
        self::$frontController->setResponse($response);
    }


    public static function setupErrorHandler() {
        self::$frontController->throwExceptions(false);

        self::$frontController->registerPlugin(new Zend_Controller_Plugin_ErrorHandler(
            array(
                'module'     => 'default',
                'controller' => 'error',
                'action'     => 'error')
            ));

        $writer = new Zend_Log_Writer_Firebug();
        $logger = new Zend_Log($writer);
        Zend_Registry::set('logger',$logger);


    }


    public static function setupController(){
        Zend_Controller_Action_HelperBroker::addHelper(new GSD_Controller_Action_Helper_AuthUsers());
        Zend_Controller_Action_HelperBroker::addHelper(new GSD_Controller_Action_Helper_Breadcrumbs());
    }

    public static function setupView() {

        $view = new Zend_View(array('encoding'=>'UTF-8'));
        $view->addHelperPath('GSD/View/Helper', 'GSD_View_Helper_');

        $viewRendered = new Zend_Controller_Action_Helper_ViewRenderer($view);
        Zend_Controller_Action_HelperBroker::addHelper($viewRendered);

        Zend_Layout::startMvc(
            array(
                'layoutPath' => self::$root . '/application/layouts',
                'layout' => 'default'
            )
        );

        if (self::$frontController) {
            self::$frontController->registerPlugin(new GSD_Layout_Controller_Plugin_Layout());
        }
    }


    public static function sendResponse(Zend_Controller_Response_Http $response){
        $response->sendResponse();
    }


    public static function setupDatabase($options = array()){
        extract($options);

        $config = self::$registry->configuration;

        $db = Zend_Db::factory($config->db->adapter, $config->db->toArray());

        $profiler = new Zend_Db_Profiler_Firebug('All DB Queries');
        $profiler->setEnabled(true);
        $db->setProfiler($profiler);

        $db->query("SET NAMES 'utf8'");

        self::$registry->database = $db;
        Zend_Db_Table::setDefaultAdapter($db);

        if (!isset($dissableCache) && $dissableCache !== true) {
            $frontendOptions = array(
                'automatic_serialization' => true
                );


                $backendOptions  = array(
                    'cache_dir' => self::$root . '/data/cache/db_table'
                );

            $cache = Zend_Cache::factory('Core',
                                         'File',
                                         $frontendOptions,
                                         $backendOptions);


            // Next, set the cache to be used with all table objects
            Zend_Db_Table_Abstract::setDefaultMetadataCache($cache);
        }
    }


    public static function setupSessions(){
        if (isset($_POST["PHPSESSID"])) {
            session_id($_POST["PHPSESSID"]);
        }

        // Now set session save handler to our custom class which saves the data in MySQL database
        $sessionManager = new GSD_Session_Manager();
        Zend_Session::setOptions(array(
            'gc_probability' => 1,
            'gc_divisor' => 5000
            ));
        Zend_Session::setSaveHandler($sessionManager);

        $defSession = new Zend_Session_Namespace('Main', true);
        Zend_Registry::set('defSession', $defSession);
    }


    public static function setupTranslation(){
        $options = array(
                    'scan' => Zend_Translate::LOCALE_FILENAME,
                    'disableNotices' => true,
                    );
        $translate = new Zend_Translate('gettext', Zend_Registry::get('siteRootDir') . '/application/languages/', 'auto', $options);
        Zend_Registry::set('Zend_Translate', $translate);

    }


    public static function setupRoutes(){
        // define some routes (URLs)
        $router = self::$frontController->getRouter();

        $config = new Zend_Config_Ini(
            self::$root . '/application/config/routes.ini',
            'development'
        );

        $router->addConfig($config, 'routes');
    }


    public static function setupAcl(){
        self::$frontController->registerPlugin(new GSD_Controller_Plugin_Acl());
    }

    public static function setupDebug() {
        $scBar = new Scienta_Controller_Plugin_Debug(array(
           'database_adapter' =>  self::$registry->database, // or array of adapters
           'memory_usage' =>      TRUE, // default value shown
           'collect_view_vars' => TRUE,
           'sort_view_vars' =>    TRUE,
           'show_exceptions' =>   TRUE,
           'handle_errors' =>     FALSE
        ));
        self::$frontController->registerPlugin($scBar);
    }
} 

// Foreach snippet

define('APPLICATION_PATH', realpath(dirname(__FILE__) . '/../application/'));

set_include_path(
    APPLICATION_PATH . '/../library'
    . PATH_SEPARATOR . get_include_path()
);

require_once "Zend/Loader.php";
Zend_Loader::registerAutoload();

try {
    require '../application/bootstrap.php';
} catch (Exception $exception) {
    echo 'Bootstrapping failed' . $exception->getMessage();
    exit(1);
}


require_once APPLICATION_PATH . '/models/Snippet.php';
$model = new Model_Snippet;
$model->setUsePaginator(false);

$client = new Zend_Http_Client();
$client->setConfig(array(
    'maxredirects' => 0,
    'timeout'      => 30));

if (is_file(APPLICATION_PATH . '/data/search/index')) {
    $index = Zend_Search_Lucene::open(APPLICATION_PATH . '/../data/search/index');
} else {
    $index = Zend_Search_Lucene::create(APPLICATION_PATH . '/../data/search/index');
}

foreach($model->fetch() as $snip) {
    $url = Zend_Registry::get('configuration')->app->url . 'snippets/view/id/' . $snip->snippet_id;
    $client->setUri($url);
    $response = $client->request();

    if ($response->isSuccessful()) {
        $doc = Zend_Search_Lucene_Document_Html::loadHTML($response->getBody());
        $doc->addField(Zend_Search_Lucene_Field::UnIndexed('indexed', time())); 
        $doc->addField(Zend_Search_Lucene_Field::UnIndexed('id', $snip->snippet_id));

        $index->addDocument($doc);
    }
}

$index->commit();

echo $index->count(), " Documents indexed.", PHP_EOL;

class GSD_View_Helper_Fb extends Zend_View_Helper_Abstract{

    public function fb($message, $label=null){
        if ($label!=null) {
            $message = array($label,$message);
        }
        Zend_Registry::get('logger')->err($message);
    }

}

$writer = new Zend_Log_Writer_Firebug();
$logger = new Zend_Log($writer);
		Zend_Registry::set('logger',$logger);