Main.php

<?php
/*
    This file is part of Erebot, a modular IRC bot written in PHP.

    Copyright © 2010 François Poirotte

    Erebot 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 3 of the License, or
    (at your option) any later version.

    Erebot 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.

    You should have received a copy of the GNU General Public License
    along with Erebot.  If not, see <http://www.gnu.org/licenses/>.
*/

namespace Erebot\Config;

class Main extends \Erebot\Config\Proxy implements \Erebot\Interfaces\Config\Main
{
    protected $configFile;

    protected $networks;

    protected $version;

    protected $timezone;

    protected $commandsPrefix;

    protected $daemonize;

    protected $userIdentity;

    protected $groupIdentity;

    protected $pidfile;

    protected $coreTranslator;

    public function __construct(
        $configData,
        $source,
        \Erebot\Intl\TranslatorInterface $translator
    ) {
        $this->proxified        = null;
        $this->modules          = array();
        $this->configFile       = null;
        $this->coreTranslator   = $translator;
        $this->load($configData, $source);
    }

    public function __destruct()
    {
        parent::__destruct();
        unset(
            $this->networks
        );
    }

    public function __clone()
    {
        throw new \Exception('Cloning is forbidden');
    }

    private function stripXGlobWrappers(&$domxml)
    {
        $xpath = new \DOMXPath($domxml);
        $xpath->registerNamespace('xglob', \Erebot\XGlobStream::XMLNS);
        $wrappers = $xpath->query('//xglob:' . \Erebot\XGlobStream::TAG);
        foreach ($wrappers as $wrapper) {
            for ($i = $wrapper->childNodes->length; $i > 0; $i--) {
                $wrapper->parentNode->insertBefore(
                    $wrapper->childNodes->item($i - 1),
                    $wrapper->nextSibling
                );
            }
            $wrapper->parentNode->removeChild($wrapper);
        }
    }

