path: root/plugins/Irc/extlib/phergie/Phergie/Plugin/Karma.php

<?php
/**
 * Phergie
 *
 * PHP version 5
 *
 * LICENSE
 *
 * This source file is subject to the new BSD license that is bundled
 * with this package in the file LICENSE.
 * It is also available through the world-wide-web at this URL:
 * http://phergie.org/license
 *
 * @category  Phergie
 * @package   Phergie_Plugin_Karma
 * @author    Phergie Development Team <team@phergie.org>
 * @copyright 2008-2010 Phergie Development Team (http://phergie.org)
 * @license   http://phergie.org/license New BSD License
 * @link      http://pear.phergie.org/package/Phergie_Plugin_Karma
 */

/**
 * Handles requests for incrementation or decrementation of a maintained list
 * of counters for specified terms and antithrottling to prevent extreme
 * inflation or depression of counters by any single individual.
 *
 * @category Phergie
 * @package  Phergie_Plugin_Karma
 * @author   Phergie Development Team <team@phergie.org>
 * @license  http://phergie.org/license New BSD License
 * @link     http://pear.phergie.org/package/Phergie_Plugin_Karma
 */
class Phergie_Plugin_Karma extends Phergie_Plugin_Abstract
{
    /**
     * Stores the SQLite object
     *
     * @var resource
     */
    protected $db = null;

    /**
     * Retains the last garbage collection date
     *
     * @var array
     */
    protected $lastGc = null;

    /**
     * Logs the karma usages and limits users to one karma change per word
     * and per day
     *
     * @return void
     */
    protected $log = array();

    /**
     * Some fixed karma values, keys must be lowercase
     *
     * @var array
     */
    protected $fixedKarma;

    /**
     * A list of blacklisted values
     *
     * @var array
     */
    protected $karmaBlacklist;

    /**
     * Answers for correct assertions
     */
    protected $positiveAnswers;

    /**
     * Answers for incorrect assertions
     */
    protected $negativeAnswers;

    /**
     * Prepared PDO statements
     *
     * @var PDOStatement
     */
    protected $insertKarma;
    protected $updateKarma;
    protected $fetchKarma;
    protected $insertComment;

