MessageSourceChange.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Extension\Translate\MessageSync;
 
use InvalidArgumentException;
 
class MessageSourceChange {
    protected $changes = [];
    public const ADDITION = 'addition';
    public const CHANGE = 'change';
    public const DELETION = 'deletion';
    public const RENAME = 'rename';
    public const NONE = 'none';
 
    private const SIMILARITY_THRESHOLD = 0.9;
 
    protected $addFunctionMap;
    protected $removeFunctionMap;
 
    public function __construct( $changes = [] ) {
        $this->changes = $changes;
        $this->addFunctionMap = [
            self::ADDITION => [ $this, 'addAddition' ],
            self::DELETION => [ $this, 'addDeletion' ],
            self::CHANGE => [ $this, 'addChange' ]
        ];
 
        $this->removeFunctionMap = [
            self::ADDITION => [ $this, 'removeAdditions' ],
            self::DELETION => [ $this, 'removeDeletions' ],
            self::CHANGE => [ $this, 'removeChanges' ]
        ];
    }
 
    public function addChange( $language, $key, $content ) {
        $this->addModification( $language, self::CHANGE, $key, $content );
    }
 
    public function addAddition( $language, $key, $content ) {
        $this->addModification( $language, self::ADDITION, $key, $content );
    }
 
    public function addDeletion( $language, $key, $content ) {
        $this->addModification( $language, self::DELETION, $key, $content );
    }
 
    public function addRename( $language, $addedMessage, $deletedMessage, $similarity = 0 ) {
        $this->changes[$language][self::RENAME][$addedMessage['key']] = [
            'content' => $addedMessage['content'],
            'similarity' => $similarity,
            'matched_to' => $deletedMessage['key'],
            'previous_state' => self::ADDITION,
            'key' => $addedMessage['key']
        ];
 
        $this->changes[$language][self::RENAME][$deletedMessage['key']] = [
            'content' => $deletedMessage['content'],
            'similarity' => $similarity,
            'matched_to' => $addedMessage['key'],
            'previous_state' => self::DELETION,
            'key' => $deletedMessage['key']
        ];
    }
 
    public function setRenameState( $language, $msgKey, $state ) {
        $possibleStates = [ self::ADDITION, self::CHANGE, self::DELETION,
            self::NONE, self::RENAME ];
        if ( !in_array( $state, $possibleStates ) ) {
            throw new InvalidArgumentException(
                "Invalid state passed - '$state'. Possible states - "
                . implode( ', ', $possibleStates )
            );
        }
 
        $languageChanges = null;
        if ( isset( $this->changes[ $language ] ) ) {
            $languageChanges = &$this->changes[ $language ];
        }
        if ( $languageChanges !== null && isset( $languageChanges[ 'rename' ][ $msgKey ] ) ) {
            $languageChanges[ 'rename' ][ $msgKey ][ 'previous_state' ] = $state;
        }
    }
 
    protected function addModification( $language, $type, $key, $content ) {
        $this->changes[$language][$type][] = [
            'key' => $key,
            'content' => $content,
        ];
    }
 
    public function getChanges( $language ) {
        return $this->getModification( $language, self::CHANGE );
    }
 
    public function getDeletions( $language ) {
        return $this->getModification( $language, self::DELETION );
    }
 
    public function getAdditions( $language ) {
        return $this->getModification( $language, self::ADDITION );
    }
 
    public function findMessage( $language, $key, $possibleStates = [], &$modificationType = null ) {
        $allChanges = [];
        $allChanges[self::ADDITION] = $this->getAdditions( $language );
        $allChanges[self::DELETION] = $this->getDeletions( $language );
        $allChanges[self::CHANGE] = $this->getChanges( $language );
        $allChanges[self::RENAME] = $this->getRenames( $language );
 
        if ( $possibleStates === [] ) {
            $possibleStates = [ self::ADDITION, self::CHANGE, self::DELETION, self::RENAME ];
        }
 
        foreach ( $allChanges as $type => $modifications ) {
            if ( !in_array( $type, $possibleStates ) ) {
                continue;
            }
 
            if ( $type === self::RENAME ) {
                if ( isset( $modifications[$key] ) ) {
                    $modificationType = $type;
                    return $modifications[$key];
                }
                continue;
            }
 
            foreach ( $modifications as $modification ) {
                $currentKey = $modification['key'];
                if ( $currentKey === $key ) {
                    $modificationType = $type;
                    return $modification;
                }
            }
        }
 
        $modificationType = null;
        return null;
    }
 
    public function breakRename( $languageCode, $msgKey ) {
        $msg = $this->findMessage( $languageCode, $msgKey, [ self::RENAME ] );
        if ( $msg === null ) {
            return null;
        }
        $matchedMsg = $this->getMatchedMessage( $languageCode, $msg['key'] );
        if ( $matchedMsg === null ) {
            return null;
        }
 
        // Remove them from the renames array
        $this->removeRenames( $languageCode, [ $matchedMsg['key'], $msg['key'] ] );
 
        $matchedMsgState = $matchedMsg[ 'previous_state' ];
        $msgState = $msg[ 'previous_state' ];
 
        // Add them to the changes under the appropriate state
        if ( $matchedMsgState !== self::NONE ) {
            if ( $matchedMsgState === self::CHANGE ) {
                $matchedMsg['key'] = $msg['key'];
            }
            call_user_func(
                $this->addFunctionMap[ $matchedMsgState ],
                $languageCode,
                $matchedMsg['key'],
                $matchedMsg['content']
            );
        }
 
        if ( $msgState !== self::NONE ) {
            if ( $msgState === self::CHANGE ) {
                $msg['key'] = $matchedMsg['key'];
            }
            call_user_func(
                $this->addFunctionMap[ $msgState ],
                $languageCode,
                $msg['key'],
                $msg['content']
            );
        }
 
        return $msgState;
    }
 
