Base.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\Module;

abstract class Base
{
    protected $connection;

    protected $channel;

    protected $translator;

    protected $factories;

    protected $logger;


    const RELOAD_INIT       = 0x01;

    const RELOAD_TESTING    = 0x02;

    const RELOAD_MEMBERS    = 0x10;

    const RELOAD_HANDLERS   = 0x20;

    const RELOAD_ALL        = 0xF0;


    const MSG_TYPE_PRIVMSG      = 'PRIVMSG';

    const MSG_TYPE_NOTICE       = 'NOTICE';

    const MSG_TYPE_CTCP         = 'CTCP';

    const MSG_TYPE_CTCPREPLY    = 'CTCPREPLY';

    const MSG_TYPE_ACTION       = 'ACTION';

    abstract protected function reload($flags);

    protected function unload()
    {
    }

    final public function __construct($channel)
    {
        $this->connection  =
        $this->translator  =
        $this->mainCfg     = null;
        $this->channel     = $channel;
        $this->factories   = array();

        $ifaces = array(
            '!EventHandler'     => '\\Erebot\\EventHandler',

            '!Identity'         => '\\Erebot\\Identity',

            '!NumericHandler'   => '\\Erebot\\NumericHandler',

            '!NumericReference' => '\\Erebot\\NumericReference',

            '!Styling'          => '\\Erebot\\Styling',

            '\\Erebot\\Styling\\Variables\\CurrencyInterface' =>
                '\\Erebot\\Styling\\Variables\\CurrencyVariable',

            '\\Erebot\\Styling\\Variables\\DateTimeInterface' =>
                '\\Erebot\\Styling\\Variables\\DateTimeVariable',

            '\\Erebot\\Styling\\Variables\\DurationInterface' =>
                '\\Erebot\\Styling\\Variables\\DurationVariable',

            '!TextWrapper'      => '\\Erebot\\TextWrapper',

            '!Timer'            => '\\Erebot\\Timer',
        );
        foreach ($ifaces as $iface => $cls) {
            try {
                $this->setFactory($iface, $cls);
            } catch (\Erebot\InvalidValueException $e) {
                // Ignore silently as the only time the default classes
                // won't exist is when we run the tests for some module.
            }
        }

        $this->logger = null;
        if (class_exists('\\Plop\\Plop')) {
            $this->logger =& \Plop\Plop::getInstance();
        }
    }

    final public function __destruct()
    {
        unset(
            $this->connection,
            $this->translator,
            $this->channel,
            $this->mainCfg
        );
    }

    final public function reloadModule(
        \Erebot\Interfaces\Connection $connection,
        $flags
    ) {
        if ($this->connection === null) {
            $flags |= self::RELOAD_INIT;
        } else {
            $flags &= ~self::RELOAD_INIT;
        }

        $this->connection   = $connection;
        $serverCfg          = $this->connection->getConfig(null);
        $this->mainCfg      = $serverCfg->getMainCfg();

        $this->translator = $this->mainCfg->getTranslator(get_called_class());
        $this->reload($flags);

        if ($this instanceof \Erebot\Interfaces\HelpEnabled) {
            $this->registerHelpMethod(\Erebot\CallableWrapper::wrap(array($this, 'getHelp')));
        }
    }

    final public function unloadModule()
    {
        return $this->unload();
    }

    public function setFactory($iface, $cls)
    {
        if (!is_string($iface)) {
            throw new \Erebot\InvalidValueException('Not an interface name');
        }

        $ifaceName = str_replace('!', '\\Erebot\\Interfaces\\', $iface);
        if (!interface_exists($ifaceName, true)) {
            $ifaceName = str_replace('!', '\\Erebot\\', $iface) . 'Interface';
            if (!interface_exists($ifaceName, true)) {
                throw new \Erebot\InvalidValueException(
                    'No such interface ('.$iface.')'
                );
            }
        }

        if (!class_exists($cls, true)) {
            throw new \Erebot\InvalidValueException('No such class ('.$cls.')');
        }

        $reflector = new \ReflectionClass($cls);
        if (!$reflector->isSubclassOf($ifaceName)) {
            throw new \Erebot\InvalidValueException(
                'A class that implements the interface was expected'
            );
        }
        $iface = strtolower($ifaceName);
        $this->factories[$iface] = $cls;
    }

    public function getFactory($iface)
    {
        if (!is_string($iface)) {
            throw new \Erebot\InvalidValueException('Not an interface name');
        }

        $ifaceKey = strtolower(str_replace('!', '\\Erebot\\Interfaces\\', $iface));
        if (!isset($this->factories[$ifaceKey])) {
            $ifaceKey = strtolower(str_replace('!', '\\Erebot\\', $iface) . 'Interface');
            if (!isset($this->factories[$ifaceKey])) {
                throw new \Erebot\InvalidValueException(
                    'No such interface ('.$iface.')'
                );
            }
        }
        return $this->factories[$ifaceKey];
    }

