IrcParser.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;

class IrcParser implements \Erebot\Interfaces\IrcParser
{
    const STRIP_NONE        = 0x00;
    const STRIP_COLORS      = 0x01;
    const STRIP_BOLD        = 0x02;
    const STRIP_UNDERLINE   = 0x04;
    const STRIP_REVERSE     = 0x08;
    const STRIP_RESET       = 0x10;
    const STRIP_ALL         = 0xFF;


    protected $eventsMapping;

    protected $connection;


    public function __construct(\Erebot\Interfaces\Connection $connection)
    {
        $this->connection = $connection;
        $this->eventsMapping = array();
    }

    public static function stripCodes($text, $strip = self::STRIP_ALL)
    {
        if (!is_int($strip)) {
            throw new \Erebot\InvalidValueException("Invalid stripping flags");
        }

        if ($strip & self::STRIP_BOLD) {
            $text = str_replace("\002", '', $text);
        }

        if ($strip & self::STRIP_COLORS) {
            $text = preg_replace("/\003(?:[0-9]{1,2}(?:,[0-9]{1,2})?)?/", '', $text);
        }

        if ($strip & self::STRIP_RESET) {
            $text = str_replace("\017", '', $text);
        }

        if ($strip & self::STRIP_REVERSE) {
            $text = str_replace("\026", '', $text);
        }

        if ($strip & self::STRIP_UNDERLINE) {
            $text = str_replace("\037", '', $text);
        }

        return $text;
    }

    public function makeEvent($iface /* , ... */)
    {
        $args = func_get_args();

        // Shortcuts.
        $iface = str_replace('!', '\\Erebot\\Interfaces\\Event\\', $iface);
        $iface = strtolower($iface);

        if (!isset($this->eventsMapping[$iface])) {
            throw new \Erebot\NotFoundException('No such declared interface');
        }

        // Replace the first argument (interface) with a reference
        // to the connection, since all events require it anyway.
        // This simplifies calls to this method a bit.
        $args[0]    = $this->connection;
        $cls        = new \ReflectionClass($this->eventsMapping[$iface]);
        $instance   = $cls->newInstanceArgs($args);
        return $instance;
    }

    protected static function ctcpUnquote($msg)
    {
        // CTCP-level unquoting
        $quoting = array(
            "\\a"   => "\001",
            "\\\\"  => "\\",
            "\\"    => "",  // Ignore quoting character
                            // for invalid sequences.
        );
        $msg = strtr($msg, $quoting);

        // Low-level unquoting
        $quoting = array(
            "\0200"     => "\000",
            "\020n"     => "\n",
            "\020r"     => "\r",
            "\020\020"  => "\020",
            "\020"      => "",  // Ignore quoting character
                                // for invalid sequences.
        );
        $msg = strtr($msg, $quoting);
        return $msg;
    }

    public function getEventClass($iface)
    {
        // Shortcuts.
        $iface = str_replace('!', '\\Erebot\\Interfaces\\Event\\', $iface);
        $iface = strtolower($iface);

        return isset($this->eventsMapping[$iface])
            ? $this->eventsMapping[$iface]
            : null;
    }

    public function getEventClasses()
    {
        return $this->eventsMapping;
    }

    public function setEventClasses($events)
    {
        foreach ($events as $iface => $cls) {
            $this->setEventClass($iface, $cls);
        }
    }

    public function setEventClass($iface, $cls)
    {
        // Shortcuts.
        $iface = str_replace('!', '\\Erebot\\Interfaces\\Event\\', $iface);
        if (!interface_exists($iface)) {
            throw new \Erebot\InvalidValueException(
                'The given interface ('.$iface.') does not exist'
            );
        }

        $iface = strtolower($iface);
        $reflector = new \ReflectionClass($cls);
        if (!$reflector->implementsInterface($iface)) {
            throw new \Erebot\InvalidValueException(
                'The given class does not implement that interface'
            );
        }
        $this->eventsMapping[$iface] = $cls;
    }

    public function parseLine($msg)
    {
        if (!strncmp($msg, ':', 1)) {
            $pos    = strcspn($msg, ' ');
            $origin = (string) substr($msg, 1, $pos - 1);
            $msg    = new \Erebot\IrcTextWrapper((string) substr($msg, $pos + 1));
        } else {
            $origin = '';
            $msg    = new \Erebot\IrcTextWrapper($msg);
        }

        $type   = $msg[0];
        $type   = strtoupper($type);
        unset($msg[0]);

        $method = 'handle'.$type;
        $exists = method_exists($this, $method);
        // We need a backup for numeric events
        // as the method may alter the message.
        $backup = clone $msg;

        if ($exists) {
            $res = $this->$method($origin, $msg);
        }

        if (ctype_digit($type)) {
            // For numeric events, the first token is always the target.
            $target = $backup[0];
            unset($backup[0]);
            return $this->connection->dispatch(
                $this->makeEvent(
                    '!Numeric',
                    intval($type, 10),
                    $origin,
                    $target,
                    $backup
                )
            );
        }

        if ($exists) {
            return $res;
        }

        return false;
    }

