As I wanted to use the same functionality and didn’t find an existing solution I wrote a simple jQuery plugin for this purpose: jquery-jknavigable. Its usage is pretty simple, to make the posts of a blog navigable with the “j” and “k” keys you would use the following code:

$('.post').jknavigable();

By default the active element is marked with the class “active” so you can style it differently. If necessary, you can specify your own class name:

$('.post').jknavigable({'activeClass': 'someClass'});

That’s it. Feedback is, as always, welcome.

PS: a good starting point for writing your own plugin is jQuery’s Plugin Authoring page.

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!

dho@tumulux:~/projects/myrailsproject$ ./script/plugin install git://github.com/rails/open_id_authentication.git

The example command from above will download the OpenIdAuthentication plugin from GitHub and put the plugin in the vendor/plugins directory. Quite handy.

In the CakePHP world there is currently no equivalent. However, John David Anderson (aka _psychic_) recently published an early version of a Plugins shell console application to manage plugins.

Happy working with plugins!

If you hover the mouse over one of the titles, it shows you the respective information, e.g. the content of the session. Pretty simple.

All you have to do is to place DebugKit in the plugins folder of your application and to add the following to your AppController (resp. the controller(s) where you want to use it):

public $components = array('DebugKit.toolbar');

You can get DebugKit either via Git with

git clone git://github.com/cakephp/debug_kit.git

or you can download it as zip/tar from github. There is also some documentation available.

Happy baking!

PS: Some days ago Garrett Woodworth (aka gwoo) talked about CakePHP and Beyond at the CakePHP conference in Tokyo. It’s not a very technical talk, but maybe it is still of interest for some of you. [via CakePHP Google Group]

In the meantime this ability has been introduced (I don’t know when it was added). To make use of it, you have to add a “vendors” folder with the subfolders “css”, “img”, and “js” to your plugin:

app
  plugins
    myplugin
      vendors
         css
         img
         js

Files in those folders can then be accessed like http://example.com/myplugin/img/my_image.jpg.

Unfortunately, HtmlHelper and JavascriptHelper are not (yet?) aware of this new feature. For example, the following code used in a view of your plugin:

<?php echo $html->image('my_image.jpg'); ?>

will create this HTML code:

<img src="/img/my_image.jpg" alt="" />

As you see, the path points to the “img” folder of your application, and not to the “img” folder of your plugin. To avoid this, we have to specify the full path to the image:

<?php echo $html->image('/'.$this->plugin.'/img/my_image.jpg'); ?>
// creates: <img src="/myplugin/img/my_image.jpg" alt="" />

The same also applies when including CSS styles and Javascript files.

Happy plugin baking :)

PS1: A new “notEmpty” validation rule has recently been added (“teknoid” was faster with an article, so here just a link to his article).

PS2: A CakePHP presentation (in German) by Timo Derstappen.

cake bake help

Anyway, its usage is quite straight-forward. With

cake bake plugin demo

you can generate the structure and the base files for a plug-in with the name “demo”. This actually creates the following structure and files in app/plugins:

demo
  controllers
    components
  models
    behaviors
  views
    helpers
  demo_app_controller.php
  demo_app_model.php

With

cake bake plugin demo controller
cake bake plugin demo model
cake bake plugin demo view

you can bake controllers, models, and views for the “demo” plug-in. The parameters you can use are the same as when baking “normal” controllers, models, and views, for example

cake bake plugin demo controller users

bakes a UsersController with var $scaffold set. See Faster baking of controllers with the bake shell script or Baking views for more details.

One thing you have to be aware of is that the generated controllers and models extend AppController resp. AppModel by default, and not the plug-in-specific versions, i.e. DemoAppController resp. DemoAppModel in the “demo” plug-in example. That means you have to manually change this if you want to make use of the plug-in-specific AppController resp. AppModel.

Happy baking :)

app/
    plugins/
        pluginname/
            tests/
                components
                controllers
                fixtures
                helpers
                models

Only the groups folder is missing, as I am not (yet) convinced it is needed.

You can write the plugin tests in the same way you write your other tests (see http://cakebaker.42dh.com/2006/12/18/testing-with-cakephp-12-a-preview/).

You can execute the plugin test via command line with:

php bake2.php test application-alias plugins  // executes all plugin tests
php bake2.php test application-alias plugin pluginname  // executes all tests of the specified plugin

Or if you use the web interface you can call:

http://example.com/tests/plugins  // executes all plugin tests
http://example.com/tests/plugin/pluginname  // executes all tests of the specified plugin

Feedback is welcome. Happy testing :)