CLASSE DE CONFIGURATION POUR LA GESTION D'ERREUR

<?php
/**
 * @author      Fred
 * @category    FredT Library
 * @package     Error
 * @subpackage
 * @version     29/12/2007
 *
 */

class FredT_Error_Config {
    /**
     * Niveau d'erreur évolutif
     * La valeur maximale (pour E_ALL) peut changer,
     */
    const E_ALL_EXTRA = 2147483647;

    /**
     * Tableau vide utilisé comme modèle la valeur retourné par getConfig()
     *
     * @var array
     */
    protected $_conf=array(
        'ErrorReporting'       => null,
        'DisplayStartupErrors' => null,
        'IgnoreRepeatedErrors' => null,
        'IgnoreRepeatedSource' => null,
        'ReportMemleaks'       => null,
        'TrackErrors'          => null,
        'WarnPlusOverloading'  => null,
        'DisplayErrors'        => null,
        'HtmlErrors'           => null,
        'DocrefRoot'           => null,
        'DocrefExt'            => null,
        'ErrorPrependString'   => null,
        'ErrorAppendString'    => null,
        'LogErrors'            => null,
        'ErrorLog'             => null,
        'LogErrorsMaxLen'      => null,
    );

	/**
	 * Affecte automatiquement la configuration pour la gestion d'erreur
	 *
	 * @see setConfig()
	 *
	 * @param array $conf facultatif
	 */
    function __construct(Array $conf=array())
	{
	    $this->setConfig($conf);
	}

	/**
	 * Renvoi le tableau complet des paramètres de configuration actuels
	 *
	 * @see setConfig()
	 *
	 * @return array
	 */
	public function getConfig()
	{
        $conf=array();
	    foreach ($this->_conf as $key => $value) {
	    	$param= 'get' . $key;
            if (method_exists($this, $param)) {
                $conf[$key] = $this->$param();
            }
	    }
        return $conf;
	}

	/**
	 * Affecte la configuration pour la gestion d'erreur
	 *
	 * @see http://www.php.net/manual/fr/ref.errorfunc.php
	 *
	 * @param array $conf
	 */
	public function setConfig(Array $conf=array() )
	{
        foreach ($conf as $param => $value) {
            $param= 'set' . $param;
            if (method_exists($this, $param)) {
                $this->$param($value);
            }
        }
        return $this;
	}

	/**
	 * Détermine si les erreurs doivent être affichées à l'écran ou non.
	 *
	 * @param boolean $value
	 * @return FredT_Error_Config
	 */
    public function setDisplayErrors($value=true)
    {
        $this->_setIni('display_errors', (bool) $value);
        return $this;
    }

    /**
     * Retourne si les erreurs sont affichées à l'écran ou non.
     *
     * @return boolean
     */
    public function getDisplayErrors()
    {
        return (bool) ini_get('display_errors');
    }

    /**
     * Afficher les erreurs qui peuvent survenir lors de la séquence de démarrage de PHP
     * Recommandé pour le débogage, fortement déconseillé en Prod
     *
     * @param boolean $value
     * @return FredT_Error_Config
     */
    public function setDisplayStartupErrors($value=false)
    {
        $this->_setIni('display_startup_errors', (bool) $value);
        return $this;
    }

    /**
     * Retourne si les erreurs qui peuvent survenir lors de la séquence de démarrage
     * de PHP sont affichées à l'écran ou non.
     *
     * @return boolean
     */
    public function getDisplayStartupErrors()
    {
        return (bool) ini_get('display_startup_errors');
    }

    /**
     * Ecrit les messages d'erreur soit dans l'historique du serveur ou dans error_log.
     *
     * @param boolean $value
     * @return FredT_Error_Config
     */
    public function setLogErrors($value=false)
    {
        $this->_setIni('log_errors', (bool) $value);
        return $this;
    }

    /**
     * Retourne si les messages d'erreur sont écrits  soit dans l'historique du serveur
     * ou dans error_log.
     *
     * @return boolean
     */
    public function getLogErrors()
    {
        return (bool) ini_get('log_errors');
    }

    /**
     * Ne pas enregistrer des messages répétitifs
     * (Provenance du même fichier et même ligne)
     *
     * @param boolean $value
     * @return FredT_Error_Config
     */
    public function setIgnoreRepeatedErrors($value=false)
    {
        $this->_setIni('ignore_repeated_errors', (bool) $value);
        return $this;
    }

    /**
     * Retourne si les messages répétitifs sont enregistrés
     * (Provenance du même fichier et même ligne)
     * ou dans error_log.
     *
     * @return boolean
     */
    public function getIgnoreRepeatedErrors()
    {
        return (bool) ini_get('ignore_repeated_errors');
    }

