File: class.config_reader.php

<?php
/* vim: set ai tabstop=4: */
// $Date: 2002/04/09 01:29:38 $
// $Revision: 1.3 $
// +----------------------------------------------------------------------+
// | CONFIG MANAGER 0.1.2 - 09-Apr-2002                                   |
// +----------------------------------------------------------------------+
// | Author: Keyvan Minoukadeh - keyvan@k1m.com - http://www.k1m.com      |
// +----------------------------------------------------------------------+
// | PHP class for managing plain text config files.                      |
// +----------------------------------------------------------------------+
// | This program is free software; you can redistribute it and/or        |
// | modify it under the terms of the GNU General Public License          |
// | as published by the Free Software Foundation; either version 2       |
// | of the License, or (at your option) any later version.               |
// |                                                                      |
// | This program is distributed in the hope that it will be useful,      |
// | but WITHOUT ANY WARRANTY; without even the implied warranty of       |
// | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        |
// | GNU General Public License for more details.                         |
// +----------------------------------------------------------------------+

if (defined('CONFIGMAN_DIR')) {
	require_once(CONFIGMAN_DIR.'class.config_base.php');
}

/**
* Config manager reader class
*
* Use this class to read plain text config files.
* This is an extension to the base config class.
*
* @author   Keyvan Minoukadeh <keyvan@k1m.com>
* @version  0.1.2
*/
class config_reader extends config_base
{
	/**
	* fetch mode
	*
	* CONFIGMAN_FETCH_ASSOC = return config vars as associative array
	* CONFIGMAN_FETCH_OBJECT = return config vars as an object
	*/
	var $fetch_mode				= CONFIGMAN_FETCH_ASSOC;

	/**
	* allow serialize?
	*/
	var $cache_config			= false;


	/////////////
	// methods
	/////////////


	/**
	* Constructor
	*
	* @param	string	$config		config file to use
	* @param	int		$fetch_mode	fetch mode
	*/
	function config_reader($config=null, $fetch_mode=null)
	{
		// run base constructor
		if (!is_null($config)) {
			$this->config_base($config);
		}

		if (!is_null($fetch_mode)) {
			$this->fetch_mode = $fetch_mode;
		}
	}

	/**
	* Load config
	*
	* Parse and update class variables with values found in config.
	* Cache file refers to a file containing the serialized values found in the config file,
	* if present it will load the values quicker.
	*
	* @param	int		$fetch_mode	either CONFIGMAN_FETCH_ASSOC or CONFIGMAN_FETCH_OBJECT
	* @param	bool	$reload		if true, will reload values from main config even if cache exists
	* @return	mixed				either associative array, or object
	*/
	function load($fetch_mode=null, $reload=false)
	{
		$func_name = 'load';

		clearstatcache();

		if (!$this->is_file_valid()) {
			if ($this->debug) $this->_debug("$func_name: Invalid config file");
		}

		$config = $this->config;
		$file_cache = $this->config_cache_dir.basename($config).'.cache';
		
		// grab file modification times
		$config_ts = @filemtime($config);
		$file_cache_ts = @filemtime($file_cache);
		
		// check if cache file available
		if (!$reload && file_exists($file_cache) && is_readable($file_cache) && ($config_ts == $file_cache_ts)) {
			if ($this->debug) $this->_debug("$func_name: Loading from cache file");
			// unserialize config cache (returns associative array)
			$fp = fopen($file_cache, 'r');
			// shared lock
			flock($fp, 1);
			$contents = fread($fp, filesize($file_cache));
			// release lock
			flock($fp, 3);
			fclose($fp);
			$config_array = unserialize($contents);
			if (!is_array($config_array)) {
				if ($this->debug) $this->_debug("$func_name: Invalid config cache ($file_cache), remove and try again");
				return false;
			}
			// loop through associative array and update vars
			foreach ($config_array as $key => $val) {
				$this->set_param_from_array($key, $val);
			}
		} elseif (file_exists($config) && is_readable($config)) {
			if ($this->debug) $this->_debug("$func_name: Loading from config file");
			// parse config file
			$this->_process_config(file($config));
			if ($this->cache_config) {
				$this->_write_config_cache($file_cache, filemtime($config));
			}
		} else {
			if ($this->debug) $this->_debug("$func_name: Could not load config file ($config)");
			return false;
		}
		return $this->_return_config_vars($fetch_mode);
	}

