The $base property tells you the current directory of the application (roughly put). If you application runs in http://example/app/ the $base property has the value /app.

The $here property tells you the current directory + the current action path. If you request http://example/app/admin/users/home the $here property has the value /app/admin/users/home.

We can use this info to our advantage when writing Ajax request in our external Javascript files. What i always do is using the JavascriptHelper to generate a code block with exactly these two values.

$javascript->codeBlock("var base = '{$this->base}, here = '{$this->here}';'");

I usually throw that line in my layout before i add anythings else, so that this info is available in all my scripts.

Now whenever i want to call something with Ajax i can either use Ajax.Request(base + '/controller/action.json'); or simply Ajax.Request(here + '.json'). If i ever decide to move the application i no longer need to worry about the base path.

Same goes for our webroot folder of course: $imgFolder = base + '/img/';

Another practice i found useful is when you want to submit a CakePHP form with Ajax. Instead of figuring out what path you need to POST to, just query the action attribute of the form. Much easier than writing the url yourself, even easier than using base.

// ajax post on all forms, just for demo
$$('form').invoke('observe', 'submit', function(evt){

  var form = evt.element();
  new Ajax.Request(form.readAttribute('action') + '.json', {
    parameters: form.serialize(),
    onComplete: function(xhr) {
      // added .json for fun
      // maybe do something neat with validationErrors
    }
  });

});

This should help you keeping your Javascript codebase lean.

Let’s stick with the admin panel example:

$this->layout = 'admin';

Now we all do some neat Ajax or XML here and there sometimes, and for Ajax we probably end up delivering JSON from the very same actions (”Yes, CakePHP is smart like that”). For that you usually start by adding Router::parseExtensions('json') to the routes.php file.

This works fine as long as you don’t call the action for JSON while it is using a different $layout. If we, for example, call /admin/users/index.json, CakePHP will tell us that it is missing the layout view file: APP/views/layouts/json/admin.ctp. Meh!

I am not saying that this is bad. It is actually quiet useful in some scenarios, but in general most people will be happy sharing the same old APP/views/layouts/json/default.ctp with all parts of the application. So… how to fix this?

Add the RequestHandler component to your app and add the following code to your AppController::beforeFilter() method (create the method if needed):

if ($this->RequestHandler->isAjax() && $this->RequestHandler->prefers('json')) {
 	$this->layout = 'default';
}

Now everytime the browser (client) prefers “json” the layout is switched back to “default”. Simple as that.

You can extend the checks to other formats.

if ($this->RequestHandler->isAjax() || $this->RequestHandler->isRss() || $this->RequestHandler->isXml()) {
 	$this->layout = 'default';
}

Hope this helps

For example: You have one “development” environment but you have multiple domains pointing to it and the app needs to behave differently based on that (language preset based on domain extension, vanity urls for user profiles, .. that kind of stuff).

There are of course alot of other reasons why that’s a good a idea. In general to avoid duplicate code and conflicts. To get around all that i needed support for arrays.

One approach to support arrays would be to just add it to the _match($param, $value) method in the Environment class, but it may not have been appropiate in all occassions. So i just followed Rafael’s lead and simply added support for instance methods. Since we may have our own class for environment config/param mapping (just create app_environment.php in /config/), it’s a good place to also add some helper methods.

That was the previous code (around line 90).

if (function_exists($param)) {
	$match = call_user_func($param, $value);
} else {
	$match = (env($param) === $value);
}
if (!$match) {
	return false;
}

I just added another “if-condition” and used getInstance to get the object.

$instance = self::getInstance();
if (method_exists($instance, low($param))) {
	$match = call_user_method(low($param), $instance, $value);
} elseif (function_exists($param)) {
	$match = call_user_func($param, $value);
} else {
// ... as above

Note the “low($param)“. I’ve set the value of $param to lower-case because param would be HTTP_HOST which doesn’t makes up for a good method name. Maybe could have used Inflector to make it camelcase just to enforce conventions here – but that would be overkill. ;-)

Okay.. so what happens here and how can we use that?

1. The getInstance method returns the AppEnvironment object, if present. So it’s imperative to have it, because we don’t want to mess with the original class.
2. method_exists looks in AppEnvironment for a lower-case method name of whatever is in $param. In our case this results to “http_host”.
3. If found, it calls the method on the $instance and returns the result. The result should be boolean.

I’ve edited my app_environment.php and added the following method:

/**
 * Support Arrays in HTTP_HOST param matching
 *
 * @param mixed $value string or array of hostnames
 * @return boolean
 */
public function http_host($value) {
	if (is_array($value)) {
		foreach ($value as $host) {
			if (env('HTTP_HOST') == $host) {
				return true;
			}
		}
	} else {
		if (env('HTTP_HOST') == $value) {
			return true;
		}
	}
	return false;
}

Should be pretty self explaining. Default to false. If $value is an array, walk through it and return true on the first match. If it’s not an array just check if $value matches the current HTTP_HOST.

With that in place i can now tweak my ’server’ config in the environment setup.

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

Environment::configure('development',
	array(
		'server' => array('localhost', 'testapp-local.com') // there we go!
	),
	array(
		'debug' => Configure::read('Env.development.debug'),
		'security' => Configure::read('Env.development.security')
	)
);
Environment::start();

That’s it. From now on we have the “development” environment running if the current HTTP_HOST is either “localhost” or “testapp-local.com”.

Edit: Oh.. btw. This is not just about http_host. You can of course add helper methods for any other param.

With this small modification in the AppHelper class you can do that in bootstrap using Configure, which also allows you to make the tags conditional if you want.. In short: flexibility!

The code:

class AppHelper extends Helper {
	function __construct() {
		if ($this->toString() == 'HtmlHelper') {
			$tags = Configure::read('HtmlHelper.tags');
			if (is_null($tags)) $tags = array();
			$this->tags = am($this->tags, $tags);
		}
	}
}

With this in place (file goes to app root and is called app_helper.php) you can now configure your tags whereever you like passing an array with sprintf templates, like so:

Configure::write('HtmlHelper.tags', array(
	'image' => '<img src="http://cdn.domain.com%s" %s/>',
));

yay!

Footnote: is_null checks if Configure value is set. This way you are not forced to set a empty array to your bootstrap just to avoid warnings.