MessageCollection.php

Go to the documentation of this file.

<?php
class MessageCollection implements ArrayAccess, Iterator, Countable {
    public $code;

    protected $definitions = null;

    protected $infile = array();

    // Keys and messages.

    protected $keys = array();

    protected $messages = array();

    protected $reverseMap;

    // Database resources

    protected $dbInfo = null;

    protected $dbData = null;

    protected $dbReviewData = array();

    protected $tags = array();

    protected $properties = array();

    protected $authors = array();

    public function __construct( $code ) {
        $this->code = $code;
    }

    public static function newFromDefinitions( MessageDefinitions $definitions, $code ) {
        $collection = new self( $code );
        $collection->definitions = $definitions;
        $collection->resetForNewLanguage( $code );

        return $collection;
    }

    public static function newEmpty( $code ) {
    }

    public function getLanguage() {
        return $this->code;
    }

    // Data setters

    public function setInfile( array $messages ) {
        $this->infile = $messages;
    }

    public function setTags( $type, array $keys ) {
        $this->tags[$type] = $keys;
    }

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

    public function getTitles() {
        return array_values( $this->keys );
    }

    public function getMessageKeys() {
        return array_keys( $this->keys );
    }

    public function getTags( $type ) {
        return isset( $this->tags[$type] ) ? $this->tags[$type] : array();
    }

    public function getAuthors() {
        $this->loadTranslations();

        $authors = array_flip( $this->authors );

        foreach ( $this->messages as $m ) {
            // Check if there are authors
            $author = $m->getProperty( 'last-translator-text' );

            if ( $author === null ) {
                continue;
            }

            if ( !isset( $authors[$author] ) ) {
                $authors[$author] = 1;
            } else {
                $authors[$author]++;
            }
        }

        # arsort( $authors, SORT_NUMERIC );
        ksort( $authors );
        $fuzzyBot = FuzzyBot::getName();
        foreach ( $authors as $author => $edits ) {
            if ( $author !== $fuzzyBot ) {
                $filteredAuthors[] = $author;
            }
        }

        return isset( $filteredAuthors ) ? $filteredAuthors : array();
    }

    public function addCollectionAuthors( $authors, $mode = 'append' ) {
        switch ( $mode ) {
            case 'append':
                $authors = array_merge( $this->authors, $authors );
                break;
            case 'set':
                break;
            default:
                throw new MWException( "Invalid mode $mode" );
        }

        $this->authors = array_unique( $authors );
    }

    public function setReviewMode( $value = true ) {
    }

    // Data modifiers

    public function loadTranslations( $dbtype = DB_SLAVE ) {
        $this->loadData( $this->keys, $dbtype );
        $this->loadInfo( $this->keys, $dbtype );
        $this->loadReviewInfo( $this->keys, $dbtype );
        $this->initMessages();
    }

    public function resetForNewLanguage( $code ) {
        $this->code = $code;
        $this->keys = $this->fixKeys();
        $this->dbInfo = null;
        $this->dbData = null;
        $this->dbReviewData = array();
        $this->messages = null;
        $this->infile = array();
        $this->authors = array();

        unset( $this->tags['fuzzy'] );
        $this->reverseMap = null;
        $this->getReverseMap();
    }

    public function slice( $offset, $limit ) {
        $indexes = array_keys( $this->keys );

        if ( $offset === '' ) {
            $offset = 0;
        }

        // Handle string offsets
        if ( !ctype_digit( strval( $offset ) ) ) {
            $count = 0;
            foreach ( array_keys( $this->keys ) as $index ) {
                if ( $index === $offset ) {
                    break;
                }
                $count++;
            }
            // Now offset is always an integer, suitable for array_slice
            $offset = $count;
        }

        // False means that cannot go back or forward
        $backwardsOffset = $forwardsOffset = false;
        // Backwards paging uses numerical indexes, see below

        // Can only skip this if no offset has been provided or the
        // offset is zero. (offset - limit ) > 1 does not work, because
        // users can end in offest=2, limit=5 and can't see the first
        // two messages. That's also why it is capped into zero with
        // max(). And finally make the offsets to be strings even if
        // they are numbers in this case.
        if ( $offset > 0 ) {
            $backwardsOffset = strval( max( 0, $offset - $limit ) );
        }

        // Forwards paging uses keys. If user opens view Untranslated,
        // translates some messages and then clicks next, the first
        // message visible in the page is the first message not shown
        // in the previous page (unless someone else translated it at
        // the same time). If we used integer offsets, we would skip
        // same number of messages that were translated, because they
        // are no longer in the list. For backwards paging this is not
        // such a big issue, so it still uses integer offsets, because
        // we would need to also implement "direction" to have it work
        // correctly.
        if ( isset( $indexes[$offset + $limit] ) ) {
            $forwardsOffset = $indexes[$offset + $limit];
        }

        $this->keys = array_slice( $this->keys, $offset, $limit, true );

        return array( $backwardsOffset, $forwardsOffset, $offset );
    }

