# Examples

The Bootstrap class itself will typically be fairly minimal; often, it will simply be an empty stub extending the base bootstrap class:

    class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
    {
    }

With a corresponding configuration file:

    ; APPLICATION_PATH/configs/application.ini
    [production]
    autoloaderNamespaces[] = "My_"
    bootstrap.path = APPLICATION_PATH "/Bootstrap.php"
    bootstrap.class = "Bootstrap"
    pluginpaths.My_Bootstrap_Resource = "My/Bootstrap/Resource"
    resources.frontController.controllerDirectory = APPLICATION_PATH "/controllers"

    [testing : production]
    [development : production]

Autoloader namespaces

Because these examples use custom code, we need to register the namespace prefixes for that code with our configuration; this is done with the autoloaderNamespaces configuration key, which is an array.

Additionally, to ensure that custom plugin resources are discovered, we need to register a plugin prefix path with the bootstrap. This is done with the pluginpaths configuration key, which is an associative array, with keys denoting the prefix to use, and values denoting the path related to that prefix.

However, should custom initialization be necessary, you have two choices. First, you can write methods prefixed with _init to specify discrete code to bootstrap. These methods will be called by bootstrap(), and can also be called as if they were public methods: bootstrap<resource>(). They should accept an optional array of options.

If your resource method returns a value, it will be stored in a container in the bootstrap. This can be useful when different resources need to interact (such as one resource injecting itself into another). The method getResource() can then be used to retrieve those values.

The example below shows a resource method for initializing the request object. It makes use of dependency tracking (it depends on the front controller resource), fetching a resource from the bootstrap, and returning a value to store in the bootstrap.

    class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
    {
        protected function _initRequest()
        {
            // Ensure front controller instance is present, and fetch it
            $this->bootstrap('FrontController');
            $front = $this->getResource('FrontController');

            // Initialize the request object
            $request = new Zend_Controller_Request_Http();
            $request->setBaseUrl('/foo');

            // Add it to the front controller
            $front->setRequest($request);

            // Bootstrap will store this value in the 'request' key of its container
            return $request;
        }
    }

Note in this example the call to bootstrap(); this ensures that the front controller has been initialized prior to calling this method. That call may trigger either a resource or another method in the class.

The other option is to use resource plugins. Resource plugins are objects that perform specific initializations, and may be specified:

- When instantiating the Zend_Application object

- During initialization of the bootstrap object

- By explicitly enabling them via method calls to the bootstrap object

Resource plugins implement Zend_Application_Resource_ResourceAbstract, which defines simply that they allow injection of the caller and options, and that they have an init() method. As an example, a custom "View" bootstrap resource might look like the following:

    class My_Bootstrap_Resource_View
        extends Zend_Application_Resource_ResourceAbstract
    {
        public function init()
        {
            $view = new Zend_View($this->getOptions());
            Zend_Dojo::enableView($view);

            $view->doctype('XHTML1_STRICT');
            $view->headTitle()->setSeparator(' - ')->append('My Site');
            $view->headMeta()->appendHttpEquiv('Content-Type',
                                               'text/html; charset=utf-8');

            $view->dojo()->setDjConfigOption('parseOnLoad', true)
                         ->setLocalPath('/js/dojo/dojo.js')
                         ->registerModulePath('../spindle', 'spindle')
                         ->addStylesheetModule('spindle.themes.spindle')
                         ->requireModule('spindle.main')
                         ->disable();

            $viewRenderer = Zend_Controller_Action_HelperBroker::getStaticHelper(
                'ViewRenderer'
            );
            $viewRenderer->setView($view);

            return $view;
        }
    }

To tell the bootstrap to use this, you would need to provide either the class name of the resource plugin, or a combination of a plugin loader prefix path and the short name of the resource plugin (e.g, "view"):

    $application = new Zend_Application(
        APPLICATION_ENV,
        array(
            'resources' => array(
                'My_Bootstrap_Resource_View' => array(), // full class name; OR
                'view' => array(),                       // short name

                'FrontController' => array(
                    'controllerDirectory' => APPLICATION_PATH . '/controllers',
                ),
            ),

            // For short names, define plugin paths:
            'pluginPaths = array(
                'My_Bootstrap_Resource' => 'My/Bootstrap/Resource',
            )
        )
    );

Resource plugins can call on other resources and initializers by accessing the parent bootstrap:

    class My_Bootstrap_Resource_Layout
        extends Zend_Application_Resource_ResourceAbstract
    {
        public function init()
        {
            // ensure view is initialized...
            $this->getBootstrap()->bootstrap('view');

            // Get view object:
            $view = $this->getBootstrap()->getResource('view');

            // ...
        }
    }

In normal usage, you would instantiate the application, bootstrap it, and run it:

    $application = new Zend_Application(...);
    $application->bootstrap()
                ->run();

For a custom script, you might need to simply initialize specific resources:

    $application = new Zend_Application(...);
    $application->getBootstrap()->bootstrap('db');

    $service = new Zend_XmlRpc_Server();
    $service->setClass('Foo');  // uses database...
    echo $service->handle();

Instead of using the bootstrap() method to call the internal methods or resources, you may also use overloading:

    $application = new Zend_Application(...);
    $application->getBootstrap()->bootstrapDb();