11395246006

Committed 18 Oct 2024 12:33AM UTC coverage: 99.502%. Remained the same

Build # 11395246006

Build Type

push

github

Committed by

web-flow

Commit Message

[TASK] Update all dependencies

Run Details

400 of 402 relevant lines covered (99.5%)

3.5 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

100.0

/src/EventListener/CreateRepositoryListener.php

<?php

declare(strict_types=1);

/*
 * This file is part of the Composer package "eliashaeussler/composer-package-template".
 *
 * Copyright (C) 2023-2024 Elias Häußler <elias@haeussler.dev>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 */

namespace EliasHaeussler\ComposerPackageTemplate\EventListener;

use Composer\IO;
use CPSIT\ProjectBuilder;
use EliasHaeussler\ComposerPackageTemplate\Enums;
use EliasHaeussler\ComposerPackageTemplate\Service;
use EliasHaeussler\ComposerPackageTemplate\ValueObject;
use Nyholm\Psr7;
use Webmozart\Assert;

/**
 * CreateRepositoryListener.
 *
 * @author Elias Häußler <elias@haeussler.dev>
 * @license GPL-3.0-or-later
 */
final class CreateRepositoryListener
{
    public function __construct(
        private readonly Service\CodeClimateService $codeClimateService,
        private readonly Service\CoverallsService $coverallsService,
        private readonly Service\GitHubService $gitHubService,
        private readonly ProjectBuilder\IO\InputReader $inputReader,
        private readonly ProjectBuilder\IO\Messenger $messenger,
    ) {}

    public function __invoke(ProjectBuilder\Event\BuildStepProcessedEvent $event): void
    {
        $buildResult = $event->getBuildResult();

        if (!($event->getStep() instanceof ProjectBuilder\Builder\Generator\Step\CollectBuildInstructionsStep)) {
            return;
        }

        $this->messenger->newLine();

        // Early return if repo should not be generated
        if (!$this->inputReader->ask('Should we create a new GitHub repository for you?')) {
            return;
        }

        // Map properties to repository object
        $repository = $this->createRepositoryFromBuildResult($buildResult);

        // Create GitHub repository
        $response = $this->createGitHubRepository($repository);

        // Store result
        $buildResult->getInstructions()->addTemplateVariable('repository.createResult', [
            'object' => $repository,
            'response' => $response,
        ]);

        // Early return if repository is not created
        if (Enums\CreateRepositoryResponse::Failed === $response) {
            return;
        }

        // Create coverage repositories
        $this->createCodeClimateRepository($buildResult, $repository);
        $this->createCoverallsRepository($buildResult, $repository);
    }

    private function createRepositoryFromBuildResult(
        ProjectBuilder\Builder\BuildResult $buildResult,
    ): ValueObject\GitHubRepository {
        $instructions = $buildResult->getInstructions();

        $owner = $instructions->getTemplateVariable('repository.owner');
        $name = $instructions->getTemplateVariable('repository.name');
        $url = $instructions->getTemplateVariable('repository.url');
        $description = $instructions->getTemplateVariable('package.description');
        $isPrivate = $this->inputReader->ask('Do you wish to keep the repository private for now?');

        Assert\Assert::string($owner);
        Assert\Assert::notEmpty($owner);
        Assert\Assert::string($name);
        Assert\Assert::notEmpty($name);
        Assert\Assert::string($url);
        Assert\Assert::string($description);

        return new ValueObject\GitHubRepository($owner, $name, new Psr7\Uri($url), $description, $isPrivate);
    }

    private function createGitHubRepository(ValueObject\GitHubRepository $repository): Enums\CreateRepositoryResponse
    {
        $this->messenger->progress('Creating new GitHub repository...', IO\IOInterface::NORMAL);

        $response = $this->gitHubService->createRepository($repository);

        match ($response) {
            Enums\CreateRepositoryResponse::Created => $this->messenger->done(),
            Enums\CreateRepositoryResponse::Failed => $this->messenger->failed(),
            Enums\CreateRepositoryResponse::AlreadyExists => $this->messenger->writeWithEmoji(
                ProjectBuilder\IO\Emoji::WhiteHeavyCheckMark->value,
                'Creating new GitHub repository... <comment>Already exists</comment>',
                true,
            ),
        };

        return $response;
    }

