Message.php

Go to the documentation of this file.

<?php
class Message implements MessageSpecifier, Serializable {

    protected $interface = true;

    protected $language = false;

    protected $key;

    protected $keysToTry;

    protected $parameters = [];

    protected $format = 'parse';

    protected $useDatabase = true;

    protected $title = null;

    protected $content = null;

    protected $message;

    public function __construct( $key, $params = [], Language $language = null ) {
        if ( $key instanceof MessageSpecifier ) {
            if ( $params ) {
                throw new InvalidArgumentException(
                    '$params must be empty if $key is a MessageSpecifier'
                );
            }
            $params = $key->getParams();
            $key = $key->getKey();
        }

        if ( !is_string( $key ) && !is_array( $key ) ) {
            throw new InvalidArgumentException( '$key must be a string or an array' );
        }

        $this->keysToTry = (array)$key;

        if ( empty( $this->keysToTry ) ) {
            throw new InvalidArgumentException( '$key must not be an empty list' );
        }

        $this->key = reset( $this->keysToTry );

        $this->parameters = array_values( $params );
        // User language is only resolved in getLanguage(). This helps preserve the
        // semantic intent of "user language" across serialize() and unserialize().
        $this->language = $language ?: false;
    }

    public function serialize() {
        return serialize( [
            'interface' => $this->interface,
            'language' => $this->language ? $this->language->getCode() : false,
            'key' => $this->key,
            'keysToTry' => $this->keysToTry,
            'parameters' => $this->parameters,
            'format' => $this->format,
            'useDatabase' => $this->useDatabase,
            'title' => $this->title,
        ] );
    }

    public function unserialize( $serialized ) {
        $data = unserialize( $serialized );
        $this->interface = $data['interface'];
        $this->key = $data['key'];
        $this->keysToTry = $data['keysToTry'];
        $this->parameters = $data['parameters'];
        $this->format = $data['format'];
        $this->useDatabase = $data['useDatabase'];
        $this->language = $data['language'] ? Language::factory( $data['language'] ) : false;
        $this->title = $data['title'];
    }

    public function isMultiKey() {
        return count( $this->keysToTry ) > 1;
    }

    public function getKeysToTry() {
        return $this->keysToTry;
    }

    public function getKey() {
        return $this->key;
    }

    public function getParams() {
        return $this->parameters;
    }

    public function getFormat() {
        return $this->format;
    }

    public function getLanguage() {
        // Defaults to false which means current user language
        return $this->language ?: RequestContext::getMain()->getLanguage();
    }

    public static function newFromKey( $key /*...*/ ) {
        $params = func_get_args();
        array_shift( $params );
        return new self( $key, $params );
    }

    public static function newFromSpecifier( $value ) {
        $params = [];
        if ( is_array( $value ) ) {
            $params = $value;
            $value = array_shift( $params );
        }

        if ( $value instanceof RawMessage ) {
            $message = new RawMessage( $value->getKey(), $value->getParams() );
        } elseif ( $value instanceof MessageSpecifier ) {
            $message = new Message( $value );
        } elseif ( is_string( $value ) ) {
            $message = new Message( $value, $params );
        } else {
            throw new InvalidArgumentException( __METHOD__ . ': invalid argument type '
                . gettype( $value ) );
        }

        return $message;
    }

    public static function newFallbackSequence( /*...*/ ) {
        $keys = func_get_args();
        if ( func_num_args() == 1 ) {
            if ( is_array( $keys[0] ) ) {
                // Allow an array to be passed as the first argument instead
                $keys = array_values( $keys[0] );
            } else {
                // Optimize a single string to not need special fallback handling
                $keys = $keys[0];
            }
        }
        return new self( $keys );
    }

    public function getTitle() {
        global $wgContLang, $wgForceUIMsgAsContentMsg;

        $code = $this->getLanguage()->getCode();
        $title = $this->key;
        if (
            $wgContLang->getCode() !== $code
            && in_array( $this->key, (array)$wgForceUIMsgAsContentMsg )
        ) {
            $title .= '/' . $code;
        }

        return Title::makeTitle( NS_MEDIAWIKI, $wgContLang->ucfirst( strtr( $title, ' ', '_' ) ) );
    }

