VersionChecker.php

Go to the documentation of this file.

<?php
 
use Composer\Semver\VersionParser;
use Composer\Semver\Constraint\Constraint;
 
class VersionChecker {
    private $coreVersion = false;
 
    private $loaded = [];
 
    private $versionParser;
 
    public function __construct( $coreVersion ) {
        $this->versionParser = new VersionParser();
        $this->setCoreVersion( $coreVersion );
    }
 
    public function setLoadedExtensionsAndSkins( array $credits ) {
        $this->loaded = $credits;
 
        return $this;
    }
 
    private function setCoreVersion( $coreVersion ) {
        try {
            $this->coreVersion = new Constraint(
                '==',
                $this->versionParser->normalize( $coreVersion )
            );
            $this->coreVersion->setPrettyString( $coreVersion );
        } catch ( UnexpectedValueException $e ) {
            // Non-parsable version, don't fatal.
        }
    }
 
    public function checkArray( array $extDependencies ) {
        $errors = [];
        foreach ( $extDependencies as $extension => $dependencies ) {
            foreach ( $dependencies as $dependencyType => $values ) {
                switch ( $dependencyType ) {
                    case ExtensionRegistry::MEDIAWIKI_CORE:
                        $mwError = $this->handleMediaWikiDependency( $values, $extension );
                        if ( $mwError !== false ) {
                            $errors[] = [
                                'msg' => $mwError,
                                'type' => 'incompatible-core',
                            ];
                        }
                        break;
                    case 'extensions':
                    case 'skins':
                        foreach ( $values as $dependency => $constraint ) {
                            $extError = $this->handleExtensionDependency(
                                $dependency, $constraint, $extension, $dependencyType
                            );
                            if ( $extError !== false ) {
                                $errors[] = $extError;
                            }
                        }
                        break;
                    default:
                        throw new UnexpectedValueException( 'Dependency type ' . $dependencyType .
                            ' unknown in ' . $extension );
                }
            }
        }
 
        return $errors;
    }
 
    private function handleMediaWikiDependency( $constraint, $checkedExt ) {
        if ( $this->coreVersion === false ) {
            // Couldn't parse the core version, so we can't check anything
            return false;
        }
 
        // if the installed and required version are compatible, return an empty array
        if ( $this->versionParser->parseConstraints( $constraint )
            ->matches( $this->coreVersion ) ) {
            return false;
        }
        // otherwise mark this as incompatible.
        return "{$checkedExt} is not compatible with the current "
            . "MediaWiki core (version {$this->coreVersion->getPrettyString()}), it requires: "
            . "$constraint.";
    }
 
    private function handleExtensionDependency( $dependencyName, $constraint, $checkedExt,
        $type
    ) {
        // Check if the dependency is even installed
        if ( !isset( $this->loaded[$dependencyName] ) ) {
            return [
                'msg' => "{$checkedExt} requires {$dependencyName} to be installed.",
                'type' => "missing-$type",
                'missing' => $dependencyName,
            ];
        }
        // Check if the dependency has specified a version
        if ( !isset( $this->loaded[$dependencyName]['version'] ) ) {
            // If we depend upon any version, and none is set, that's fine.
            if ( $constraint === '*' ) {
                wfDebug( "{$dependencyName} does not expose its version, but {$checkedExt}"
                    . " mentions it with constraint '*'. Assume it's ok so." );
                return false;
            } else {
                // Otherwise, mark it as incompatible.
                $msg = "{$dependencyName} does not expose its version, but {$checkedExt}"
                    . " requires: {$constraint}.";
                return [
                    'msg' => $msg,
                    'type' => "incompatible-$type",
                    'incompatible' => $checkedExt,
                ];
            }
        } else {
            // Try to get a constraint for the dependency version
            try {
                $installedVersion = new Constraint(
                    '==',
                    $this->versionParser->normalize( $this->loaded[$dependencyName]['version'] )
                );
            } catch ( UnexpectedValueException $e ) {
                // Non-parsable version, output an error message that the version
                // string is invalid
                return [
                    'msg' => "$dependencyName does not have a valid version string.",
                    'type' => 'invalid-version',
                ];
            }
            // Check if the constraint actually matches...
            if (
                !$this->versionParser->parseConstraints( $constraint )->matches( $installedVersion )
            ) {
                $msg = "{$checkedExt} is not compatible with the current "
                    . "installed version of {$dependencyName} "
                    . "({$this->loaded[$dependencyName]['version']}), "
                    . "it requires: " . $constraint . '.';
                return [
                    'msg' => $msg,
                    'type' => "incompatible-$type",
                    'incompatible' => $checkedExt,
                ];
            }
        }
 
        return false;
    }
}