    private function createCodeClimateRepository(
        ProjectBuilder\Builder\BuildResult $result,
        ValueObject\GitHubRepository $repository,
    ): void {
        $isCodeClimateEnabled = (bool) $result->getInstructions()->getTemplateVariable('ci.codeclimate');

        if (!$isCodeClimateEnabled || $repository->isPrivate()) {
            return;
        }

        $this->messenger->newLine();

        if ($this->inputReader->ask('Should we initialize CodeClimate?')) {
            $this->messenger->progress('Initializing CodeClimate...', IO\IOInterface::NORMAL);
            $this->codeClimateService->addRepository($repository);
            $this->messenger->done();
            $this->messenger->newLine();
        }
    }

    private function createCoverallsRepository(
        ProjectBuilder\Builder\BuildResult $result,
        ValueObject\GitHubRepository $repository,
    ): void {
        $isCoverallsEnabled = (bool) $result->getInstructions()->getTemplateVariable('ci.coveralls');

        if (!$isCoverallsEnabled || $repository->isPrivate()) {
            return;
        }

        $this->messenger->newLine();

        if ($this->inputReader->ask('Should we initialize Coveralls?')) {
            $this->messenger->progress('Initializing Coveralls...', IO\IOInterface::NORMAL);
            $this->coverallsService->addRepository($repository);
            $this->messenger->done();
            $this->messenger->newLine();
        }
    }
}