    public function params( /*...*/ ) {
        $args = func_get_args();
        if ( isset( $args[0] ) && is_array( $args[0] ) ) {
            $args = $args[0];
        }
        $args_values = array_values( $args );
        $this->parameters = array_merge( $this->parameters, $args_values );
        return $this;
    }

    public function rawParams( /*...*/ ) {
        $params = func_get_args();
        if ( isset( $params[0] ) && is_array( $params[0] ) ) {
            $params = $params[0];
        }
        foreach ( $params as $param ) {
            $this->parameters[] = self::rawParam( $param );
        }
        return $this;
    }

    public function numParams( /*...*/ ) {
        $params = func_get_args();
        if ( isset( $params[0] ) && is_array( $params[0] ) ) {
            $params = $params[0];
        }
        foreach ( $params as $param ) {
            $this->parameters[] = self::numParam( $param );
        }
        return $this;
    }

    public function durationParams( /*...*/ ) {
        $params = func_get_args();
        if ( isset( $params[0] ) && is_array( $params[0] ) ) {
            $params = $params[0];
        }
        foreach ( $params as $param ) {
            $this->parameters[] = self::durationParam( $param );
        }
        return $this;
    }

    public function expiryParams( /*...*/ ) {
        $params = func_get_args();
        if ( isset( $params[0] ) && is_array( $params[0] ) ) {
            $params = $params[0];
        }
        foreach ( $params as $param ) {
            $this->parameters[] = self::expiryParam( $param );
        }
        return $this;
    }

    public function timeperiodParams( /*...*/ ) {
        $params = func_get_args();
        if ( isset( $params[0] ) && is_array( $params[0] ) ) {
            $params = $params[0];
        }
        foreach ( $params as $param ) {
            $this->parameters[] = self::timeperiodParam( $param );
        }
        return $this;
    }

    public function sizeParams( /*...*/ ) {
        $params = func_get_args();
        if ( isset( $params[0] ) && is_array( $params[0] ) ) {
            $params = $params[0];
        }
        foreach ( $params as $param ) {
            $this->parameters[] = self::sizeParam( $param );
        }
        return $this;
    }

    public function bitrateParams( /*...*/ ) {
        $params = func_get_args();
        if ( isset( $params[0] ) && is_array( $params[0] ) ) {
            $params = $params[0];
        }
        foreach ( $params as $param ) {
            $this->parameters[] = self::bitrateParam( $param );
        }
        return $this;
    }

    public function plaintextParams( /*...*/ ) {
        $params = func_get_args();
        if ( isset( $params[0] ) && is_array( $params[0] ) ) {
            $params = $params[0];
        }
        foreach ( $params as $param ) {
            $this->parameters[] = self::plaintextParam( $param );
        }
        return $this;
    }

    public function setContext( IContextSource $context ) {
        $this->inLanguage( $context->getLanguage() );
        $this->title( $context->getTitle() );
        $this->interface = true;

        return $this;
    }

    public function inLanguage( $lang ) {
        if ( $lang instanceof Language ) {
            $this->language = $lang;
        } elseif ( is_string( $lang ) ) {
            if ( !$this->language instanceof Language || $this->language->getCode() != $lang ) {
                $this->language = Language::factory( $lang );
            }
        } elseif ( $lang instanceof StubUserLang ) {
            $this->language = false;
        } else {
            $type = gettype( $lang );
            throw new MWException( __METHOD__ . " must be "
                . "passed a String or Language object; $type given"
            );
        }
        $this->message = null;
        $this->interface = false;
        return $this;
    }

    public function inContentLanguage() {
        global $wgForceUIMsgAsContentMsg;
        if ( in_array( $this->key, (array)$wgForceUIMsgAsContentMsg ) ) {
            return $this;
        }

        global $wgContLang;
        $this->inLanguage( $wgContLang );
        return $this;
    }

