In CakePHP, the names of those “magic” columns are:

created
modified / updated

In Rails, on the other hand, the respective column names are:

created_at / created_on
updated_at / updated_on

Fortunately, the other database-related naming conventions seem to be the same in both frameworks.

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.

As its name implies, the beforeRender() callback method is called before the view is rendered, but after the beforeRender() callback method of the controller:

// in your component
public function beforeRender($controller) {
    // do something
}

The beforeRedirect() callback is also quite obvious, it gets called before a redirect is performed:

// in your component
public function beforeRedirect($controller, $url, $status = null, $exit = true) {
    // do something
}

By providing a return value, you can override the values with which the redirect method was originally called. For example:

public function beforeRedirect($controller, $url, $status = null, $exit = true) {
    // return '/redirect/target';  // a single value is treated as an URL
    return array('url' => '/redirect/target', 'status' => 307);
}

The last callback method, shutdown(), is called after Controller::render() and before Controller::afterFilter():

// in your component
public function shutdown($controller) {
    // do something
}

Those callback methods are probably a “nice to have” feature, at least I didn’t miss them up to now.

Anyway, happy baking!

boolean is self-explanatory: it validates whether a field contains a boolean value (i.e. 0, 1, “0″, “1″, false, or true). Example:

var $validate = array('is_enabled' => array('rule' => array('boolean')));

inList ensures that the respective field only contains a value from the defined array. It is case-sensitive, i.e. if you use the rule from the example below, then the value “Red” would be invalid.

var $validate = array('color' => array('rule' => array('inList', array('red', 'green', 'blue'))));

time determines whether a field contains a valid time value. It supports both the 24 hour format (e.g. 08:10:10) and the 12 hour format (e.g. 8:10:10am). The minutes and seconds are optional in both cases.

var $validate = array('starttime' => array('rule' => array('time')));

Another recent change affected View::renderElement(): it has been deprecated in favor of View::element():

$this->renderElement('my_element', array('param1' => 'a value'));

becomes

$this->element('my_element', array('param1' => 'a value'));

I don’t know why View::renderElement() was deprecated and not View::element(), as I think the method name “renderElement” is more expressive than “element”.

Anyway, happy baking :)

To use the new behavior, you either have to add it to the $actsAs property of your model:

class Post extends AppModel {
    var $actsAs = array('Containable');
}

or you can attach the behavior on the fly with:

$this->Post->Behaviors->attach('Containable');

Ok, now let’s have a look at some examples. For the examples I will use the three models Post, Comment, and Tag, with the associations: Post hasMany Comments, Post hasAndBelongsToMany Tags.

If we perform a simple find all statement, then we get back all posts plus all associated records, something like:

debug($this->Post->find('all'));

[0] => Array
        (
            [Post] => Array
                (
                    [id] => 1
                    [title] => First article
                    [content] => aaa
                    [created] => 2008-05-18 00:00:00
                )
            [Comment] => Array
                (
                    [0] => Array
                        (
                            [id] => 1
                            [post_id] => 1
                            [author] => Daniel
                            [email] => dan@example.com
                            [website] => http://example.com
                            [comment] => First comment
                            [created] => 2008-05-18 00:00:00
                        )
                    [1] => Array
                        (
                            [id] => 2
                            [post_id] => 1
                            [author] => Sam
                            [email] => sam@example.net
                            [website] => http://example.net
                            [comment] => Second comment
                            [created] => 2008-05-18 00:00:00
                        )
                )
            [Tag] => Array
                (
                    [0] => Array
                        (
                            [id] => 1
                            [name] => A
                        )
                    [1] => Array
                        (
                            [id] => 2
                            [name] => B
                        )
                )
        )

But often you don’t want to get all those data, and that’s when the Containable behavior comes to the rescue.

To get only the posts, you can do the following:

$this->Post->contain();
debug($this->Post->find('all'));

or

debug($this->Post->find('all', array('contain' => false)));

or without the Containable behavior

$this->Post->recursive = -1;
debug($this->Post->find('all'));

With the contain() method resp. the “contain” option we specify from which of the associated models we want to get data. If we want to get all posts plus the associated tags (without the comments), we would do it in the following way:

$this->Post->contain('Tag'); // we could also use an array
debug($this->Post->find('all'));

or

debug($this->Post->find('all', array('contain' => 'Tag'))); // we could also use an array

or without the Containable behavior

$this->Post->unbindModel(array('hasMany' => array('Comment')));
debug($this->Post->find('all'));

As you can see, the code using the Containable behavior is much cleaner than the code without it.

But that’s not all the Containable behavior can do for you. You can also filter the data of the associated models. If you are interested in the posts and the names of the comment authors, you could write:

$this->Post->contain('Comment.author');
debug($this->Post->find('all'));

or

debug($this->Post->find('all', array('contain' => 'Comment.author')));

[0] => Array
        (
            [Post] => Array
                (
                    [id] => 1
                    [title] => First article
                    [content] => aaa
                    [created] => 2008-05-18 00:00:00
                )
            [Comment] => Array
                (
                    [0] => Array
                        (
                            [author] => Daniel
                            [post_id] => 1
                        )
                    [1] => Array
                        (
                            [author] => Sam
                            [post_id] => 1
                        )
                )
        )

