public function example() {
    App::import('Vendor', 'example', array('file' => 'Example.php'));
    $example = new Example();
    ...
}

This snippet works fine if it is used in an application, but it will fail with a “Class not found” error if the snippet and the corresponding vendors file (“Example.php”) are put into a plugin. The reason for the failure is that you have to use the plugin name as a prefix when importing something from a plugin, even if you use App::import() from within the respective plugin:

// test is the plugin name
App::import('Vendor', 'test.example', array('file' => 'Example.php'));

The consequence of this behavior is that your code has to know in which “environment” it runs if you want to make it really reusable. An alternative is to “circumvent” the application “environment” and to distribute your code, and the required vendors files, as a plugin.

In the OpenID component I solved this problem by determining in which “vendors” directory the required library is. And if it is in the plugin’s “vendors” directory, I set an instance variable $importPrefix with the plugin name. This prefix is then used whenever a file is imported.

Here is the relevant code:

class OpenidComponent extends Object {
    private $importPrefix = '';

    public function __construct() {
        parent::__construct();

        $pathToVendorsFolder = $this->getPathToVendorsFolderWithOpenIDLibrary();
		
        if ($pathToVendorsFolder == '') {
            exit('Unable to find the PHP OpenID library');
        }
		
        if ($this->isPathWithinPlugin($pathToVendorsFolder)) {
            $this->importPrefix = $this->getPluginName() . '.';
        }

        $this->importCoreFilesFromOpenIDLibrary();
    }

    private function getPathToVendorsFolderWithOpenIDLibrary() {
        $pathToVendorsFolder = '';
		
        if ($this->isPathWithinPlugin(__FILE__)) {
            $pluginName = $this->getPluginName();
			
            if (file_exists(APP.'plugins'.DS.$pluginName.DS.'vendors'.DS.'Auth')) {
                $pathToVendorsFolder = APP.'plugins'.DS.$pluginName.DS.'vendors'.DS;
            }
        }

        if ($pathToVendorsFolder == '') {
            if (file_exists(APP.'vendors'.DS.'Auth')) {
                $pathToVendorsFolder = APP.'vendors'.DS;
            } elseif (file_exists(VENDORS.'Auth')) {
                $pathToVendorsFolder = VENDORS;
            }
        }
		
        return $pathToVendorsFolder;
    }
	
    private function getPluginName() {
        $result = array();
        if (preg_match('#'.DS.'plugins'.DS.'(.*)'.DS.'controllers#', __FILE__, $result)) { 
            return $result[1];
        }

        return false;
    }

    private function importCoreFilesFromOpenIDLibrary() {
        App::import('Vendor', $this->importPrefix.'consumer', array('file' => 'Auth'.DS.'OpenID'.DS.'Consumer.php'));
        App::import('Vendor', $this->importPrefix.'sreg', array('file' => 'Auth'.DS.'OpenID'.DS.'SReg.php'));
    }

    private function isPathWithinPlugin($path) {
        return strpos($path, DS.'plugins'.DS) ? true : false;
    }
}

This code is meant to give you an idea of how it could be solved in that specific situation, and not as a solution you can copy 1:1…

Happy baking!

Fortunately, PHP5 provides a solution for this “problem”: auto-loading. The explanation from the manual: “You may define an __autoload function which is automatically called in case you are trying to use a class/interface which hasn’t been defined yet. By calling this function the scripting engine is given a last chance to load the class before PHP fails with an error.”

In CakePHP a good place for this function is app/config/bootstrap.php. The function to auto-load vendor files looks like:

function __autoload($className) {
    App::import('Vendor', $className);
}

If you want to use a custom function or a method of a class, you simply have to register your auto-load implementation. The example from above realized with a static method looks like:

class AutoLoader {
    public static function load($className) {
        App::import('Vendor', $className);
    }
}

spl_autoload_register(array('AutoLoader', 'load'));

You can find more information about auto-loading in the PHP manual: Autoloading objects and spl_autoload_register.

Happy baking!

The new way is to use App::import(). To load a file named “example.php”, you have to use the following snippet:

App::import('Vendor', 'example');

Unfortunately, there’s a snag to it: it only works if the name is in lowercase, i.e. the following snippet won’t load the file “Example.php”:

App::import('Vendor', 'Example');

Instead you have to use:

App::import('Vendor', 'example', array('file' => 'Example.php'));

The second parameter can be any string except an empty string or null, but I don’t know what the meaning of this parameter is in this context…

The same also applies for folder names:

App::import('Vendor', 'example'.DS.'example'); // loads example/example.php
App::import('Vendor', 'example', array('file' => 'Example'.DS.'example.php')); // loads Example/example.php

It’s quite illogical, but according to some newly added tests it is supposed to work in this way…