    public function setInterfaceMessageFlag( $interface ) {
        $this->interface = (bool)$interface;
        return $this;
    }

    public function useDatabase( $useDatabase ) {
        $this->useDatabase = (bool)$useDatabase;
        return $this;
    }

    public function title( $title ) {
        $this->title = $title;
        return $this;
    }

    public function content() {
        if ( !$this->content ) {
            $this->content = new MessageContent( $this );
        }

        return $this->content;
    }

    public function toString() {
        $string = $this->fetchMessage();

        if ( $string === false ) {
            if ( $this->format === 'plain' || $this->format === 'text' ) {
                return '<' . $this->key . '>';
            }
            return '&lt;' . htmlspecialchars( $this->key ) . '&gt;';
        }

        # Replace $* with a list of parameters for &uselang=qqx.
        if ( strpos( $string, '$*' ) !== false ) {
            $paramlist = '';
            if ( $this->parameters !== [] ) {
                $paramlist = ': $' . implode( ', $', range( 1, count( $this->parameters ) ) );
            }
            $string = str_replace( '$*', $paramlist, $string );
        }

        # Replace parameters before text parsing
        $string = $this->replaceParameters( $string, 'before' );

        # Maybe transform using the full parser
        if ( $this->format === 'parse' ) {
            $string = $this->parseText( $string );
            $string = Parser::stripOuterParagraph( $string );
        } elseif ( $this->format === 'block-parse' ) {
            $string = $this->parseText( $string );
        } elseif ( $this->format === 'text' ) {
            $string = $this->transformText( $string );
        } elseif ( $this->format === 'escaped' ) {
            $string = $this->transformText( $string );
            $string = htmlspecialchars( $string, ENT_QUOTES, 'UTF-8', false );
        }

        # Raw parameter replacement
        $string = $this->replaceParameters( $string, 'after' );

        return $string;
    }

    public function __toString() {
        // PHP doesn't allow __toString to throw exceptions and will
        // trigger a fatal error if it does. So, catch any exceptions.

        try {
            return $this->toString();
        } catch ( Exception $ex ) {
            try {
                trigger_error( "Exception caught in " . __METHOD__ . " (message " . $this->key . "): "
                    . $ex, E_USER_WARNING );
            } catch ( Exception $ex ) {
                // Doh! Cause a fatal error after all?
            }

            if ( $this->format === 'plain' || $this->format === 'text' ) {
                return '<' . $this->key . '>';
            }
            return '&lt;' . htmlspecialchars( $this->key ) . '&gt;';
        }
    }

    public function parse() {
        $this->format = 'parse';
        return $this->toString();
    }

    public function text() {
        $this->format = 'text';
        return $this->toString();
    }

    public function plain() {
        $this->format = 'plain';
        return $this->toString();
    }

    public function parseAsBlock() {
        $this->format = 'block-parse';
        return $this->toString();
    }

    public function escaped() {
        $this->format = 'escaped';
        return $this->toString();
    }

    public function exists() {
        return $this->fetchMessage() !== false;
    }

    public function isBlank() {
        $message = $this->fetchMessage();
        return $message === false || $message === '';
    }

    public function isDisabled() {
        $message = $this->fetchMessage();
        return $message === false || $message === '' || $message === '-';
    }

    public static function rawParam( $raw ) {
        return [ 'raw' => $raw ];
    }

    public static function numParam( $num ) {
        return [ 'num' => $num ];
    }

    public static function durationParam( $duration ) {
        return [ 'duration' => $duration ];
    }

    public static function expiryParam( $expiry ) {
        return [ 'expiry' => $expiry ];
    }

    public static function timeperiodParam( $period ) {
        return [ 'period' => $period ];
    }

    public static function sizeParam( $size ) {
        return [ 'size' => $size ];
    }

    public static function bitrateParam( $bitrate ) {
        return [ 'bitrate' => $bitrate ];
    }

    public static function plaintextParam( $plaintext ) {
        return [ 'plaintext' => $plaintext ];
    }

