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!");
    }

    protected static function getBaseDir($component)
    {
        $reflector = new \ReflectionClass($component);
        $parts = explode(DIRECTORY_SEPARATOR, $reflector->getFileName());
        do {
            $last = array_pop($parts);
        } while ($last !== 'src' && count($parts));
        $parts[] = 'data';
        $parts[] = 'i18n';
        $base = implode(DIRECTORY_SEPARATOR, $parts);
        return $base;
    }

    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));
        }

        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,
        callable $parser,
        $origin,
        callable $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,
            array($this, 'parseBoolHelper'),
            __FUNCTION__,
            'is_bool'
        );
    }

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

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

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