Message.php

Go to the documentation of this file.

<?php
class Message {
        protected $interface = true;

        protected $language = null;

        protected $key;

        protected $parameters = array();

        protected $format = 'parse';

        protected $useDatabase = true;

        protected $title = null;

        protected $message;

        public function __construct( $key, $params = array() ) {
                global $wgLang;
                $this->key = $key;
                $this->parameters = array_values( $params );
                $this->language = $wgLang;
        }

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

        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 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 setContext( IContextSource $context ) {
                $this->inLanguage( $context->getLanguage() );
                $this->title( $context->getTitle() );

                return $this;
        }

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

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

                global $wgContLang;
                $this->interface = false;
                $this->language = $wgContLang;
                return $this;
        }

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

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

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

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

                # Maybe transform using the full parser
                if( $this->format === 'parse' ) {
                        $string = $this->parseText( $string );
                        $m = array();
                        if( preg_match( '/^<p>(.*)\n?<\/p>\n?$/sU', $string, $m ) ) {
                                $string = $m[1];
                        }
                } 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() {
                return $this->toString();
        }

        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( $value ) {
                return array( 'raw' => $value );
        }

        public static function numParam( $value ) {
                return array( 'num' => $value );
        }

        protected function replaceParameters( $message, $type = 'before' ) {
                $replacementKeys = array();
                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 ) && isset( $param['raw'] ) ) {
                        return array( 'after', $param['raw'] );
                } elseif ( is_array( $param ) && isset( $param['num'] ) ) {
                        // Replace number params always in before step for now.
                        // No support for combined raw and num params
                        return array( 'before', $this->language->formatNum( $param['num'] ) );
                } elseif ( !is_array( $param ) ) {
                        return array( 'before', $param );
                } else {
                        trigger_error(
                                "Invalid message parameter: " . htmlspecialchars( serialize( $param ) ),
                                E_USER_WARNING
                        );
                        return array( 'before', '[INVALID]' );
                }
        }

        protected function parseText( $string ) {
                return MessageCache::singleton()->parse( $string, $this->title, /*linestart*/true, $this->interface, $this->language )->getText();
        }

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

        protected function getMessageText() {
                $message = $this->fetchMessage();
                if ( $message === false ) {
                        return '&lt;' . htmlspecialchars( is_array($this->key) ? $this->key[0] : $this->key ) . '&gt;';
                } else {
                        return $message;
                }
        }

        protected function fetchMessage() {
                if ( !isset( $this->message ) ) {
                        $cache = MessageCache::singleton();
                        if ( is_array( $this->key ) ) {
                                if ( !count( $this->key ) ) {
                                        throw new MWException( "Given empty message key array." );
                                }
                                foreach ( $this->key as $key ) {
                                        $message = $cache->get( $key, $this->useDatabase, $this->language );
                                        if ( $message !== false && $message !== '' ) {
                                                break;
                                        }
                                }
                                $this->message = $message;
                        } else {
                                $this->message = $cache->get( $this->key, $this->useDatabase, $this->language );
                        }
                }
                return $this->message;
        }

}