    protected function replaceParameters( $message, $type = 'before' ) {
        $replacementKeys = [];
        foreach ( $this->parameters as $n => $param ) {
            list( $paramType, $value ) = $this->extractParam( $param );
            if ( $type === $paramType ) {
                $replacementKeys['$' . ( $n + 1 )] = $value;
            }
        }
        $message = strtr( $message, $replacementKeys );
        return $message;
    }

    protected function extractParam( $param ) {
        if ( is_array( $param ) ) {
            if ( isset( $param['raw'] ) ) {
                return [ 'after', $param['raw'] ];
            } elseif ( isset( $param['num'] ) ) {
                // Replace number params always in before step for now.
                // No support for combined raw and num params
                return [ 'before', $this->getLanguage()->formatNum( $param['num'] ) ];
            } elseif ( isset( $param['duration'] ) ) {
                return [ 'before', $this->getLanguage()->formatDuration( $param['duration'] ) ];
            } elseif ( isset( $param['expiry'] ) ) {
                return [ 'before', $this->getLanguage()->formatExpiry( $param['expiry'] ) ];
            } elseif ( isset( $param['period'] ) ) {
                return [ 'before', $this->getLanguage()->formatTimePeriod( $param['period'] ) ];
            } elseif ( isset( $param['size'] ) ) {
                return [ 'before', $this->getLanguage()->formatSize( $param['size'] ) ];
            } elseif ( isset( $param['bitrate'] ) ) {
                return [ 'before', $this->getLanguage()->formatBitrate( $param['bitrate'] ) ];
            } elseif ( isset( $param['plaintext'] ) ) {
                return [ 'after', $this->formatPlaintext( $param['plaintext'] ) ];
            } else {
                $warning = 'Invalid parameter for message "' . $this->getKey() . '": ' .
                    htmlspecialchars( serialize( $param ) );
                trigger_error( $warning, E_USER_WARNING );
                $e = new Exception;
                wfDebugLog( 'Bug58676', $warning . "\n" . $e->getTraceAsString() );

                return [ 'before', '[INVALID]' ];
            }
        } elseif ( $param instanceof Message ) {
            // Message objects should not be before parameters because
            // then they'll get double escaped. If the message needs to be
            // escaped, it'll happen right here when we call toString().
            return [ 'after', $param->toString() ];
        } else {
            return [ 'before', $param ];
        }
    }

    protected function parseText( $string ) {
        $out = MessageCache::singleton()->parse(
            $string,
            $this->title,
            /*linestart*/true,
            $this->interface,
            $this->getLanguage()
        );

        return $out instanceof ParserOutput ? $out->getText() : $out;
    }

    protected function transformText( $string ) {
        return MessageCache::singleton()->transform(
            $string,
            $this->interface,
            $this->getLanguage(),
            $this->title
        );
    }

    protected function fetchMessage() {
        if ( $this->message === null ) {
            $cache = MessageCache::singleton();

            foreach ( $this->keysToTry as $key ) {
                $message = $cache->get( $key, $this->useDatabase, $this->getLanguage() );
                if ( $message !== false && $message !== '' ) {
                    break;
                }
            }

            // NOTE: The constructor makes sure keysToTry isn't empty,
            //       so we know that $key and $message are initialized.
            $this->key = $key;
            $this->message = $message;
        }
        return $this->message;
    }

    protected function formatPlaintext( $plaintext ) {
        switch ( $this->format ) {
        case 'text':
        case 'plain':
            return $plaintext;

        case 'parse':
        case 'block-parse':
        case 'escaped':
        default:
            return htmlspecialchars( $plaintext, ENT_QUOTES );

        }
    }
}

class RawMessage extends Message {

    public function __construct( $text, $params = [] ) {
        if ( !is_string( $text ) ) {
            throw new InvalidArgumentException( '$text must be a string' );
        }

        parent::__construct( $text, $params );

        // The key is the message.
        $this->message = $text;
    }

    public function fetchMessage() {
        // Just in case the message is unset somewhere.
        if ( $this->message === null ) {
            $this->message = $this->key;
        }

        return $this->message;
    }

}