    /**
     * Connects to the database containing karma ratings and initializes
     * class properties.
     *
     * @return void
     */
    public function onLoad()
    {
        $this->db = null;
        $this->lastGc = null;
        $this->log = array();

        if(!defined('M_EULER')) {
            define('M_EULER', '0.57721566490153286061');
        }

        $this->fixedKarma = array(
            'phergie'      => '%s has karma of awesome',
            'pi'           => '%s has karma of ' . M_PI,
            'Î '            => '%s has karma of ' . M_PI,
            'Ï€'            => '%s has karma of ' . M_PI,
            'chucknorris'  => '%s has karma of Warning: Integer out of range',
            'chuck norris' => '%s has karma of Warning: Integer out of range',
            'c'            => '%s has karma of 299 792 458 m/s',
            'e'            => '%s has karma of ' . M_E,
            'euler'        => '%s has karma of ' . M_EULER,
            'mole'         => '%s has karma of 6.02214e23 molecules',
            'avogadro'     => '%s has karma of 6.02214e23 molecules',
            'spoon'        => '%s has no karma. There is no spoon',
            'mc^2'         => '%s has karma of E',
            'mc2'          => '%s has karma of E',
            'mc²'          => '%s has karma of E',
            'i'            => '%s haz big karma',
            'karma' => 'The karma law says that all living creatures are responsible for their karma - their actions and the effects of their actions. You should watch yours.'
        );

        $this->karmaBlacklist = array(
            '*',
            'all',
            'everything'
        );

        $this->positiveAnswers = array(
            'No kidding, %owner% totally kicks %owned%\'s ass !',
            'True that.',
            'I concur.',
            'Yay, %owner% ftw !',
            '%owner% is made of WIN!',
            'Nothing can beat %owner%!',
        );

        $this->negativeAnswers = array(
            'No sir, not at all.',
            'You\'re wrong dude, %owner% wins.',
            'I\'d say %owner% is better than %owned%.',
            'You must be joking, %owner% ftw!',
            '%owned% is made of LOSE!',
            '%owned% = Epic Fail',
        );

        // Load or initialize the database
        $class = new ReflectionClass(get_class($this));
        $dir = dirname($class->getFileName() . '/' . $this->name);
        $this->db = new PDO('sqlite:' . $dir . 'karma.db');

        // Check to see if the table exists
        $table = $this->db->query('
            SELECT COUNT(*)
            FROM sqlite_master
            WHERE name = ' . $this->db->quote('karmas')
        )->fetchColumn();

        // Create database tables if necessary
        if (!$table) {
            $this->db->query('
                CREATE TABLE karmas ( word VARCHAR ( 255 ), karma MEDIUMINT );
                CREATE UNIQUE INDEX word ON karmas ( word );
                CREATE INDEX karmaIndex ON karmas ( karma );
                CREATE TABLE comments ( wordid INT , comment VARCHAR ( 255 ) );
                CREATE INDEX wordidIndex ON comments ( wordid );
                CREATE UNIQUE INDEX commentUnique ON comments ( comment );
            ');
        }

        $this->insertKarma = $this->db->prepare('
            INSERT INTO karmas (
                word,
                karma
            )
            VALUES (
                :word,
                :karma
            )
        ');

        $this->insertComment = $this->db->prepare('
            INSERT INTO comments (
                wordid,
                comment
            )
            VALUES (
                :wordid,
                :comment
            )
        ');

        $this->fetchKarma = $this->db->prepare('
            SELECT karma, ROWID id FROM karmas WHERE LOWER(word) = LOWER(:word) LIMIT 1
        ');

        $this->updateKarma = $this->db->prepare('
            UPDATE karmas SET karma = :karma WHERE LOWER(word) = LOWER(:word)
        ');
    }

    /**
     * Checks for dependencies.
     *
     * @return void
     */
    public static function onLoad()
    {
    	if (!extension_loaded('PDO') || !extension_loaded('pdo_sqlite')) {
            $this->fail('PDO and pdo_sqlite extensions must be installed');
    	}
    }

    /**
     * Handles requests for incrementation, decrementation, or lookup of karma
     * ratings sent via messages from users.
     *
     * @return void
     */
    public function onPrivmsg()
    {
        $source = $this->event->getSource();
        $message = $this->event->getArgument(1);
        $target = $this->event->getNick();

        // Command prefix check
        $prefix = preg_quote(trim($this->getConfig('command.prefix')));
        $bot = preg_quote($this->getConfig('connections.nick'));
        $exp = '(?:(?:' . $bot . '\s*[:,>]?\s+(?:' . $prefix . ')?)|(?:' . $prefix . '))';

        // Karma status request
        if (preg_match('#^' . $exp . 'karma\s+(.+)$#i', $message, $m)) {
            // Return user's value if "me" is requested
            if (strtolower($m[1]) === 'me') {
                $m[1] = $target;
            }
            // Clean the term
            $term = $this->doCleanWord($m[1]);

            // Check the blacklist
            if (is_array($this->karmaBlacklist) && in_array($term, $this->karmaBlacklist)) {
                $this->doNotice($target, $term . ' is blacklisted');
                return;
            }

            // Return fixed value if set
            if (isset($this->fixedKarma[$term])) {
                $this->doPrivmsg($source, $target . ': ' . sprintf($this->fixedKarma[$term], $m[1]) . '.');
                return;
            }

            // Return current karma or neutral if not set yet
            $this->fetchKarma->execute(array(':word'=>$term));
            $res = $this->fetchKarma->fetch(PDO::FETCH_ASSOC);

            // Sanity check if someone if someone prefixed their conversation with karma
            if (!$res && substr_count($term, ' ') > 1 && !(substr($m[1], 0, 1) === '(' && substr($m[1], -1) === ')')) {
                return;
            }

            // Clean the raw term if it was contained within brackets
            if (substr($m[1], 0, 1) === '(' && substr($m[1], -1) === ')') {
                $m[1] = substr($m[1], 1, -1);
            }

            if ($res && $res['karma'] != 0) {
                $this->doPrivmsg($source, $target . ': ' . $m[1] . ' has karma of ' . $res['karma'] . '.');
            } else {
                $this->doPrivmsg($source, $target . ': ' . $m[1] . ' has neutral karma.');
            }
        // Incrementation/decrementation request
        } elseif (preg_match('{^' . $exp . '?(?:(\+{2,2}|-{2,2})(\S+?|\(.+?\)+)|(\S+?|\(.+?\)+)(\+{2,2}|-{2,2}))(?:\s+(.*))?$}ix', $message, $m)) {
            if (!empty($m[4])) {
                $m[1] = $m[4]; // Increment/Decrement
                $m[2] = $m[3]; // Word
            }
            $m[3] = (isset($m[5]) ? $m[5] : null); // Comment
            unset($m[4], $m[5]);
            list(, $sign, $word, $comment) = array_pad($m, 4, null);

            // Clean the word
            $word = strtolower($this->doCleanWord($word));
            if (empty($word)) {
                return;
            }

            // Do nothing if the karma is fixed or blacklisted
            if (isset($this->fixedKarma[$word]) ||
                is_array($this->karmaBlacklist) && in_array($word, $this->karmaBlacklist)) {
                return;
            }

            // Force a decrementation if someone tries to update his own karma
            if ($word == strtolower($target) && $sign != '--' && !$this->fromAdmin(true)) {
                $this->doNotice($target, 'Bad ' . $target . '! You can not modify your own Karma. Shame on you!');
                $sign = '--';
            }

            // Antithrottling check
            $host = $this->event->getHost();
            $limit = $this->getConfig('karma.limit');
            // This is waiting on the Acl plugin from Elazar, being bypassed for now
            //if ($limit > 0 && !$this->fromAdmin()) {
            if ($limit > 0) {
                if (isset($this->log[$host][$word]) && $this->log[$host][$word] >= $limit) {
                    // Three strikes, you're out, so lets decrement their karma for spammage
                    if ($this->log[$host][$word] == ($limit+3)) {
                        $this->doNotice($target, 'Bad ' . $target . '! Didn\'t I tell you that you reached your limit already?');
                        $this->log[$host][$word] = $limit;
                        $word = $target;
                        $sign = '--';
                    // Toss a notice to the user if they reached their limit
                    } else {
                        $this->doNotice($target, 'You have currently reached your limit in modifying ' . $word . ' for this day, please wait a bit.');
                        $this->log[$host][$word]++;
                        return;
                    }
                } else {
                    if (isset($this->log[$host][$word])) {
                        $this->log[$host][$word]++;
                    } else {
                        $this->log[$host][$word] = 1;
                    }
                }
            }

            // Get the current value then update or create entry
            $this->fetchKarma->execute(array(':word'=>$word));
            $res = $this->fetchKarma->fetch(PDO::FETCH_ASSOC);
            if ($res) {
                $karma = ($res['karma'] + ($sign == '++' ? 1 : -1));
                $args = array(
                    ':word' => $word,
                    ':karma' => $karma
                );
                $this->updateKarma->execute($args);
            } else {
                $karma = ($sign == '++' ? '1' : '-1');
                $args = array(
                    ':word' => $word,
                    ':karma' => $karma
                );
                $this->insertKarma->execute($args);
                $this->fetchKarma->execute(array(':word'=>$word));
                $res = $this->fetchKarma->fetch(PDO::FETCH_ASSOC);
            }
            $id = $res['id'];
            // Add comment
            $comment = preg_replace('{(?:^//(.*)|^#(.*)|^/\*(.*?)\*/$)}', '$1$2$3', $comment);
            if (!empty($comment)) {
                $this->insertComment->execute(array(':wordid' => $id, ':comment' => $comment));
            }
            // Perform garbage collection on the antithrottling log if needed
            if (date('d') !== $this->lastGc) {
                $this->doGc();
            }
        // Assertion request
        } elseif (preg_match('#^' . $exp . '?([^><]+)(<|>)([^><]+)$#', $message, $m)) {
            // Trim words
            $word1 = strtolower($this->doCleanWord($m[1]));
            $word2 = strtolower($this->doCleanWord($m[3]));
            $operator = $m[2];

            // Do nothing if the karma is fixed
            if (isset($this->fixedKarma[$word1]) || isset($this->fixedKarma[$word2]) ||
                empty($word1) || empty($word2)) {
                return;
            }

            // Fetch first word
            if ($word1 === '*' || $word1 === 'all' || $word1 === 'everything') {
                $res = array('karma' => 0);
                $word1 = 'everything';
            } else {
                $this->fetchKarma->execute(array(':word'=>$word1));
                $res = $this->fetchKarma->fetch(PDO::FETCH_ASSOC);
            }
            // If it exists, fetch second word
            if ($res) {
                if ($word2 === '*' || $word2 === 'all' || $word2 === 'everything') {
                    $res2 = array('karma' => 0);
                    $word2 = 'everything';
                } else {
                    $this->fetchKarma->execute(array(':word'=>$word2));
                    $res2 = $this->fetchKarma->fetch(PDO::FETCH_ASSOC);
                }
                // If it exists, compare and return value
                if ($res2 && $res['karma'] != $res2['karma']) {
                    $assertion = ($operator === '<' && $res['karma'] < $res2['karma']) || ($operator === '>' && $res['karma'] > $res2['karma']);
                    // Switch arguments if they are in the wrong order
                    if ($operator === '<') {
                        $tmp = $word2;
                        $word2 = $word1;
                        $word1 = $tmp;
                    }
                    $this->doPrivmsg($source, $assertion ? $this->fetchPositiveAnswer($word1, $word2) : $this->fetchNegativeAnswer($word1, $word2));
                    // If someone asserts that something is greater or lesser than everything, we increment/decrement that something at the same time
                    if ($word2 === 'everything') {
                        $this->event = clone$this->event;
                        $this->event->setArguments(array($this->event->getArgument(0), '++'.$word1));
                        $this->onPrivmsg();
                    } elseif ($word1 === 'everything') {
                        $this->event = clone$this->event;
                        $this->event->setArguments(array($this->event->getArgument(0), '--'.$word2));
                        $this->onPrivmsg();
                    }
                }
            }
        }
    }

    protected function fetchPositiveAnswer($owner, $owned)
    {
        return str_replace(array('%owner%','%owned%'), array($owner, $owned), $this->positiveAnswers[array_rand($this->positiveAnswers,1)]);
    }

    protected function fetchNegativeAnswer($owned, $owner)
    {
        return str_replace(array('%owner%','%owned%'), array($owner, $owned), $this->negativeAnswers[array_rand($this->negativeAnswers,1)]);
    }

    protected function doCleanWord($word)
    {
        $word = trim($word);
        if (substr($word, 0, 1) === '(' && substr($word, -1) === ')') {
            $word = trim(substr($word, 1, -1));
        }
        $word = preg_replace('#\s+#', ' ', strtolower(trim($word)));
        return $word;
    }

    /**
     * Performs garbage collection on the antithrottling log.
     *
     * @return void
     */
    public function doGc()
    {
        unset($this->log);
        $this->log = array();
        $this->lastGc = date('d');
    }
}