SimpleFFS.php

Go to the documentation of this file.

<?php
use MediaWiki\Extension\Translate\Services;
use UtfNormal\Validator;
 
class SimpleFFS implements FFS {
    public function supportsFuzzy() {
        return 'no';
    }
 
    public function getFileExtensions() {
        return [];
    }
 
    protected $group;
    protected $writePath;
    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 ) {
        $this->group = $group;
    }
 
    public function getGroup() {
        return $this->group;
    }
 
    public function setWritePath( $writePath ) {
        $this->writePath = $writePath;
    }
 
    public function getWritePath() {
        return $this->writePath;
    }
 
    public function exists( $code = false ) {
        if ( $code === false ) {
            $code = $this->group->getSourceLanguage();
        }
 
        $filename = $this->group->getSourceFilePath( $code );
        if ( $filename === null ) {
            return false;
        }
 
        return file_exists( $filename );
    }
 
    public function read( $code ) {
        if ( !$this->isGroupFfsReadable() ) {
            return [];
        }
 
        if ( !$this->exists( $code ) ) {
            return false;
        }
 
        $filename = $this->group->getSourceFilePath( $code );
        $input = file_get_contents( $filename );
        if ( $input === false ) {
            throw new MWException( "Unable to read file $filename." );
        }
 
        if ( !StringUtils::isUtf8( $input ) ) {
            throw new MWException( "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 MWException( "Parsing $filename failed: " . $e->getMessage() );
        }
    }
 
    public function readFromVariable( $data ) {
        $parts = explode( self::PART_SEPARATOR, $data );
 
        if ( count( $parts ) !== 2 ) {
            throw new MWException( 'Wrong number of parts.' );
        }
 
        list( $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 MWException( "Wrong number of parts in line $line." );
            }
 
            list( $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 ) {
        $writePath = $this->writePath;
 
        if ( $writePath === null ) {
            throw new MWException( 'Write path is not set.' );
        }
 
        if ( !file_exists( $writePath ) ) {
            throw new MWException( "Write path '$writePath' does not exist." );
        }
 
        if ( !is_writable( $writePath ) ) {
            throw new MWException( "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 ( !$this->shouldOverwrite( $oldContent, $output ) ) {
                return;
            }
        }
 
        wfMkdirParents( dirname( $targetFile ), null, __METHOD__ );
        file_put_contents( $targetFile, $output );
    }
 
    public function writeIntoVariable( MessageCollection $collection ) {
        $sourceFile = $this->group->getSourceFilePath( $collection->code );
        $this->tryReadSource( $sourceFile, $collection );
 
        return $this->writeReal( $collection );
    }
 
    protected function writeReal( MessageCollection $collection ) {
        $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( $filename, MessageCollection $collection ) {
        if ( !$this->isGroupFfsReadable() ) {
            return;
        }
 
        $sourceText = $this->tryReadFile( $filename );
 
        // No need to do anything in SimpleFFS if it's false,
        // it only reads author data from it.
        if ( $sourceText !== false ) {
            $sourceData = $this->readFromVariable( $sourceText );
 
            if ( isset( $sourceData['AUTHORS'] ) ) {
                $collection->addCollectionAuthors( $sourceData['AUTHORS'] );
            }
        }
    }
 
    protected function tryReadFile( $filename ) {
        if ( !$filename ) {
            return false;
        }
 
        if ( !file_exists( $filename ) ) {
            return false;
        }
 
        if ( !is_readable( $filename ) ) {
            throw new MWException( "File $filename is not readable." );
        }
 
        $data = file_get_contents( $filename );
        if ( $data === false ) {
            throw new MWException( "Unable to read file $filename." );
        }
 
        return $data;
    }
 
    public function filterAuthors( array $authors, $code ) {
        $groupId = $this->group->getId();
        $configHelper = Services::getInstance()->getConfigHelper();
 
        foreach ( $authors as $i => $v ) {
            if ( $configHelper->isAuthorExcluded( $groupId, $code, $v ) ) {
                unset( $authors[$i] );
            }
        }
 
        return array_values( $authors );
    }
 
    public static function fixNewLines( $data ) {
        $data = str_replace( "\r\n", "\n", $data );
        $data = str_replace( "\r", "\n", $data );
 
        return $data;
    }
 
    public function isContentEqual( $a, $b ) {
        return $a === $b;
    }
 
    public function shouldOverwrite( $a, $b ) {
        return true;
    }
 
    public function isGroupFfsReadable(): bool {
        try {
            $ffs = $this->group->getFFS();
        } catch ( RunTimeException $e ) {
            if ( $e->getCode() === FileBasedMessageGroup::NO_FFS_CLASS ) {
                return false;
            }
 
            throw $e;
        }
 
        return get_class( $ffs ) === get_class( $this );
    }
}