SimpleFormat.php

<?php
declare( strict_types = 1 );
 
namespace MediaWiki\Extension\Translate\FileFormatSupport;
 
use Exception;
use FileBasedMessageGroup;
use InvalidArgumentException;
use LogicException;
use MediaWiki\Extension\Translate\MessageLoading\Message;
use MediaWiki\Extension\Translate\MessageLoading\MessageCollection;
use MediaWiki\Extension\Translate\Services;
use RuntimeException;
use StringUtils;
use UtfNormal\Validator;
 
class SimpleFormat implements FileFormatSupport {
 
    public function supportsFuzzy(): string {
        return 'no';
    }
 
    public function getFileExtensions(): array {
        return [];
    }
 
    protected FileBasedMessageGroup $group;
    protected ?string $writePath = null;
    protected $extra;
 
    private const RECORD_SEPARATOR = "\0";
    private const PART_SEPARATOR = "\0\0\0\0";
 
    public function __construct( FileBasedMessageGroup $group ) {
        $this->setGroup( $group );
        $conf = $group->getConfiguration();
        $this->extra = $conf['FILES'];
    }
 
    public function setGroup( FileBasedMessageGroup $group ): void {
        $this->group = $group;
    }
 
    public function getGroup(): FileBasedMessageGroup {
        return $this->group;
    }
 
    public function setWritePath( string $target ): void {
        $this->writePath = $target;
    }
 
    public function getWritePath(): string {
        return $this->writePath;
    }
 
    public function exists( $code = false ): bool {
        if ( $code === false ) {
            $code = $this->group->getSourceLanguage();
        }
 
        $filename = $this->group->getSourceFilePath( $code );
        if ( $filename === null ) {
            return false;
        }
 
        return file_exists( $filename );
    }
 
    public function read( string $languageCode ) {
        if ( !$this->isGroupFfsReadable() ) {
            return [];
        }
 
        if ( !$this->exists( $languageCode ) ) {
            return false;
        }
 
        $filename = $this->group->getSourceFilePath( $languageCode );
        $input = file_get_contents( $filename );
        if ( $input === false ) {
            throw new RuntimeException( "Unable to read file $filename." );
        }
 
        if ( !StringUtils::isUtf8( $input ) ) {
            throw new RuntimeException( "Contents of $filename are not valid utf-8." );
        }
 
        $input = Validator::cleanUp( $input );
 
        // Strip BOM mark
        $input = ltrim( $input, "\u{FEFF}" );
 
        try {
            return $this->readFromVariable( $input );
        } catch ( Exception $e ) {
            throw new RuntimeException( "Parsing $filename failed: " . $e->getMessage() );
        }
    }
 
    public function readFromVariable( string $data ): array {
        $parts = explode( self::PART_SEPARATOR, $data );
 
        if ( count( $parts ) !== 2 ) {
            throw new InvalidArgumentException( 'Wrong number of parts.' );
        }
 
        [ $authorsPart, $messagesPart ] = $parts;
        $authors = explode( self::RECORD_SEPARATOR, $authorsPart );
        $messages = [];
 
        foreach ( explode( self::RECORD_SEPARATOR, $messagesPart ) as $line ) {
            if ( $line === '' ) {
                continue;
            }
 
            $lineParts = explode( '=', $line, 2 );
 
            if ( count( $lineParts ) !== 2 ) {
                throw new InvalidArgumentException( "Wrong number of parts in line $line." );
            }
 
            [ $key, $message ] = $lineParts;
            $key = trim( $key );
            $messages[$key] = $message;
        }
 
        $messages = $this->group->getMangler()->mangleArray( $messages );
 
        return [
            'AUTHORS' => $authors,
            'MESSAGES' => $messages,
        ];
    }
 
