[PHP5.3]PACKAGE CONFIG

<?php
namespace System\Iterator;

/**
 * @abstract
 * @name MapIterator
 * @author aberthelot
 * @since 05/12/2008
 * @package System::Iterator
 * @version 4.0.0 - AXB - 05/12/2008 
 */
abstract class MapIterator implements Iterator, Countable, ArrayAccess
{
  /**
   * Tableau MAP
   *
   * @access protected
   * @var array
   */
  protected $_aMap;

  /**
   * Nombre d'élément du tableau
   *
   * @access private
   * @var integer
   */
  private $_iCount;

  /**
   * Index de l'itérateur
   *
   * @access private
   * @var integer
   */
  private $_iIndex;
  
  /**
   * Défini si on peut modifier les éléments du tableau
   *
   * @access private
   * @var boolean
   */
  private $_bWritable;

  /**
   * Constructeur de la classe
   * Initialise le tableau et le compteur
   * 
   * @access public
   * @param array $aMap
   * @param boolean $bWritable
   * @return void
   */
  public function __construct(array $aMap = array(), $bWritable = true)
  {
    $this->_iIndex    = 0;
    $this->_aMap      = array();
    $this->_bWritable = $bWritable;

    if( count($aMap) > 0 )
    {
      $this->add($aMap);
    }

    $this->_iCount = count($this->_aMap);
  }

  /**
   * Retourne le nombre d'élément du tableau
   *
   * @access public
   * @return integer
   */
  public function count()
  {
    return $this->_iCount;
  }

  /**
   * Retourne l'élément suivant
   * 
   * @access public
   * @return mixed
   */
  public function current()
  {
    return current($this->_aMap);
  }

  /**
   * Retourne la clé de l'élément courant
   *
   * @access public
   * @return mixed
   */
  public function key()
  {
    return key($this->_aMap);
  }

  /**
   * Passe le pointeur sur l'élément suivant
   *
   * @access public
   * @return void
   */
  public function next()
  {
    next($this->_aMap);
    $this->_iIndex++;
  }

  /**
   * Met le pointeur au début du tableau
   *
   * @access public
   * @return void
   */
  public function rewind()
  {
    reset($this->_aMap);
    $this->_iIndex = 0;
  }

  /**
   * Test si l'iterateur est valide
   *
   * @access public
   * @return boolean
   */
  public function valid()
  {
    return $this->_iIndex < $this->_iCount;
  }
  
  /**
   * Test l'existance de l'élément dans le tableau
   *
   * @access public
   * @param mixed $mOffset
   * @return boolean
   */
  public function offsetExists($mOffset) 
  { 
    return isset($this->_aMap[$mOffset]); 
  } 
  
  /**
   * Retourne un élément du tableau
   *
   * @param mixed $mOffset
   * @return mixed
   */
  public function offsetGet($mOffset) 
  {
    return $this->get($mOffset); 
  } 
  
  /**
   * Modifie un élément du tableau
   *
   * @access public
   * @param mixed $mOffset
   * @param mixed $mValue
   * @return void
   */
  public function offsetSet($mOffset, $mValue) 
  { 
    $this->set($mOffset, $mValue);
  } 
    
  /**
   * Efface un élément du tableau
   * 
   * @access public
   * @param mixed $mKey
   * @return void
   */
  public function offsetUnset($mOffset) 
  { 
    return $this->remove($mOffset);
  } 
  
  /**
   * Ajoute un tableau
   *
   * @access public
   * @param array $aMap
   * @return void
   */
  public function add(array $aMap)
  {
    $sClass = get_called_class();
    
    foreach( $aMap as $mKey => $mValue ) 
    {
      if( is_array($mValue) )
      {
        $this->_aMap[$mKey] = new $sClass($mValue);
      } 
      else 
      {
        $this->_aMap[$mKey] = $mValue;
      }
    }
    
    $this->_iCount = count($this->_aMap);
  }
  
  /**
   * Retourne un élément du tableau
   *
   * @access public
   * @param mixed $mKey
   * @return mixed
   */
  public function get($mKey)
  {
    if( isset($this->_aMap[$mKey]) )
    {
      return $this->_aMap[$mKey];
    }
    
    return null;
  }
  