    /**
     * Permet d'éviter d'enregistrer les erreurs provenant du même fichier source.
     * N'est effectif seulement si ignore_repeated_errors est activée.
     * (Provenance du même fichier)
     *
     * @param boolean $value
     * @return FredT_Error_Config
     */
    public function setIgnoreRepeatedSource($value=false)
    {
        $this->_setIni('ignore_repeated_source', (bool) $value);
        return $this;
    }

    /**
     * Retourne si les erreurs provenant d'un même fichier source sont enregistrés
     * N'est effectif seulement si ignore_repeated_errors est activée.
     * (Provenance du même fichier)
     *
     * @return boolean
     */
    public function getIgnoreRepeatedSource()
    {
        return (bool) ini_get('ignore_repeated_source');
    }


    /**
     * A false, les fuites de mémoires seront ignorées.
     * Option valable si PHP compilé avec l'option de débogage,
     * et si error_reporting inclut E_WARNING
     *
     * @param boolean $value
     * @return FredT_Error_Config
     */
    public function setReportMemleaks($value=true)
    {
        $this->_setIni('report_memleaks', (bool) $value);
        return $this;
    }

    /**
     * Retourne false si les fuites de mémoires sont ignorées
     * Option valable si PHP compilé avec l'option de débogage,
     * et si error_reporting inclut E_WARNING
     *
     * @return boolean
     */
    public function getReportMemleaks()
    {
        return (bool) ini_get('report_memleaks');
    }

    /**
     * A True, le dernier message d'erreur sera placé dans
     * la variable globale $php_errormsg.
     *
     * @param boolean $value
     * @return FredT_Error_Config
     */
    public function setTrackErrors($value=false)
    {
        $this->_setIni('track_errors', (bool) $value);
        return $this;
    }

    /**
     * Retourne True si le dernier message d'erreur est placé dans
     * la variable globale $php_errormsg.
     *
     * @return boolean
     */
    public function getTrackErrors()
    {
        return (bool) ini_get('track_errors');
    }

    /**
     * A True, Active les balises HTML dans les messages d'erreurs.
     * la variable globale $php_errormsg.
     *
     * @param boolean $value
     * @return FredT_Error_Config
     */
    public function setHtmlErrors($value=true)
    {
        $this->_setIni('html_errors', (bool) $value);
        return $this;
    }

    /**
     * Retourne True si les balises HTML dans les messages d'erreurs sont activées
     *
     * @return boolean
     */
    public function getHtmlErrors()
    {
        return (bool) ini_get('html_errors');
    }

    /**
     * A True PHP affiche une alerte lorsque l'opérateur (+) est utilisé
     * avec des chaînes de caractères.
     * ATTENTION: modifiable? La doc PHP indique "PHP_INI??"
     *
     * @param boolean $value
     * @return FredT_Error_Config
     */
    public function setWarnPlusOverloading($value=null)
    {
        $this->_setIni('warn_plus_overloading', (bool) $value);
        return $this;
    }

    /**
     * Retourne True PHP affiche une alerte lorsque l'opérateur (+) est utilisé
     * avec des chaînes de caractères.
     *
     * @return boolean
     */
    public function getWarnPlusOverloading()
    {
        return (bool) ini_get('warn_plus_overloading');
    }

    /**
     * Des messages avec liens hypertexte, redirige vers la documentation
     * de l'erreur ou de la fonction. Défini le lien vers le manuel PHP
     * à utiliser si html_errors est activée.
     * Ne pas utiliser sur un système de production
     * @todo La valeur de l'URL n'est pas vérifier
     *
     * @example
     * Avec une copie locale: "/manual/php/"
     * Avec une référence externe: "http://www.php.net/manual/fr/"
     *
     * @param string $value
     * @return FredT_Error_Config
     */
    public function setDocrefRoot($value='')
    {
        $this->_setIni('docref_root', (string) $value);
        return $this;
    }

    /**
     * Retourne le lien utilisé vers le manuel PHP
     * Valable Seulement si html_errors est activée.
     *
     * @return string
     */
    public function getDocrefRoot()
    {
        return (string) ini_get('docref_root');
    }

    /**
     * A configurer en complément de docref_root.
     * La valeur doit commencer par un point '.'
     * et correspondre aux extensions du manuel.
     *
     * @example
     * ".php"
     *
     * @param string $value
     * @return FredT_Error_Config
     */
    public function setDocrefExt($value='')
    {
        $this->_setIni('docref_ext', (string) $value);
        return $this;
    }

