8584679655

Committed 07 Apr 2024 12:09AM UTC coverage: 100.0%. Remained the same

Build # 8584679655

Build Type

push

github

Committed by

web-flow

Commit Message

[TASK] Update all dependencies

Run Details

352 of 352 relevant lines covered (100.0%)

3.64 hits per line

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

100.0

/src/EventListener/InitializeRepositoryListener.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;

/**
 * InitializeRepositoryListener.
 *
 * @author Elias Häußler <elias@haeussler.dev>
 * @license GPL-3.0-or-later
 */
final class InitializeRepositoryListener
{
    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
    {
        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($event->getBuildResult());

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

        // Create coverage repositories
        if (Enums\CreateRepositoryResponse::Failed !== $response) {
            $this->createCodeClimateRepository($event->getBuildResult(), $repository);
            $this->createCoverallsRepository($event->getBuildResult(), $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	* InitializeRepositoryListener.
36	*
37	* @author Elias Häußler <elias@haeussler.dev>
38	* @license GPL-3.0-or-later
39	*/
40	final class InitializeRepositoryListener
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	if (!($event->getStep() instanceof ProjectBuilder\Builder\Generator\Step\CollectBuildInstructionsStep)) {	8✔
53	return;	1✔
54	}
55
56	$this->messenger->newLine();	7✔
57
58	// Early return if repo should not be generated
59	if (!$this->inputReader->ask('Should we create a new GitHub repository for you?')) {	7✔
60	return;	1✔
61	}
62
63	// Map properties to repository object
64	$repository = $this->createRepositoryFromBuildResult($event->getBuildResult());	6✔
65
66	// Create GitHub repository
67	$response = $this->createGitHubRepository($repository);	6✔
68
69	// Create coverage repositories
70	if (Enums\CreateRepositoryResponse::Failed !== $response) {	6✔
71	$this->createCodeClimateRepository($event->getBuildResult(), $repository);	5✔
72	$this->createCoverallsRepository($event->getBuildResult(), $repository);	5✔
73	}
74	}
75
76	private function createRepositoryFromBuildResult(	6✔
77	ProjectBuilder\Builder\BuildResult $buildResult,
78	): ValueObject\GitHubRepository {
79	$instructions = $buildResult->getInstructions();	6✔
80
81	$owner = $instructions->getTemplateVariable('repository.owner');	6✔
82	$name = $instructions->getTemplateVariable('repository.name');	6✔
83	$url = $instructions->getTemplateVariable('repository.url');	6✔
84	$description = $instructions->getTemplateVariable('package.description');	6✔
85	$isPrivate = $this->inputReader->ask('Do you wish to keep the repository private for now?');	6✔
86
87	Assert\Assert::string($owner);	6✔
88	Assert\Assert::notEmpty($owner);	6✔
89	Assert\Assert::string($name);	6✔
90	Assert\Assert::notEmpty($name);	6✔
91	Assert\Assert::string($url);	6✔
92	Assert\Assert::string($description);	6✔
93
94	return new ValueObject\GitHubRepository($owner, $name, new Psr7\Uri($url), $description, $isPrivate);	6✔
95	}
96
97	private function createGitHubRepository(ValueObject\GitHubRepository $repository): Enums\CreateRepositoryResponse	6✔
98	{
99	$this->messenger->progress('Creating new GitHub repository...', IO\IOInterface::NORMAL);	6✔
100
101	$response = $this->gitHubService->createRepository($repository);	6✔
102
103	match ($response) {	6✔
104	Enums\CreateRepositoryResponse::Created => $this->messenger->done(),	6✔
105	Enums\CreateRepositoryResponse::Failed => $this->messenger->failed(),	6✔
106	Enums\CreateRepositoryResponse::AlreadyExists => $this->messenger->writeWithEmoji(	6✔
107	ProjectBuilder\IO\Emoji::WhiteHeavyCheckMark->value,	6✔
108	'Creating new GitHub repository... <comment>Already exists</comment>',	6✔
109	true,	6✔
110	),	6✔
111	};	6✔
112
113	return $response;	6✔
114	}
115
116	private function createCodeClimateRepository(	5✔
117	ProjectBuilder\Builder\BuildResult $result,
118	ValueObject\GitHubRepository $repository,
119	): void {
120	$isCodeClimateEnabled = (bool) $result->getInstructions()->getTemplateVariable('ci.codeclimate');	5✔
121
122	if (!$isCodeClimateEnabled \|\| $repository->isPrivate()) {	5✔
123	return;	4✔
124	}
125
126	$this->messenger->newLine();	1✔
127
128	if ($this->inputReader->ask('Should we initialize CodeClimate?')) {	1✔
129	$this->messenger->progress('Initializing CodeClimate...', IO\IOInterface::NORMAL);	1✔
130	$this->codeClimateService->addRepository($repository);	1✔
131	$this->messenger->done();	1✔
132	$this->messenger->newLine();	1✔
133	}
134	}
135
136	private function createCoverallsRepository(	5✔
137	ProjectBuilder\Builder\BuildResult $result,
138	ValueObject\GitHubRepository $repository,
139	): void {
140	$isCoverallsEnabled = (bool) $result->getInstructions()->getTemplateVariable('ci.coveralls');	5✔
141
142	if (!$isCoverallsEnabled \|\| $repository->isPrivate()) {	5✔
143	return;	4✔
144	}
145
146	$this->messenger->newLine();	1✔
147
148	if ($this->inputReader->ask('Should we initialize Coveralls?')) {	1✔
149	$this->messenger->progress('Initializing Coveralls...', IO\IOInterface::NORMAL);	1✔
150	$this->coverallsService->addRepository($repository);	1✔
151	$this->messenger->done();	1✔
152	$this->messenger->newLine();	1✔
153	}
154	}
155	}

eliashaeussler / composer-package-template / 8584679655

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