  /**
   * Ajoute un élément au tableau
   *
   * @access public
   * @param mixed $mKey
   * @param mixed $mValue
   * @return void
   */
  public function set($mKey, $mValue)
  {
    if( false === $this->_bWritable )
    {
      throw new Exception('Vous n\'avez pas les droits d\'écriture.', E_ERROR);
    }
    
    if( is_array($mValue) )
    {
      $sClass             = get_called_class();
      $this->_aMap[$mKey] = new $sClass($mValue);
    }
    else 
    {
      $this->_aMap[$mKey] = $mValue;
    }
      
    $this->_iCount = count($this->_aMap);
  }
  
  /**
   * Retourne un tableau contenant les clé
   *
   * @access public
   * @return array
   */
  public function getKeys()
  {
    return array_keys($this->_aMap);
  }
  
  /**
   * Combine une autre instance de la class
   *
   * @access public
   * @param object $merge
   * @return object
   */
  public function merge($oMerge)
  {
    $sClass     = get_called_class();
    $oReflexion = new ReflectionClass($sClass);
    
    if(! $oReflexion->isSubclassOf($this) )
    {
      throw new Exception('Vous devez passer en paramètre une classe enfant de MapIterator.', E_ERROR);
    }
    
    foreach($oMerge as $mKey => $mItem) 
    {
      if(isset($this->_aMap[$mKey])) 
      {
        if($mItem instanceof $sClass && $this->$mKey instanceof $sClass) 
        {
          $this->$mKey = $this->$mKey->merge($mItem);
        } 
        else 
        {
          $this->$mKey = $mItem;
        }
      } 
      else 
      {
        $this->$mKey = $mItem;
      }
    }

    return $this;
  }
  
  /**
   * Efface un élément du tableau
   * 
   * @access public
   * @param mixed $mKey
   * @return object|boolean
   */
  public function remove($mKey)
  {
    if( false === $this->_bWritable )
    {
      throw new Exception('Vous n\'avez pas les droits d\'écriture.', E_ERROR);
    }
    
    if( isset($this->_aMap[$mKey]) ) 
    {
      unset($this->_aMap[$mKey]);
      $this->_iCount = count($this->_aMap);
      
      return $this;
    }
    
    return false;
  }

  /**
   * Transforme l'object en tableau
   *
   * @access public
   * @return array
   */
  public function __toArray()
  {
    $aArray = array();

    foreach( $this->_aMap as $mKey => $mValue )
    {
      if( $mValue instanceof MapIterator )
      {
        $aArray[$mKey] = $mValue->__toArray();
      }
      else
      {
        $aArray[$mKey] = $mValue;
      }
    }

    return $aArray;
  }

  /**
   * Test si l'élément existe
   *
   * @access public
   * @param mixed $mKey
   * @return boolean
   */
  public function __isset($mKey)
  {
    return isset($this->_aMap[$mKey]);
  }

  /**
   * Efface un élément du tableau
   * 
   * @access public
   * @param mixed $mKey
   * @return object
   */
  public function __unset($mKey)
  {
    if( false === $this->_bWritable )
    {
      throw new Exception('Vous n\'avez pas les droits d\'écriture.', E_ERROR);
    }
    
    return $this->remove($mKey);
  }
  
  /**
   * Retourne un élément du tableau
   *
   * @access public
   * @param mixed $mKey
   * @return mixed
   */
  abstract public function __get($mKey);
  
  /**
   * Ajoute un élément au tableau
   *
   * @access public
   * @param mixed $mKey
   * @param mixed $mValue
   * @return void
   */
  abstract public function __set($mKey, $mValue);
}
?>

<?php
namespace System\Config;
use System\Iterator\MapIterator;
use System\Config\Reader\IConfig;

/**
 * @name ConfigManager
 * @author aberthelot
 * @since 07/12/2008
 * @package System::Config
 * @version 4.0.0 - AXB - 07/12/2008
 */