    /**
     * Retourne l'extension des pages utilisé pour le manuel PHP
     *
     * @return string
     */
    public function getDocrefExt()
    {
        return (string) ini_get('docref_ext');
    }

    /**
     * Chaîne qui sera utilisé pour préfixer les messages d'erreur.
     * peut très bien être du code HTML.
     *
     * @param string $value
     * @return FredT_Error_Config
     */
    public function setErrorPrependString($value='')
    {
        $this->_setIni('error_prepend_string', (string) $value);
        return $this;
    }

    /**
     * Retourne la chaîne utilisé pour préfixer les messages d'erreur.
     *
     * @return string
     */
    public function getErrorPrependString()
    {
        return (string) ini_get('error_prepend_string');
    }

    /**
     * Chaîne qui sera utilisé pour suffixer les messages d'erreur.
     * peut très bien être du code HTML.
     *
     * @param string $value
     * @return FredT_Error_Config
     */
    public function setErrorAppendString($value='')
    {
        $this->_setIni('error_append_string', (string) $value);
        return $this;
    }

    /**
     * Retourne la chaîne utilisé pour suffixer les messages d'erreur.
     *
     * @return string
     */
    public function getErrorAppendString()
    {
        return (string) ini_get('error_append_string');
    }

    /**
     * Nom du fichier où seront enregistrées les erreurs.
     * Le fichier doit être accessible en écriture par l'utilisateur
     * exécutant le serveur web.
     * indiquez soit le nom d'un fichier (exemple : /var/log/php/php_errors.log)
     * soit syslog pour que l'erreur soit enregistrée dans les logs système.
     * Si la valeur spéciale syslog est utilisée, les erreurs seront envoyées
     * au système d'historique du serveur.
     * Sous Unix, cela correspond à syslog(3) et sous Windows NT, à l'historique
     * d'événement.
     * Voir aussi : syslog(). Si cette directive n'est pas fixée, les erreurs
     * sont envoyées au journal d'erreurs SAPI. Par exemple, s'il s'agit d'une
     * erreur de journal dans Apache ou stderr dans CLI.
     *
     * @todo Vérifier la validité du path l'accesibilité en écriture du path ou du fichier
     *
     * @param string $value
     * @return FredT_Error_Config
     */
    public function setErrorLog($value=null)
    {
        $this->_setIni('error_log', (string) $value);
        return $this;
    }

    /**
     * Retourne le Nom du fichier où seront enregistrées les erreurs.
     *
     * @return string
     */
    public function getErrorLog()
    {
        return (string) ini_get('error_log');
    }

    /**
     * Taille maximale des messages d'erreurs qui seront enregistrés (octets)
     * Le message est tronqué, l'affichage de [Stack trace] sera réduit
     *
     * @param int $value
     * @return FredT_Error_Config
     */
    public function setLogErrorsMaxLen($value=1024)
    {
        $this->_setIni('log_errors_max_len', (int) $value);
        return $this;
    }

    /**
     * Retourne la Taille maximale des erreurs qui sont enregistrées (octets)
     *
     * @return int
     */
    public function getLogErrorsMaxLen()
    {
        $val = ini_get('log_errors_max_len');
        $last = strtolower($val{strlen($val)-1});
        switch($last) {

            case 'g':
                $val *= 1024;
            case 'm':
                $val *= 1024;
            case 'k':
                $val *= 1024;
        }
        return $val;
    }

    /**
     * Fixe le niveau du rapport d'erreur
     * La valeur maximale (pour E_ALL) peut changer,
     * on peut utiliser la valeur maximale 2147483647 pour tout couvrir
     * 6135 correspond à E_ALL & ~E_NOTICE
     *
     * @param int $value
     * @return FredT_Error_Config
     */
    public function setErrorReporting($value=6135)
    {
        $this->_setIni('error_reporting', (int) $value);
        return $this;
    }

    /**
     * Retourne le niveau du rapport d'erreur
     *
     * @return string
     */
    public function getErrorReporting()
    {
        return (int) ini_get('error_reporting');
    }

    /**
     * Retourne true si $errLevel est compris dans le niveau du rapport d'erreur
     *
     * @return boolean
     */
    public function isErrorReport($errLevel) {
        return ($this->getErrorReporting() & $errLevel)==$errLevel;
    }

    /**
     * Alias pour la fonction ini_set
     * Lance une exception si la config n'est pas appliquée
     *
     * @throws si ini_set retourne false, false pouvait être
     * la valeur originale, on vérifie donc si la nouvelle valeur est appliqué avant de lancer l'Exception
     *
     * @param string $varname
     * @param mixed $value
     */
    private function _setIni($varname, $value)
    {
        $result = ini_set($varname, $value);
        if (false===$result) {
            if ($value != ini_get($varname)) {
                throw new Exception('Config "' . $varname . '" non appliquée');
            }
        }
    }
}


