Converter.php

Go to the documentation of this file.

<?php
 
namespace MediaWiki\Message;
 
use InvalidArgumentException;
use Message;
use ReflectionClass;
use Wikimedia\Message\ListParam;
use Wikimedia\Message\MessageParam;
use Wikimedia\Message\MessageValue;
use Wikimedia\Message\ParamType;
use Wikimedia\Message\ScalarParam;
 
class Converter {
 
    private static $constants = null;
 
    private static function getTypes() {
        if ( self::$constants === null ) {
            $rc = new ReflectionClass( ParamType::class );
            self::$constants = array_values( $rc->getConstants() );
        }
 
        return self::$constants;
    }
 
    public function createMessage( $key ) {
        return new Message( $key );
    }
 
    public function convertMessage( Message $m ) {
        $mv = new MessageValue( $m->getKey() );
        foreach ( $m->getParams() as $param ) {
            $mv->params( $this->convertParam( $param ) );
        }
        return $mv;
    }
 
    private function convertParam( $param ) {
        if ( $param instanceof Message ) {
            return new ScalarParam( ParamType::TEXT, $this->convertMessage( $param ) );
        }
        if ( !is_array( $param ) ) {
            return new ScalarParam( ParamType::TEXT, $param );
        }
 
        if ( isset( $param['list'] ) && isset( $param['type'] ) ) {
            $convertedElements = [];
            foreach ( $param['list'] as $element ) {
                $convertedElements[] = $this->convertParam( $element );
            }
            return new ListParam( $param['type'], $convertedElements );
        }
 
        foreach ( self::getTypes() as $type ) {
            if ( $type !== ParamType::LIST && isset( $param[$type] ) ) {
                return new ScalarParam( $type, $param[$type] );
            }
        }
 
        throw new InvalidArgumentException( "Unrecognized Message param: " . json_encode( $param ) );
    }
 
    public function convertMessageValue( MessageValue $mv ) {
        $m = $this->createMessage( $mv->getKey() );
        foreach ( $mv->getParams() as $param ) {
            $m->params( $this->convertMessageParam( $param ) );
        }
        return $m;
    }
 
    private function convertMessageParam( MessageParam $param ) {
        if ( $param instanceof ListParam ) {
            $convertedElements = [];
            foreach ( $param->getValue() as $element ) {
                $convertedElements[] = $this->convertMessageParam( $element );
            }
            return Message::listParam( $convertedElements, $param->getListType() );
        }
        $value = $param->getValue();
        if ( $value instanceof MessageValue ) {
            $value = $this->convertMessageValue( $value );
        }
 
        if ( $param->getType() === ParamType::TEXT ) {
            return $value;
        }
        return [ $param->getType() => $value ];
    }
 
}