    public function filter( $type, $condition = true, $value = null ) {
        if ( !in_array( $type, self::getAvailableFilters(), true ) ) {
            throw new MWException( "Unknown filter $type" );
        }
        $this->applyFilter( $type, $condition, $value );
    }

    public static function getAvailableFilters() {
        return array(
            'fuzzy',
            'optional',
            'ignored',
            'hastranslation',
            'changed',
            'translated',
            'reviewer',
            'last-translator',
        );
    }

    protected function applyFilter( $filter, $condition, $value ) {
        $keys = $this->keys;
        if ( $filter === 'fuzzy' ) {
            $keys = $this->filterFuzzy( $keys, $condition );
        } elseif ( $filter === 'hastranslation' ) {
            $keys = $this->filterHastranslation( $keys, $condition );
        } elseif ( $filter === 'translated' ) {
            $fuzzy = $this->filterFuzzy( $keys, false );
            $hastranslation = $this->filterHastranslation( $keys, false );
            // Fuzzy messages are not counted as translated messages
            $translated = $this->filterOnCondition( $hastranslation, $fuzzy );
            $keys = $this->filterOnCondition( $keys, $translated, $condition );
        } elseif ( $filter === 'changed' ) {
            $keys = $this->filterChanged( $keys, $condition );
        } elseif ( $filter === 'reviewer' ) {
            $keys = $this->filterReviewer( $keys, $condition, $value );
        } elseif ( $filter === 'last-translator' ) {
            $keys = $this->filterLastTranslator( $keys, $condition, $value );
        } else {
            // Filter based on tags.
            if ( !isset( $this->tags[$filter] ) ) {
                if ( $filter !== 'optional' && $filter !== 'ignored' ) {
                    throw new MWException( "No tagged messages for custom filter $filter" );
                }
                $keys = $this->filterOnCondition( $keys, array(), $condition );
            } else {
                $taggedKeys = array_flip( $this->tags[$filter] );
                $keys = $this->filterOnCondition( $keys, $taggedKeys, $condition );
            }
        }

        $this->keys = $keys;
    }

    protected function filterOnCondition( array $keys, array $condKeys, $condition = true ) {
        if ( $condition === true ) {
            // Delete $condKeys from $keys
            foreach ( array_keys( $condKeys ) as $key ) {
                unset( $keys[$key] );
            }
        } else {
            // Keep the keys which are in $condKeys
            foreach ( array_keys( $keys ) as $key ) {
                if ( !isset( $condKeys[$key] ) ) {
                    unset( $keys[$key] );
                }
            }
        }

        return $keys;
    }

    protected function filterFuzzy( array $keys, $condition ) {
        $this->loadInfo( $keys );

        $origKeys = array();
        if ( $condition === false ) {
            $origKeys = $keys;
        }

        foreach ( $this->dbInfo as $row ) {
            if ( $row->rt_type !== null ) {
                unset( $keys[$this->rowToKey( $row )] );
            }
        }

        if ( $condition === false ) {
            $keys = array_diff( $origKeys, $keys );
        }

        return $keys;
    }

    protected function filterHastranslation( array $keys, $condition ) {
        $this->loadInfo( $keys );

        $origKeys = array();
        if ( $condition === false ) {
            $origKeys = $keys;
        }

        foreach ( $this->dbInfo as $row ) {
            unset( $keys[$this->rowToKey( $row )] );
        }

        // Check also if there is something in the file that is not yet in the database
        foreach ( array_keys( $this->infile ) as $inf ) {
            unset( $keys[$inf] );
        }

        // Remove the messages which do not have a translation from the list
        if ( $condition === false ) {
            $keys = array_diff( $origKeys, $keys );
        }

        return $keys;
    }

    protected function filterChanged( array $keys, $condition ) {
        $this->loadData( $keys );

        $origKeys = array();
        if ( $condition === false ) {
            $origKeys = $keys;
        }

        foreach ( $this->dbData as $row ) {
            $mkey = $this->rowToKey( $row );
            if ( !isset( $this->infile[$mkey] ) ) {
                continue;
            }

            $text = Revision::getRevisionText( $row );
            if ( $this->infile[$mkey] === $text ) {
                // Remove unchanged messages from the list
                unset( $keys[$mkey] );
            }
        }

        // Remove the messages which have not changed from the list
        if ( $condition === false ) {
            $keys = $this->filterOnCondition( $keys, $origKeys, false );
        }

        return $keys;
    }