    public function getRenames( $language ) {
        $renames = $this->getModification( $language, self::RENAME );
        foreach ( $renames as $key => &$rename ) {
            $rename['key'] = $key;
        }
 
        return $renames;
    }
 
    protected function getModification( $language, $type ) {
        return $this->changes[$language][$type] ?? [];
    }
 
    public function removeAdditions( $language, $keysToRemove ) {
        $this->removeModification( $language, self::ADDITION, $keysToRemove );
    }
 
    public function removeDeletions( $language, $keysToRemove ) {
        $this->removeModification( $language, self::DELETION, $keysToRemove );
    }
 
    public function removeChanges( $language, $keysToRemove ) {
        $this->removeModification( $language, self::CHANGE, $keysToRemove );
    }
 
    public function removeRenames( $language, $keysToRemove ) {
        $this->removeModification( $language, self::RENAME, $keysToRemove );
    }
 
    public function removeBasedOnType( $language, $keysToRemove, $type ) {
        $callable = $this->removeFunctionMap[ $type ] ?? null;
 
        if ( $callable === null ) {
            throw new InvalidArgumentException( 'Type should be one of ' .
                implode( ', ', [ self::ADDITION, self::CHANGE, self::DELETION ] ) .
                ". Invalid type $type passed."
            );
        }
 
        call_user_func( $callable, $language, $keysToRemove );
    }
 
    public function removeChangesForLanguage( $language ) {
        unset( $this->changes[ $language ] );
    }
 
    protected function removeModification( $language, $type, $keysToRemove = null ) {
        if ( !isset( $this->changes[$language][$type] ) ) {
            return;
        }
 
        if ( $keysToRemove === null ) {
            unset( $this->changes[$language][$type] );
        }
 
        if ( $keysToRemove === [] ) {
            return;
        }
 
        if ( $type === self::RENAME ) {
            $this->changes[$language][$type] =
                array_diff_key( $this->changes[$language][$type], array_flip( $keysToRemove ) );
        } else {
            $this->changes[$language][$type] = array_filter(
                $this->changes[$language][$type],
                static function ( $change ) use ( $keysToRemove ) {
                    return !in_array( $change['key'], $keysToRemove, true );
                }
            );
        }
    }
 
    public function getAllModifications() {
        return $this->changes;
    }
 
    public function getModificationsForLanguage( $language ) {
        return $this->changes[$language] ?? [];
    }
 
    public static function loadModifications( $changesData ) {
        return new self( $changesData );
    }
 
    public function getLanguages() {
        return array_keys( $this->changes );
    }
 
    public function hasOnly( $language, $type ) {
        $deletions = $this->getDeletions( $language );
        $additions = $this->getAdditions( $language );
        $renames = $this->getRenames( $language );
        $changes = $this->getChanges( $language );
        $hasOnlyAdditions = $hasOnlyRenames =
            $hasOnlyChanges = $hasOnlyDeletions = true;
 
        if ( $deletions ) {
            $hasOnlyAdditions = $hasOnlyRenames = $hasOnlyChanges = false;
        }
 
        if ( $renames ) {
            $hasOnlyDeletions = $hasOnlyAdditions = $hasOnlyChanges = false;
        }
 
        if ( $changes ) {
            $hasOnlyAdditions = $hasOnlyRenames = $hasOnlyDeletions = false;
        }
 
        if ( $additions ) {
            $hasOnlyDeletions = $hasOnlyRenames = $hasOnlyChanges = false;
        }
 
        if ( $type === self::DELETION ) {
            $response = $hasOnlyDeletions;
        } elseif ( $type === self::RENAME ) {
            $response = $hasOnlyRenames;
        } elseif ( $type === self::CHANGE ) {
            $response = $hasOnlyChanges;
        } elseif ( $type === self::ADDITION ) {
            $response = $hasOnlyAdditions;
        } else {
            throw new InvalidArgumentException( "Unknown $type passed." );
        }
 
        return $response;
    }
 
    public function isPreviousState( $languageCode, $key, array $types ) {
        $msg = $this->findMessage( $languageCode, $key, [ self::RENAME ] );
 
        return isset( $msg['previous_state'] ) && in_array( $msg['previous_state'], $types );
    }
 
    public function getMatchedMessage( $languageCode, $key ) {
        $matchedKey = $this->getMatchedKey( $languageCode, $key );
        if ( $matchedKey ) {
            return $this->changes[ $languageCode ][ self::RENAME ][ $matchedKey ] ?? null;
        }
 
        return null;
    }
 
    public function getMatchedKey( $languageCode, $key ) {
        return $this->changes[ $languageCode ][ self::RENAME ][ $key ][ 'matched_to' ] ?? null;
    }
 
    public function getSimilarity( $languageCode, $key ) {
        $msg = $this->findMessage( $languageCode, $key, [ self::RENAME ] );
 
        return $msg[ 'similarity' ] ?? null;
    }
 
    public function isEqual( $languageCode, $key ) {
        $msg = $this->findMessage( $languageCode, $key, [ self::RENAME ] );
        return $msg && $this->areStringsEqual( $msg[ 'similarity' ] );
    }
 
    public function isSimilar( $languageCode, $key ) {
        $msg = $this->findMessage( $languageCode, $key, [ self::RENAME ] );
        return $msg && $this->areStringsSimilar( $msg[ 'similarity' ] );
    }
 
    public function areStringsSimilar( $similarity ) {
        return $similarity >= self::SIMILARITY_THRESHOLD;
    }
 
    public function areStringsEqual( $similarity ) {
        return $similarity === 1;
    }
}