1	<?php
2
3	declare(strict_types=1);
4
5	/*
6	* This file is part of the Composer package "eliashaeussler/composer-package-template".
7	*
8	* Copyright (C) 2023-2024 Elias Häußler <elias@haeussler.dev>
9	*
10	* This program is free software: you can redistribute it and/or modify
11	* it under the terms of the GNU General Public License as published by
12	* the Free Software Foundation, either version 3 of the License, or
13	* (at your option) any later version.
14	*
15	* This program is distributed in the hope that it will be useful,
16	* but WITHOUT ANY WARRANTY; without even the implied warranty of
17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18	* GNU General Public License for more details.
19	*
20	* You should have received a copy of the GNU General Public License
21	* along with this program. If not, see <https://www.gnu.org/licenses/>.
22	*/
23
24	namespace EliasHaeussler\ComposerPackageTemplate\EventListener;
25
26	use Composer\IO;
27	use CPSIT\ProjectBuilder;
28	use EliasHaeussler\ComposerPackageTemplate\Enums;
29	use EliasHaeussler\ComposerPackageTemplate\Service;
30	use EliasHaeussler\ComposerPackageTemplate\ValueObject;
31	use Nyholm\Psr7;
32	use Webmozart\Assert;
33
34	/**
35	* CreateRepositoryListener.
36	*
37	* @author Elias Häußler <elias@haeussler.dev>
38	* @license GPL-3.0-or-later
39	*/
40	final class CreateRepositoryListener
41	{
42	public function __construct(	8✔
43	private readonly Service\CodeClimateService $codeClimateService,
44	private readonly Service\CoverallsService $coverallsService,
45	private readonly Service\GitHubService $gitHubService,
46	private readonly ProjectBuilder\IO\InputReader $inputReader,
47	private readonly ProjectBuilder\IO\Messenger $messenger,
48	) {}	8✔
49
50	public function __invoke(ProjectBuilder\Event\BuildStepProcessedEvent $event): void	8✔
51	{
52	$buildResult = $event->getBuildResult();	8✔
53
54	if (!($event->getStep() instanceof ProjectBuilder\Builder\Generator\Step\CollectBuildInstructionsStep)) {	8✔
55	return;	1✔
56	}
57
58	$this->messenger->newLine();	7✔
59
60	// Early return if repo should not be generated
61	if (!$this->inputReader->ask('Should we create a new GitHub repository for you?')) {	7✔
62	return;	1✔
63	}
64
65	// Map properties to repository object
66	$repository = $this->createRepositoryFromBuildResult($buildResult);	6✔
67
68	// Create GitHub repository
69	$response = $this->createGitHubRepository($repository);	6✔
70
71	// Store result
72	$buildResult->getInstructions()->addTemplateVariable('repository.createResult', [	6✔
73	'object' => $repository,	6✔
74	'response' => $response,	6✔
75	]);	6✔
76
77	// Early return if repository is not created
78	if (Enums\CreateRepositoryResponse::Failed === $response) {	6✔
79	return;	1✔
80	}
81
82	// Create coverage repositories
83	$this->createCodeClimateRepository($buildResult, $repository);	5✔
84	$this->createCoverallsRepository($buildResult, $repository);	5✔
85	}
86
87	private function createRepositoryFromBuildResult(	6✔
88	ProjectBuilder\Builder\BuildResult $buildResult,
89	): ValueObject\GitHubRepository {
90	$instructions = $buildResult->getInstructions();	6✔
91
92	$owner = $instructions->getTemplateVariable('repository.owner');	6✔
93	$name = $instructions->getTemplateVariable('repository.name');	6✔
94	$url = $instructions->getTemplateVariable('repository.url');	6✔
95	$description = $instructions->getTemplateVariable('package.description');	6✔
96	$isPrivate = $this->inputReader->ask('Do you wish to keep the repository private for now?');	6✔
97
98	Assert\Assert::string($owner);	6✔
99	Assert\Assert::notEmpty($owner);	6✔
100	Assert\Assert::string($name);	6✔
101	Assert\Assert::notEmpty($name);	6✔
102	Assert\Assert::string($url);	6✔
103	Assert\Assert::string($description);	6✔
104
105	return new ValueObject\GitHubRepository($owner, $name, new Psr7\Uri($url), $description, $isPrivate);	6✔
106	}
107
108	private function createGitHubRepository(ValueObject\GitHubRepository $repository): Enums\CreateRepositoryResponse	6✔
109	{
110	$this->messenger->progress('Creating new GitHub repository...', IO\IOInterface::NORMAL);	6✔
111
112	$response = $this->gitHubService->createRepository($repository);	6✔
113
114	match ($response) {
115	Enums\CreateRepositoryResponse::Created => $this->messenger->done(),	6✔
116	Enums\CreateRepositoryResponse::Failed => $this->messenger->failed(),	6✔
117	Enums\CreateRepositoryResponse::AlreadyExists => $this->messenger->writeWithEmoji(	5✔
118	ProjectBuilder\IO\Emoji::WhiteHeavyCheckMark->value,	5✔
119	'Creating new GitHub repository... <comment>Already exists</comment>',	5✔
120	true,	5✔
121	),	5✔
122	};
123
124	return $response;	6✔
125	}
126
127	private function createCodeClimateRepository(	5✔
128	ProjectBuilder\Builder\BuildResult $result,
129	ValueObject\GitHubRepository $repository,
130	): void {
131	$isCodeClimateEnabled = (bool) $result->getInstructions()->getTemplateVariable('ci.codeclimate');	5✔
132
133	if (!$isCodeClimateEnabled \|\| $repository->isPrivate()) {	5✔
134	return;	4✔
135	}
136
137	$this->messenger->newLine();	1✔
138
139	if ($this->inputReader->ask('Should we initialize CodeClimate?')) {	1✔
140	$this->messenger->progress('Initializing CodeClimate...', IO\IOInterface::NORMAL);	1✔
141	$this->codeClimateService->addRepository($repository);	1✔
142	$this->messenger->done();	1✔
143	$this->messenger->newLine();	1✔
144	}
145	}
146
147	private function createCoverallsRepository(	5✔
148	ProjectBuilder\Builder\BuildResult $result,
149	ValueObject\GitHubRepository $repository,
150	): void {
151	$isCoverallsEnabled = (bool) $result->getInstructions()->getTemplateVariable('ci.coveralls');	5✔
152
153	if (!$isCoverallsEnabled \|\| $repository->isPrivate()) {	5✔
154	return;	4✔
155	}
156
157	$this->messenger->newLine();	1✔
158
159	if ($this->inputReader->ask('Should we initialize Coveralls?')) {	1✔
160	$this->messenger->progress('Initializing Coveralls...', IO\IOInterface::NORMAL);	1✔
161	$this->coverallsService->addRepository($repository);	1✔
162	$this->messenger->done();	1✔
163	$this->messenger->newLine();	1✔
164	}
165	}
166	}

eliashaeussler / composer-package-template / 11395246006

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous