SemanticVersionUpdater::checkUncommittedChanges() - Code Metrics - Inspection of "test: Added fixtures" - Voral/vs-version-incrementor - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 351308...878789 )

by Alexander
created 2025-04-15 04:29 UTC
SemanticVersionUpdater::checkUncommittedChanges() A

↳ Parent: SemanticVersionUpdater
Complexity

Conditions	3
Paths	4
Size

Total Lines	9
Code Lines	5
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	6
CRAP Score	3
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	3
eloc	5
c	1
b	0
f	0
nc	4
nop	0
dl	0
loc	9
ccs	6
cts	6
cp	1
crap	3
rs	10
<?php

declare(strict_types=1);

namespace Vasoft\VersionIncrement;

use Vasoft\VersionIncrement\Commits\CommitCollection;
use Vasoft\VersionIncrement\Contract\VcsExecutorInterface;
use Vasoft\VersionIncrement\Exceptions\BranchException;
use Vasoft\VersionIncrement\Exceptions\ChangelogException;
use Vasoft\VersionIncrement\Exceptions\ComposerException;
use Vasoft\VersionIncrement\Exceptions\GitCommandException;
use Vasoft\VersionIncrement\Exceptions\IncorrectChangeTypeException;
use Vasoft\VersionIncrement\Exceptions\UncommittedException;

class SemanticVersionUpdater
{
    private bool $debug = false;
    private VcsExecutorInterface $gitExecutor;
    private array $availableTypes = [
        'major',
        'minor',
        'patch',
    ];

    public function __construct(
        private readonly string $projectPath,
        private readonly Config $config,
        private string $changeType = '',
    ) {
        $this->gitExecutor = $config->getVcsExecutor();
    }

    /**
     * @throws IncorrectChangeTypeException
     */
    private function checkChangeType(): void
    {
        if ('' !== $this->changeType && !in_array($this->changeType, $this->availableTypes, true)) {
            throw  new IncorrectChangeTypeException($this->changeType);
        }
    }

    /**
     * @throws ComposerException
     */
    public function getComposerJson(): array
    {
        $composer = $this->projectPath . '/composer.json';
        if (!file_exists($composer)) {
            throw new ComposerException();
        }
        if (!is_writable($composer)) {
            throw new ComposerException('Composer file is not writable.');
        }

        try {
            $result = json_decode(file_get_contents($composer), true, 512, JSON_THROW_ON_ERROR);
        } catch (\JsonException $e) {
            throw new ComposerException('JSON: ' . $e->getMessage());
        }

        return $result;
    }

    /**
     * @throws BranchException
     * @throws ChangelogException
     * @throws ComposerException
     * @throws GitCommandException
     * @throws IncorrectChangeTypeException
     * @throws UncommittedException
     */
    public function updateVersion(): void
    {
        $this->checkChangeType();
        $this->checkGitBranch();
        $this->checkUncommittedChanges();

        $lastTag = $this->gitExecutor->getLastTag();
        if ($this->config->isEnabledComposerVersioning()) {
            $composerJson = $this->getComposerJson();
            $currentVersion = $composerJson['version'] ?? '1.0.0';
        } else {
            $currentVersion = $this->config->getTagFormatter()->extractVersion($lastTag);
            $currentVersion = $this->config->getTagFormatter()->extractVersion(/** @scrutinizer ignore-type */ $lastTag);
        }

        $commitCollection = $this->config->getCommitParser()->process($lastTag);
        $this->detectionTypeChange($commitCollection);

        $newVersion = $this->incrementVersion($currentVersion, $this->changeType);

        if ($this->config->isEnabledComposerVersioning()) {
            $composerJson['version'] = $newVersion;
            $this->updateComposerJson($composerJson);
        }
        $changelog = $this->config->getChangelogFormatter()($commitCollection, $newVersion);

        $this->updateChangeLog($changelog);
        $this->commitRelease($newVersion);
    }

    /**
     * @throws GitCommandException
     */
    private function commitRelease(string $newVersion): void
    {
        if (!$this->debug) {
            $releaseScope = trim($this->config->getReleaseScope());
            if ('' !== $releaseScope) {
                $releaseScope = sprintf('(%s)', $releaseScope);
            }
            $this->gitExecutor->commit(
                sprintf(
                    '%s%s: v%s',
                    $this->config->getReleaseSection(),
                    $releaseScope,
                    $newVersion,
                ),
            );
            $this->gitExecutor->setVersionTag($newVersion);
            echo "Release {$newVersion} successfully created!\n";
        }
    }

    /**
     * @throws ChangelogException
     * @throws GitCommandException
     */
    private function updateChangeLog(string $changelog): void
    {
        if ($this->debug) {
            echo $changelog;
        } else {
            $fileChangelog = $this->projectPath . '/CHANGELOG.md';
            if (file_exists($fileChangelog)) {
                if (!is_writable($fileChangelog)) {
                    throw new ChangelogException();
                }

                $changeLogContent = file_get_contents($fileChangelog);
                $changeLogAddToGit = false;
            } else {
                $changeLogContent = '';
                $changeLogAddToGit = true;
            }
            file_put_contents($fileChangelog, $changelog . $changeLogContent);
            if ($changeLogAddToGit) {
                $this->gitExecutor->addFile('CHANGELOG.md');
            }
        }
    }

    private function updateComposerJson(array $composerJson): void
    {
        if (!$this->debug) {
            file_put_contents(
                $this->projectPath . '/composer.json',
                json_encode($composerJson, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES),
            );
        }
    }

    private function detectionTypeChange(CommitCollection $commitCollection): void
    {
        if ('' === $this->changeType) {
            if ($commitCollection->hasMajorMarker()) {
                $this->changeType = 'major';
            } elseif ($commitCollection->hasMinorMarker()) {
                $this->changeType = 'minor';
            } else {
                $this->changeType = 'patch';
            }
        }
    }

    /**
     * @throws GitCommandException
     * @throws UncommittedException
     */
    private function checkUncommittedChanges(): void
    {
        $out = $this->gitExecutor->status();
        if ($this->config->mastIgnoreUntrackedFiles()) {
            $out = array_filter($out, static fn(string $item): bool => !str_starts_with($item, '??'));
        }

        if (!empty($out)) {
            throw new UncommittedException();
        }
    }

    /**
     * @throws BranchException
     * @throws GitCommandException
     */
    private function checkGitBranch(): void
    {
        $currentBranch = $this->gitExecutor->getCurrentBranch();
        $targetBranch = $this->config->getMasterBranch();
        if ($currentBranch !== $targetBranch) {
            throw new BranchException($currentBranch, $targetBranch);
        }
    }

    private function incrementVersion(string $currentVersion, string $changeType): string
    {
        [$major, $minor, $patch] = explode('.', $currentVersion);
        switch ($changeType) {
            case 'major':
                $major++;
                $minor = 0;
                $patch = 0;
                break;
            case 'minor':
                $minor++;
                $patch = 0;
                break;
            case 'patch':
            default:
                $patch++;
                break;
        }

        return "{$major}.{$minor}.{$patch}";
    }

    public function setDebug(bool $debug): self
    {
        $this->debug = $debug;

        return $this;
    }
}

Voral / vs-version-incrementor

Push — master ( 351308...878789 )

SemanticVersionUpdater::checkUncommittedChanges() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
