root/trunk/Phergie/Plugin/Lart.php @ 59

<?php

/**
* @see Phergie_Event_Handler
*/
require_once 'Phergie/Event/Handler.php';

/**
* Accepts terms and corresponding definitions for storage to a local data
* source and performs and returns the result of lookups for term definitions
* as they are requested.
*/
class Phergie_Plugin_Lart extends Phergie_Event_Handler
{
    /**
    * Date string indicating the last time the cache was emptied
    *
    * @var string
    */
    protected $flushed;

    /**
    * Maps terms to corresponding definitions to serve as an in-memory cache
    *
    * @var array
    */
    protected $cache;

    /**
    * Prepared statement for inserting a new definition into or updating an
    * existing definition in the database
    *
    * @var PDOStatement
    */
    protected $replace;

    /**
    * Prepared statement for selecting the definition of a given term
    *
    * @var PDOStatement
    */
    protected $select;

    /**
    * Prepared statement for deleting the definition for a given term
    *
    * @var PDOStatement
    */
    protected $delete;

    /**
    * Creates the database if needed, connects to it, and sets up prepared
    * statements for common operations.
    *
    * @return void
    */
    public function init()
    {
        // Check for the necessary extensions
        if (!extension_loaded('PDO') || !extension_loaded('pdo_sqlite')) {
            return;
        }

        // Create the plugin directory if needed
        $dir = dirname(__FILE__) . '/' . $this->getName();
        if (!file_exists($dir)) {
            mkdir($dir);
        }

        // Initialize the database connection
        $db = $dir . '/lart.db';
        $create= !file_exists($db);
        $this->db = new PDO('sqlite:' . $db);

        // Create database tables if necessary
        if ($create) {
            $this->db->exec('CREATE TABLE lart ( name VARCHAR(255), definition TEXT )');
            $this->db->exec('CREATE UNIQUE INDEX lart_name ON lart (name)');
        }

        // Initialize prepared statements for common operations
        $this->replace = $this->db->prepare('
            REPLACE INTO lart (name, definition) VALUES (:name, :definition)
        ');
        $this->select = $this->db->prepare('
            SELECT definition FROM lart WHERE name = :name
        ');
        $this->delete = $this->db->prepare('
            DELETE FROM lart WHERE name = :name
        ');
    }

    /**
    * Retrieves the definition for a given term if it exists, from the cache
    * or from the database into the cache if needed, and returns it.
    *
    * @param string $term Term to search for
    * @return mixed String containing the definition or FALSE if no definition
    *               exists
    */
    protected function getDefinition($term)
    {
        if (!isset($this->cache[$term])) {
            $this->select->execute(array(':name' => $term));
            $definition = $this->select->fetchColumn();
            if ($definition) {
                $this->cache[$term] = $definition;
            } else {
                return false;
            }
        }
        return $this->cache[$term];
    }

    /**
    * Searches for a definition for a given term, resolves definition aliases,
    * handles cases of circular references, and sends the definition back to
    * the sender if it exists.
    *
    * @param string $message Message containing the term to search for
    * @return void
    */
    private function checkLart($message)
    {
        if (strlen($message) > 255) {
            return;
        }

        $message = strtolower($message);
        $definition = $this->getDefinition($message);
        $seen = array($message);

        if ($definition) {
            do {
                $redirect = $this->getDefinition($definition);
                if ($redirect) {
                    $seen[] = $definition;
                    if (in_array($redirect, $seen)) {
                        foreach ($seen as $term) {
                            $this->delete->execute(array('name' => $term));
                        }
                        $this->doAction(
                            $this->event->getSource(),
                            'puts her hands over her ears and cries, "Stop confusing me!"'
                        );
                    }
                    $definition = $redirect;
                }
            } while($redirect);

            $this->doPrivmsg($this->event->getSource(), $definition);
        }
    }

    /**
    * Performs a lookup for the contents of CTCP ACTION (/me) commands.
    *
    * @return void
    */
    public function onAction()
    {
        $this->checkLart($this->event->getArgument(1));
    }

    /**
    * Performs a lookup for the contents of messages to the bot or a channel
    * in which the bot is present.
    *
    * @return void
    */
    public function onPrivmsg()
    {
        $source = $this->event->getArgument(0);
        $message = $this->event->getArgument(1);
        $nick = $this->getIni('nick');
        $today = date('md');

        if ($this->flushed != $today) {
            unset($this->cache);
            $this->flushed = $today;
            $this->cache = array();
        }

        if (preg_match('/^(' . $nick . ': )?(.*) is (.*)$/U', $message, $match)) {
            list (, $address, $name, $definition) = $match;
            if (!empty($nick) || $source[0] != '#') {
                $name = strtolower($name);
                $this->replace->execute(array(':name' => $name, ':definition' => $definition));
                $this->cache[$name] = $definition;
            }
        } else if (preg_match('/^(' . $nick . ': )?forget (.*)$/U', $message, $match)) {
            if (!empty($nick) || $source[0] != '#') {
                $name = strtolower($match[2]);
                $this->delete->execute(array(':name' => $name));
                unset($this->cache[$name]);
            }
        } else {
            $this->checkLart($message);
        }
    }
}