class ConfigManager extends MapIterator
{
  /**
   * Constructeur de la classe
   * 
   * @access public
   * @param array $aConfig
   * @param boolean $bWritable
   * @return void
   */
  public function __construct(array $aConfig = array(), $bWritable = false)
  {
    parent::__construct($aConfig, $bWritable);
  }

  /**
   * Modifie un élément de la config
   *
   * @access public
   * @param mixed $mKey
   * @param mixed $mValue
   * @return object
   */
  public function __set($mKey, $mValue)
  {
    $this->set($mKey, $mValue);
  }

  /**
   * Retourne un élément de la configuration
   *
   * @access public
   * @param mixed $mKey
   * @return mixed var
   */
  public function __get($mKey)
  {
    return $this->get($mKey);
  }
  
  /**
   * Charge tous les fichiers d'un répertoire
   *
   * @static 
   * @access public
   * @param string $sDirectory 
   * @param boolean $bWritable
   * @param string $sType
   * @param string $sSection
   * @return object
   */
  public static function loadAllFile($sDirectory, $bWritable = false, $sType = 'yaml', array $aException = array())
  {
    $sClass      = 'System\\Config\\Reader\\Config'.ucfirst($sType);
    $oReflection = new ReflectionClass($sClass);

    if(! $oReflection->implementsInterface('System\\Config\\Reader\\IConfig') )
    {
      throw new InvalidArgumentException('The "'.$sClass.'" class must implement the "IConfig" interface.');
    }

    $oReader = new $sClass();
    $aConfig = self::recursiveDir($sDirectory, $oReader, $aException);
    $oConfig = new ConfigManager($aConfig, $bWritable);
    
    return $oConfig;
  }

  /**
   * Charge un fichier de config
   *
   * @static 
   * @access public
   * @param string $sDirectory 
   * @param boolean $bWritable
   * @param string $sType
   * @param string $sSection
   * @return object
   */
  public static function load($sFile, $bWritable = false, $sType = 'yaml', $sSection = null)
  {
    $sClass      = 'System\\Config\\Reader\\Config'.ucfirst($sType);
    $oReflection = new ReflectionClass($sClass);

    if(! $oReflection->implementsInterface('System\\Config\\Reader\\IConfig') )
    {
      throw new InvalidArgumentException('The "'.$sClass.'" class must implement the "IConfig" interface.');
    }

    $oReader = new $sClass();
    $oConfig = new ConfigManager($oReader->load($sFile, $sSection), $bWritable);
    return $oConfig;
  }
  
  /**
   * Parcours le répertoire de façon récursive
   *
   * @static 
   * @access private
   * @param string $sDirectory
   * @param object $oReader
   * @param array $aException
   * @return array
   */
  private static function recursiveDir($sDirectory, $oReader, $aException)
  {
    if( false === ($sFolder = @opendir($sDirectory)) )
    {
      throw new Exception('Erreur lors de l\'ouverture du dossier "'.$sDirectory.'".', E_ERROR);
    }
    
    $aConfig = array();
    $aFilter = array_merge(array('.', '..', '...'), $aException);

    while( false !== ($sFile = readdir($sFolder)) )
    {
      if( is_dir($sDirectory.$sFile) )
      {
        if( !in_array($sFile, $aFilter) )
        {
          $aConfig = array_merge($aConfig, self::recursiveDir($sDirectory.$sFile.'/', $oReader, $aException));  
        }
      }
      else 
      {
        if( !in_array($sFile, $aFilter) && !is_dir($sFile) )
        {
          $aConfig = array_merge($aConfig, $oReader->load($sDirectory.$sFile));
        }
      }
    }

    closedir($sFolder);
    return $aConfig;
  }
}
?>


<?php
namespace System\Config\Reader;
use System\Config\Reader\IConfig;
use Plugin\Spy\Spyc;

/**
 * @name ConfigYaml
 * @author aberthelot
 * @since 07/12/2008
 * @package System::Config
 * @version 4.0.0 - AXB - 07/12/2008 
 */
