Styling.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 Styling implements \Erebot\StylingInterface
{
    protected $translator;

    protected $cls;

    public function __construct(\Erebot\IntlInterface $translator)
    {
        $this->translator  = $translator;
        $this->cls = array(
            'int'       => '\\Erebot\\Styling\\Variables\\IntegerVariable',
            'float'     => '\\Erebot\\Styling\\Variables\\FloatVariable',
            'string'    => '\\Erebot\\Styling\\Variables\\StringVariable',
        );
    }

    public function getClass($type)
    {
        if (!isset($this->cls[$type])) {
            throw new \InvalidArgumentException('Invalid type');
        }
        return $this->cls[$type];
    }

    public function setClass($type, $cls)
    {
        if (!isset($this->cls[$type])) {
            throw new \InvalidArgumentException('Invalid type');
        }
        if (!is_string($cls)) {
            throw new \InvalidArgumentException(
                'Expected a string for the class'
            );
        }
        if (!class_exists($cls)) {
            throw new \InvalidArgumentException('Class not found');
        }
        if (!($cls instanceof \Erebot\Styling\VariableInterface)) {
            throw new \InvalidArgumentException(
                'Must be a subclass of \\Erebot\\Styling\\VariableInterface'
            );
        }
        $this->cls[$type] = $cls;
    }

    protected static function checkVariableName($var)
    {
        if (!preg_match('/^[a-zA-Z0-9_\.]+$/D', $var)) {
            throw new \InvalidArgumentException(
                'Invalid variable name "'.$var.'". '.
                'Variable names may only contain alphanumeric '.
                'characters, underscores ("_") and dots (".").'
            );
        }
    }

    // @codingStandardsIgnoreStart
    public function _($template, array $vars = array())
    {
        $source = $this->translator->_($template);
        return $this->render($source, $vars);
        // @codingStandardsIgnoreEnd
    }

    public function render($template, array $vars = array())
    {
        // For basic strings that don't contain any markup,
        // we try to be as efficient as possible.
        if (strpos($template, '<') === false &&
            strpos($template, '&') === false) {
            return $template;
        }

        $attributes = array(
            'underline' => 0,
            'bold'      => 0,
            'bg'        => null,
            'fg'        => null,
        );

        $variables = array();
        foreach ($vars as $name => $var) {
            $variables[$name] = $this->wrapScalar($var, $name);
        }

        $dom = self::parseTemplate($template);
        $result = $this->parseNode(
            $dom->documentElement,
            $attributes,
            $variables
        );

        $pattern =  '@'.
                    '\\003,(?![01])'.
                    '|'.
                    '\\003(?:[0-9]{2})?,(?:[0-9]{2})?(?:\\002\\002)?(?=\\003)'.
                    '|'.
                    '(\\003(?:[0-9]{2})?,)\\002\\002(?![0-9])'.
                    '|'.
                    '(\\003[0-9]{2})\\002\\002(?!,)'.
                    '@';
        $replace    = '\\1\\2';
        $result     = preg_replace($pattern, $replace, $result);
        return $result;
    }

    public function getTranslator()
    {
        return $this->translator;
    }

    protected function wrapScalar($var, $name)
    {
        self::checkVariableName($name);

        if (is_object($var)) {
            if ($var instanceof \Erebot\Styling\VariableInterface) {
                return $var;
            }

            if (!is_callable(array($var, '__toString'), false)) {
                throw new \InvalidArgumentException(
                    $name.' must be a scalar or an instance of '.
                    '\\Erebot\\Styling\\VariableInterface'
                );
            }
        }

        if (is_array($var)) {
            return $var;
        }

        if (is_string($var) || is_callable(array($var, '__toString'), false)) {
            $cls = $this->cls['string'];
        } elseif (is_int($var)) {
            $cls = $this->cls['int'];
        } elseif (is_float($var)) {
            $cls = $this->cls['float'];
        } else {
            throw new \InvalidArgumentException(
                'Unsupported scalar type ('.gettype($var).') for "'.$name.'"'
            );
        }
        return new $cls($var);
    }

    protected static function parseTemplate($source)
    {
        $source =
            '<msg xmlns="http://www.erebot.net/xmlns/erebot/styling">'.
            $source.
            '</msg>';
        $schema = dirname(__DIR__) .
                    DIRECTORY_SEPARATOR . 'data' .
                    DIRECTORY_SEPARATOR . 'styling.rng';
        $dom    =   new \Erebot\DOM();
        $dom->substituteEntities    = true;
        $dom->resolveExternals      = false;
        $dom->recover               = true;
        $ue     = libxml_use_internal_errors(true);
        $dom->loadXML($source);
        $valid  = $dom->relaxNGValidate($schema);
        $errors = $dom->getErrors();
        libxml_use_internal_errors($ue);

        if (!$valid || count($errors)) {
            // Some unpredicted error occurred,
            // show some (hopefully) useful information.
            if (class_exists('\\Plop')) {
                $logger = \Plop::getInstance();
                $logger->error(print_r($errors, true));
            }
            throw new \InvalidArgumentException(
                'Error while validating the message'
            );
        }
        return $dom;
    }

    protected function parseNode($node, &$attributes, $vars)
    {
        $result     = '';
        $saved      = $attributes;

        if ($node->nodeType == XML_TEXT_NODE) {
            return $node->nodeValue;
        }

        if ($node->nodeType != XML_ELEMENT_NODE) {
            return '';
        }

        // Pre-handling.
        switch ($node->tagName) {
            case 'var':
                $lexer = new \Erebot\Styling\Lexer(
                    $node->getAttribute('name'),
                    $vars
                );
                $var = $lexer->getResult();
                if (!($var instanceof \Erebot\Styling\VariableInterface)) {
                    return (string) $var;
                }
                return $var->render($this->translator);

            case 'u':
                if (!$attributes['underline']) {
                    $result .= self::CODE_UNDERLINE;
                }
                $attributes['underline'] = 1;
                break;

            case 'b':
                if (!$attributes['bold']) {
                    $result .= self::CODE_BOLD;
                }
                $attributes['bold'] = 1;
                break;

            case 'color':
                $colors     = array('', '');
                $mapping    = array('fg', 'bg');

                foreach ($mapping as $pos => $color) {
                    $value = $node->getAttribute($color);
                    if ($value != '') {
                        $value = str_replace(array(' ', '-'), '_', $value);
                        if (strspn($value, '1234567890') !== strlen($value)) {
                            $reflector = new \ReflectionClass('\\Erebot\\StylingInterface');
                            if (!$reflector->hasConstant('COLOR_'.strtoupper($value))) {
                                throw new \InvalidArgumentException(
                                    'Invalid color "'.$value.'"'
                                );
                            }
                            $value = $reflector->getConstant('COLOR_'.strtoupper($value));
                        }
                        $attributes[$color] = sprintf('%02d', $value);
                        if ($attributes[$color] != $saved[$color]) {
                            $colors[$pos] = $attributes[$color];
                        }
                    }
                }

                $code = implode(',', $colors);
                if ($colors[0] != '' && $colors[1] != '') {
                    $result .= self::CODE_COLOR.$code;
                } elseif ($code != ',') {
                    $result .= self::CODE_COLOR.rtrim($code, ',').
                               self::CODE_BOLD.self::CODE_BOLD;
                }
                break;
        }

        if ($node->tagName == 'for') {
            // Handle loops.
            $savedVariables = $vars;
            $separator      = array(', ', ' & ');

            foreach (array('separator', 'sep') as $attr) {
                $attrNode       = $node->getAttributeNode($attr);
                if ($attrNode !== false) {
                    $separator[0] = $separator[1] = $attrNode->nodeValue;
                    break;
                }
            }

            foreach (array('last_separator', 'last') as $attr) {
                $attrNode       = $node->getAttributeNode($attr);
                if ($attrNode !== false) {
                    $separator[1] = $attrNode->nodeValue;
                    break;
                }
            }

            $loopKey    = $node->getAttribute('key');
            $loopItem   = $node->getAttribute('item');
            $loopFrom   = $node->getAttribute('from');
            $count      = count($vars[$loopFrom]);
            reset($vars[$loopFrom]);

            for ($i = 1; $i < $count; $i++) {
                if ($i > 1) {
                    $result .= $separator[0];
                }

                $key = key($vars[$loopFrom]);
                next($vars[$loopFrom]);
                if ($loopKey !== null) {
                    $cls = $this->cls['string'];
                    $vars[$loopKey] = new $cls($key);
                }
                $vars[$loopItem] = $this->wrapScalar(
                    $vars[$loopFrom][$key],
                    $loopItem
                );

                $result .= $this->parseChildren(
                    $node,
                    $attributes,
                    $vars
                );
            }

            $key = key($vars[$loopFrom]);
            if ($key === null) {
                $item = array('key' => '', 'value' => '');
            } else {
                $item = array('key' => $key, 'value' => $vars[$loopFrom][$key]);
            }

            if ($loopKey !== null) {
                $cls = $this->cls['string'];
                $vars[$loopKey] = new $cls($item['key']);
            }

            $vars[$loopItem] = $this->wrapScalar($item['value'], $loopItem);
            if ($count > 1) {
                $result .= $separator[1];
            }

            $result .= $this->parseChildren($node, $attributes, $vars);
            $vars = $savedVariables;
        } elseif ($node->tagName == 'plural') {
            // Handle plurals.
            /* We don't need the full set of features/complexity/bugs
             * ICU contains. Here, we use a simple "plural" formatter
             * to detect the right plural form to use. The formatting
             * steps are done without relying on ICU. */
            $attrNode = $node->getAttributeNode('var');
            if ($attrNode === false) {
                throw new \InvalidArgumentException(
                    'No variable name given'
                );
            }

            $lexer = new \Erebot\Styling\Lexer($attrNode->nodeValue, $vars);
            $value = $lexer->getResult();
            if ($value instanceof \Erebot\Styling\VariableInterface) {
                $value = $value->getValue();
            }
            $value          = (int) $value;

            $subcontents    = array();
            $pattern        = '{0,plural,';
            for ($child = $node->firstChild; $child != null; $child = $child->nextSibling) {
                if ($child->nodeType != XML_ELEMENT_NODE ||
                    $child->tagName != 'case') {
                    continue;
                }

                // See this class documentation for a link
                // which lists available forms for each language.
                $form = $child->getAttribute('form');
                $subcontents[$form] = $this->parseNode($child, $attributes, $vars);
                $pattern .= $form.'{'.$form.'} ';
            }
            $pattern .= '}';
            $locale = $this->translator->getLocale(
                \Erebot\IntlInterface::LC_MESSAGES
            );
            $formatter = new \MessageFormatter($locale, $pattern);
            // HACK: PHP <= 5.3.3 returns null when the pattern in invalid
            // instead of throwing an exception.
            // See http://bugs.php.net/bug.php?id=52776
            if ($formatter === null) {
                throw new \InvalidArgumentException('Invalid plural forms');
            }
            $correctForm = $formatter->format(array($value));
            $result .= $subcontents[$correctForm];
        } else {
            // Handle children.
            $result .= $this->parseChildren($node, $attributes, $vars);
        }

        // Post-handling : restore old state.
        switch ($node->tagName) {
            case 'u':
                if (!$saved['underline']) {
                    $result .= self::CODE_UNDERLINE;
                }
                $attributes['underline'] = 0;
                break;

            case 'b':
                if (!$saved['bold']) {
                    $result .= self::CODE_BOLD;
                }
                $attributes['bold'] = 0;
                break;

            case 'color':
                $colors     = array('', '');
                $mapping    = array('fg', 'bg');

                foreach ($mapping as $pos => $color) {
                    if ($attributes[$color] != $saved[$color]) {
                        $colors[$pos] = $saved[$color];
                    }
                    $attributes[$color] = $saved[$color];
                }

                $code = implode(',', $colors);
                if ($colors[0] != '' && $colors[1] != '') {
                    $result .= self::CODE_COLOR.$code;
                } elseif ($code != ',') {
                    $result .= self::CODE_COLOR.rtrim($code, ',').
                               self::CODE_BOLD.self::CODE_BOLD;
                }
                break;
        }

        return $result;
    }

    private function parseChildren($node, &$attributes, $vars)
    {
        $result = '';
        for ($child = $node->firstChild; $child != null; $child = $child->nextSibling) {
            $result .=  $this->parseNode($child, $attributes, $vars);
        }
        return $result;
    }
}