function ComposerInspector::validateExecutable

Validates that the Composer executable exists in a supported version.

Throws

\Exception Thrown if the Composer executable is not available or the detected version of Composer is not supported.

File

core/modules/package_manager/src/ComposerInspector.php, line 145

Class

ComposerInspector

Defines a class to get information from Composer.

Namespace

Code

private function validateExecutable() : void {
    $messages = [];
    // Ensure the Composer executable is available. For performance reasons,
    // statically cache the result, since it's unlikely to change during the
    // current request. If $unavailable_message is NULL, it means we haven't
    // done this check yet. If it's FALSE, it means we did the check and there
    // were no errors; and, if it's a string, it's the error message we received
    // the last time we did this check.
    static $unavailable_message;
    if ($unavailable_message === NULL) {
        try {
            // The "Composer is available" precondition requires active and stage
            // directories, but they don't actually matter to it, nor do path
            // exclusions, so dummies can be passed for simplicity.
            $active_dir = $this->pathFactory
                ->create(__DIR__);
            $stage_dir = $active_dir;
            $this->composerIsAvailable
                ->assertIsFulfilled($active_dir, $stage_dir);
            $unavailable_message = FALSE;
        } catch (PreconditionException $e) {
            $unavailable_message = $e->getMessage();
        }
    }
    if ($unavailable_message) {
        $messages[] = $unavailable_message;
    }
    // The detected version of Composer is unlikely to change during the
    // current request, so statically cache it. If $unsupported_message is NULL,
    // it means we haven't done this check yet. If it's FALSE, it means we did
    // the check and there were no errors; and, if it's a string, it's the error
    // message we received the last time we did this check.
    static $unsupported_message;
    if ($unsupported_message === NULL) {
        try {
            $detected_version = $this->getVersion();
            if (Semver::satisfies($detected_version, static::SUPPORTED_VERSION)) {
                // We did the version check, and it did not produce an error message.
                $unsupported_message = FALSE;
            }
            else {
                $unsupported_message = $this->t('The detected Composer version, @version, does not satisfy <code>@constraint</code>.', [
                    '@version' => $detected_version,
                    '@constraint' => static::SUPPORTED_VERSION,
                ]);
            }
        } catch (\UnexpectedValueException $e) {
            $unsupported_message = $e->getMessage();
        }
    }
    if ($unsupported_message) {
        $messages[] = $unsupported_message;
    }
    if ($messages) {
        throw new ComposerNotReadyException(NULL, $messages);
    }
}