    protected function noticeOrPrivmsg($origin, $msg, $mapping)
    {
        // :nick1!ident@host NOTICE <nick2/#chan> :Message
        // :nick1!ident@host PRIVMSG <nick2/#chan> :Message
        $target = $msg[0];
        $msg    = $msg[1];
        $isChan = (int) $this->connection->isChannel($target);
        $len = strlen($msg);
        if ($len > 1 && $msg[$len-1] == "\x01" && $msg[0] == "\x01") {
            // Remove the markers.
            $msg    = (string) substr($msg, 1, -1);
            // Unquote the message.
            $msg    = self::ctcpUnquote($msg);
            // Extract the tag from the rest of the message.
            $pos    = strcspn($msg, " ");
            $ctcp   = substr($msg, 0, $pos);
            $msg    = (string) substr($msg, $pos + 1);

            if ($ctcp == "ACTION") {
                if ($isChan) {
                    return $this->connection->dispatch(
                        $this->makeEvent($mapping['action'][$isChan], $target, $origin, $msg)
                    );
                }

                return $this->connection->dispatch(
                    $this->makeEvent($mapping['action'][$isChan], $origin, $msg)
                );
            }

            if ($isChan) {
                return $this->connection->dispatch(
                    $this->makeEvent($mapping['ctcp'][$isChan], $target, $origin, $ctcp, $msg)
                );
            }

            return $this->connection->dispatch(
                $this->makeEvent($mapping['ctcp'][$isChan], $origin, $ctcp, $msg)
            );
        }

        if ($isChan) {
            return $this->connection->dispatch(
                $this->makeEvent(
                    $mapping['normal'][$isChan],
                    $target,
                    $origin,
                    $msg
                )
            );
        }

        return $this->connection->dispatch(
            $this->makeEvent($mapping['normal'][$isChan], $origin, $msg)
        );
    }

    protected function handleINVITE($origin, $msg)
    {
        // :nick1!ident@host INVITE nick2 :#chan
        return $this->connection->dispatch(
            $this->makeEvent('!Invite', $msg[1], $origin, $msg[0])
        );
    }

    protected function handleJOIN($origin, $msg)
    {
        // :nick1!ident@host JOIN :#chan
        return $this->connection->dispatch(
            $this->makeEvent('!Join', $msg[0], $origin)
        );
    }

    protected function handleKICK($origin, $msg)
    {
        // :nick1!ident@host KICK #chan nick2 :Reason
        return $this->connection->dispatch(
            $this->makeEvent('!Kick', $msg[0], $origin, $msg[1], $msg[2])
        );
    }

    protected function handleMODE($origin, $msg)
    {
        // :nick1!ident@host MODE <nick2/#chan> <modes> [args]
        $target = $msg[0];
        unset($msg[0]);
        if (!$this->connection->isChannel($target)) {
            return $this->connection->dispatch(
                $this->makeEvent('!UserMode', $origin, $target, $msg)
            );
        }

        $event = $this->makeEvent('!RawMode', $target, $origin, $msg);
        $this->connection->dispatch($event);
        if ($event->preventDefault(true)) {
            return;
        }

        $modes  = $msg[0];
        unset($msg[0]);
        $len    = strlen($modes);
        $mode   = 'add';
        $k      = 0;

        $priv     = array(
            'add' => array(
                'o' => '!Op',
                'h' => '!Halfop',
                'v' => '!Voice',
                'a' => '!Protect',
                'q' => '!Owner',
                'b' => '!Ban',
                'e' => '!Except',
            ),
            'remove' => array(
                'o' => '!DeOp',
                'h' => '!DeHalfop',
                'v' => '!DeVoice',
                'a' => '!DeProtect',
                'q' => '!DeOwner',
                'b' => '!UnBan',
                'e' => '!UnExcept',
            ),
        );

        $remains = array();
        for ($i = 0; $i < $len; $i++) {
            switch ($modes[$i]) {
                case '+':
                    $mode = 'add';
                    break;
                case '-':
                    $mode = 'remove';
                    break;

                case 'o':
                case 'v':
                case 'h':
                case 'a':
                case 'q':
                case 'b':
                case 'e':
                    $tnick  = $msg[$k++];
                    $cls    = $priv[$mode][$modes[$i]];
                    $this->connection->dispatch(
                        $this->makeEvent($cls, $target, $origin, $tnick)
                    );
                    break;

                default:
            }
        } // for each mode in $modes
    }

