One man’s voice

<?php
$array = array(
	'defaults' => array(
		'page' => 'index',
		'action' => 'default',
	),
	'routes' => array(
		'controller', 
		'view', 
		'model',
	),
	'application' => 'Bilbo',
	'nested' => array(
		'levels' => array(
			1 => 'floor',
			'garage',
			'canopy',
		),
		'names' => array(
			1 => 'Hectar',
			'Jonas',
			'Phil',
		),
		'named' => array(
			'floor' => 'Hectar',
			'garage' => 'Jonas',
			'canopy' => 'Phil',
		),
	),
);
?>

<?php
/**
 * Padlock - The PHP Application Developer's Library of Objects and Code Kits
 * 
 * @category Padlock
 * @package Padlock
 * @author Robert Gonzalez <robert@everah.com>
 * @license PLEASE SEE ACCOMPANYING LICENSE TEXT OR THE {@see Padlock::license()} method
 * @version $Id: Config.php 33 2008-08-20 06:30:39Z robert $
 */
/**
 * Padlock Configuration object abstract
 * 
 * The Padlock Configuration object handles parsing of initial framework instructions
 * and individual configuration items. This class is designed to be extended by
 * concrete classes that are specific to a particular type of config implementation.
 * 
 * @author Robert Gonzalez <robert@everah.com>
 * @category Padlock
 * @package Padlock
 * @version @package_version@
 */
abstract class Padlock_Config {
	/**
	 * String type config param constant
	 */
	const CONFIG_TYPE_STRING = 'string';
 
	/**
	 * Array type config param constant
	 */
	const CONFIG_TYPE_ARRAY = 'array';
 
	/**
	 * Object type config param constant
	 */
	const CONFIG_TYPE_OBJECT = 'object';
 
	/**
	 * Flag that tells the configuration class whether to merge new values or not
	 * 
	 * @access protected
	 * @var boolean
	 */
	protected static $_merge = true;
 
	/**
	 * The framework configuration array
	 * 
	 * @access protected
	 * @var array
	 */
	protected static $_config = array();
 
	/**
	 * The framework configuration array in the raw
	 * 
	 * @access protected
	 * @var array
	 */
	protected static $_configRaw = array();
 
	/**
	 * Object constructor
	 * 
	 * This is final and private - basicaly this class is meant to never be 
	 * instantiated.
	 * 
	 * @access private
	 */
	final private function __construct() {
		trigger_error('The Config object cannot be instantiated', E_USER_ERROR);
	}
 
	/**
	 * Abstracted child method that requires definition within child classes
	 * 
	 * @access public
	 * @param mixed $config Source of the configuration collection
	 */
	abstract public static function setFrom($config);
 
	/**
	 * Sets up and loads a configuration collection into the framework
	 * 
	 * If the $config param is an array the array will be loaded into the config
	 * class as a merge. It was also be traversed and exploded out into each 
	 * component of the array as a map to the end element value of the array 
	 * path.
	 * 
	 * If the $config param is an object the object will be traversed as an 
	 * array and set into the config class as an array and a mapped array.
	 * 
	 * If the $config param is a string it will be treated as though it were a 
	 * file name and handled accordingly.
	 * 
	 * @access public
	 * @param mixed $config Configuration to process
	 */
	public static function setup($config) {
		switch(gettype($config)) {
			case self::CONFIG_TYPE_ARRAY:
			case self::CONFIG_TYPE_OBJECT:
				Padlock_Config_Array::setFrom($config);
				break;
 
			case self::CONFIG_TYPE_STRING:
				Padlock_Config_File::setFrom($config);
				break;
		}
 
		// Set it now
		self::_setConfig(self::$_configRaw);
	}
 
	/**
	 * Appends the config setup with more config params
	 * 
	 * @access public
	 * @param array $config More config params to set, in the form of an array
	 */
	public static function append($config) {
		self::_setRaw($config);
		self::_setConfig(self::$_configRaw);
	}
 