    protected function filterReviewer( array $keys, $condition, $user ) {
        $this->loadReviewInfo( $keys );
        $origKeys = $keys;

        /* This removes messages from the list which have certain
         * reviewer (among others) */
        $userId = intval( $user );
        foreach ( $this->dbReviewData as $row ) {
            if ( $user === null || intval( $row->trr_user ) === $userId ) {
                unset( $keys[$this->rowToKey( $row )] );
            }
        }

        if ( $condition === false ) {
            $keys = array_diff( $origKeys, $keys );
        }

        return $keys;
    }

    protected function filterLastTranslator( array $keys, $condition, $user ) {
        $this->loadData( $keys );
        $origKeys = $keys;

        $user = intval( $user );
        foreach ( $this->dbData as $row ) {
            if ( intval( $row->rev_user ) === $user ) {
                unset( $keys[$this->rowToKey( $row )] );
            }
        }

        if ( $condition === false ) {
            $keys = array_diff( $origKeys, $keys );
        }

        return $keys;
    }

    protected function fixKeys() {
        $newkeys = array();
        // array( namespace, pagename )
        $pages = $this->definitions->getPages();
        $code = $this->code;

        foreach ( $pages as $key => $page ) {
            list ( $namespace, $pagename ) = $page;
            $title = Title::makeTitleSafe( $namespace, "$pagename/$code" );
            if ( !$title ) {
                wfWarn( "Invalid title $namespace:$pagename/$code" );
                continue;
            }
            $newkeys[$key] = $title;
        }

        return $newkeys;
    }

    protected function loadInfo( array $keys, $dbtype = DB_SLAVE ) {
        if ( $this->dbInfo !== null ) {
            return;
        }

        $this->dbInfo = array();

        if ( !count( $keys ) ) {
            return;
        }

        $dbr = wfGetDB( $dbtype );
        $tables = array( 'page', 'revtag' );
        $fields = array( 'page_namespace', 'page_title', 'rt_type' );
        $conds = $this->getTitleConds( $dbr );
        $joins = array( 'revtag' =>
        array(
            'LEFT JOIN',
            array( 'page_id=rt_page', 'page_latest=rt_revision', 'rt_type' => RevTag::getType( 'fuzzy' ) )
        )
        );

        $this->dbInfo = $dbr->select( $tables, $fields, $conds, __METHOD__, array(), $joins );
    }

    protected function loadReviewInfo( array $keys, $dbtype = DB_SLAVE ) {
        if ( $this->dbReviewData !== array() ) {
            return;
        }

        $this->dbReviewData = array();

        if ( !count( $keys ) ) {
            return;
        }

        $dbr = wfGetDB( $dbtype );
        $tables = array( 'page', 'translate_reviews' );
        $fields = array( 'page_namespace', 'page_title', 'trr_user' );
        $conds = $this->getTitleConds( $dbr );
        $joins = array( 'translate_reviews' =>
        array(
            'JOIN',
            array( 'page_id=trr_page', 'page_latest=trr_revision' )
        )
        );

        $this->dbReviewData = $dbr->select( $tables, $fields, $conds, __METHOD__, array(), $joins );
    }

    protected function loadData( array $keys, $dbtype = DB_SLAVE ) {
        if ( $this->dbData !== null ) {
            return;
        }

        $this->dbData = array();

        if ( !count( $keys ) ) {
            return;
        }

        $dbr = wfGetDB( $dbtype );

        $tables = array( 'page', 'revision', 'text' );
        $fields = array(
            'page_namespace',
            'page_title',
            'page_latest',
            'rev_user',
            'rev_user_text',
            'old_flags',
            'old_text'
        );
        $conds = array(
            'page_latest = rev_id',
            'old_id = rev_text_id',
        );
        $conds[] = $this->getTitleConds( $dbr );

        $res = $dbr->select( $tables, $fields, $conds, __METHOD__ );

        $this->dbData = $res;
    }

    protected function getTitleConds( $db ) {
        // Array of array( namespace, pagename )
        $byNamespace = array();
        foreach ( $this->getTitles() as $title ) {
            $namespace = $title->getNamespace();
            $pagename = $title->getDBKey();
            $byNamespace[$namespace][] = $pagename;
        }

        $conds = array();
        foreach ( $byNamespace as $namespaces => $pagenames ) {
            $cond = array(
                'page_namespace' => $namespaces,
                'page_title' => $pagenames,
            );

            $conds[] = $db->makeList( $cond, LIST_AND );
        }

        return $db->makeList( $conds, LIST_OR );
    }

    protected function rowToKey( $row ) {
        $map = $this->getReverseMap();
        if ( isset( $map[$row->page_namespace][$row->page_title] ) ) {
            return $map[$row->page_namespace][$row->page_title];
        } else {
            wfWarn( "Got unknown title from the database: {$row->page_namespace}:{$row->page_title}" );

            return null;
        }
    }

