Well, the assumption that there is no controller is wrong. There is one, the PagesController, though by default it is “hidden” in cake/libs/controller (unless you baked your project with the bake script, then you will also find a PagesController in app/controllers).

And this means you can specify the helpers you want to use in your static pages in the usual way: by adding them to the $helpers array of the PagesController resp. the AppController (app/app_controller.php), if you want to use the helpers in the views of more than one controller. Please do not edit the PagesController in the cake/libs/controller directory, but copy it to app/controllers and make the changes there.

The first approach is to copy the HtmlHelper from the core (cake/libs/view/helpers/html.php) to the helpers folder of your application (app/views/helpers). And then you can modify this file as you like. Easy. The problem of this approach is the code duplication. If something in the core HtmlHelper is changed by the developers you have to reapply the changes in your own HtmlHelper…

The second approach is to replace the HtmlHelper with your own helper that extends the HtmlHelper. For this purpose you have to create a custom view class which overrides the _loadHelpers() method of the View. It’s probably best if I do a simple example to show the idea.

First we create our own helper:

// app/views/helpers/example.php
App::import('Helper', 'Html');
class ExampleHelper extends HtmlHelper {
    public function link($title, $url = null, $htmlAttributes = array(), $confirmMessage = false, $escapeTitle = true) {
        return '<a href="http://example.com">example</a>';
    }
}

Next, we create our custom view class:

// app/views/example.php
class ExampleView extends View {
    public function &_loadHelpers(&$loaded, $helpers, $parent = null) {
        $loaded = parent::_loadHelpers($loaded, $helpers, $parent);
        $helper = 'Html';
		
        if (isset($loaded[$helper])) {
            App::import('Helper', 'Example');
            $loaded[$helper] = new ExampleHelper();
	
            // everything from here on is copied from View::_loadHelpers()
		
            $vars = array('base', 'webroot', 'here', 'params', 'action', 'data', 'themeWeb', 'plugin');
            $c = count($vars);

            for ($j = 0; $j < $c; $j++) {
                $loaded[$helper]->{$vars[$j]} = $this->{$vars[$j]};
            }

            if (!empty($this->validationErrors)) {
                $loaded[$helper]->validationErrors = $this->validationErrors;
            }

            if (is_array($loaded[$helper]->helpers) && !empty($loaded[$helper]->helpers)) {
                $loaded =& $this->_loadHelpers($loaded, $loaded[$helper]->helpers, $helper);
            }
        }
		
        return $loaded;
    }
}

You probably wonder why I override _loadHelpers() and not _loadHelper(). Well, the reason is simple, there is no _loadHelper() method in the View class. And so I have to copy the code to setup a helper from the parent method. Not very clean, I know…

The last step is to specify that we want to use the view class we created above. We can do this in the AppController with:

// app/app_controller.php
class AppController extends Controller {
    public $view = 'Example';
}

Now, all links in our views should point to example.com.

The obvious disadvantage of this approach is that it is a hack ;-) And I’m not sure whether it works to 100%. Use it on your own risk!

Personally, I would like to see the approach described by grigri (see his comment) in the core (or something similar): “It would be great if the cake helpers were really named ‘BaseHtmlHelper’ with an empty class ‘HtmlHelper’ which is loaded from the cake folder if not present in the app folder.”

Have a look at the following helper implementing the callback methods:

class ExampleHelper extends AppHelper {
    public function beforeLayout() {
        echo 'beforeLayout';
    }

    public function afterLayout() {
        echo 'afterLayout';
    }
	
    public function beforeRender() {
        echo 'beforeRender';
    }
	
    public function afterRender() {
        echo 'afterRender';
    }
}

What will be the output if you have a simple view and you add this helper to the $helpers array of the respective controller?

Personally I would have expected an output like:

beforeLayout
<html>...
beforeRender
the content of the view
afterRender
...</html>
afterLayout

But to my surprise the output is quite different:

beforeRender
beforeLayout
afterLayout
<html>...
the content of the view
afterRender
...</html>

I’m not sure whether this output is generated due to bugs in the rendering process or because it is the intended output…

On a first glance this might look like it is a good idea: it works fine and you can access the method with $html->myMethod() in the views. Perfect. Only, on a conceptual level this approach is wrong (and CakePHP shouldn’t allow you to do such things).