    public function write( MessageCollection $collection ): void {
        $writePath = $this->writePath;
 
        if ( $writePath === null ) {
            throw new LogicException( 'Write path is not set. Set write path before calling write()' );
        }
 
        if ( !file_exists( $writePath ) ) {
            throw new InvalidArgumentException( "Write path '$writePath' does not exist." );
        }
 
        if ( !is_writable( $writePath ) ) {
            throw new InvalidArgumentException( "Write path '$writePath' is not writable." );
        }
 
        $targetFile = $writePath . '/' . $this->group->getTargetFilename( $collection->code );
 
        $targetFileExists = file_exists( $targetFile );
 
        if ( $targetFileExists ) {
            $this->tryReadSource( $targetFile, $collection );
        } else {
            $sourceFile = $this->group->getSourceFilePath( $collection->code );
            $this->tryReadSource( $sourceFile, $collection );
        }
 
        $output = $this->writeReal( $collection );
        if ( !$output ) {
            return;
        }
 
        // Some file formats might have changing parts, such as timestamp.
        // This allows the file handler to skip updating files, where only
        // the timestamp would change.
        if ( $targetFileExists ) {
            $oldContent = $this->tryReadFile( $targetFile );
            if ( $oldContent === null || !$this->shouldOverwrite( $oldContent, $output ) ) {
                return;
            }
        }
 
        wfMkdirParents( dirname( $targetFile ), null, __METHOD__ );
        file_put_contents( $targetFile, $output );
    }
 
    public function writeIntoVariable( MessageCollection $collection ): string {
        $sourceFile = $this->group->getSourceFilePath( $collection->code );
        $this->tryReadSource( $sourceFile, $collection );
 
        return $this->writeReal( $collection );
    }
 
    protected function writeReal( MessageCollection $collection ): string {
        $output = '';
 
        $authors = $collection->getAuthors();
        $authors = $this->filterAuthors( $authors, $collection->code );
 
        $output .= implode( self::RECORD_SEPARATOR, $authors );
        $output .= self::PART_SEPARATOR;
 
        $mangler = $this->group->getMangler();
 
        foreach ( $collection as $key => $m ) {
            $key = $mangler->unmangle( $key );
            $trans = $m->translation();
            $output .= "$key=$trans" . self::RECORD_SEPARATOR;
        }
 
        return $output;
    }
 
    protected function tryReadSource( string $filename, MessageCollection $collection ): void {
        if ( !$this->isGroupFfsReadable() ) {
            return;
        }
 
        $sourceText = $this->tryReadFile( $filename );
 
        // No need to do anything in SimpleFormat if it's null,
        // it only reads author data from it.
        if ( $sourceText !== null ) {
            $sourceData = $this->readFromVariable( $sourceText );
 
            if ( isset( $sourceData['AUTHORS'] ) ) {
                $collection->addCollectionAuthors( $sourceData['AUTHORS'] );
            }
        }
    }
 
    protected function tryReadFile( string $filename ): ?string {
        if ( $filename === '' || !file_exists( $filename ) ) {
            return null;
        }
 
        if ( !is_readable( $filename ) ) {
            throw new InvalidArgumentException( "File $filename is not readable." );
        }
 
        $data = file_get_contents( $filename );
        if ( $data === false ) {
            throw new InvalidArgumentException( "Unable to read file $filename." );
        }
 
        return $data;
    }
 
    public function filterAuthors( array $authors, string $code ): array {
        $groupId = $this->group->getId();
        $configHelper = Services::getInstance()->getConfigHelper();
        foreach ( $authors as $i => $v ) {
            if ( $configHelper->isAuthorExcluded( $groupId, $code, (string)$v ) ) {
                unset( $authors[$i] );
            }
        }
 
        return array_values( $authors );
    }
 
    public function isContentEqual( ?string $a, ?string $b ): bool {
        return $a === $b;
    }
 
    public function shouldOverwrite( string $a, string $b ): bool {
        return true;
    }
 
    public function isGroupFfsReadable(): bool {
        try {
            $ffs = $this->group->getFFS();
        } catch ( RuntimeException $e ) {
            if ( $e->getCode() === FileBasedMessageGroup::NO_FILE_FORMAT ) {
                return false;
            }
 
            throw $e;
        }
 
        return get_class( $ffs ) === get_class( $this );
    }
}
 
class_alias( SimpleFormat::class, 'SimpleFFS' );