	/**
	 * Sets a single config property and value
	 * 
	 * This method will not set null values as null values have special meaning
	 * throughout the framework. Essentially if the value is null then it means
	 * there is no known config setting for the name/property. Nulls are returned
	 * when names/props cannot be found.
	 * 
	 * @param string $name Config property to set
	 * @param mixed $value Value for this config property
	 */
	public static function set($name, $value, $merge = true) {
		/**
		 * Before anything we do we must check a value. 
		 * 
		 * Null values are special to the config class in that a NULL will be 
		 * literally translated to nonexitence. So if the value being passed is 
		 * null any searching for it will return null anyway.
		 */
		if ($value === null) {
			return false;
		}
 
		/**
		 * If we are merging OR if the config item is not currently set then we 
		 * handle that first and call it done.
		 */
		if ($merge || self::$_merge || !self::has($name)) {
			self::append(array($name => $value));
			return true;
		}
 
		/**
		 * The only this could mean is that the value is null or the name 
		 * already lives and is not being merged.
		 */ 
		return false;
	}
 
	/**
	 * Checks existence of a config property
	 * 
	 * This will return true for null values of a property. This might appear
	 * counterintuitive until you consider that we are just checking if there
	 * is a property set in this object. Yes, the property can be set as a false
	 * or a null. It will be without value, but it will be set, which is what 
	 * we are asking about.
	 * 
	 * @access public
	 * @param string $name Config property to check
	 * @return boolean True if set, false otherwise
	 */
	public static function has($name) {
		return is_string($name) && array_key_exists($name, self::$_config);
	}
 
	/**
	 * Gets a property value
	 * 
	 * @access public
	 * @param string $name Property to get the value for
	 * @return mixed
	 */
	public static function get($name) {
		// Return what is being asked for, or null
		return self::has($name) ? self::$_config[$name] : null;
	}
 
	/**
	 * Fetches the entire configuration array from this class
	 * 
	 * This is a useful convenience method meant to allow the fetching of the 
	 * config settings array and use outside of this class. It can also be used 
	 * to set these configs into other objects.
	 * 
	 * @access public
	 * @return array Entire configuration array
	 */
	public static function fetch() {
		return self::$_config;
	}
 
	/**
	 * Tells the class to turn merging of values on or off.
	 * 
	 * This can be useful when the need to override or not override comes up as 
	 * this method allows for changing of the config merge argument. By default 
	 * this class will merge all set values.
	 * 
	 * @access public
	 * @param boolean $on Flag setting to pass to the class
	 */
	public static function setMerge($on = true) {
		self::$_merge = (bool) $on;
	}
 
	/**
	 * Sets a series of properties from an array of properties
	 * 
	 * @access protected
	 * @param array $source Array to set values from
	 * @param string $key Name of the key to append to the config stack
	 */
	protected static function _setConfig($source, $key = null) {
		// This should only be pushed if there is an array that isn't empty
		if (is_array($source) && !empty($source)) {
			// Loop through the array and start setting stuff
			foreach ($source as $k => $v) {
				/**
				 * This is where the setting magic takes place, putting the 
				 * hierarchy together for the entire config tree.
				 */
				$newkey = $key === null ? $k : "$key:$k";
 
				// Set the new values into the config
				self::$_config[$newkey] = $v;
 
				// Run through this process again until we need not do this
				self::_setConfig($v, $newkey);
			}
		}
	}
 
	/**
	 * Sets the raw config array data for use later, if it is needed
	 * 
	 * @access public 
	 * @param array $config Config array to set into the raw array
	 */
	protected static function _setRaw($config) {
		if (is_array($config) || is_object($config)) {
			self::$_configRaw = array_merge(self::$_configRaw, (array) $config);
		}
	}
}

<?php
/**
 * Padlock - The PHP Application Developer's Library of Objects and Code Kits
 * 
 * @category Padlock
 * @package Padlock_Config
 * @author Robert Gonzalez <robert@everah.com>
 * @license PLEASE SEE ACCOMPANYING LICENSE TEXT OR THE {@see Padlock::license()} method 
 * @version $Id: Array.php 32 2008-08-20 00:59:12Z robert $
 */
/**
 * Padlock Configuration Array handler class
 * 
 * The Padlock Configuration Array handling class handles setting of config params 
 * from an array. The nature of this handler builds the configuration array into
 * tiers that are made up of other segments of the initial data set so that the
 * hierarchy of config elements is easily fetched.
 * 
 * @author Robert Gonzalez <robert@everah.com>
 * @category Padlock
 * @package Padlock_Config
 * @version @package_version@
 */
