FFS.php

Go to the documentation of this file.

<?php
interface FFS {
    public function __construct( FileBasedMessageGroup $group );

    public function setWritePath( $target );

    public function getWritePath();

    public function read( $code );

    public function readFromVariable( $data );

    public function write( MessageCollection $collection );

    public function writeIntoVariable( MessageCollection $collection );

    public function supportsFuzzy();

    public function getFileExtensions();
}

class SimpleFFS implements FFS {
    public function supportsFuzzy() {
        return 'no';
    }

    public function getFileExtensions() {
        return array();
    }

    protected $group;

    protected $writePath;

    protected $extra;

    const RECORD_SEPARATOR = "\0";
    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;
        }

        if ( !file_exists( $filename ) ) {
            return false;
        }

        return true;
    }

    public function read( $code ) {
        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." );
        }

        return $this->readFromVariable( $input );
    }

    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 = array();

        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()->mangle( $messages );

        return array(
            '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 );

        if ( file_exists( $targetFile ) ) {
            $this->tryReadSource( $targetFile, $collection );
        } else {
            $sourceFile = $this->group->getSourceFilePath( $collection->code );
            $this->tryReadSource( $sourceFile, $collection );
        }

        $output = $this->writeReal( $collection );
        if ( $output ) {
            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->group instanceof SingleFileBasedMessageGroup ) {
            return;
        }

        if ( get_class( $this->group->getFFS() ) !== get_class( $this ) ) {
            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;
    }

    protected function filterAuthors( array $authors, $code ) {
        global $wgTranslateAuthorBlacklist;
        $groupId = $this->group->getId();

        foreach ( $authors as $i => $v ) {
            $hash = "$groupId;$code;$v";

            $blacklisted = false;
            foreach ( $wgTranslateAuthorBlacklist as $rule ) {
                list( $type, $regex ) = $rule;

                if ( preg_match( $regex, $hash ) ) {
                    if ( $type === 'white' ) {
                        $blacklisted = false;
                        break;
                    } else {
                        $blacklisted = true;
                    }
                }
            }

            if ( $blacklisted ) {
                unset( $authors[$i] );
            }
        }

        return $authors;
    }

    public static function fixNewLines( $data ) {
        $data = str_replace( "\r\n", "\n", $data );
        $data = str_replace( "\r", "\n", $data );

        return $data;
    }
}