Final Class Yiisoft\YiiDevTool\App\Command\Release\MakeCommand

                protected function afterProcessingPackages(InputInterface $input): void
{
}

            

                protected function areTargetPackagesSpecifiedExplicitly(): bool
{
    if ($this->targetPackagesSpecifiedExplicitly === null) {
        throw new RuntimeException('Target packages are not initialized.');
    }
    return $this->targetPackagesSpecifiedExplicitly;
}

            

                protected function checkSSHConnection(): bool
{
    $process = new Process(['ssh', '-T', 'git@github.com']);
    $process
        ->setTimeout(null)
        ->run();
    if ($process->getExitCode() !== 1) {
        $this
            ->getIO()
            ->error([
                'Checking access to github.com ... DENIED',
                'Error: ' . $process->getErrorOutput(),
                'Seems like you have not installed SSH key to you Github account.',
                'Key is required to work with repository via SSH.',
                'See here for instructions: https://docs.github.com/en/github/authenticating-to-github/adding-a-new-ssh-key-to-your-github-account',
            ]);
        return false;
    }
    return true;
}

            

                protected function doesPackageContainErrors(Package $package): bool
{
    return $this->errorList->has($package);
}

            

                protected function execute(InputInterface $input, OutputInterface $output): int
{
    $this->initPackageList();
    $this->initTargetPackages($input);
    $io = $this->getIO();
    $this->beforeProcessingPackages($input);
    $packages = $this->getTargetPackages();
    sort($packages);
    foreach ($packages as $package) {
        if ($this->isCurrentInstallationValid($package)) {
            $this->processPackage($package);
        }
    }
    $io->clearPreparedPackageHeader();
    $this->afterProcessingPackages($input);
    $this->showPackageErrors();
    if ($io->nothingHasBeenOutput()) {
        $message = $this->getMessageWhenNothingHasBeenOutput();
        if ($message !== null) {
            $io
                ->important()
                ->info($message);
        }
    }
    return Command::SUCCESS;
}

            

                protected function getAppRootDir(): string
{
    return rtrim($this
            ->getApplication()
            ->getRootDir(), DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR;
}

            

                protected function getErrorsList(): PackageErrorList
{
    return $this->errorList;
}

            

                protected function getExampleCommandPrefix(): string
{
    $shell = getenv('SHELL');
    $isBash = ($shell && stripos($shell, 'bash')) !== false;
    return $isBash ? './' : '';
}

            

                public function getGitHubToken(): string
{
    if ($this->gitHubToken !== null) {
        return $this->gitHubToken;
    }
    $io = $this->getIO();
    $tokenFile = $this->getAppRootDir() . 'config/github.token';
    if (!file_exists($tokenFile)) {
        $io->error([
            "There's no $tokenFile.",
            '<href=https://github.com/settings/tokens>Please create a GitHub token</> and put it there.',
        ]);
        exit(Command::FAILURE);
    }
    $token = trim(file_get_contents($tokenFile));
    if (empty($token)) {
        $io->error([
            "$tokenFile exists but is empty.",
            '<href=https://github.com/settings/tokens>Please create a GitHub token</> and put it there.',
        ]);
        exit(Command::FAILURE);
    }
    // Test the token by making an authenticated request
    $client = new Client();
    $client->authenticate($token, null, AuthMethod::ACCESS_TOKEN);
    try {
        $client->currentUser()->show();
    } catch (\Exception $e) {
        $io->error([
            "Failed to authenticate with GitHub using the provided token from $tokenFile.",
            '<href=https://github.com/settings/tokens>Please make sure the token is valid and has the required permissions</>.',
            'Error: ' . $e->getMessage(),
        ]);
        exit(Command::FAILURE);
    }
    $this->gitHubToken = $token;
    return $token;
}

            

                protected function getIO(): OutputManager
{
    if ($this->io === null) {
        throw new RuntimeException('IO is not initialized.');
    }
    return $this->io;
}

            

                protected function getPackageList(): PackageList
{
    return $this->packageList;
}

            

                protected function getTargetPackages(): array
{
    if ($this->targetPackages === null) {
        throw new RuntimeException('Target packages are not initialized.');
    }
    return $this->targetPackages;
}

            

                protected function initPackageList(): void
{
    $io = $this->getIO();
    try {
        $ownerPackages = require $this->getAppRootDir() . 'owner-packages.php';
        if (!preg_match('/^[a-z0-9][a-z0-9-]*[a-z0-9]$/i', $ownerPackages)) {
            $io->error([
                'The packages owner can only contain the characters [a-z0-9-], and the character \'-\' cannot appear at the beginning or at the end.',
                'See <file>owner-packages.php</file> to set the packages owner.',
            ]);
            exit(1);
        }
        $packagesRootDir = $this->getApplication()->getConfig('packagesRootDir') ??  $this->getAppRootDir() . 'dev';
        $this->packageList = new PackageList(
            $ownerPackages,
            $this->getAppRootDir() . 'packages.php',
            packagesRootDir: $packagesRootDir,
        );
        $this->errorList = new PackageErrorList();
    } catch (InvalidArgumentException $e) {
        $io->error([
            'Invalid local package configuration <file>packages.local.php</file>',
            $e->getMessage(),
            'See <file>packages.local.php.example</file> for configuration examples.',
        ]);
        exit(1);
    }
}

            

                protected function initTargetPackages(InputInterface $input): void
{
    if ($this->packageList === null) {
        throw new RuntimeException('Package list is not initialized.');
    }
    $io = $this->getIO();
    $commaSeparatedPackageIds = $input->getArgument('packages');
    if ($commaSeparatedPackageIds === null) {
        $this->targetPackagesSpecifiedExplicitly = false;
        $this->targetPackages = $this->packageList->getEnabledPackages();
        return;
    }
    $targetPackageIds = array_unique(explode(',', $commaSeparatedPackageIds));
    $problemsFound = false;
    $targetPackages = [];
    foreach ($targetPackageIds as $targetPackageId) {
        $package = $this->packageList->getPackage($targetPackageId);
        if ($package === null) {
            $io->error("Package <package>$targetPackageId</package> not found in <file>packages.php</file>");
            $problemsFound = true;
            continue;
        }
        if ($package->disabled()) {
            $io->error("Package <package>$targetPackageId</package> disabled in <file>packages.local.php</file>");
            $problemsFound = true;
            continue;
        }
        $targetPackages[] = $package;
    }
    if ($problemsFound) {
        exit(1);
    }
    $this->targetPackagesSpecifiedExplicitly = true;
    $this->targetPackages = $targetPackages;
}

            

                protected function initialize(InputInterface $input, OutputInterface $output)
{
    $this->io = new OutputManager(new YiiDevToolStyle($input, $output));
}

            

                protected function registerPackageError(Package $package, string $message, string $during): void
{
    $this->errorList->set($package, $message, $during);
}