class Padlock_Config_Array extends Padlock_Config {
	/**
	 * Sets a series of properties from an array of properties
	 * 
	 * @access public
	 * @param array|object $config Array or object to set values from
	 */
	public static function setFrom($config) {
		self::_setRaw($config);
	}
}

<?php
/**
 * Gets the next 12 months of the year, starting again at January.
 * 
 * This function will return an array of 'month year' for the next twelve months
 * 
 * @access public
 * @return array Array of month and year strings
 */
function getNextMonths() {
    /**
     * Get this month by number
     * 
     * Using the numeric value of the month allows for easy transposition into a 
     * new array.
     */
    $tm = date('n');
 
    /**
     * Get this year - because we will need this for the string output
     */
    $ty = date('Y');
 
    /**
     * Array of months keyed at 1
     * 
     * These are keyed at 1 because the date() function does this
     */
    $ms = array(1 => 'January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December');
 
    /**
     * Create a variable to hold out output array
     */
    $ma = array();
 
    /**
     * Now build the array, using only one loop
     */
    for ($j = 1, $i = $tm; $j <= 12; $i++, $j++, $ma[$j] = $i <= 12 ? "$ms[$i] $ty" : $ms[$i-12].' '.($ty+1));
 
    /**
     * Send back what we just made
     */
    return $ma;
}
 
/**
 * Output control - for the record, I do not count this as a line of code :-)
 */
header('Content-Type: text/plain');
 
/**
 * Test it
 */
var_dump(getNextMonths());
?>

<?php
/**
 * Gets the next 12 months from this month
 * 
 * @return array Array of "month year" strings
 */
function getNextMonths() {
    for ($i = 1; $i < 13; $i++) {
        $array[] = date('F Y', mktime(0, 0, 0, date('m') + $i, 1, date('y')));
    }
 
    return $array;
}
 
// Test it
var_dump(getNextMonths());
?>

<?php
/**
 * Coin flipper class helps determine outcome of situations in which an outcome
 * cannot be decided by sheer manpower alone.
 * 
 * @author Scott Martin <scottayy@devnetwork.net>
 * @license None, don't even try to use this or your hair will turn yellow
 */
class coin {
	/**
	 * The outcome determinators
	 * 
	 * Each invocation of this object will require a determinator upon which the
	 * object relies to build a determined outcome. These are those determinators.
	 * 
	 * @access private
	 * @var array
	 */
	private static $_sides = array('heads', 'tails');
 
	/**
	 * The determinating method
	 * 
	 * This method, when called, invokes a determination sequence and returns a
	 * determined value for use in decision making.
	 * 
	 * @access public
	 * @return string Randomly selected determinator
	 */
	public static function flip() {
		// Quick, randomize me some determinators
		shuffle(self::$_sides);
 
		// Quick, offer it back before it gets angry
		return self::$_sides[mt_rand(0, 1)];
	}
}
 
/**
 * We should always test our determinating decision establisher
 *
 * 2,4,6,8 You know you want to determinate
 */
echo coin::flip();
?>

<?php
/**
 * Coin flipper class helps determine outcome of situations in which an outcome
 * cannot be decided by shear manpower alone.
 * 
 * @author Scott Martin <scottayy@devnetwork.net>
 * @license None, don't even try to use this or your hair will turn yellow
 */
class coin {
	/**
	 * The outcome determinators
	 * 
	 * Each invocation of this object will require a determinator upon which the
	 * object relies to build a determined outcome. These are those determinators.
	 * 
	 * @access private
	 * @var array
	 */
	private $_sides = array('heads', 'tails');
 
	/**
	 * The determinating method
	 * 
	 * This method, when called, invokes a determination sequence and returns a
	 * determined value for use in decision making.
	 * 
	 * @access public
	 * @return string Randomly selected determinator
	 */
	public function flip() {
		// Quick, randomize me some determinators
		shuffle($this->_sides);
 
		// Quick, offer it back before it gets angry
		return $this->_sides[mt_rand(0, 1)];
	}
}
 
/**
 * We should always test our determinating decision establisher
 */
$coin = new coin;
 
/**
 * 2,4,6,8 You know you want to determinate
 */
echo $coin->flip();
?>