	/**
	* Load config from string
	*
	* Same as load() except first parameter will be the string contaning
	* the config lines. (useful if you're not storing the config in a file, eg. using a DB
	* or generating it some way)
	*
	* @param	string	$config		config contents as string
	* @param	int		$fetch_mode	either CONFIGMAN_FETCH_ASSOC or CONFIGMAN_FETCH_OBJECT
	* @return	mixed				either associative array, or object
	*/
	function load_from_string($config, $fetch_mode=null)
	{
		$func_name = 'load_from_string';

		$config = explode("\n", trim($config));
		if (is_array($config) && (count($config) > 0)) {
			$this->_process_config($config);
			return $this->_return_config_vars($fetch_mode);
		} else {
			if ($this->debug) $this->_debug("$func_name: Invalid config contents");
			return false;
		}
	}

	///////////////////////
	// PRIVATE FUNCTIONS //
	///////////////////////

	/**
	* Return config vars
	*
	* @param	int		$fetch_mode	CONFIGMAN_FETCH_ASSOC or CONFIGMAN_FETCH_OBJECT or null for default
	* @return	mixed				array or object, depending on fetch mode
	* @access	private
	*/
	function _return_config_vars($fetch_mode=null)
	{
		$return = array();
		foreach ($this->param as $key => $val) {
			$return["$key"] = $val[(string)key($val)]['value'];
		}
		if (is_null($fetch_mode)) {
			$fetch_mode = $this->fetch_mode;
		}
		if ($fetch_mode === CONFIGMAN_FETCH_OBJECT) {
			return (object)$return;
		} else {
			return $return;
		}
	}

	/**
	* Write config cache
	*
	* @param	string	$file_path	serialize config array and write to disk
	* @param	int		$timestamp	unix timestamp to set as modification time
	* @return	bool
	* @access	private
	* @see		load
	*/
	function _write_config_cache($file_path, $timestamp=null)
	{
		$func_name = '_write_config_cache';
		if ($this->cache_config) {
			$serialized = serialize($this->param);
			$fp = @fopen($file_path, "w");
			if (!$fp) {
				if ($this->debug) $this->_debug("$func_name: Could not create cache file");
				return false;
			} else {
				// exclusive lock
				flock($fp, 2);
				$result = @fwrite($fp, $serialized);
				// release lock
				flock($fp, 3);
				fclose($fp);
				if (!$result) {
					if ($this->debug) $this->_debug("$func_name: Could not write cache file");
					return false;
				} else {
					if ($this->debug) $this->_debug("$func_name: Cache file written");
					// touch file with modification time of main config file (used for comparison)
					touch($file_path, ((is_null($timestamp) || !$timestamp) ? time() : $timestamp));
					@chmod($file_path, 0600);
					return true;
				}
			}
		}
		return false;
	}

