$ cd ~/example.git
$ git archive master | tar -x -C /path/to/target/folder

The first part of this statement creates a tar archive with the content of the master branch. The second part then extracts this archive to the specified folder (-x means “extract”, and -C means “change to directory”).

I hope this is useful for some of you!

Router::mapResources('Posts', array('prefix' => '/example'));

Unfortunately, it doesn’t work, and you get a “Controller not found” error when requesting “/example/posts”, because CakePHP looks for an Example controller instead of a Posts controller. The same error occurs when I remove the leading slash from the prefix, like it is done with “normal” prefix routing:

Router::mapResources('Posts', array('prefix' => 'example'));

At this point I went to the source and found the reason, why it didn’t work: the prefix simply gets concatenated with the underscored controller name while Router::mapResources() generates the necessary routes for the resource. And this means, the prefix must contain a leading and a trailing slash:

Router::mapResources('Posts', array('prefix' => '/example/'));

Not really intuitive ;-)

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!

<!-- 0.6885s -->

This comment is automatically added by Cake if the debug value in app/config/core.php is greater than 0.

As long as you only work with HTML in your views, this is no problem. But if you have to use a different format like JSON, you won’t love this comment and you have to get rid of it ;-)

There are two ways to accomplish this.

The first approach is to set the debug value to 0, for example in a single action, with:

Configure::write('debug', 0);

The other approach is to remove the code snippet which adds the comment with the page execution time. For this purpose open app/webroot/index.php, and at the end of the file remove the following code:

if (Configure::read() > 0) {
    echo "<!-- " . round(getMicrotime() - $TIME_START, 4) . "s -->";
}

Happy baking!

In plain PHP you could implement such a solution in the following way:

if (file_exists('path_to_library_file')) {
    include('path_to_library_file');
    use_library_function();
}

In CakePHP, we usually use App::import() to load files. And as this method returns false if it can’t load the specified file, we can rewrite the snippet from above to:

if (App::import('Vendor', 'library', array('file' => 'path_to_library_file'))) {
    use_library_function();
}

Not really earth-shattering, but maybe it is helpful for some of you ;)

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…

To use this feature efficiently it makes sense to use a convention to structure your code (the example in the image is unstructured hence it is more difficult to find a certain method). And even if your IDE doesn’t provide such a feature it makes sense to follow a convention as it makes your code more cleaner.

The convention I use is simple: first public stuff, then private stuff, both ordered alphabetically. So a CakePHP file may look like:

class A {
    var $a = ...
    var $z = ...
    var $__a = ...
    var $__z = ...

    function a() {}

    function z() {}

    function __a() {}

    function __z() {}
}

Especially if you have larger files it helps to avoid that you get a messy code structure. And it doesn’t require any additional effort.

The solution is rather simple:

$this->User->findAll(null, 'DISTINCT User.city');

Or with the array syntax:

$this->User->findAll(null, array('DISTINCT User.city'));

Please notice that the keyword “DISTINCT” has to be uppercase, else you will get the following error:

Unknown column 'distinct User.city'

$this->User->findAll(array('DATE(User.modified)' => '-!CURDATE()'));

This snippet returns all user records modified at the current day. Now John-Henrique asked in a comment how to do the contrary, i.e. select those records not modified at the current day.

There exist at least two possible ways to accomplish this, the simplest one is to use “<>”:

$this->User->findAll(array('DATE(User.modified)' => '<> -!CURDATE()'));

It creates the following SQL code:

... WHERE DATE(`User`.`modified`) <> CURDATE()

Another approach is to use the “NOT” keyword of SQL:

$this->User->findAll(array('NOT' => array('DATE(User.modified)' => '-!CURDATE()')));

With this snippet we get the following SQL statement:

... WHERE NOT (DATE(`User`.`modified`) = CURDATE())

The obvious approach doesn’t work:

$this->User->findAll(array('DATE(User.modified)' => 'CURDATE()'));

The function “CURDATE()” is escaped and treated as a string as you can see in the generated SQL statement:

... WHERE DATE(`User`.`modified`) = 'CURDATE()'

To avoid the escaping we have to add the magical “-!” marker in front of the function name:

$this->User->findAll(array('DATE(User.modified)' => '-!CURDATE()'));

This will generate the expected SQL:

... WHERE DATE(`User`.`modified`) = CURDATE()

Hooray!

Thanks to Kabturek who mentioned this little trick some time ago in his blog.