////////////////////////////////////////////
////////////////////////////////////////////
/**
 *  -------------    TESTs     -------------
 *   configuration pour la gestion d'erreur
 *
 * @example  1) avec les méthodes de classe
 */
$errConf= new FredT_Error_Config();
$errConf->setDisplayErrors(true)
        ->setDisplayStartupErrors(true)
        ->setLogErrors(true)
        ->setIgnoreRepeatedErrors(true)
        ->setIgnoreRepeatedSource(true)
        ->setReportMemleaks(true)
        ->setTrackErrors(true)
        ->setHtmlErrors(true)
        ->setDocrefRoot('http://www.php.net/manual/fr/')
        ->setDocrefExt('.php')
        ->setErrorLog('E:\\log_test_php.log')
        ->setLogErrorsMaxLen(1024)
        ->setErrorPrependString('<div class="erreur">')
        ->setErrorAppendString('</div>')
        ->setErrorReporting(FredT_Error_Config::E_ALL_EXTRA )
    ;
    try {
        $errConf->setWarnPlusOverloading(true);
    } catch (Exception $e) {}

/**
 * @example  2) avec un array fourni au constructeur
 *          ou également possible avec la méthode setConfig()
 *
 */

/**
 * array avec les valeurs par défaut de php.ini
 * @var array
 */
$defaultConf=array(
    'DisplayErrors'        => true,
    'DisplayStartupErrors' => false,
    'LogErrors'            => false,
    'IgnoreRepeatedErrors' => false,
    'IgnoreRepeatedSource' => false,
    'ReportMemleaks'       => true,
    'TrackErrors'          => false,
    'HtmlErrors'           => true,
    'WarnPlusOverloading'  => null,
    'DocrefRoot'           => '',
    'DocrefExt'            => '',
    'ErrorPrependString'   => '',
    'ErrorAppendString'    => '',
    'ErrorLog'             => null,
    'LogErrorsMaxLen'      => 1024,
    'ErrorReporting'       => 6135 //E_ALL & ~E_NOTICE (attention, variable)
);
/**
 * configuration entièrement personnalisée
 * @var array
 */
$conf=array(
    'DisplayErrors'        => true,
    'DisplayStartupErrors' => true,
    'LogErrors'            => true,
    'IgnoreRepeatedErrors' => false,
    'IgnoreRepeatedSource' => false,
    'ReportMemleaks'       => true,
    'TrackErrors'          => true,
    'HtmlErrors'           => true,
    'WarnPlusOverloading'  => null, // todo Erreur
    'DocrefRoot'           => 'http://www.php.net/manual/fr/',
    'DocrefExt'            => '.php',
    'ErrorPrependString'   => '<div class="erreur">',
    'ErrorAppendString'    => '</div>',
    'ErrorLog'             => 'E:\\log_test_php.log',
    'LogErrorsMaxLen'      => 2048,
    'ErrorReporting'       => FredT_Error_Config::E_ALL_EXTRA
);
/**
 * configuration pour seulement revoir le comportement avec log
 * @var array
 */
$confLog=array(
    'LogErrors'            => true,
    'ErrorLog'             => 'E:\\log_test_php.log',
    'LogErrorsMaxLen'      => 2048,
);

$errConf= new FredT_Error_Config($conf);

/**
 *  -------------    TESTs     -------------
 *   lecture de la configuration
 *
 */
header ('Content-type: text/plain; charset=utf-8');
/**
 * Méthode easy to use
 */
echo (   $errConf->isErrorReport(E_NOTICE)
         ? 'Le rapport des E_NOTICE est activé'
         : 'Attention, il est souhaitable d\'activer le rapport des E_NOTICE'
     ) . "\n";

/**
 * Simple vérif
 */
$myConf= $errConf->getConfig();
if($conf==$myConf){
    echo "\n".'Comparaison reverse $conf==$myConf : OK'."\n"."\n";
} else {
    echo "\n".'Comparaison reverse $conf==$myConf : ECHEC'."\n"."\n";
}

/**
 * génère code à insérer dans un fichier .ini perso
 */
echo '[section errorConfig]' . "\n";
foreach ($myConf as $key => $value) {
	echo $key;
	echo str_repeat(' ', 30 - strlen($key));
	echo '= ';
	if (is_bool($value) ) {
	    echo $value ? 'true' : 'false';
	} elseif (is_string($value)) {
	    echo '"' . $value . '"';
	} elseif (is_int($value)) {
	    echo $value;
	} else {
	    echo $value;
	}
	echo "\n";
}