	/**
	* Process config
	*
	* @param	array	$config	each line of the config file as a seperate array element
	* @return	bool			true if successfully loaded, false otherwise
	* @access	private
	*/
	function _process_config($config)
	{
		$func_name = "_process_config";

		if (!is_array($config) || (count($config) < 1)) {
			if ($this->debug) $this->_debug("$func_name: Config file is empty, or is not an array");
			return false;
		}

		$var = array();
		$section = $this->default_section;
		$comment = "";
		$line_count = 0;

		foreach ($config as $line) {
			$line_count++;
			$line = trim($line);
			if (empty($line)) {
				continue;
			}
			// plain comment
			if (preg_match('!^'.preg_quote($this->comment).'(.*)$!', $line, $match)) {
				if (trim($match[1]) != '') {
					$comment .= trim($match[1])."\n";
				}
				unset($match);
				continue;
			}
			// variable definition
			if (preg_match('!^'.$this->regex_type.'?('.$this->regex_var.')(\.'.$this->regex_assoc.')?\s*'.preg_quote($this->separator).'\s*(?'.'>(["\'])?)(.*)(?(4)\4)$!i', $line, $match)) {
				if (trim($match[1]) != '') {
					$type = $this->type_prefix[$match[1]];
				} elseif ($this->default_type != 'auto') {
					$type = $this->default_type;
				} elseif ($match[4] == '"' || $match[4] == '\'') {
					$type = CONFIGMAN_TYPE_STRING;
				} else {
					$type = CONFIGMAN_TYPE_INTEGER;
				}
				
				// replace escaped characters (\n \r and \t)
				if ($match[4] == '"') {
					$match[5] = preg_replace(array('/(?<!\\\\)\\\\n/','/(?<!\\\\)\\\\r/','/(?<!\\\\)\\\\t/'), array("\n","\r","\t"), $match[5]);
					$match[5] = str_replace('\\\\', '\\', $match[5]);
				}

				$var[$match[2]][][$type] = array(	'value' => $match[5],
													'comment' => $comment,
													'assoc' => (empty($match[3]) ? null : substr($match[3], 1)));
				$comment = "";
				unset($match);
				continue;
			}
			// section tag (comment)
			if (preg_match('!^\[('.$this->regex_section.')\]!', $line, $match)) {
				if (trim($match[1]) != '') {
					// set previous section vars
					$this->_set_param_from_config($var, $section);
					$var = array();
					$section = trim($match[1]);
				} else {
					$this->_error("Incorrect section tag on line $line_count");
				}
				unset($match);
				continue;
			}
			// unrecognized config syntax
			if ($this->debug) $this->_debug("$func_name: Unrecognised syntax on line $line_count");
		}
		$this->_set_param_from_config($var, $section);
	}

	/**
	* Set params from parsed config
	*
	* Sets parameters for 1 section
	*
	* @param	array	$param		parameters for 1 section passed from _process_config
	* @param	string	$section	section name to enter parameter in
	* @return	bool				true
	* @access	private
	* @see		_process_config
	*/
	function _set_param_from_config($param, $section)
	{
		foreach ($param as $var => $value) {
			// array?
			if (count($value) > 1) {
				// it is an array
				$cur_val = array();
				$cur_comment = '';
				// loop through the array
				foreach ($value as $arr_element) {
					// grab the type
					$cur_type = key($arr_element);
					if (trim($arr_element[$cur_type]['comment']) != '') {
						if ($cur_comment != '') {
							$cur_comment .= "------------------------------\n";
						}
						$cur_comment .= $arr_element[$cur_type]['comment'];
					}
					// is it associative?
					if (!is_null($arr_element[$cur_type]['assoc'])) {
						// store key
						$cur_key = (string)$arr_element[$cur_type]['assoc'];
						// add value
						$cur_val[$cur_key] = $this->_cast_type($arr_element[$cur_type]['value'], $cur_type);
					} else {
						// not associative
						$cur_val[] = $this->_cast_type($arr_element[$cur_type]['value'], $cur_type);
					}
				}
			} else {
				// not array or single assoc array
				$cur_type = key($value[0]);
				$cur_val = $this->_cast_type($value[0][key($value[0])]['value'], $cur_type);
				$cur_comment = $value[0][key($value[0])]['comment'];
				$cur_key = $value[0][key($value[0])]['assoc'];
				if (!is_null($cur_key)) {
					$cur_val = array("$cur_key" => $cur_val);
				}
			}

			$this->set_param($var, $cur_val, $cur_comment, $section);
		}
		return true;
	}

}

?>