To see why it is wrong, let’s do a little thought experiment with a less abstract example. We have a Dog. Dog is an Animal. A Dog can run and follow commands, we can say they are its “methods”. For some reason the guy who created the Dog forgot that a Dog can bark, and so our Dog doesn’t bark. But we want a barking Dog! We only have the power to modify Animal but not the Dog, so we add the bark feature to the Animal. Now our Dog barks. Fine. However, what’s that? A barking cow. Barking birds. Hm, something went wrong…

Ok, I think you see what the problem is ;-)

There are two possible solutions to help you to avoid this problem: you either use inheritance to create a new type of Dog or you use composition to create a new type of Animal that uses a Dog (weird example, I know).

Applied to the helper situation I mentioned at the beginning of this article, it means you either create your own helper which extends the HtmlHelper or you create your own helper which extends AppHelper and uses internally the HtmlHelper.

Happy baking :)

That’s indeed a bit illogical if you think about it. It would be more logical to define the helpers directly where they are needed, in the views.

After some experimenting and digging in the source of the View class I found a relatively clean way to accomplish that by using a custom view class.

Ok, here is what I did. First I created a custom view class called “AppView” in app/views/app.php. It contains one method to load the helpers, which is later used in the views. I also had to override the constructor to support “global” helpers (i.e. they can be used in all views). So instead of defining them in the AppController they are now defined in the $helpers array of this custom view. FormHelper, HtmlHelper, and SessionHelper do not have to be defined, they are automatically loaded by CakePHP.

// app/views/app.php
class AppView extends View {
    public $helpers = array('Navigation');
	
    public function __construct(&$controller, $register = true) {
        $globalHelpers = $this->helpers;
        parent::__construct($controller, $register);
        $this->loadHelpers(array_merge($this->helpers, $globalHelpers));
    }
	
    public function loadHelpers($helperNames) {
        $helpers = $this->_loadHelpers($this->loaded, $helperNames);

        foreach ($helpers as $helper) {
            $name = str_replace('Helper', '', get_class($helper));
            $this->$name = $helper;
        }
    }
}

To use this custom view class, I have to tell the AppController to do so by setting the $view property:

// app/app_controller.php
class AppController extends Controller {
    public $view = 'App';
    ...
}

And finally I can load and use the desired helpers in the views like:

<?php 
$this->loadHelpers(array('CamelCase')); 
echo $this->CamelCase->getSomething();
echo $this->Form->create('MyModel');
...
?>

As you can see from the example above, the usage of the helpers is different from what you are used to. Instead of $form->create() I used $this->Form->create(). It’s more to write, but I think it is more consistent with the rest of the framework.

What do you think about this approach?

Update (2008-08-28): Thanks to Rafael Bandeira’s idea it is no longer necessary to call the loadHelpers() method in your views, just copy the following method to the AppView and it will auto-load the helpers when they are needed:

public function __get($property) {
    $this->loadHelpers(array($property));
    return $this->{$property};
}

public $helpers = array('Navigation');

or

public $helpers = array('navigation');

In both cases, you access the helper’s methods in your view with:

$navigation->someMethod();

If you use $Navigation instead of $navigation, then it causes a “call to a member function on a non-object” error.

If you use a helper from within another helper, the behavior changes and now it matters whether the first character of the helper’s name is lower- or uppercase in the $helpers array. Is the first character uppercased as in the example below:

// in your helper
public $helpers = array('Navigation');

Then you also have to use the uppercased name to access the helper’s methods, or you will get an error (with a lowercased name it is just the other way around):

$this->Navigation->someMethod();

vs.

$this->navigation->someMethod(); // causes an error

It’s one of those little pitfalls I encounter from time to time ;-)

In the following example I use an interval of 15 minutes, i.e. the generated select box for the minutes only contains the values “00″, “15″, “30″, and “45″:

echo $form->input('start', array('type' => 'time', 'interval' => 15));

The default interval is one minute, but from the user’s point of view it is not that user-friendly to have a select box with 60 values, so I recommend to specify a different interval as shown above.

Obviously this issue was caused by a recent change in the FormHelper, and according to a comment by Nate it was intentionally: “In order to enable model association mapping for FormHelper, non-existent fields are no longer supported. In order for a field to be recognized, it must exist in the model’s schema, or have a validation rule defined in Model::$validate.”