    public function load($configData, $source)
    {
        $logger = \Plop\Plop::getInstance();
        $possibleSources = array(
            self::LOAD_FROM_FILE,
            self::LOAD_FROM_STRING,
        );
        if (!in_array($source, $possibleSources, true)) {
            throw new \Erebot\InvalidValueException('Invalid $source');
        }

        if ($source == self::LOAD_FROM_FILE) {
            if (is_string($configData) && $configData != "") {
                if (!strncasecmp(PHP_OS, "Win", 3)) {
                    if (!in_array($configData[0], array("/", "\\")) &&
                        strlen($configData) > 1 && $configData[1] != ":") {
                        $configData = getcwd() . DIRECTORY_SEPARATOR .
                                        $configData;
                    }
                } elseif ($configData[0] != DIRECTORY_SEPARATOR) {
                    $configData = getcwd() . DIRECTORY_SEPARATOR . $configData;
                }
                $file = \Erebot\URI::fromAbsPath($configData, false);
            } elseif (is_object($configData) &&
                $configData instanceof \Erebot\URIInterface) {
                $file = $configData;
            } else {
                throw new \Erebot\InvalidValueException(
                    "Invalid configuration file"
                );
            }
        } elseif (!is_string($configData)) {
            throw new \Erebot\InvalidValueException(
                "Invalid configuration file"
            );
        } else {
            $file = null;
        }

        $mainSchema = dirname(dirname(__DIR__)) .
                        DIRECTORY_SEPARATOR . 'data' .
                        DIRECTORY_SEPARATOR . 'config.rng';
        $mainSchema = file_get_contents($mainSchema);
        $ue         = libxml_use_internal_errors(true);
        $domxml     = new \Erebot\DOM();
        if ($source == self::LOAD_FROM_FILE) {
            $domxml->load((string) $file);
        } else {
            $domxml->loadXML($configData);
        }

        $domxml->xinclude(LIBXML_NOBASEFIX);
        $this->stripXGlobWrappers($domxml);

        $ok         = $domxml->relaxNGValidateSource($mainSchema);
        $errors     = $domxml->getErrors();
        libxml_use_internal_errors($ue);

        if (!$ok || count($errors)) {
            // Some unpredicted error occurred,
            // show some (hopefully) useful information.
            $logger->error(print_r($errors, true));
            throw new \Erebot\InvalidValueException(
                'Errors were found while validating the configuration file'
            );
        }

        $xml = simplexml_import_dom($domxml);
        parent::__construct($this, $xml);

        if (!isset($xml['version'])) {
            $this->version = null;
        } else {
            $this->version  = (string) $xml['version'];
        }

        if (!isset($xml['timezone'])) {
            throw new \Erebot\InvalidValueException('No timezone defined');
        }
        $this->timezone = (string) $xml['timezone'];

        // Set timezone information.
        // This is needed to configure the logging subsystem.
        if (function_exists('date_default_timezone_set')) {
            if (!date_default_timezone_set($this->timezone)) {
                throw \Erebot\InvalidValueException(
                    sprintf(
                        'Invalid timezone: "%s"',
                        $this->timezone
                    )
                );
            }
        }

        $daemonize      = isset($xml['daemon'])
                        ? $this->parseBool((string) $xml['daemon'])
                        : false;
        $userIdentity   = isset($xml['uid']) ? ((string) $xml['uid']) : null;
        $groupIdentity  = isset($xml['gid']) ? ((string) $xml['gid']) : null;
        $pidfile        = isset($xml['pidfile'])
                        ? ((string) $xml['pidfile'])
                        : null;

        if ($daemonize === null) {
            throw new \Erebot\InvalidValueException('Invalid "daemon" value');
        }

        if (!isset($xml['commands-prefix'])) {
            $this->commandsPrefix = '!';
        } else {
            $this->commandsPrefix = (string) $xml['commands-prefix'];
            if (strcspn($this->commandsPrefix, " \r\n\t") !=
                strlen($this->commandsPrefix)) {
                throw new \Erebot\InvalidValueException(
                    'Invalid command prefix'
                );
            }
        }

        $logger->debug(
            $this->coreTranslator->gettext(
                'Loaded configuration data'
            )
        );

        $this->networks = array();
        foreach ($xml->networks->network as $netCfg) {
            $newConfig  = new \Erebot\Config\Network($this, $netCfg);
            $this->networks[$newConfig->getName()] = $newConfig;
            unset($newConfig);
        }

        if ($source == self::LOAD_FROM_FILE) {
            $this->configFile   = $configData;
        } else {
            $this->configFile   = null;
        }

        // Default values.
        $this->daemonize        = $daemonize;
        $this->userIdentity     = $userIdentity;
        $this->groupIdentity    = $groupIdentity;
        $this->pidfile          = $pidfile;
    }

    public function getNetworkCfg($network)
    {
        if (!isset($this->networks[$network])) {
            throw new \Erebot\NotFoundException('No such network');
        }
        return $this->networks[$network];
    }

    public function getNetworks()
    {
        return $this->networks;
    }

    public function getVersion()
    {
        return $this->version;
    }

    public function getTimezone()
    {
        return $this->timezone;
    }

    public function getCommandsPrefix()
    {
        return $this->commandsPrefix;
    }

    public function getConfigFile()
    {
        return $this->configFile;
    }

    public function mustDaemonize()
    {
        return $this->daemonize;
    }

    public function getGroupIdentity()
    {
        return $this->groupIdentity;
    }

    public function getUserIdentity()
    {
        return $this->userIdentity;
    }

    public function getPidfile()
    {
        return $this->pidfile;
    }

    public function getTranslator($component)
    {
        if (isset($this->locale)) {
            $domain = str_replace('\\', '_', ltrim($component, '\\'));
            $localedir = static::getBaseDir($component);
            return \Erebot\Intl\GettextFactory::translation($domain, $localedir, array($this->locale));
        }

        return $this->coreTranslator;
    }
}