    protected function sendMessage(
        $targets,
        $message,
        $type = self::MSG_TYPE_PRIVMSG
    ) {
        $types  = array('PRIVMSG', 'NOTICE', 'CTCP', 'CTCPREPLY', 'ACTION');
        $type   = strtoupper($type);
        if (!in_array($type, $types)) {
            throw new \Exception('Not a valid type');
        }

        if (is_array($targets)) {
            $targets = implode(',', $targets);
        } elseif ($targets instanceof \Erebot\Identity) {
            $targets = (string) $targets;
        } elseif (!is_string($targets)) {
            throw new \Exception('Not a valid target (expected a string)');
        }

        if (!\Erebot\Utils::stringifiable($message)) {
            throw new \Exception('Not a valid message (expected a string)');
        }

        $message    = (string) $message;
        $parts      = array_map('trim', explode("\n", trim($message)));
        $message    = implode(' ', $parts);
        $marker     = '';
        $ctcpType   = '';

        if ($type == 'ACTION') {
            $type       = 'PRIVMSG';
            $marker     = "\001";
            $ctcpType   = 'ACTION';
        }

        if ($type == 'CTCP' || $type == 'CTCPREPLY') {
                $type       = ($type == 'CTCP' ? 'PRIVMSG' : 'NOTICE');
                $marker     = "\001";
                $parts      = explode(' ', $message);
                $ctcpType   = array_shift($parts);
                $message    = implode(' ', $parts);
        }

        if ($ctcpType != "" && $message != "") {
            $ctcpType .= " ";
            $message = self::ctcpQuote($message);
        }

        $prefix = $type.' '.$targets.' :'.$marker.$ctcpType;
        // 400 is a rough estimation of how big
        // a message we may send.
        $messages = explode(
            "\n",
            wordwrap(
                $message,
                400 - strlen($prefix) - 2,
                "\n",
                true
            )
        );
        $io = $this->connection->getIO();
        foreach ($messages as $msg) {
            $io->push($prefix.$msg.$marker);
        }
    }

    protected static function ctcpQuote($message)
    {
        // First comes low-level quoting.
        $quoting = array(
            "\000"  => "\0200",
            "\n"    => "\020n",
            "\r"    => "\020r",
            "\020"  => "\020\020",
        );
        $message = strtr($message, $quoting);

        // Next some CTCP-level quoting and we're done.
        $quoting = array(
            "\001"  => "\\a",
            "\\"    => "\\\\",
        );
        $message = strtr($message, $quoting);
        return $message;
    }

    protected function sendCommand($command)
    {
        if (!\Erebot\Utils::stringifiable($command)) {
            throw new \Exception('Invalid command (not a string)');
        }
        $this->connection->getIO()->push((string) $command);
    }

    protected function addTimer(\Erebot\TimerInterface $timer)
    {
        $bot = $this->connection->getBot();
        return $bot->addTimer($timer);
    }

    protected function removeTimer(\Erebot\TimerInterface $timer)
    {
        $bot = $this->connection->getBot();
        return $bot->removeTimer($timer);
    }

    private function parseSomething($something, $param, $default)
    {
        $function   = 'parse'.$something;
        $bot        = $this->connection->getBot();
        if ($this->channel !== null) {
            try {
                $config = $this->connection->getConfig($this->channel);
                return $config->$function('\\' . get_called_class(), $param);
            } catch (\Erebot\Exception $e) {
                unset($config);
            }
        }
        $config = $this->connection->getConfig(null);
        return $config->$function('\\' . get_called_class(), $param, $default);
    }

    protected function parseBool($param, $default = null)
    {
        return $this->parseSomething('Bool', $param, $default);
    }

    protected function parseString($param, $default = null)
    {
        return $this->parseSomething('String', $param, $default);
    }

    protected function parseInt($param, $default = null)
    {
        return $this->parseSomething('Int', $param, $default);
    }

    protected function parseReal($param, $default = null)
    {
        return $this->parseSomething('Real', $param, $default);
    }

    protected function registerHelpMethod(\Erebot\CallableInterface $callback)
    {
        try {
            $helper = $this->connection->getModule(
                '\\Erebot\\Module\\Helper',
                $this->channel
            );
            return $helper->realRegisterHelpMethod($this, $callback);
        } catch (\Exception $e) {
            return false;
        }
    }

    protected function getFormatter($chan)
    {
        $cls = $this->getFactory('!Styling');
        if ($chan === false) {
            return new $cls($this->translator);
        } elseif ($chan !== null) {
            $config = $this->connection->getConfig($chan);
            try {
                return new $cls($config->getTranslator(get_called_class()));
            } catch (\Erebot\Exception $e) {
            // The channel lacked a specific config. Use the cascade.
            }
            unset($config);
        }

        $config = $this->connection->getConfig($this->channel);
        try {
            return new $cls($config->getTranslator(get_called_class()));
        } catch (\Erebot\Exception $e) {
            // The channel lacked a specific config. Use the cascade.
        }
        unset($config);

        $config = $this->connection->getConfig(null);
        return new $cls($config->getTranslator(get_called_class()));
    }

    public function getNumRef($name)
    {
        $cls = $this->getFactory('!NumericReference');
        return new $cls($this->connection, $name);
    }
}