class ConfigYaml implements IConfig 
{
  /**
	 * Retourne le contenu du fichier de configuration sous forme de tableau
	 * Possibilité de récupérer qu'une partie du fichier avec l'option $sSection
	 *
	 * @access public
	 * @param string $sPathFile
	 * @param string $sSection
	 * @return array
	 */
	public function load($sPathFile, $sSection = null)
	{
		if(! file_exists($sPathFile))
		{
			throw new Exception('Le fichier "'.basename($sPathFile).'" est inexistant.', E_ERROR);
		}
		
		if (! is_readable($sPathFile))
    {
    	throw new Exception('Vous n\'avez pas les droits de lecture sur le fichier "'.basename($sPathFile).'".', E_ERROR);
    }
		
		$aConfig = Spyc::YAMLLoad($sPathFile);
		
		if(! is_null($sSection) )
		{
			if( isset($aConfig[$sSection]) ) 
			{
			  return $aConfig[$sSection];
			}
		}
		
		return $aConfig;
	}
}
?>


<?php
namespace System\Config\Reader;
use System\Config\Reader\IConfig;

/**
 * @name ConfigXml
 * @author aberthelot
 * @since 07/12/2008
 * @package System::Config
 * @version 4.0.0 - AXB - 07/12/2008 
 */
class ConfigXml implements IConfig 
{  
  /**
	 * Retourne le contenu du fichier de configuration sous forme de tableau
	 * Possibilité de récupérer qu'une partie du fichier avec l'option $sSection
	 *
	 * @access public
	 * @param string $sPathFile
	 * @param string $sSection
	 * @return array
	 */
	public function load($sPathFile, $sSection = null)
	{
		if(! file_exists($sPathFile))
		{
			throw new Exception('Le fichier "'.basename($sPathFile).'" est inexistant.', E_ERROR);
		}
		
		if (! is_readable($sPathFile))
    {
    	throw new Exception('Vous n\'avez pas les droits de lecture sur le fichier "'.basename($sPathFile).'".', E_ERROR);
    }
    
    $oXml = simplexml_load_file($sPathFile);
		
		if(! is_null($sSection) ) 
		{
			$aConfig = $this->recursive($oXml->$sSection);
		}
		else 
		{
			$aConfig = $this->recursive($oXml);
		}
	
		return $aConfig;
	}
	
	/**
	 * Affectation des valeurs xml dans un tableau
	 *
	 * @access private
	 * @param object $aData
	 * @return array $aDataTmp
	 */
	private function recursive(SimpleXMLElement $oConfig)
	{
		foreach( $oConfig as $mKey => $mValue )
		{
			if( is_array($value) )
			{
				$aConfigTmp[$mKey] = $this->recursive($mValue);
			}
			else
			{ 
				$aConfigTmp[$mKey] = $mValue;
			}
		}
		
		return $aConfigTmp;
	}
}
?>


<?php
namespace System\Config\Reader;
use System\Config\Reader\IConfig;

/**
 * @name ConfigIni
 * @author aberthelot
 * @since 07/12/2008
 * @package System::Config
 * @version 4.0.0 - AXB - 07/12/2008
 */
class ConfigIni implements IConfig
{
  /**
   * Retourne le contenu du fichier de configuration sous forme de tableau
	 * Possibilité de récupérer qu'une partie du fichier avec l'option $sSection
	 *
	 * @access public
	 * @param string $sPathFile
	 * @param string $sSection
	 * @return array
	 */
  public static function load($sPathFile, $sSection = null)
  {
    if(! file_exists($sPathFile))
    {
      throw new Exception('Le fichier "'.basename($sPathFile).'" est inexistant.', E_ERROR);
    }

    if (! is_readable($sPathFile))
    {
      throw new Exception('Vous n\'avez pas les droits de lecture sur le fichier "'.basename($sPathFile).'".', E_ERROR);
    }

    $aConfig = parse_ini_file($sPathFile, true);

    if(! is_null($sSection) )
    {
      if( isset($aConfig[$sSection]) )
      {
        return $aConfig[$sSection];
      }
    }

    return $aConfig;
  }
}
?>


##### EXEMPLE D UTILISATION #####
$oConfig = System\Config\ConfigManager::load('./config/config.yml');
print $oConfig->config1->test1;