    protected function handleNICK($origin, $msg)
    {
        // :oldnick!ident@host NICK newnick
        return $this->connection->dispatch(
            $this->makeEvent('!Nick', $origin, $msg[0])
        );
    }

    protected function handleNOTICE($origin, $msg)
    {
        // :nick1!ident@host NOTICE <nick2/#chan> :Message
        $mapping = array(
            'action'    => array('!PrivateCtcpReply', '!ChanCtcpReply'),
            'ctcp'      => array('!PrivateCtcpReply', '!ChanCtcpReply'),
            'normal'    => array('!PrivateNotice', '!ChanNotice'),
        );
        return $this->noticeOrPrivmsg($origin, $msg, $mapping);
    }

    protected function handlePART($origin, $msg)
    {
        // :nick1!ident@host PART #chan [reason]
        return $this->connection->dispatch(
            $this->makeEvent(
                '!Part',
                $msg[0],
                $origin,
                isset($msg[1]) ? $msg[1] : ''
            )
        );
    }

    protected function handlePING($origin, $msg)
    {
        // PING origin
        return $this->connection->dispatch(
            $this->makeEvent('!Ping', $msg)
        );
    }

    protected function handlePONG($origin, $msg)
    {
        // :origin PONG origin target
        return $this->connection->dispatch(
            $this->makeEvent('!Pong', $origin, $msg[1])
        );
    }

    protected function handlePRIVMSG($origin, $msg)
    {
        // :nick1!ident@host PRIVMSG <nick2/#chan> :Message
        $mapping = array(
            'action'    => array('!PrivateAction', '!ChanAction'),
            'ctcp'      => array('!PrivateCtcp', '!ChanCtcp'),
            'normal'    => array('!PrivateText', '!ChanText'),
        );
        return $this->noticeOrPrivmsg($origin, $msg, $mapping);
    }

    protected function handleQUIT($origin, $msg)
    {
        // :nick1!ident@host QUIT :Reason
        return $this->connection->dispatch(
            $this->makeEvent('!Quit', $origin, $msg[0])
        );
    }

    protected function handleTOPIC($origin, $msg)
    {
        // :nick1!ident@host TOPIC #chan :New topic
        return $this->connection->dispatch(
            $this->makeEvent('!Topic', $msg[0], $origin, $msg[1])
        );
    }

    protected function handle255($origin, $msg)
    {
        // \Erebot\Interfaces\Numerics::RPL_LUSERME
        /* We can't rely on RPL_WELCOME because we may need
         * to detect the server's capabilities first.
         * So, we delay detection of the connection for as
         * long as we can (while retaining portability). */
        if (!$this->connection->isConnected()) {
            return $this->connection->dispatch($this->makeEvent('!Connect'));
        }
    }

    protected function handle600($origin, $msg)
    {
        // \Erebot\Interfaces\Numerics::RPL_LOGON
        return $this->watchList('!Notify', $msg);
    }

    protected function handle601($origin, $msg)
    {
        // \Erebot\Interfaces\Numerics::RPL_LOGOFF
        return $this->watchList('!UnNotify', $msg);
    }

    protected function handle604($origin, $msg)
    {
        // \Erebot\Interfaces\Numerics::RPL_NOWON
        return $this->watchList('!Notify', $msg);
    }

    protected function handle605($origin, $msg)
    {
        // \Erebot\Interfaces\Numerics::RPL_NOWOFF
        return $this->watchList('!UnNotify', $msg);
    }

    protected function watchList($event, $msg)
    {
        // <bot> <nick> <ident> <host> <timestamp> :<msg>
        unset($msg[0]);
        $nick       = $msg[0];
        $ident      = $msg[1];
        $host       = $msg[2];
        $timestamp  = intval($msg[3], 10);
        $timestamp  = new \DateTime('@'.$timestamp);
        $text       = $msg[4];

        return $this->connection->dispatch(
            $this->makeEvent(
                $event,
                $nick,
                ($ident == '*' ? null : $ident),
                ($host == '*' ? null : $host),
                $timestamp,
                $text
            )
        );
    }
}