Something on Everything

This week Chris Hartjes published his approach on how to handle different environments on a PHP application.
Although a nice approach, it demands different versions of a file in all environments, what,
correct me if I’m wrong, may lead to serious headaches with version control when server has to be tweaked.
Then Neil Crookes published his own, straight forward, but not very extensible.
Now it’s my turn. Got this shiny piece of code from an old cd-rw that I used to store some ideas – well I
didn’t born knowing about SCM – and then refactored it to look prettier.

So, the code is the following:

/**
 * Singleton class to handle environment specific configurations.
 *
 * Auto-detect environment based on specific configured params and
 * allow per environment configuration and environment emulation.
 *
 * Environment. Smart Environment Handling.
 * Copyright 2008 Rafael Bandeira - rafaelbandeira3
 *
 * Licensed under The MIT License
 * Redistributions of files must retain the above copyright notice.
 */
class Environment {

	public $environments = array();

	protected $_configMap = array(
		'security' => 'Security.level'
	);

	protected $_paramMap = array(
		'server' => 'SERVER_NAME'
	);

	static function &getInstance() {
		static $instance = array();
		if (!isset($instance[0])) {
			$Environment = 'Environment';
			if (config('app_environment')) {
				$Environment = 'App' . $Environment;
			}
			$instance[0] = new $Environment();
			Configure::write('Environment.initialized', true);
		}
		return $instance[0];
	}

	static function configure($name, $params, $config = null) {
		$_this = Environment::getInstance();
		$_this->environments[$name] = compact('name', 'params', 'config');
	}

	static function start($environment = null) {
		$_this =& Environment::getInstance();
		$_this->setup($environment);
	}

	static function is($environment) {
		$_this =& Environment::getInstance();
		return ($_this->name === $environment);
	}

	public function __construct() {
		if (Configure::read('Environment.initialized')) {
			throw new Exception('Environment can only be initialized once');
			return false;
		}
	}

	public function setup($environment = null) {
		if (empty($environment)) {
			foreach ($this->environments as $environment => $config) {
				if ($this->_match($config['params'])) {
					break;
				}
			}
		}
		$config = array_merge(
			$this->environments[$environment]['config'],
			array('Environment.name' => $environment)
		);
		foreach ($config as $param => $value) {
			if (isset($this->_configMap[$param])) {
				$param = $this->_configMap[$param];
			}
			Configure::write($param, $value);
		}
	}

	protected function _match($params) {
		if ($params === true) {
			return true;
		}
		foreach ($params as $param => $value) {
			if (isset($this->_paramMap[$param])) {
				$param = $this->_paramMap[$param];
			}
			if (function_exists($param)) {
				$match = call_user_func($param, $value);
			} else {
				$match = (env($param) === $value);
			}
			if (!$match) {
				return false;
			}
		}
		return true;
	}
}

The cool is that, placing it inside APP/config folder,
it can be loaded like

config('environment');

Wow, and even a dog would know what it does.

The usage is simple, as you might guess, to configure enviroments

Environment::configure(
	'my_environment',
	array('server' => 'sandbox.localhost'),
	array('debug' => 3)
);
Environment::configure(
	'mama\'s pc',
	array('DOCUMENT_ROOT' => 'C:\\Workspace\\my_proj\\webroot'),
	array('debug' => 1, 'Email.server' => false)
);

And then to start

Environment::start();

start it anywhere, when you want.

You can also emulate an environment configuration

Environment::start('staging');

useful on tests

Environment::start('linux_development');
$this->assertFalse($obj->doIt(), 'works fine on dev');

Environment::start('linux_staging');
$this->assertFalse($obj->doIt(), 'breaks with some staging configs');

and

$this->skipIf(Environment::is('cli'));
$this->assertEqual('mamma', $variable);

You can easily configure all your environments

Environment::configure(
	'cli'
	,array('defined' => 'CAKEPHP_SHELL')
	,array('debug' => 1)
);
Enviroment::configure(
	'development'
	,array('server' => 'localhost')
	,array('debug' => 2, 'security' => 'low')
);
Environment::configure(
	'staging'
	,array('server' => 'staging.localhost')
	,array('debug' => 2, 'security' => 'medium')
);
Environment::configure(
	'production'
	,true
	,array('debug' => 1, 'security' => 'high')
);

notice that the “true” param on ‘production’ says that it will match always, so,
if it’s not ‘dev’, nor ’staging’, nor ‘cli’, Environment will, by default, assume it’s ‘production’,
but you could do the same with the ‘dev’ set.

You can create ‘app_environment.php’ on APP/config containing the AppEnvironment class,
that should extend Environment, and then specify different config key aliases and
match params. So, to mix Hartjes’ approach, you can create the AppEnvironment

class AppEnvironment extends Environment {
	protected $_paramMap = array('env' => 'APP_ENV');
}

set APP_ENV in the .htaccess

SetEnv APP_ENV "littlehart.net"

and configure needed enviroments

Environment::configure(
	'production'
	,array('env' => 'littlehart')
	,array('debug' => 1, 'Session.cookie' => 'attthekeyboard')
);
Environment::configure(
	'development'
	,array('env' => 'sandbox')
	,array('debug' => 1, 'Session.timeout' => '1500')
);

To get rid of the ‘Session.cookie’, you can map ‘cookie’ to it, doing

class AppEnvironment extends Environment {
	protected $_paramMap = array('env' => 'APP_ENV');
	protected $_configMap = array('cookie' => 'Session.cookie');
}

and then configuring

Environment::configure(
	'production'
	,array('env' => 'littlehart')
	,array('debug' => 1, 'cookie' => 'attthekeyboard')
);
Environment::configure(
	'development'
	,array('env' => 'sandbox')
	,array('debug' => 1, 'Session.timeout' => '1500')
);

Although the implementation is CakePHP specific, it’s really easy to adapt – actually replace two or three lines
and you are done… ok, here is the tip: get rid of all Configure::write() and Configure::read(), config() and env()…
ok… maybe it’s 4 or 5 lines, but you got the picture.

What do you think? I think it’s just fine!