    public function getReverseMap() {
        if ( isset( $this->reverseMap ) ) {
            return $this->reverseMap;
        }

        $map = array();
        foreach ( $this->keys as $mkey => $title ) {
            $map[$title->getNamespace()][$title->getDBKey()] = $mkey;
        }

        return $this->reverseMap = $map;
    }

    public function initMessages() {
        if ( $this->messages !== null ) {
            return;
        }

        $messages = array();
        $definitions = $this->definitions->getDefinitions();
        foreach ( array_keys( $this->keys ) as $mkey ) {
            $messages[$mkey] = new ThinMessage( $mkey, $definitions[$mkey] );
        }

        // Copy rows if any.
        if ( $this->dbData !== null ) {
            foreach ( $this->dbData as $row ) {
                $mkey = $this->rowToKey( $row );
                if ( !isset( $messages[$mkey] ) ) {
                    continue;
                }
                $messages[$mkey]->setRow( $row );
                $messages[$mkey]->setProperty( 'revision', $row->page_latest );
            }
        }

        if ( $this->dbInfo !== null ) {
            $fuzzy = array();
            foreach ( $this->dbInfo as $row ) {
                if ( $row->rt_type !== null ) {
                    $fuzzy[] = $this->rowToKey( $row );
                }
            }

            $this->setTags( 'fuzzy', $fuzzy );
        }

        // Copy tags if any.
        foreach ( $this->tags as $type => $keys ) {
            foreach ( $keys as $mkey ) {
                if ( isset( $messages[$mkey] ) ) {
                    $messages[$mkey]->addTag( $type );
                }
            }
        }

        // Copy properties if any.
        foreach ( $this->properties as $type => $keys ) {
            foreach ( $keys as $mkey => $value ) {
                if ( isset( $messages[$mkey] ) ) {
                    $messages[$mkey]->setProperty( $type, $value );
                }
            }
        }

        // Copy infile if any.
        foreach ( $this->infile as $mkey => $value ) {
            if ( isset( $messages[$mkey] ) ) {
                $messages[$mkey]->setInfile( $value );
            }
        }

        foreach ( $this->dbReviewData as $row ) {
            $mkey = $this->rowToKey( $row );
            if ( !isset( $messages[$mkey] ) ) {
                continue;
            }
            $messages[$mkey]->appendProperty( 'reviewers', $row->trr_user );
        }

        // Set the status property
        foreach ( $messages as $obj ) {
            if ( $obj->hasTag( 'fuzzy' ) ) {
                $obj->setProperty( 'status', 'fuzzy' );
            } elseif ( is_array( $obj->getProperty( 'reviewers' ) ) ) {
                $obj->setProperty( 'status', 'proofread' );
            } elseif ( $obj->translation() !== null ) {
                $obj->setProperty( 'status', 'translated' );
            } else {
                $obj->setProperty( 'status', 'untranslated' );
            }
        }

        $this->messages = $messages;
    }

    public function offsetExists( $offset ) {
        return isset( $this->keys[$offset] );
    }

    public function offsetGet( $offset ) {
        return $this->messages[$offset];
    }

    public function offsetSet( $offset, $value ) {
        $this->messages[$offset] = $value;
    }

    public function offsetUnset( $offset ) {
        unset( $this->keys[$offset] );
    }

    public function __get( $name ) {
        throw new MWException( __METHOD__ . ": Trying to access unknown property $name" );
    }

    public function __set( $name, $value ) {
        throw new MWException( __METHOD__ . ": Trying to modify unknown property $name" );
    }

    public function rewind() {
        reset( $this->keys );
    }

    public function current() {
        if ( !count( $this->keys ) ) {
            return false;
        }

        return $this->messages[key( $this->keys )];
    }

    public function key() {
        return key( $this->keys );
    }

    public function next() {
        return next( $this->keys );
    }

    public function valid() {
        return isset( $this->messages[key( $this->keys )] );
    }

    public function count() {
        return count( $this->keys() );
    }
}

class MessageDefinitions {
    protected $namespace;
    protected $messages;

    public function __construct( array $messages, $namespace = false ) {
        $this->namespace = $namespace;
        $this->messages = $messages;
    }

    public function getDefinitions() {
        return $this->messages;
    }

    public function getPages() {
        $namespace = $this->namespace;
        $pages = array();
        foreach ( array_keys( $this->messages ) as $key ) {
            if ( $namespace === false ) {
                // pages are in format ex. "8:jan"
                $pages[$key] = explode( ':', $key, 2 );
            } else {
                $pages[$key] = array( $namespace, $key );
            }
        }

        return $pages;
    }
}