Proxy.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 Proxy
{
    protected $locale;

    protected $proxified;

    protected $modules;

    protected function __construct(
        \Erebot\Interfaces\Config\Proxy   $proxified,
        \SimpleXMLElement $xml
    ) {
        $this->proxified    = $proxified;
        $this->modules      = array();

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

        if (!isset($xml->modules->module)) {
            return;
        }

        foreach ($xml->modules->module as $module) {
            $instance = new \Erebot\Config\Module($module);
            $this->modules[$instance->getName()] = $instance;
        }
    }

    public function __destruct()
    {
        unset(
            $this->modules,
            $this->proxified
        );
    }

    public function __clone()
    {
        throw new \Exception("Cloning forbidden!");
    }

    public function getTranslator($component)
    {
        if (isset($this->locale)) {
            $translator = new \Erebot\Intl($component);
            $translator->setLocale(
                \Erebot\IntlInterface::LC_MESSAGES,
                $this->locale
            );
            $categories = array(
                \Erebot\IntlInterface::LC_MONETARY,
                \Erebot\IntlInterface::LC_NUMERIC,
                \Erebot\IntlInterface::LC_TIME,
            );
            $proxiedTranslator = $this->proxified->getTranslator($component);
            foreach ($categories as $category) {
                $translator->setLocale(
                    $category,
                    $proxiedTranslator->getLocale($category)
                );
            }
            return $translator;
        }
        if ($this->proxified === $this) {
            throw new \Erebot\NotFoundException('No translator associated');
        }
        return $this->proxified->getTranslator($component);
    }

    public function getMainCfg()
    {
        if ($this->proxified === $this) {
            return $this;
        }
        return $this->proxified->getMainCfg();
    }

    public function getModules($recursive)
    {
        if (!is_bool($recursive)) {
            throw new \Erebot\InvalidValueException(
                'Invalid value for recursion'
            );
        }

        if ($recursive && $this->proxified !== $this) {
            $inherited = $this->proxified->getModules(true);
        } else {
            $inherited = array();
        }

        $added      = array();
        $removed    = array();
        foreach ($this->modules as $name => $module) {
            if ($module->isActive()) {
                $added[]    = $name;
            } else {
                $removed[]  = $name;
            }
        }

        $inherited = array_diff($inherited, $removed);
        return array_merge($added, $inherited);
    }

    public function getModule($moduleName)
    {
        $moduleName = '\\' . ltrim($moduleName, '\\');
        if (!isset($this->modules[$moduleName])) {
            if ($this->proxified !== $this) {
                return $this->proxified->getModule($moduleName);
            }
            throw new \Erebot\NotFoundException('No such module "' .
                                                $moduleName . '"');
        }
        return $this->modules[$moduleName];
    }

    public static function parseBoolHelper($value)
    {
        $value = strtolower($value);
        if (in_array($value, array('true', '1', 'on', 'yes'), true)) {
            return true;
        }
        if (in_array($value, array('false', '0', 'off', 'no'), true)) {
            return false;
        }
        return null;
    }

    public static function parseIntHelper($value)
    {
        if ($value == '') {
            return null;
        }

        if (is_int($value)) {
            return $value;
        }

        if (ctype_digit($value)) {
            return (int) $value;
        }

        if (strpos('+-', $value[0]) !== false && ctype_digit(substr($value, 1))) {
            return (int) $value;
        }

        return null;
    }

    public static function parseRealHelper($value)
    {
        if (!is_numeric($value)) {
            return null;
        }

        return (double) $value;
    }

    protected function parseSomething(
        $module,
        $param,
        $default,
        \Erebot\CallableInterface $parser,
        $origin,
        \Erebot\CallableInterface $checker
    ) {
        try {
            if (!isset($this->modules[$module])) {
                throw new \Erebot\NotFoundException('No such module');
            }
            $value  = $this->modules[$module]->getParam($param);
            $value  = $parser($value);
            if ($value !== null) {
                return $value;
            }
            throw new \Erebot\InvalidValueException(
                'Bad value in configuration'
            );
        } catch (\Erebot\NotFoundException $e) {
            if ($this->proxified !== $this) {
                return $this->proxified->$origin($module, $param, $default);
            }

            if ($default === null) {
                throw new \Erebot\NotFoundException('No such parameter "' .
                                                    $param . '" for module "' .
                                                    $module . '"');
            }

            if ($checker($default)) {
                return $default;
            }
            throw new \Erebot\InvalidValueException('Bad default value');
        }
    }

    public function parseBool($module, $param, $default = null)
    {
        return $this->parseSomething(
            $module,
            $param,
            $default,
            \Erebot\CallableWrapper::wrap(array($this, 'parseBoolHelper')),
            __FUNCTION__,
            \Erebot\CallableWrapper::wrap('is_bool')
        );
    }

    public function parseString($module, $param, $default = null)
    {
        return $this->parseSomething(
            $module,
            $param,
            $default,
            \Erebot\CallableWrapper::wrap('strval'),
            __FUNCTION__,
            \Erebot\CallableWrapper::wrap('is_string')
        );
    }

    public function parseInt($module, $param, $default = null)
    {
        return $this->parseSomething(
            $module,
            $param,
            $default,
            \Erebot\CallableWrapper::wrap(array($this, 'parseIntHelper')),
            __FUNCTION__,
            \Erebot\CallableWrapper::wrap('is_int')
        );
    }

    public function parseReal($module, $param, $default = null)
    {
        return $this->parseSomething(
            $module,
            $param,
            $default,
            \Erebot\CallableWrapper::wrap(array($this, 'parseRealHelper')),
            __FUNCTION__,
            \Erebot\CallableWrapper::wrap('is_real')
        );
    }
}