Hm, I have to say I don’t like it as it introduces dependencies which are not obvious. So the following snippet may work in one case, but not in another case:

echo $form->create('Model');
echo $form->input('Model.field');
echo $form->end();

If the model and the field exist, then the correct code is generated. The same if the model doesn’t exist. But if the model exists, and the field not, it generates wrong code (i.e. all input fields for non-existing model fields will have the same id). So, be careful when using virtual fields.

Let’s write a simple helper which creates an author meta tag.

Usually you write first the test, and then the application code. But in this case I will make an exception, as I think it is easier to understand if I write first the application code and then the test.

Writing the helper is straight-forward: we have to get the view and add the meta tag to this view:

// app/views/helpers/head.php
class HeadHelper extends AppHelper {
    function authorMetaTag($authorName) {
        $metaTag = '<meta name="author" content="'.$authorName.'">';
        $view = ClassRegistry::getObject('view');
        $view->addScript($metaTag);
    }
}

Before this helper can be used we have to add the following line to the head section of the (default) layout:

<?php echo $scripts_for_layout; ?>

With that we are ready to write our test (resp. we are finished with our work if we don’t write tests).

The test skeleton is easy:

class HeadHelperTest extends CakeTestCase {
    var $helper = null;

    function setUp() {
        $this->helper = new HeadHelper();
    }

    function testAuthorMetaTag() {
        $this->helper->authorMetaTag('cakebaker');
    }
}

As you have seen in the implementation of the helper, we retrieve a view object from the ClassRegistry. So to test our helper we also have to put a view object into the ClassRegistry. If you look at the source code of the view class constructor, you will see the view is automatically added to the ClassRegistry (to make sure the correct view is in the ClassRegistry we have to remove a possible view due to the behavior of ClassRegistry I explained in an earlier article). And you will also see that the constructor expects a controller object. As we don’t have any controller, we will use the AppController for this purpose.

loadController(null);

class HeadHelperTest extends CakeTestCase {
    var $helper = null;

    function setUp() {
        $this->helper = new HeadHelper();
    }

    function testAuthorMetaTag() {
        ClassRegistry::removeObject('view');
        $view = new View(new AppController());
        $this->helper->authorMetaTag('cakebaker');
    }
}

The last step is to render the view resp. the layout of the view and to check whether our meta tag has been added. For this purpose we can use the regular expression I described in “Regular expression to check for content between tags” and which was improved by BurntSushi.

loadController(null);

class HeadHelperTest extends CakeTestCase {
    var $helper = null;

    function setUp() {
        $this->helper = new HeadHelper();
    }

    function testAuthorMetaTag() {
        ClassRegistry::removeObject('view');
        $view = new View(new AppController());
        $this->helper->authorMetaTag('cakebaker');
        $renderedLayout = $view->renderLayout('');
        $this->assertPattern('#<head>.*?<meta name="author" content="cakebaker">.*?</head>#si', $renderedLayout);
    }
}

Now, we can run the test and should get a green bar.

Happy testing :)

Well, helpers are not thought to be used in controllers. They are designed to be used in views. So whenever this question arises, you have to ask yourself (or others) whether you are doing something wrong and if there is no better solution.

Nonetheless, in some (rare) cases it can be useful to use a helper inside a controller to avoid code duplication. It can be accomplished in the following way:

class UsersController extends AppController {
    function index() {
        App::import('Helper', 'Html'); // loadHelper('Html'); in CakePHP 1.1.x.x
        $html = new HtmlHelper();
        debug($html->link('Cake!', 'http://cakephp.org'));
    }
}

Or, if you are using CakePHP 2.0, you can use the following approach:

class UsersController extends AppController {
    function index() {
        $view = new View($this);
        $html = $view->loadHelper('Html');
        debug($html->link('Cake!', 'http://cakephp.org'));
    }
}

Update 2007-08-13: m3nt0r has published a helper component in his blog which allows you to use a helper like a component. The article is in German, but the code should be self-explanatory.
Update 2008-06-07: Using App::import() instead of loadHelper() in the example. Thanks to mjamesd for the hint!
Update 2011: Adding snippet for CakePHP 2.0