As you can see, the comment arrays only contain the author plus the post_id (which is needed by Cake to map the results).

You can also filter the (comment) data by using a condition:

$this->Post->contain('Comment.author = "Daniel"');
debug($this->Post->find('all'));

or 

debug($this->Post->find('all', array('contain' => 'Comment.author = "Daniel"')));

[0] => Array
        (
            [Post] => Array
                (
                    [id] => 1
                    [title] => First article
                    [content] => aaa
                    [created] => 2008-05-18 00:00:00
                )
            [Comment] => Array
                (
                    [0] => Array
                        (
                            [id] => 1
                            [post_id] => 1
                            [author] => Daniel
                            [email] => dan@example.com
                            [website] => http://example.com
                            [comment] => First comment
                            [created] => 2008-05-18 00:00:00
                        )
                )
        )

As you can see from these examples, the Containable behavior is very powerful, and I recommend to have a look at the tests.

Anyway, it’s very cool to have this behavior in the core :)

First we create a behavior which outputs a text before a find operation is performed:

// app/models/behaviors/example.php
class ExampleBehavior extends ModelBehavior {
    private $text = 'this is an example text';

    function setUp(&$model, $config) {
        if (isset($config['text'])) {
            $this->text = $config['text'];
        }
    }

    function beforeFind(&$model, $query) {
        echo $this->text;

        return true;
    }
}

The usual way to use a behavior is to define it with the $actsAs variable in the model. For example, to use the ExampleBehavior with the Post model, we would define it in the following way:

// app/models/post.php
class Post extends AppModel {
    var $actsAs = array('Example' => array('text' => 'some text'));
}

Every time we execute a find method of the Post model, the string “some text” is echoed.

With the new methods Model::attach() and Model::detach() With having a BehaviorCollection (with the methods attach() and detach()) as a property of the model more flexible scenarios are possible (even though I can’t think of any real use cases at the moment). If we want our Post model to act as Example only temporarily, we could write the following code:

// app/models/post.php
class Post extends AppModel {
}

// action in our controller
function index() {
    $this->Post->Behaviors->attach('Example', array('text' => 'hello world'));
    $this->set('all_posts', $this->Post->find('all'));
    $this->Post->Behaviors->detach('Example');
    $this->set('first_post', $this->Post->findById(1));
}

When we perform the find(‘all’) statement, our Post model acts as Example, i.e. the specified text is echoed, whereas with the findById statement, it no longer acts as Example, and so there is no output.

Happy baking :)

Update (2008-08-14): The example now uses the methods of the BehaviorCollection object, which is a property of the model. Thanks to kabturek for the hint!

$this->redirect('/controller/action', null, true);

or

$this->redirect('/controller/action');
exit();

Thanks to a recent change of the API of the “redirect” method — the default value for the $exit parameter was changed from “false” to “true” — you can now simply use:

$this->redirect('/controller/action');

As it does an exit() by default, you can no longer encounter a possible security hole I described in Don’t forget to exit after a redirect (well, theoretically you can still encounter it when setting the $exit parameter explicitly to “false”, but that’s rather unlikely I think).

Merry Christmas to everyone!

PS: From the activity in the repository it looks like the Cake team is baking a Christmas Cake :)

In the meantime this feature has been added to the development branch (I don’t know when) as I learned today from a comment by gwoo.

If you have an element /app/views/elements/example.ctp in your application, then you can render it with the following code snippet from within your controller:

$this->render('/elements/example');

In the same way you can also render views which belong to other controllers.

$expectedPosts = array(array('Post' => array('id' => 3, 'title' => 'a title', 'content' => 'some content')),
			               array('Post' => array('id' => 4, 'title' => 'another title', 'content' => 'some other content')));

The core class Set provides an alternative way to create arrays using a dot notation. The example from above can be rewritten as:

$expectedPosts = array();
$expectedPosts = Set::insert($expectedPosts, '0.Post.id', 3);
$expectedPosts = Set::insert($expectedPosts, '0.Post.title', 'a title');
$expectedPosts = Set::insert($expectedPosts, '0.Post.content', 'some content');
$expectedPosts = Set::insert($expectedPosts, '1.Post.id', 4);
$expectedPosts = Set::insert($expectedPosts, '1.Post.title', 'another title');
$expectedPosts = Set::insert($expectedPosts, '1.Post.content', 'some other content');

You can also mix those two approaches:

$expectedPosts = array();
$expectedPosts = Set::insert($expectedPosts, '0.Post', array('id' => 3, 'title' => 'a title', 'content' => 'some content'));
$expectedPosts = Set::insert($expectedPosts, '1.Post', array('id' => 4, 'title' => 'another title', 'content' => 'some other content'));

It is quite handy, especially if you have to create more complex array structures.

Its usage is simple:

echo Inflector::slug('This is a test');
// outputs: This_is_a_test

echo Inflector::slug('This is a test', '-');
// outputs: This-is-a-test

You have to be careful with this function if you use it for example with german umlauts, as you may get an unexpected result:

echo Inflector::slug('Es sind Kühe auf der Wiese');
// outputs: Es_sind_K_he_auf_der_Wiese