├── composer.json
└── src
    ├── AbstractGit.php
    ├── Attributes
        ├── ConfigKey.php
        ├── ConfigSectionName.php
        └── ConfigValue.php
    ├── Backup
        ├── AbstractBackup.php
        ├── ArrayBackupElementDict.php
        ├── Backup.php
        └── Elements
        │   ├── AbstractBackupElement.php
        │   ├── ConfigBackupElement.php
        │   ├── HookBackupElement.php
        │   └── UntrackedFilesBackupElement.php
    ├── CachedGit.php
    ├── Command
        ├── Commands
        │   ├── AbstractCommand.php
        │   ├── ArchiveCommand.php
        │   ├── AttributeCommand.php
        │   ├── BranchCommand.php
        │   ├── CommitCommand.php
        │   ├── ConfigCommand.php
        │   ├── FetchCommand.php
        │   ├── FileCommand.php
        │   ├── GarbageCommand.php
        │   ├── GrepCommand.php
        │   ├── HelpCommand.php
        │   ├── HookCommand.php
        │   ├── IgnoreCommand.php
        │   ├── IndexCommand.php
        │   ├── LogCommand.php
        │   ├── MergeCommand.php
        │   ├── PathCommand.php
        │   ├── PullCommand.php
        │   ├── PushCommand.php
        │   ├── RemoteCommand.php
        │   ├── SetupCommand.php
        │   ├── StashCommand.php
        │   ├── StatusCommand.php
        │   ├── SubmoduleCommand.php
        │   └── TagCommand.php
        └── GitCommandBuilder.php
    ├── Concerns
        └── SwitchFolder.php
    ├── Config
        ├── Configurators
        │   ├── AliasConfigurator.php
        │   ├── BranchConfigurator.php
        │   ├── CommitConfigurator.php
        │   ├── CoreConfigurator.php
        │   ├── CredentialConfigurator.php
        │   ├── DiffConfigurator.php
        │   ├── InstawebConfigurator.php
        │   ├── PackConfigurator.php
        │   ├── SubmoduleConfigurator.php
        │   └── UserConfigurator.php
        ├── ConfiguratorsDict.php
        ├── RegexConfigResultParser.php
        └── Subjects
        │   ├── AbstractSubject.php
        │   ├── Alias.php
        │   ├── AliasList.php
        │   ├── Branch.php
        │   ├── BranchList.php
        │   ├── ConfigCommit.php
        │   ├── ConfigDiff.php
        │   ├── ConfigSubmodule.php
        │   ├── ConfigSubmoduleList.php
        │   ├── Core.php
        │   ├── Credential.php
        │   ├── Instaweb.php
        │   ├── Pack.php
        │   ├── SubjectsCollection.php
        │   └── User.php
    ├── Contracts
        ├── Attribute
        │   └── GitAttribute.php
        ├── AuthorHydrator.php
        ├── Backup
        │   ├── BackupElement.php
        │   ├── BackupElementDict.php
        │   └── GitBackup.php
        ├── Commands
        │   ├── FolderSwitchable.php
        │   ├── GitArchiveCommand.php
        │   ├── GitAttributeCommand.php
        │   ├── GitBranchCommand.php
        │   ├── GitCommitCommand.php
        │   ├── GitConfigCommand.php
        │   ├── GitFetchCommand.php
        │   ├── GitFileCommand.php
        │   ├── GitGarbageCommand.php
        │   ├── GitGrepCommand.php
        │   ├── GitHelpCommand.php
        │   ├── GitHookCommand.php
        │   ├── GitIgnoreCommand.php
        │   ├── GitIndexCommand.php
        │   ├── GitLogCommand.php
        │   ├── GitMergeCommand.php
        │   ├── GitPathCommand.php
        │   ├── GitPullCommand.php
        │   ├── GitPushCommand.php
        │   ├── GitRemoteCommand.php
        │   ├── GitSetupCommand.php
        │   ├── GitStashCommand.php
        │   ├── GitStatusCommand.php
        │   ├── GitSubmoduleCommand.php
        │   ├── GitTagCommand.php
        │   ├── HasSubmodules.php
        │   └── RefsPacker.php
        ├── Common
        │   └── Arrayable.php
        ├── Config
        │   ├── ConfigAttribute.php
        │   ├── ConfigResultParser.php
        │   ├── ConfigSubject.php
        │   ├── ConfigSubjectList.php
        │   └── SubjectConfigurator.php
        ├── Factory
        │   └── GitHandlerFactory.php
        ├── Handler
        │   ├── GitHandler.php
        │   ├── HasAttributes.php
        │   ├── HasBackup.php
        │   ├── HasRemotes.php
        │   └── Versionable.php
        ├── HasContext.php
        ├── HasUrl.php
        ├── Log
        │   ├── LogQuery.php
        │   ├── LogQueryAction.php
        │   └── LogQueryBuilder.php
        ├── LogParser.php
        ├── Origin
        │   ├── OriginDownloader.php
        │   └── OriginUrlBuilder.php
        ├── PathGenerator.php
        ├── PushSetup.php
        └── Transaction
        │   ├── GitTransaction.php
        │   └── TransactionOperation.php
    ├── Data
        ├── Author.php
        ├── Author
        │   ├── CacheableHydrator.php
        │   └── Hydrator.php
        ├── Commit.php
        ├── CommitsAuthor.php
        ├── FileMatch.php
        ├── GitAttributes.php
        ├── GitContext.php
        ├── Hook.php
        ├── Log.php
        ├── LogCollection.php
        ├── Remotes.php
        ├── Repo.php
        ├── Stash.php
        ├── Submodule.php
        ├── Tag.php
        └── Version.php
    ├── Enum
        ├── ArchiveFormat.php
        ├── BranchBadName.php
        ├── ConfigSectionName.php
        ├── Enumerable.php
        ├── FormatPlaceholder.php
        ├── GarbageCollectMode.php
        ├── HookName.php
        ├── ResetMode.php
        └── StatusResult.php
    ├── Exceptions
        ├── AlreadySwitched.php
        ├── BadRevision.php
        ├── BranchAlreadyExists.php
        ├── BranchDoesNotHaveCommits.php
        ├── BranchHasNoUpstream.php
        ├── BranchNotFound.php
        ├── CannotMergeAbort.php
        ├── CannotMergeException.php
        ├── ConfigDataNotFound.php
        ├── ConfigSectionNotFound.php
        ├── ConfigVariableNotFound.php
        ├── FileNotFound.php
        ├── GitHandlerException.php
        ├── GivenInvalidUri.php
        ├── HookNotExists.php
        ├── MergeHeadMissing.php
        ├── NotSomethingWeCanMerge.php
        ├── NothingToCommit.php
        ├── ObjectNameNotValid.php
        ├── OriginUrlNotFound.php
        ├── PathAlreadyExists.php
        ├── PathIncorrect.php
        ├── PathIsDirectoryNotCould.php
        ├── PreviousCherryPickIsNowEmpty.php
        ├── ReferenceInvalid.php
        ├── RemoteAlreadyExists.php
        ├── RemoteNotFilled.php
        ├── RemoteNotFound.php
        ├── RemoteRepositoryNotFound.php
        ├── RepositoryAlreadyExists.php
        ├── StashDoesNotExists.php
        ├── SubjectConfiguratorNotFound.php
        ├── SubmoduleNotFound.php
        ├── TagAlreadyExists.php
        ├── TagNotFound.php
        ├── UnexpectedException.php
        └── UnknownRevisionInWorkingTree.php
    ├── Factory
        ├── CachedGitFactory.php
        ├── DownloaderFactory.php
        └── LocalGitFactory.php
    ├── Files
        ├── AttributesFile.php
        └── SubmodulesFile.php
    ├── Git.php
    ├── Making
        └── MakingPush.php
    ├── Origin
        ├── Downloader.php
        └── Url
        │   ├── AbstractOriginUrlBuilder.php
        │   ├── BitbucketOriginUrlBuilder.php
        │   ├── GitUrl.php
        │   ├── GithubOriginUrlBuilder.php
        │   ├── GitlabOriginUrlBuilder.php
        │   └── OriginUrlSelector.php
    ├── Support
        ├── Chmod.php
        ├── LocalFileSystem.php
        ├── LogBuilder.php
        ├── Logger.php
        ├── SimpleHttpClient.php
        ├── TemporaryPathGenerator.php
        ├── ToArray.php
        ├── TypeCaster.php
        └── Uri.php
    └── Transactions
        └── ArchiveTransaction.php


/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "artarts36/git-handler",
 3 |     "description": "Git Handler",
 4 |     "type": "library",
 5 |     "require": {
 6 |         "php": ">=7.3",
 7 |         "artarts36/shell-command": "^2.1.13",
 8 |         "artarts36/str": "^2.0.1",
 9 |         "artarts36/file-system-contracts": "0.2.0",
10 |         "psr/http-client": "^1.0",
11 |         "guzzlehttp/psr7": "^1.8 | ^2",
12 |         "artarts36/local-file-system": "^0.1.1"
13 |     },
14 |     "require-dev": {
15 |         "phpunit/phpunit": "^9.3",
16 |         "squizlabs/php_codesniffer": "^3.5",
17 |         "guzzlehttp/guzzle": "^7.3",
18 |         "infection/infection": "^0.18.2",
19 |         "composer/package-versions-deprecated": "1.11.99.2",
20 |         "phpstan/phpstan": "^0.12.96",
21 |         "jetbrains/phpstorm-attributes": "^1.0",
22 |         "roave/security-advisories": "dev-latest",
23 |         "phpdocumentor/reflection": "^5.3"
24 |     },
25 |     "license": "MIT",
26 |     "authors": [
27 |         {
28 |             "name": "ArtARTs36",
29 |             "email": "temicska99@mail.ru"
30 |         }
31 |     ],
32 |     "autoload": {
33 |         "psr-4": {
34 |             "ArtARTs36\\GitHandler\\": "src/"
35 |         }
36 |     },
37 |     "autoload-dev": {
38 |         "psr-4": {
39 |             "ArtARTs36\\GitHandler\\Tests\\": "tests/",
40 |             "ArtARTs36\\GitHandler\\DocBuilder\\": "docs/DocBuilder"
41 |         },
42 |         "files": [
43 |             "tests/functions.php"
44 |         ]
45 |     },
46 |     "config": {
47 |         "allow-plugins": {
48 |             "infection/extension-installer": true
49 |         }
50 |     },
51 |     "scripts": {
52 |         "lint": [
53 |             "echo 'Check code on PSR'",
54 |             "./vendor/bin/phpcs --standard=PSR2 src/",
55 |             "./vendor/bin/phpcs --standard=PSR2 tests/"
56 |         ],
57 |         "stat-analyse": [
58 |             "echo 'Run stat analyse'",
59 |             "./vendor/bin/phpstan analyse -l 5 src"
60 |         ],
61 |         "test": [
62 |             "echo 'Run tests'",
63 |             "XDEBUG_MODE=coverage ./vendor/bin/phpunit -v --coverage-text --configuration phpunit.xml --coverage-clover=tests/reports/logs/clover.xml --coverage-xml=tests/reports/logs/coverage-xml --log-junit=tests/reports/logs/junit.xml"
64 |         ],
65 |         "mutate-test": [
66 |             "echo 'Run mutation testing'",
67 |             "./vendor/infection/infection/bin/infection --threads=4 --no-progress --min-covered-msi=76.5 --coverage=tests/reports/logs/"
68 |         ],
69 |         "build-docs": [
70 |             "echo 'Build documentation'",
71 |             "php docs/DocBuilder/build.php"
72 |         ],
73 |         "check-docs-actual": [
74 |             "echo 'Check Documentation is actually'",
75 |             "php docs/DocBuilder/is_actual.php"
76 |         ],
77 |         "build-changelog": [
78 |             "echo 'Build CHANGELOG.MD'",
79 |             "php docs/DocBuilder/build_changelog.php"
80 |         ]
81 |     }
82 | }
83 | 


--------------------------------------------------------------------------------
/src/Attributes/ConfigKey.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Attributes;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Config\ConfigAttribute;
 6 | 
 7 | #[\Attribute]
 8 | class ConfigKey implements ConfigAttribute
 9 | {
10 |     public $key;
11 | 
12 |     public function __construct(string $key)
13 |     {
14 |         $this->key = $key;
15 |     }
16 | 
17 |     public function __toString(): string
18 |     {
19 |         return $this->key;
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Attributes/ConfigSectionName.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Attributes;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Config\ConfigAttribute;
 6 | 
 7 | #[\Attribute]
 8 | class ConfigSectionName implements ConfigAttribute
 9 | {
10 |     public function __toString(): string
11 |     {
12 |         return static::class;
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Attributes/ConfigValue.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Attributes;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Config\ConfigAttribute;
 6 | 
 7 | #[\Attribute]
 8 | class ConfigValue implements ConfigAttribute
 9 | {
10 |     public function __toString(): string
11 |     {
12 |         return static::class;
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Backup/AbstractBackup.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Backup;
 4 | 
 5 | use ArtARTs36\FileSystem\Contracts\FileSystem;
 6 | use ArtARTs36\GitHandler\Contracts\Handler\GitHandler;
 7 | use ArtARTs36\GitHandler\Contracts\Backup\GitBackup;
 8 | use ArtARTs36\GitHandler\Contracts\Backup\BackupElementDict;
 9 | 
10 | abstract class AbstractBackup implements GitBackup
11 | {
12 |     /**
13 |      * Execute dump backup
14 |      */
15 |     abstract protected function doDump(string $path, BackupElementDict $dict): void;
16 | 
17 |     /**
18 |      * Execute restore backup
19 |      */
20 |     abstract protected function doRestore(string $path, BackupElementDict $dict): void;
21 | 
22 |     protected $git;
23 | 
24 |     protected $files;
25 | 
26 |     protected $building;
27 | 
28 |     public function __construct(GitHandler $git, FileSystem $files, BackupElementDict $building)
29 |     {
30 |         $this->git = $git;
31 |         $this->files = $files;
32 |         $this->building = $building;
33 |     }
34 | 
35 |     public function dump(string $path): void
36 |     {
37 |         $this->doDump($path, $this->building);
38 |     }
39 | 
40 |     public function dumpOnly(string $path, array $elements): void
41 |     {
42 |         $this->doDump($path, $this->building->only($elements));
43 |     }
44 | 
45 |     public function restore(string $path): void
46 |     {
47 |         $this->doRestore($path, $this->building);
48 |     }
49 | 
50 |     public function restoreOnly(string $path, array $elements): void
51 |     {
52 |         $this->doRestore($path, $this->building->only($elements));
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/src/Backup/ArrayBackupElementDict.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Backup;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Backup\BackupElementDict;
 6 | use ArtARTs36\GitHandler\Contracts\Backup\BackupElement;
 7 | 
 8 | class ArrayBackupElementDict implements BackupElementDict
 9 | {
10 |     protected $elements = [];
11 | 
12 |     /**
13 |      * @param list<BackupElement> $elements
14 |      */
15 |     public function __construct(array $elements)
16 |     {
17 |         $this->elements = $elements;
18 |     }
19 | 
20 |     /**
21 |      * @return iterable<BackupElement>
22 |      */
23 |     public function getIterator(): iterable
24 |     {
25 |         return new \ArrayIterator($this->elements);
26 |     }
27 | 
28 |     public function get(array $classes): array
29 |     {
30 |         $elems = [];
31 | 
32 |         foreach ($this->elements as $element) {
33 |             if (in_array($element->identity(), $classes) || in_array(get_class($element), $classes)) {
34 |                 $elems[] = $element;
35 |             }
36 |         }
37 | 
38 |         return $elems;
39 |     }
40 | 
41 |     public function only(array $classes): self
42 |     {
43 |         $elements = $this->get($classes);
44 | 
45 |         if (count($elements) === 0) {
46 |             throw new \LogicException('Not found workflow elements');
47 |         }
48 | 
49 |         return new self($elements);
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/src/Backup/Backup.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Backup;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Backup\GitBackup;
 6 | use ArtARTs36\GitHandler\Contracts\Backup\BackupElementDict;
 7 | 
 8 | final class Backup extends AbstractBackup implements GitBackup
 9 | {
10 |     public function doRestore(string $path, BackupElementDict $dict): void
11 |     {
12 |         $dumpMap = unserialize($this->files->getFileContent($path));
13 | 
14 |         foreach ($dict->get(array_keys($dumpMap)) as $element) {
15 |             $element->restore($this->git, $dumpMap[get_class($element)]);
16 |         }
17 |     }
18 | 
19 |     protected function doDump(string $path, BackupElementDict $dict): void
20 |     {
21 |         $dumpMap = [];
22 | 
23 |         foreach ($dict as $element) {
24 |             $dumpMap[get_class($element)] = $element->dump($this->git);
25 |         }
26 | 
27 |         $this->files->createFile($path, serialize($dumpMap));
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Backup/Elements/AbstractBackupElement.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Backup\Elements;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Backup\BackupElement;
 6 | 
 7 | abstract class AbstractBackupElement implements BackupElement
 8 | {
 9 |     public const IDENTITY = '';
10 | 
11 |     /**
12 |      * @codeCoverageIgnore
13 |      */
14 |     public function identity(): string
15 |     {
16 |         return static::IDENTITY;
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Backup/Elements/ConfigBackupElement.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Backup\Elements;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Handler\GitHandler;
 6 | use ArtARTs36\GitHandler\Enum\ConfigSectionName;
 7 | use JetBrains\PhpStorm\ArrayShape;
 8 | 
 9 | final class ConfigBackupElement extends AbstractBackupElement
10 | {
11 |     public const IDENTITY = 'config';
12 | 
13 |     /**
14 |      * @return array<string, string>
15 |      */
16 |     #[ArrayShape(['content' => 'string'])]
17 |     public function dump(GitHandler $git): array
18 |     {
19 |         return [
20 |             'content' => $git->files()->getContent('.git/config'),
21 |         ];
22 |     }
23 | 
24 |     /**
25 |      * @param array<string, string> $data
26 |      */
27 |     public function restore(
28 |         GitHandler $git,
29 |         #[ArrayShape(['content' => 'string'])]
30 |         array $data
31 |     ): void {
32 |         $git->files()->createFile('.git/config', $data['content']);
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Backup/Elements/HookBackupElement.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Backup\Elements;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Handler\GitHandler;
 6 | use ArtARTs36\GitHandler\Contracts\Backup\BackupElement;
 7 | use ArtARTs36\GitHandler\Data\Hook;
 8 | use ArtARTs36\GitHandler\Enum\HookName;
 9 | 
10 | class HookBackupElement extends AbstractBackupElement implements BackupElement
11 | {
12 |     public const IDENTITY = 'hooks';
13 | 
14 |     /**
15 |      * @return array<string, Hook>
16 |      */
17 |     public function dump(GitHandler $git): array
18 |     {
19 |         return $git->hooks()->getAll();
20 |     }
21 | 
22 |     /**
23 |      * @param array<Hook> $data
24 |      */
25 |     public function restore(GitHandler $git, array $data): void
26 |     {
27 |         $hooks = $git->hooks();
28 | 
29 |         foreach ($data as $hook) {
30 |             $hooks->add(HookName::from($hook->name), $hook->script);
31 |         }
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/Backup/Elements/UntrackedFilesBackupElement.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Backup\Elements;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Handler\GitHandler;
 6 | use ArtARTs36\GitHandler\Contracts\Backup\BackupElement;
 7 | 
 8 | class UntrackedFilesBackupElement extends AbstractBackupElement implements BackupElement
 9 | {
10 |     public const IDENTITY = 'files.untracked';
11 | 
12 |     public function dump(GitHandler $git): array
13 |     {
14 |         $map = [];
15 |         $manager = $git->files();
16 | 
17 |         foreach ($git->statuses()->getUntrackedFiles() as $file) {
18 |             $map[$file] = $manager->getContent($file);
19 |         }
20 | 
21 |         return $map;
22 |     }
23 | 
24 |     /**
25 |      * @param array<string, string> $data
26 |      */
27 |     public function restore(GitHandler $git, array $data): void
28 |     {
29 |         $manager = $git->files();
30 | 
31 |         foreach ($data as $path => $content) {
32 |             $manager->createFile($path, $content);
33 |         }
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/Command/Commands/AbstractCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Command\Commands;
 4 | 
 5 | use ArtARTs36\GitHandler\Command\GitCommandBuilder;
 6 | use ArtARTs36\ShellCommand\Interfaces\ShellCommandExecutor;
 7 | 
 8 | abstract class AbstractCommand
 9 | {
10 |     protected $builder;
11 | 
12 |     protected $executor;
13 | 
14 |     /**
15 |      * @codeCoverageIgnore
16 |      */
17 |     public function __construct(GitCommandBuilder $builder, ShellCommandExecutor $executor)
18 |     {
19 |         $this->builder = $builder;
20 |         $this->executor = $executor;
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Command/Commands/ArchiveCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Command\Commands;
 4 | 
 5 | use ArtARTs36\GitHandler\Command\GitCommandBuilder;
 6 | use ArtARTs36\GitHandler\Contracts\Commands\GitArchiveCommand;
 7 | use ArtARTs36\FileSystem\Contracts\FileSystem;
 8 | use ArtARTs36\GitHandler\Data\GitContext;
 9 | use ArtARTs36\GitHandler\Enum\ArchiveFormat;
10 | use ArtARTs36\GitHandler\Exceptions\PathIsDirectoryNotCould;
11 | use ArtARTs36\ShellCommand\Exceptions\UserExceptionTrigger;
12 | use ArtARTs36\ShellCommand\Interfaces\ShellCommandExecutor;
13 | use ArtARTs36\ShellCommand\Result\CommandResult;
14 | 
15 | class ArchiveCommand extends AbstractCommand implements GitArchiveCommand
16 | {
17 |     protected $files;
18 | 
19 |     protected $context;
20 | 
21 |     /**
22 |      * @codeCoverageIgnore
23 |      */
24 |     public function __construct(
25 |         FileSystem $files,
26 |         GitContext $context,
27 |         GitCommandBuilder $builder,
28 |         ShellCommandExecutor $executor
29 |     ) {
30 |         $this->files = $files;
31 |         $this->context = $context;
32 | 
33 |         parent::__construct($builder, $executor);
34 |     }
35 | 
36 |     public function create(string $path): void
37 |     {
38 |         $this
39 |             ->builder
40 |             ->make()
41 |             ->addArgument('archive')
42 |             ->addOptionWithValue('format', ArchiveFormat::from(pathinfo($path, PATHINFO_EXTENSION))->value)
43 |             ->addOptionWithValue('output', $path)
44 |             ->addArgument('HEAD')
45 |             ->setExceptionTrigger(UserExceptionTrigger::fromCallbacks([
46 |                 function (CommandResult $result) use ($path) {
47 |                     if ($result
48 |                         ->getError()
49 |                         ->contains("fatal: could not create archive file '$path': Is a directory")) {
50 |                         throw new PathIsDirectoryNotCould();
51 |                     }
52 |                 }
53 |             ]))
54 |             ->executeOrFail($this->executor);
55 |     }
56 | 
57 |     public function packRefs(string $path): void
58 |     {
59 |         $this
60 |             ->builder
61 |             ->toDir($this->files->downPath($this->context->getRefsDir()), 'tar')
62 |             ->addCutOption('cf')
63 |             ->addArgument($path)
64 |             ->addArgument(pathinfo($this->context->getRefsDir(), PATHINFO_BASENAME))
65 |             ->executeOrFail($this->executor);
66 |     }
67 | 
68 |     public function unpackRefs(string $path): void
69 |     {
70 |         $this
71 |             ->builder
72 |             ->toDir($this->context->getGitDir(), 'tar')
73 |             ->addCutOption('xf')
74 |             ->addArgument($path)
75 |             ->executeOrFail($this->executor);
76 |     }
77 | }
78 | 


--------------------------------------------------------------------------------
/src/Command/Commands/AttributeCommand.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace ArtARTs36\GitHandler\Command\Commands;
  4 | 
  5 | use ArtARTs36\FileSystem\Contracts\FileSystem;
  6 | use ArtARTs36\GitHandler\Files\AttributesFile;
  7 | use ArtARTs36\GitHandler\Concerns\SwitchFolder;
  8 | use ArtARTs36\GitHandler\Contracts\Commands\GitAttributeCommand;
  9 | use ArtARTs36\GitHandler\Data\GitAttributes;
 10 | use ArtARTs36\GitHandler\Data\GitContext;
 11 | 
 12 | class AttributeCommand implements GitAttributeCommand
 13 | {
 14 |     use SwitchFolder;
 15 | 
 16 |     protected $files;
 17 | 
 18 |     protected $context;
 19 | 
 20 |     protected $file;
 21 | 
 22 |     /**
 23 |      * @codeCoverageIgnore
 24 |      */
 25 |     public function __construct(FileSystem $files, GitContext $context)
 26 |     {
 27 |         $this->files = $files;
 28 |         $this->context = $context;
 29 |         $this->file = new AttributesFile();
 30 |         $this->seeToRoot();
 31 |     }
 32 | 
 33 |     public function add(string $pattern, array $attributes): void
 34 |     {
 35 |         $map = $this->isFileExists() ? $this->getMap() : [];
 36 | 
 37 |         $map[$pattern] = array_unique(array_merge($map[$pattern] ?? [], $attributes));
 38 | 
 39 |         $this->saveFromMap($map);
 40 |     }
 41 | 
 42 |     public function find(string $pattern): ?GitAttributes
 43 |     {
 44 |         $map = $this->getMap();
 45 | 
 46 |         if (! array_key_exists($pattern, $map)) {
 47 |             return null;
 48 |         }
 49 | 
 50 |         return new GitAttributes($pattern, $map[$pattern]);
 51 |     }
 52 | 
 53 |     public function delete(string $pattern): bool
 54 |     {
 55 |         $map = $this->getMap();
 56 | 
 57 |         if (! array_key_exists($pattern, $map)) {
 58 |             return false;
 59 |         }
 60 | 
 61 |         unset($map[$pattern]);
 62 | 
 63 |         return $this->saveFromMap($map);
 64 |     }
 65 | 
 66 |     /**
 67 |      * @return array<string, array<\ArtARTs36\Str\Str>>
 68 |      * @throws \ArtARTs36\FileSystem\Contracts\FileNotFound
 69 |      */
 70 |     public function getMap(): array
 71 |     {
 72 |         $content = $this->files->getFileContent($this->getPath());
 73 | 
 74 |         return $this->file->buildMap($content);
 75 |     }
 76 | 
 77 |     /**
 78 |      * @codeCoverageIgnore
 79 |      */
 80 |     public function getPath(): string
 81 |     {
 82 |         return $this->folder . DIRECTORY_SEPARATOR . '.gitattributes';
 83 |     }
 84 | 
 85 |     /**
 86 |      * @param array<string, array<string>> $map
 87 |      */
 88 |     protected function saveFromMap(array $map): bool
 89 |     {
 90 |         return $this->files->createFile(
 91 |             $this->getPath(),
 92 |             count($map) === 0 ? '' : $this->file->buildContent($map)
 93 |         );
 94 |     }
 95 | 
 96 |     final protected function isFileExists(): bool
 97 |     {
 98 |         return $this->files->exists($this->getPath());
 99 |     }
100 | }
101 | 


--------------------------------------------------------------------------------
/src/Command/Commands/BranchCommand.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace ArtARTs36\GitHandler\Command\Commands;
  4 | 
  5 | use ArtARTs36\GitHandler\Contracts\Commands\GitBranchCommand;
  6 | use ArtARTs36\GitHandler\Exceptions\AlreadySwitched;
  7 | use ArtARTs36\GitHandler\Exceptions\BranchAlreadyExists;
  8 | use ArtARTs36\GitHandler\Exceptions\BranchNotFound;
  9 | use ArtARTs36\GitHandler\Exceptions\ObjectNameNotValid;
 10 | use ArtARTs36\GitHandler\Exceptions\ReferenceInvalid;
 11 | use ArtARTs36\ShellCommand\Exceptions\UserExceptionTrigger;
 12 | use ArtARTs36\ShellCommand\Interfaces\ShellCommandInterface;
 13 | use ArtARTs36\ShellCommand\Result\CommandResult;
 14 | use ArtARTs36\Str\Str;
 15 | 
 16 | class BranchCommand extends AbstractCommand implements GitBranchCommand
 17 | {
 18 |     public function delete(string $branch): bool
 19 |     {
 20 |         return $this
 21 |             ->builder
 22 |             ->make()
 23 |             ->addArgument('branch')
 24 |             ->addCutOption('d')
 25 |             ->addArgument($branch)
 26 |             ->setExceptionTrigger(UserExceptionTrigger::fromCallbacks([
 27 |                 function (CommandResult $result) use ($branch) {
 28 |                     if ($result->getError()->contains("error: branch '$branch' not found")) {
 29 |                         throw new BranchNotFound($branch);
 30 |                     }
 31 |                 }
 32 |             ]))
 33 |             ->executeOrFail($this->executor)
 34 |             ->getResult()
 35 |             ->contains("Deleted branch $branch");
 36 |     }
 37 | 
 38 |     public function create(string $branch): void
 39 |     {
 40 |         $this
 41 |             ->builder
 42 |             ->make()
 43 |             ->addArgument('branch')
 44 |             ->addArgument($branch)
 45 |             ->setExceptionTrigger(UserExceptionTrigger::fromCallbacks([
 46 |                 function (CommandResult $result) use ($branch) {
 47 |                     $already = $result->getError()->match("/fatal: A branch named '$branch' already exists/i");
 48 |                     if ($already->isNotEmpty()) {
 49 |                         throw new BranchAlreadyExists($already);
 50 |                     }
 51 | 
 52 |                     $objectName = $result->getError()->match('/fatal: Not a valid object name: \'(.*)\'/i');
 53 |                     if ($objectName->isNotEmpty()) {
 54 |                         throw new ObjectNameNotValid($objectName);
 55 |                     }
 56 |                 }
 57 |             ]))
 58 |             ->executeOrFail($this->executor);
 59 |     }
 60 | 
 61 |     public function getAll(): array
 62 |     {
 63 |         $result = $this
 64 |             ->builder
 65 |             ->make()
 66 |             ->addArgument('branch')
 67 |             ->addCutOption('a')
 68 |             ->executeOrFail($this->executor);
 69 | 
 70 |         return $result->getResult()->trim()->replace([
 71 |             '* master' => 'master',
 72 |         ])->lines()->trim()->toStrings();
 73 |     }
 74 | 
 75 |     public function current(): Str
 76 |     {
 77 |         return $this
 78 |             ->builder
 79 |             ->make()
 80 |             ->addArgument('branch')
 81 |             ->addOption('show-current')
 82 |             ->executeOrFail($this->executor)
 83 |             ->getResult()
 84 |             ->trim();
 85 |     }
 86 | 
 87 |     public function switch(string $branch): bool
 88 |     {
 89 |         return $this
 90 |             ->builder
 91 |             ->make()
 92 |             ->addArgument('switch')
 93 |             ->addArgument($branch)
 94 |             ->setExceptionTrigger(UserExceptionTrigger::fromCallbacks([
 95 |                 function (CommandResult $result) use ($branch) {
 96 |                     if ($result->getError()->contains('fatal: invalid reference: '. $branch)) {
 97 |                         throw new ReferenceInvalid($branch);
 98 |                     }
 99 | 
100 |                     if ($result->getError()->contains("Already on '$branch'")) {
101 |                         throw new AlreadySwitched($branch);
102 |                     }
103 |                 }
104 |             ]))
105 |             ->executeOrFail($this->executor)
106 |             ->getResult()
107 |             ->contains("Switched to branch '$branch'");
108 |     }
109 | }
110 | 


--------------------------------------------------------------------------------
/src/Command/Commands/CommitCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Command\Commands;
 4 | 
 5 | use ArtARTs36\GitHandler\Command\GitCommandBuilder;
 6 | use ArtARTs36\GitHandler\Contracts\Commands\GitIndexCommand;
 7 | use ArtARTs36\GitHandler\Contracts\Commands\GitCommitCommand;
 8 | use ArtARTs36\GitHandler\Contracts\Commands\GitStatusCommand;
 9 | use ArtARTs36\GitHandler\Data\Author;
10 | use ArtARTs36\GitHandler\Exceptions\NothingToCommit;
11 | use ArtARTs36\ShellCommand\Exceptions\UserExceptionTrigger;
12 | use ArtARTs36\ShellCommand\Interfaces\ShellCommandExecutor;
13 | use ArtARTs36\ShellCommand\Interfaces\ShellCommandInterface;
14 | use ArtARTs36\ShellCommand\Result\CommandResult;
15 | 
16 | class CommitCommand extends AbstractCommand implements GitCommitCommand
17 | {
18 |     protected $adds;
19 | 
20 |     protected $statuses;
21 | 
22 |     /**
23 |      * @codeCoverageIgnore
24 |      */
25 |     public function __construct(
26 |         GitIndexCommand $adds,
27 |         GitStatusCommand $statuses,
28 |         GitCommandBuilder $builder,
29 |         ShellCommandExecutor $executor
30 |     ) {
31 |         $this->adds = $adds;
32 |         $this->statuses = $statuses;
33 | 
34 |         parent::__construct($builder, $executor);
35 |     }
36 | 
37 |     public function commit(string $message, bool $amend = false, ?Author $author = null): bool
38 |     {
39 |         return $this
40 |             ->builder
41 |             ->make()
42 |             ->addArgument('commit')
43 |             ->when($author !== null, function (ShellCommandInterface $command) use ($author) {
44 |                 $command->addOptionWithValue('author', $author, true);
45 |             })
46 |             ->addCutOption('m')
47 |             ->addArgument($message, true)
48 |             ->when($amend === true, function (ShellCommandInterface $command) {
49 |                 $command->addOption('amend');
50 |             })
51 |             ->setExceptionTrigger(UserExceptionTrigger::fromCallbacks([
52 |                 function (CommandResult $result) {
53 |                     if ($result->getError()->contains('nothing to commit')) {
54 |                         throw new NothingToCommit();
55 |                     }
56 |                 }
57 |             ]))
58 |             ->executeOrFail($this->executor)
59 |             ->getResult()
60 |             ->contains('file changed');
61 |     }
62 | 
63 |     /**
64 |      * equals: git add (untracked files) && git commit -m $message
65 |      * @codeCoverageIgnore
66 |      */
67 |     public function autoCommit(string $message, bool $amend = false): bool
68 |     {
69 |         $this->adds->add($this->statuses->getModifiedFiles());
70 | 
71 |         return $this->commit($message, $amend);
72 |     }
73 | }
74 | 


--------------------------------------------------------------------------------
/src/Command/Commands/ConfigCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Command\Commands;
 4 | 
 5 | use ArtARTs36\GitHandler\Command\GitCommandBuilder;
 6 | use ArtARTs36\GitHandler\Contracts\Commands\GitConfigCommand;
 7 | use ArtARTs36\GitHandler\Config\Subjects\SubjectsCollection;
 8 | use ArtARTs36\GitHandler\Contracts\Config\ConfigResultParser;
 9 | use ArtARTs36\GitHandler\Contracts\Config\ConfigSubject;
10 | use ArtARTs36\GitHandler\Exceptions\ConfigSectionNotFound;
11 | use ArtARTs36\GitHandler\Exceptions\ConfigVariableNotFound;
12 | use ArtARTs36\ShellCommand\Exceptions\UserExceptionTrigger;
13 | use ArtARTs36\ShellCommand\Interfaces\ShellCommandExecutor;
14 | use ArtARTs36\ShellCommand\Interfaces\ShellCommandInterface;
15 | use ArtARTs36\ShellCommand\Result\CommandResult;
16 | use ArtARTs36\Str\Str;
17 | 
18 | class ConfigCommand extends AbstractCommand implements GitConfigCommand
19 | {
20 |     protected $reader;
21 | 
22 |     public function __construct(ConfigResultParser $reader, GitCommandBuilder $builder, ShellCommandExecutor $executor)
23 |     {
24 |         $this->reader = $reader;
25 | 
26 |         parent::__construct($builder, $executor);
27 |     }
28 | 
29 |     public function getAll(): SubjectsCollection
30 |     {
31 |         return $this->reader->parse($this->executeConfigList());
32 |     }
33 | 
34 |     public function getSubject(string $prefix): ConfigSubject
35 |     {
36 |         return $this->reader->parseByPrefix($this->executeConfigList(), $prefix);
37 |     }
38 | 
39 |     public function set(string $scope, string $field, string $value, bool $replaceAll = false): bool
40 |     {
41 |         return $this
42 |             ->builder
43 |             ->make()
44 |             ->addArgument('config')
45 |             ->addArgument("$scope.$field")
46 |             ->addArgument($value, true)
47 |             ->when($replaceAll === true, function (ShellCommandInterface $command) {
48 |                 $command->addOption('replace-all');
49 |             })
50 |             ->executeOrFail($this->executor)
51 |             ->isOk();
52 |     }
53 | 
54 |     protected function executeConfigList(): Str
55 |     {
56 |         return $this
57 |             ->builder
58 |             ->make()
59 |             ->addArgument('config')
60 |             ->addOption('list')
61 |             ->executeOrFail($this->executor)
62 |             ->getResult();
63 |     }
64 | 
65 |     public function unset(string $scope, string $field): void
66 |     {
67 |         $this
68 |             ->builder
69 |             ->make()
70 |             ->addArgument('config')
71 |             ->addOption('unset')
72 |             ->addArgument("$scope.$field")
73 |             ->setExceptionTrigger(UserExceptionTrigger::fromCallbacks([
74 |                 function (CommandResult $result) {
75 |                     $error = $result->getError()->trim();
76 | 
77 |                     $section = $error->match('#key does not contain a section: (.*)#');
78 | 
79 |                     if ($section->isNotEmpty()) {
80 |                         throw new ConfigSectionNotFound($section);
81 |                     }
82 | 
83 |                     $variable = $error->match('#key does not contain variable name: (.*)#');
84 | 
85 |                     if ($variable->isNotEmpty()) {
86 |                         throw new ConfigVariableNotFound($variable);
87 |                     }
88 |                 },
89 |             ]))
90 |             ->executeOrFail($this->executor);
91 |     }
92 | }
93 | 


--------------------------------------------------------------------------------
/src/Command/Commands/FetchCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Command\Commands;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Commands\GitFetchCommand;
 6 | use ArtARTs36\ShellCommand\Interfaces\ShellCommandInterface;
 7 | 
 8 | class FetchCommand extends AbstractCommand implements GitFetchCommand
 9 | {
10 |     public function fetch(): void
11 |     {
12 |         $this->buildFetchCommand()->executeOrFail($this->executor);
13 |     }
14 | 
15 |     public function fetchAll(): void
16 |     {
17 |         $this->buildFetchCommand()->addOption('all')->executeOrFail($this->executor);
18 |     }
19 | 
20 |     protected function buildFetchCommand(): ShellCommandInterface
21 |     {
22 |         return $this->builder->make()->addArgument('fetch');
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Command/Commands/FileCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Command\Commands;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Commands\GitFileCommand;
 6 | use ArtARTs36\FileSystem\Contracts\FileSystem;
 7 | use ArtARTs36\GitHandler\Data\GitContext;
 8 | 
 9 | class FileCommand implements GitFileCommand
10 | {
11 |     protected $files;
12 | 
13 |     protected $context;
14 | 
15 |     /**
16 |      * @codeCoverageIgnore
17 |      */
18 |     public function __construct(FileSystem $files, GitContext $context)
19 |     {
20 |         $this->files = $files;
21 |         $this->context = $context;
22 |     }
23 | 
24 |     public function createFile(string $name, string $content, ?string $folder = null): string
25 |     {
26 |         $path = $this->context->getRootDir();
27 | 
28 |         if (! empty($folder)) {
29 |             $path .= DIRECTORY_SEPARATOR . $folder;
30 | 
31 |             $this->createFolder($folder);
32 |         }
33 | 
34 |         $path .= DIRECTORY_SEPARATOR . $name;
35 | 
36 |         $this->files->createFile($path, $content);
37 | 
38 |         return $path;
39 |     }
40 | 
41 |     public function createFolder(string $name): GitFileCommand
42 |     {
43 |         $this->files->createDir($this->createPathTo($name));
44 | 
45 |         return $this;
46 |     }
47 | 
48 |     public function getContent(string $name): string
49 |     {
50 |         return $this->files->getFileContent($this->createPathTo($name));
51 |     }
52 | 
53 |     public function createPathTo(string $name): string
54 |     {
55 |         return $this->context->getRootDir() . DIRECTORY_SEPARATOR . $name;
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/src/Command/Commands/GarbageCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Command\Commands;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Commands\GitGarbageCommand;
 6 | use ArtARTs36\GitHandler\Enum\GarbageCollectMode;
 7 | use ArtARTs36\ShellCommand\Interfaces\ShellCommandInterface;
 8 | use ArtARTs36\ShellCommand\Result\CommandResult;
 9 | 
10 | class GarbageCommand extends AbstractCommand implements GitGarbageCommand
11 | {
12 |     public function collect(GarbageCollectMode $mode): bool
13 |     {
14 |         return $this->analyzeCollectAnswer($this->buildPureCommand($mode)->executeOrFail($this->executor));
15 |     }
16 | 
17 |     public function collectOnDate(GarbageCollectMode $mode, \DateTimeInterface $date): bool
18 |     {
19 |         return $this->analyzeCollectAnswer($this
20 |             ->buildPureCommand($mode)
21 |             ->addOptionWithValue('prune', $date->format('Y-m-d'))
22 |             ->executeOrFail($this->executor));
23 |     }
24 | 
25 |     protected function analyzeCollectAnswer(CommandResult $result): bool
26 |     {
27 |         if ($result->getResult()->contains('Nothing new to pack.')) {
28 |             return false;
29 |         }
30 | 
31 |         return true;
32 |     }
33 | 
34 |     protected function buildPureCommand(GarbageCollectMode $mode): ShellCommandInterface
35 |     {
36 |         return $this->builder->make()->addArgument('gc')->addOption($mode->value);
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Command/Commands/GrepCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Command\Commands;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Commands\GitGrepCommand;
 6 | use ArtARTs36\GitHandler\Data\FileMatch;
 7 | 
 8 | class GrepCommand extends AbstractCommand implements GitGrepCommand
 9 | {
10 |     private $grepRegex = '/(?<file>.*)\:(?<line>\d+)\:(?<content>.*)\n?/i';
11 | 
12 |     public function grep(string $term): array
13 |     {
14 |         $result = $this->builder->make()
15 |                 ->addOption('no-pager')
16 |                 ->addArgument('grep')
17 |                 ->addCutOption('n')
18 |                 ->addArgument($term, true)
19 |                 ->executeOrFail($this->executor)
20 |                 ->getResult();
21 | 
22 |         if ($result->isEmpty()) {
23 |             return [];
24 |         }
25 | 
26 |         $matches = [];
27 | 
28 |         foreach ($result->globalMatch($this->grepRegex) as $match) {
29 |             $matches[] = FileMatch::fromArray($match);
30 |         }
31 | 
32 |         return $matches;
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Command/Commands/HelpCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Command\Commands;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Commands\GitHelpCommand;
 6 | 
 7 | class HelpCommand extends AbstractCommand implements GitHelpCommand
 8 | {
 9 |     public function get(): string
10 |     {
11 |         return $this->builder->make()->addOption('help')->executeOrFail($this->executor);
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Command/Commands/HookCommand.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace ArtARTs36\GitHandler\Command\Commands;
  4 | 
  5 | use ArtARTs36\GitHandler\Contracts\Commands\GitHookCommand;
  6 | use ArtARTs36\FileSystem\Contracts\FileSystem;
  7 | use ArtARTs36\GitHandler\Data\Hook;
  8 | use ArtARTs36\GitHandler\Enum\HookName;
  9 | use ArtARTs36\GitHandler\Exceptions\HookNotExists;
 10 | use ArtARTs36\GitHandler\Data\GitContext;
 11 | use ArtARTs36\GitHandler\Support\Chmod;
 12 | use ArtARTs36\ShellCommand\Interfaces\ShellCommandExecutor;
 13 | 
 14 | class HookCommand implements GitHookCommand
 15 | {
 16 |     protected $fileSystem;
 17 | 
 18 |     protected $executor;
 19 | 
 20 |     protected $context;
 21 | 
 22 |     /**
 23 |      * @codeCoverageIgnore
 24 |      */
 25 |     public function __construct(
 26 |         FileSystem $fileSystem,
 27 |         ShellCommandExecutor $executor,
 28 |         GitContext $context
 29 |     ) {
 30 |         $this->fileSystem = $fileSystem;
 31 |         $this->executor = $executor;
 32 |         $this->context = $context;
 33 |     }
 34 | 
 35 |     /**
 36 |      * @see HookName for $name
 37 |      */
 38 |     public function add(HookName $name, string $script): bool
 39 |     {
 40 |         $path = $this->doAdd($name, $script);
 41 | 
 42 |         Chmod::executable($path)->executeOrFail($this->executor);
 43 | 
 44 |         return $this->has($name);
 45 |     }
 46 | 
 47 |     public function get(HookName $name): Hook
 48 |     {
 49 |         if (! $this->has($name)) {
 50 |             throw new HookNotExists($name);
 51 |         }
 52 | 
 53 |         return $this->makeHookObject($name);
 54 |     }
 55 | 
 56 |     /**
 57 |      * @see HookName for $name
 58 |      */
 59 |     public function has(HookName $name): bool
 60 |     {
 61 |         return $this->fileSystem->exists($this->getHookPath($name));
 62 |     }
 63 | 
 64 |     public function delete(HookName $name): bool
 65 |     {
 66 |         if (! $this->has($name)) {
 67 |             throw new HookNotExists($name);
 68 |         }
 69 | 
 70 |         return $this->fileSystem->removeFile($this->getHookPath($name));
 71 |     }
 72 | 
 73 |     /**
 74 |      * @return array<string, Hook>
 75 |      */
 76 |     public function getAll(bool $onlyWorked = true): array
 77 |     {
 78 |         $map = [];
 79 |         $paths = $this->fileSystem->getFromDirectory($this->getHookPath());
 80 | 
 81 |         if ($onlyWorked) {
 82 |             $paths = array_filter($paths, function (string $path) {
 83 |                 return empty(pathinfo($path, PATHINFO_EXTENSION));
 84 |             });
 85 |         }
 86 | 
 87 |         $existsNames = array_map(function (string $path) {
 88 |             return pathinfo($path, PATHINFO_BASENAME);
 89 |         }, $paths);
 90 | 
 91 |         foreach ($existsNames as $name) {
 92 |             $map[$name] = $this->makeHookObject($name);
 93 |         }
 94 | 
 95 |         return $map;
 96 |     }
 97 | 
 98 |     /**
 99 |      * @codeCoverageIgnore
100 |      */
101 |     public function getHookPath(?string $name = null): string
102 |     {
103 |         return $this->context->getGitDir() . DIRECTORY_SEPARATOR . 'hooks'. DIRECTORY_SEPARATOR . $name;
104 |     }
105 | 
106 |     protected function makeHookObject(string $name): Hook
107 |     {
108 |         return new Hook(
109 |             $name,
110 |             $this->fileSystem->getFileContent($path = $this->getHookPath($name)),
111 |             $this->fileSystem->getLastUpdateDate($path)
112 |         );
113 |     }
114 | 
115 |     protected function doAdd(string $name, string $script): string
116 |     {
117 |         $this
118 |             ->fileSystem
119 |             ->createFile($path = $this->getHookPath($name), $script);
120 | 
121 |         return $path;
122 |     }
123 | }
124 | 


--------------------------------------------------------------------------------
/src/Command/Commands/IgnoreCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Command\Commands;
 4 | 
 5 | use ArtARTs36\GitHandler\Concerns\SwitchFolder;
 6 | use ArtARTs36\GitHandler\Contracts\Commands\GitIgnoreCommand;
 7 | use ArtARTs36\FileSystem\Contracts\FileSystem;
 8 | use ArtARTs36\GitHandler\Data\GitContext;
 9 | use ArtARTs36\Str\Str;
10 | 
11 | class IgnoreCommand implements GitIgnoreCommand
12 | {
13 |     use SwitchFolder;
14 | 
15 |     protected $context;
16 | 
17 |     protected $fileSystem;
18 | 
19 |     /**
20 |      * @codeCoverageIgnore
21 |      */
22 |     public function __construct(GitContext $context, FileSystem $fileSystem)
23 |     {
24 |         $this->context = $context;
25 |         $this->fileSystem = $fileSystem;
26 |         $this->seeToRoot();
27 |     }
28 | 
29 |     /**
30 |      * @return array<string>
31 |      */
32 |     public function files(): array
33 |     {
34 |         $path = $this->getPath();
35 | 
36 |         if (! $this->fileSystem->exists($path)) {
37 |             return [];
38 |         }
39 | 
40 |         return Str::make($this->fileSystem->getFileContent($this->getPath()))->lines()->trim()->toStrings();
41 |     }
42 | 
43 |     public function add(string $path): bool
44 |     {
45 |         $gitIgnore = $this->getPath();
46 | 
47 |         $content = $this->fileSystem->exists($gitIgnore) ? $this->fileSystem->getFileContent($gitIgnore) : '';
48 |         $content = new Str($content);
49 | 
50 |         if (! $content->isEmpty()) {
51 |             $content = $content->append("\n");
52 |         }
53 | 
54 |         return $this->fileSystem->createFile($gitIgnore, $content->append($path));
55 |     }
56 | 
57 |     public function delete(string $path): bool
58 |     {
59 |         if (! $this->fileSystem->exists($gitignore = $this->getPath())) {
60 |             return false;
61 |         }
62 | 
63 |         $content = Str::make($this->fileSystem->getFileContent($gitignore))->lines();
64 |         $excepts = [];
65 | 
66 |         foreach ($content as $index => $line) {
67 |             if ($line->trim()->equals($path)) {
68 |                 $excepts[] = $index;
69 |             }
70 |         }
71 | 
72 |         return $this->fileSystem->createFile($gitignore, $content->exceptKeys($excepts)->implodeAsLines());
73 |     }
74 | 
75 |     public function has(string $path): bool
76 |     {
77 |         if (! $this->isFileExists()) {
78 |             return false;
79 |         }
80 | 
81 |         return (new Str($this->fileSystem->getFileContent($this->getPath())))
82 |             ->hasLine($path);
83 |     }
84 | 
85 |     /**
86 |      * @codeCoverageIgnore
87 |      */
88 |     public function getPath(): string
89 |     {
90 |         return $this->folder . DIRECTORY_SEPARATOR . '.gitignore';
91 |     }
92 | 
93 |     final protected function isFileExists(): bool
94 |     {
95 |         return $this->fileSystem->exists($this->getPath());
96 |     }
97 | }
98 | 


--------------------------------------------------------------------------------
/src/Command/Commands/LogCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Command\Commands;
 4 | 
 5 | use ArtARTs36\GitHandler\Command\GitCommandBuilder;
 6 | use ArtARTs36\GitHandler\Contracts\Commands\GitLogCommand;
 7 | use ArtARTs36\GitHandler\Contracts\LogParser;
 8 | use ArtARTs36\GitHandler\Data\LogCollection;
 9 | use ArtARTs36\GitHandler\Enum\FormatPlaceholder;
10 | use ArtARTs36\GitHandler\Exceptions\BranchDoesNotHaveCommits;
11 | use ArtARTs36\GitHandler\Support\LogBuilder;
12 | use ArtARTs36\ShellCommand\Exceptions\UserExceptionTrigger;
13 | use ArtARTs36\ShellCommand\Interfaces\ShellCommandExecutor;
14 | use ArtARTs36\ShellCommand\Interfaces\ShellCommandInterface;
15 | use ArtARTs36\ShellCommand\Result\CommandResult;
16 | 
17 | class LogCommand extends AbstractCommand implements GitLogCommand
18 | {
19 |     protected $parser;
20 | 
21 |     public function __construct(LogParser $parser, GitCommandBuilder $builder, ShellCommandExecutor $executor)
22 |     {
23 |         $this->parser = $parser;
24 | 
25 |         parent::__construct($builder, $executor);
26 |     }
27 | 
28 |     public function getAll(): ?LogCollection
29 |     {
30 |         return $this->executeAndParseLogCommand($this->buildLogCommand());
31 |     }
32 | 
33 |     public function get(callable $callback): ?LogCollection
34 |     {
35 |         $callback($builder = new LogBuilder());
36 | 
37 |         return $this->executeAndParseLogCommand($builder->build($this->buildLogCommand()));
38 |     }
39 | 
40 |     public function count(callable $callback): int
41 |     {
42 |         $callback($builder = new LogBuilder());
43 | 
44 |         return $builder
45 |             ->build($this->buildLogCommand())
46 |             ->addPipe()
47 |             ->addArgument('wc')
48 |             ->addCutOption('l')
49 |             ->executeOrFail($this->executor)
50 |             ->getResult()
51 |             ->toInteger();
52 |     }
53 | 
54 |     protected function executeAndParseLogCommand(ShellCommandInterface $command): ?LogCollection
55 |     {
56 |         return $this->parser->parse($command->executeOrFail($this->executor)->getResult());
57 |     }
58 | 
59 |     protected function buildLogCommand(): ShellCommandInterface
60 |     {
61 |         return $this->builder->make()
62 |             ->addArgument('log')
63 |             ->addOption('oneline')
64 |             ->addOption('decorate')
65 |             ->addOption('graph')
66 |             ->addOptionWithValue('pretty', "format:'|log-entry|%H|%ad|%an|%ae|%Creset%s|'")
67 |             ->addOptionWithValue('date', 'iso')
68 |             ->setExceptionTrigger(UserExceptionTrigger::fromCallbacks([
69 |                 function (CommandResult $result) {
70 |                     $branch = $result
71 |                         ->getError()
72 |                         ->match("/fatal: your current branch '(.*)' does not have any commits yet/i");
73 | 
74 |                     if ($branch->isNotEmpty()) {
75 |                         throw new BranchDoesNotHaveCommits($branch);
76 |                     }
77 |                 }
78 |             ]));
79 |     }
80 | }
81 | 


--------------------------------------------------------------------------------
/src/Command/Commands/MergeCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Command\Commands;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Commands\GitMergeCommand;
 6 | use ArtARTs36\GitHandler\Exceptions\MergeHeadMissing;
 7 | use ArtARTs36\GitHandler\Exceptions\NotSomethingWeCanMerge;
 8 | use ArtARTs36\ShellCommand\Exceptions\UserExceptionTrigger;
 9 | use ArtARTs36\ShellCommand\Interfaces\ShellCommandInterface;
10 | use ArtARTs36\ShellCommand\Result\CommandResult;
11 | 
12 | class MergeCommand extends AbstractCommand implements GitMergeCommand
13 | {
14 |     public function merge(string $branch, ?string $message = null): void
15 |     {
16 |         $this->buildMergeCommand($branch, $message)->executeOrFail($this->executor);
17 |     }
18 | 
19 |     public function mergeSquash(string $branch, ?string $message = null): void
20 |     {
21 |         $this->buildMergeCommand($branch, $message)->addOption('squash')->executeOrFail($this->executor);
22 |     }
23 | 
24 |     public function abort(): void
25 |     {
26 |         $this
27 |             ->builder
28 |             ->make()
29 |             ->addArgument('merge')
30 |             ->addOption('abort')
31 |             ->setExceptionTrigger(UserExceptionTrigger::fromCallbacks([
32 |                 function (CommandResult $result) {
33 |                     if ($result
34 |                         ->getError()
35 |                         ->contains('fatal: There is no merge to abort (MERGE_HEAD missing)')) {
36 |                         throw new MergeHeadMissing();
37 |                     }
38 |                 }
39 |             ]))
40 |             ->executeOrFail($this->executor);
41 |     }
42 | 
43 |     protected function buildMergeCommand(string $branch, ?string $message = null): ShellCommandInterface
44 |     {
45 |         return $this
46 |             ->builder
47 |             ->make()
48 |             ->addArgument('merge')
49 |             ->addArgument($branch)
50 |             ->setExceptionTrigger(UserExceptionTrigger::fromCallbacks([
51 |                 function (CommandResult $result) {
52 |                     $failedBranch = $result->getError()->match('#merge: (.*) - not something we can merge#i');
53 |                     if ($failedBranch->isNotEmpty()) {
54 |                         throw new NotSomethingWeCanMerge($failedBranch);
55 |                     }
56 |                 }
57 |             ]))
58 |             ->when($message !== null, function (ShellCommandInterface $command) use ($message) {
59 |                 $command->addCutOption('m')->addArgument($message);
60 |             });
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/src/Command/Commands/PathCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Command\Commands;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Commands\GitPathCommand;
 6 | 
 7 | class PathCommand extends AbstractCommand implements GitPathCommand
 8 | {
 9 |     public function info(): string
10 |     {
11 |         return $this->getPathByOption('info-path');
12 |     }
13 | 
14 |     public function html(): string
15 |     {
16 |         return $this->getPathByOption('html-path');
17 |     }
18 | 
19 |     public function man(): string
20 |     {
21 |         return $this->getPathByOption('man-path');
22 |     }
23 | 
24 |     protected function getPathByOption(string $option): string
25 |     {
26 |         return $this->builder->make()->addOption($option)->executeOrFail($this->executor)->getResult()->trim();
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Command/Commands/PullCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Command\Commands;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Commands\GitPullCommand;
 6 | use ArtARTs36\ShellCommand\Interfaces\ShellCommandInterface;
 7 | 
 8 | class PullCommand extends AbstractCommand implements GitPullCommand
 9 | {
10 |     /** @var array<string> */
11 |     protected static $okResults = [
12 |         'Already up to date',
13 |         'Receiving objects',
14 |         'Resolving deltas',
15 |     ];
16 | 
17 |     public function pull(): bool
18 |     {
19 |         return $this
20 |             ->buildPurePullCommand()
21 |             ->executeOrFail($this->executor)
22 |             ->getResult()
23 |             ->containsAny(static::$okResults);
24 |     }
25 | 
26 |     public function pullBranch(string $branch): bool
27 |     {
28 |         return $this
29 |             ->buildPurePullCommand()
30 |             ->addArgument($branch)
31 |             ->executeOrFail($this->executor)
32 |             ->getResult()
33 |             ->containsAny(static::$okResults);
34 |     }
35 | 
36 |     protected function buildPurePullCommand(): ShellCommandInterface
37 |     {
38 |         return $this->builder->make()->addArgument('pull');
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Command/Commands/RemoteCommand.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace ArtARTs36\GitHandler\Command\Commands;
  4 | 
  5 | use ArtARTs36\GitHandler\Contracts\Commands\GitRemoteCommand;
  6 | use ArtARTs36\GitHandler\Data\Remotes;
  7 | use ArtARTs36\GitHandler\Exceptions\RemoteAlreadyExists;
  8 | use ArtARTs36\GitHandler\Exceptions\RemoteNotFound;
  9 | use ArtARTs36\GitHandler\Exceptions\RemoteRepositoryNotFound;
 10 | use ArtARTs36\GitHandler\Exceptions\UnexpectedException;
 11 | use ArtARTs36\ShellCommand\Exceptions\UserExceptionTrigger;
 12 | use ArtARTs36\ShellCommand\Result\CommandResult;
 13 | use ArtARTs36\Str\Str;
 14 | 
 15 | class RemoteCommand extends AbstractCommand implements GitRemoteCommand
 16 | {
 17 |     public function show(): Remotes
 18 |     {
 19 |         $sh = $this->executeShowRemote();
 20 | 
 21 |         return new Remotes(
 22 |             $sh->match('/origin\s+(.*)\(fetch\)/')->trim(),
 23 |             $sh->match('/origin\s+(.*)\(push\)/')->trim()
 24 |         );
 25 |     }
 26 | 
 27 |     public function hasAnyRemoteUrl(string $url): bool
 28 |     {
 29 |         $remotes = $this->show();
 30 | 
 31 |         return $remotes->fetch->equals($url) || $remotes->push->equals($url);
 32 |     }
 33 | 
 34 |     /**
 35 |      * @inheritDoc
 36 |      */
 37 |     public function remove(string $shortName): bool
 38 |     {
 39 |         return $this
 40 |             ->builder
 41 |             ->make()
 42 |             ->addArgument('remote')
 43 |             ->addArgument('remove')
 44 |             ->addArgument($shortName)
 45 |             ->setExceptionTrigger(UserExceptionTrigger::fromCallbacks([
 46 |                 function (CommandResult $result) {
 47 |                     $notFound = $result->getError()->match("/No such remote: '(.*)'/i");
 48 |                     if ($notFound->isNotEmpty()) {
 49 |                         throw new RemoteNotFound($notFound);
 50 |                     }
 51 |                 }
 52 |             ]))
 53 |             ->executeOrFail($this->executor)
 54 |             ->isOk();
 55 |     }
 56 | 
 57 |     /**
 58 |      * @inheritDoc
 59 |      */
 60 |     public function add(string $shortName, string $url): bool
 61 |     {
 62 |         return $this
 63 |             ->builder
 64 |             ->make()
 65 |             ->addArgument('remote')
 66 |             ->addArgument('add')
 67 |             ->addArgument($shortName)
 68 |             ->addArgument($url)
 69 |             ->setExceptionTrigger(UserExceptionTrigger::fromCallbacks([
 70 |                 function (CommandResult $result) {
 71 |                     $already = $result->getError()->match('/remote (.*) already exists/i');
 72 |                     if ($already->isNotEmpty()) {
 73 |                         throw new RemoteAlreadyExists($already);
 74 |                     }
 75 |                 }
 76 |             ]))
 77 |             ->executeOrFail($this->executor)
 78 |             ->isOk();
 79 |     }
 80 | 
 81 |     /**
 82 |      * equals: git remote -v
 83 |      */
 84 |     protected function executeShowRemote(): Str
 85 |     {
 86 |         return $this
 87 |             ->builder
 88 |             ->make()
 89 |             ->addArgument('remote')
 90 |             ->addOption('v')
 91 |             ->setExceptionTrigger(UserExceptionTrigger::fromCallbacks([
 92 |                 function (CommandResult $result) {
 93 |                     $failed = $result->getError()->match("/repository '(.*)' not found/i");
 94 |                     if ($failed->isNotEmpty()) {
 95 |                         throw new RemoteRepositoryNotFound($failed);
 96 |                     }
 97 |                 }
 98 |             ]))
 99 |             ->executeOrFail($this->executor)
100 |             ->getResult();
101 |     }
102 | }
103 | 


--------------------------------------------------------------------------------
/src/Command/Commands/SetupCommand.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace ArtARTs36\GitHandler\Command\Commands;
  4 | 
  5 | use ArtARTs36\GitHandler\Contracts\Commands\GitRemoteCommand;
  6 | use ArtARTs36\GitHandler\Command\GitCommandBuilder;
  7 | use ArtARTs36\GitHandler\Contracts\Commands\GitSetupCommand;
  8 | use ArtARTs36\FileSystem\Contracts\FileSystem;
  9 | use ArtARTs36\GitHandler\Exceptions\PathAlreadyExists;
 10 | use ArtARTs36\GitHandler\Exceptions\RemoteNotFilled;
 11 | use ArtARTs36\GitHandler\Exceptions\RepositoryAlreadyExists;
 12 | use ArtARTs36\GitHandler\Data\GitContext;
 13 | use ArtARTs36\ShellCommand\Exceptions\UserExceptionTrigger;
 14 | use ArtARTs36\ShellCommand\Interfaces\ShellCommandExecutor;
 15 | use ArtARTs36\ShellCommand\Result\CommandResult;
 16 | use ArtARTs36\ShellCommand\ShellCommand;
 17 | 
 18 | class SetupCommand extends AbstractCommand implements GitSetupCommand
 19 | {
 20 |     protected $remotes;
 21 | 
 22 |     protected $files;
 23 | 
 24 |     protected $context;
 25 | 
 26 |     /**
 27 |      * @codeCoverageIgnore
 28 |      */
 29 |     public function __construct(
 30 |         GitRemoteCommand $remotes,
 31 |         FileSystem $fileSystem,
 32 |         GitContext $context,
 33 |         GitCommandBuilder $builder,
 34 |         ShellCommandExecutor $executor
 35 |     ) {
 36 |         $this->remotes = $remotes;
 37 |         $this->files = $fileSystem;
 38 |         $this->context = $context;
 39 | 
 40 |         parent::__construct($builder, $executor);
 41 |     }
 42 | 
 43 |     public function init(): bool
 44 |     {
 45 |         if ($this->isInit()) {
 46 |             throw new RepositoryAlreadyExists($this->context->getGitDir());
 47 |         } elseif (! $this->files->exists($this->context->getGitDir())) {
 48 |             $this->files->createDir($this->context->getRootDir());
 49 |         }
 50 | 
 51 |         return $this
 52 |             ->builder
 53 |             ->make()
 54 |             ->addArgument('init')
 55 |             ->executeOrFail($this->executor)
 56 |             ->getResult()
 57 |             ->contains('Initialized empty Git repository');
 58 |     }
 59 | 
 60 |     public function isInit(): bool
 61 |     {
 62 |         return $this->files->exists($this->context->getGitDir());
 63 |     }
 64 | 
 65 |     public function clone(string $url, ?string $branch = null, ?string $folder = null): bool
 66 |     {
 67 |         return $this
 68 |             ->builder
 69 |             ->make($this->files->downPath($this->context->getRootDir()))
 70 |             ->addArgument('clone')
 71 |             ->when($branch !== null, function (ShellCommand $command) use ($branch) {
 72 |                 $command
 73 |                     ->addCutOption('b')
 74 |                     ->addArgument($branch);
 75 |             })
 76 |             ->addArgument($url)
 77 |             ->addArgument($folder = $folder ?? $this->context->getRootFolder())
 78 |             ->setExceptionTrigger(UserExceptionTrigger::fromCallbacks([
 79 |                 function (CommandResult $result) use ($folder) {
 80 |                     PathAlreadyExists::handleIfSo($folder, $result->getError());
 81 |                 }
 82 |             ]))
 83 |             ->executeOrFail($this->executor)
 84 |             ->getResult()
 85 |             ->contains("Cloning into '{$folder}'");
 86 |     }
 87 | 
 88 |     /**
 89 |      * Delete this repository
 90 |      */
 91 |     public function delete(): bool
 92 |     {
 93 |         return $this->files->removeDir($this->context->getRootDir());
 94 |     }
 95 | 
 96 |     /**
 97 |      * Delete local repository and fetch from origin
 98 |      */
 99 |     public function reinstall(?string $branch = null): void
100 |     {
101 |         $remote = $this->remotes->show()->fetch;
102 | 
103 |         if ($remote->isEmpty()) {
104 |             throw new RemoteNotFilled();
105 |         }
106 | 
107 |         $this->delete();
108 | 
109 |         $this->clone($remote, $branch);
110 |     }
111 | }
112 | 


--------------------------------------------------------------------------------
/src/Command/Commands/StashCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Command\Commands;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Commands\GitStashCommand;
 6 | use ArtARTs36\GitHandler\Data\Stash;
 7 | use ArtARTs36\GitHandler\Exceptions\StashDoesNotExists;
 8 | use ArtARTs36\GitHandler\Exceptions\UnexpectedException;
 9 | use ArtARTs36\GitHandler\Enum\FormatPlaceholder;
10 | use ArtARTs36\ShellCommand\Exceptions\UserExceptionTrigger;
11 | use ArtARTs36\ShellCommand\Result\CommandResult;
12 | use ArtARTs36\ShellCommand\ShellCommand;
13 | 
14 | class StashCommand extends AbstractCommand implements GitStashCommand
15 | {
16 |     public function stash(?string $message = null): bool
17 |     {
18 |         return $this
19 |             ->builder
20 |             ->make()
21 |             ->addArgument('stash')
22 |             ->when($message !== null, function (ShellCommand $command) use ($message) {
23 |                 $command
24 |                     ->addArgument('save')
25 |                     ->addArgument('"'. $message .'"');
26 |             })
27 |             ->executeOrFail($this->executor)
28 |             ->getResult()
29 |             ->containsAny([
30 |                 'Saved working directory and index',
31 |                 'No local changes to save',
32 |             ]);
33 |     }
34 | 
35 |     public function pop(): bool
36 |     {
37 |         return $this
38 |             ->builder
39 |             ->make()
40 |             ->addArgument('stash')
41 |             ->addArgument('pop')
42 |             ->executeOrFail($this->executor)
43 |             ->getResult()
44 |             ->contains('Changes not staged for commit:');
45 |     }
46 | 
47 |     /**
48 |      * @return array<Stash>
49 |      */
50 |     public function getList(): array
51 |     {
52 |         $result = $this
53 |             ->builder
54 |             ->make()
55 |             ->addOption('no-pager')
56 |             ->addArgument('stash')
57 |             ->addArgument('list')
58 |             ->addOptionWithValue('pretty', FormatPlaceholder::format([
59 |                 FormatPlaceholder::REFLOG_SHORTENED_SELECTOR,
60 |                 FormatPlaceholder::REFLOG_SUBJECT,
61 |             ]))
62 |             ->executeOrFail($this->executor)
63 |             ->getResult();
64 | 
65 |         return array_map(function (array $data) {
66 |             return new Stash($data[1], $data[2], trim($data[3]));
67 |         }, $result->globalMatch('/stash@{(.*)}\|.*on (.*):(.*)/i'));
68 |     }
69 | 
70 |     public function apply(int $id): bool
71 |     {
72 |         return $this
73 |             ->builder
74 |             ->make()
75 |             ->addArgument('stash')
76 |             ->addArgument('apply')
77 |             ->addArgument('stash@{'. $id . '}')
78 |             ->setExceptionTrigger(UserExceptionTrigger::fromCallbacks([
79 |                 function (CommandResult $result) use ($id) {
80 |                     if ($result->getError()->contains("fatal: Log for 'stash' only has (.*) entries", true)) {
81 |                         throw new StashDoesNotExists($id);
82 |                     }
83 |                 }
84 |             ]))
85 |             ->executeOrFail($this->executor)
86 |             ->getResult()
87 |             ->containsAny(['Changes not staged for commit', 'Changes to be committed']);
88 |     }
89 | }
90 | 


--------------------------------------------------------------------------------
/src/Command/Commands/StatusCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Command\Commands;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Commands\GitStatusCommand;
 6 | use ArtARTs36\GitHandler\Enum\StatusResult;
 7 | use ArtARTs36\ShellCommand\ShellCommand;
 8 | use ArtARTs36\Str\Str;
 9 | 
10 | class StatusCommand extends AbstractCommand implements GitStatusCommand
11 | {
12 |     public function status(bool $short = false): Str
13 |     {
14 |         return $this
15 |             ->builder
16 |             ->make()
17 |             ->addArgument('status')
18 |             ->when($short, function (ShellCommand $command) {
19 |                 $command->addCutOption('s');
20 |             })
21 |             ->executeOrFail($this->executor)
22 |             ->getResult()
23 |             ->trim();
24 |     }
25 | 
26 |     public function hasChanges(): bool
27 |     {
28 |         $status = $this->status(true);
29 |         $groups = $this->getGroupsByStatusResult($status);
30 | 
31 |         return $status->isNotEmpty() && (
32 |                 array_key_exists(StatusResult::GROUP_MODIFIED, $groups) ||
33 |                 array_key_exists(StatusResult::GROUP_ADDED, $groups));
34 |     }
35 | 
36 |     public function getUntrackedFiles(): array
37 |     {
38 |         return $this
39 |                 ->getGroupsByStatusResult($this->status(true)->trim())[StatusResult::GROUP_UNTRACKED] ?? [];
40 |     }
41 | 
42 |     public function getModifiedFiles(): array
43 |     {
44 |         return $this->getGroupsByStatusResult($this->status(true)->trim())[StatusResult::GROUP_MODIFIED] ?? [];
45 |     }
46 | 
47 |     public function getAddedFiles(): array
48 |     {
49 |         return $this->getGroupsByStatusResult($this->status(true)->trim())[StatusResult::GROUP_ADDED] ?? [];
50 |     }
51 | 
52 |     /**
53 |      * @return array<string, array<string>>
54 |      */
55 |     protected function getGroupsByStatusResult(Str $result): array
56 |     {
57 |         $groups = [];
58 | 
59 |         if ($result->isEmpty()) {
60 |             return [];
61 |         }
62 | 
63 |         foreach ($result->lines() as $line) {
64 |             [$group, $file] = $line->trim()->explode(' ');
65 | 
66 |             if ($group === null || $file === null) {
67 |                 continue;
68 |             }
69 | 
70 |             $groups[$group->__toString()][] = $file->__toString();
71 |         }
72 | 
73 |         return $groups;
74 |     }
75 | }
76 | 


--------------------------------------------------------------------------------
/src/Command/Commands/TagCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Command\Commands;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Commands\GitTagCommand;
 6 | use ArtARTs36\GitHandler\Data\Author;
 7 | use ArtARTs36\GitHandler\Data\Commit;
 8 | use ArtARTs36\GitHandler\Data\Tag;
 9 | use ArtARTs36\GitHandler\Exceptions\TagAlreadyExists;
10 | use ArtARTs36\GitHandler\Exceptions\TagNotFound;
11 | use ArtARTs36\GitHandler\Exceptions\UnexpectedException;
12 | use ArtARTs36\GitHandler\Enum\FormatPlaceholder;
13 | use ArtARTs36\ShellCommand\Exceptions\UserExceptionTrigger;
14 | use ArtARTs36\ShellCommand\Result\CommandResult;
15 | use ArtARTs36\ShellCommand\ShellCommand;
16 | 
17 | class TagCommand extends AbstractCommand implements GitTagCommand
18 | {
19 |     public function getAll(?string $pattern = null): array
20 |     {
21 |         $result = $this->builder->make()->addArgument('tag')
22 |             ->when($pattern !== null, function (ShellCommand $command) use ($pattern) {
23 |                 $command
24 |                     ->addCutOption('l')
25 |                     ->addArgument($pattern, true);
26 |             })->executeOrFail($this->executor)->getResult()->trim();
27 | 
28 |         return $result->isEmpty() ? [] : $result->lines()->toStrings();
29 |     }
30 | 
31 |     public function add(string $tag, ?string $message = null): bool
32 |     {
33 |         if ($this->exists($tag)) {
34 |             throw new TagAlreadyExists($tag);
35 |         }
36 | 
37 |         return $this
38 |             ->builder
39 |             ->make()
40 |             ->addArgument('tag')
41 |             ->addCutOption('a')
42 |             ->addArgument($tag)
43 |             ->addCutOption('m')
44 |             ->addArgument($message ?? "Version {$tag}", true)
45 |             ->executeOrFail($this->executor)
46 |             ->isEmpty();
47 |     }
48 | 
49 |     public function get(string $tagName): Tag
50 |     {
51 |         $result = $this
52 |             ->builder
53 |             ->make()
54 |             ->addArgument('show')
55 |             ->addArgument($tagName)
56 |             ->addOptionWithValue('pretty', FormatPlaceholder::format([
57 |                 FormatPlaceholder::AUTHOR_NAME,
58 |                 FormatPlaceholder::AUTHOR_EMAIL,
59 |                 FormatPlaceholder::AUTHOR_DATE_RFC2822,
60 |                 FormatPlaceholder::COMMIT_HASH,
61 |                 FormatPlaceholder::SUBJECT,
62 |             ]))
63 |             ->addCutOption('s')
64 |             ->setExceptionTrigger(UserExceptionTrigger::fromCallbacks([
65 |                 function (CommandResult $result) use ($tagName) {
66 |                     if ($result
67 |                         ->getError()
68 |                         ->contains(
69 |                             "ambiguous argument '$tagName': unknown revision or path not in the working tree"
70 |                         )) {
71 |                         throw new TagNotFound($tagName);
72 |                     }
73 |                 }
74 |             ]))
75 |             ->executeOrFail($this->executor);
76 | 
77 |         $parts = $result->getResult()->explode('|');
78 | 
79 |         if ($parts->count() !== 5) {
80 |             throw new UnexpectedException($result->getCommandLine());
81 |         }
82 | 
83 |         [$authorName, $authorEmail, $date, $commit, $message] = $parts->toStrings();
84 | 
85 |         return new Tag(
86 |             new Author($authorName, $authorEmail),
87 |             new \DateTime($date),
88 |             new Commit($commit),
89 |             $message
90 |         );
91 |     }
92 | 
93 |     public function exists(string $tag): bool
94 |     {
95 |         return in_array($tag, $this->getAll());
96 |     }
97 | }
98 | 


--------------------------------------------------------------------------------
/src/Command/GitCommandBuilder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Command;
 4 | 
 5 | use ArtARTs36\ShellCommand\Interfaces\CommandBuilder;
 6 | use ArtARTs36\ShellCommand\Interfaces\ShellCommandInterface;
 7 | 
 8 | class GitCommandBuilder
 9 | {
10 |     protected $builder;
11 | 
12 |     protected $bin;
13 | 
14 |     protected $dir;
15 | 
16 |     /**
17 |      * @codeCoverageIgnore
18 |      */
19 |     public function __construct(CommandBuilder $builder, string $bin, string $dir)
20 |     {
21 |         $this->builder = $builder;
22 |         $this->bin = $bin;
23 |         $this->dir = $dir;
24 |     }
25 | 
26 |     public function make(?string $dir = null): ShellCommandInterface
27 |     {
28 |         return $this->builder->makeNavigateToDir($dir ?? $this->dir, $this->bin);
29 |     }
30 | 
31 |     /**
32 |      * @codeCoverageIgnore
33 |      */
34 |     public function toDir(string $dir, string $bin): ShellCommandInterface
35 |     {
36 |         return $this->builder->makeNavigateToDir($dir, $bin);
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Concerns/SwitchFolder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Concerns;
 4 | 
 5 | trait SwitchFolder
 6 | {
 7 |     protected $folder;
 8 | 
 9 |     public function seeToRoot(): self
10 |     {
11 |         $this->folder = $this->context->getRootDir();
12 | 
13 |         return $this;
14 |     }
15 | 
16 |     public function seeToFolder(string $folder): self
17 |     {
18 |         $this->folder = $this->context->getRootDir() . DIRECTORY_SEPARATOR . $folder;
19 | 
20 |         return $this;
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Config/Configurators/AliasConfigurator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Config\Configurators;
 4 | 
 5 | use ArtARTs36\GitHandler\Config\Subjects\Alias;
 6 | use ArtARTs36\GitHandler\Config\Subjects\AliasList;
 7 | use ArtARTs36\GitHandler\Contracts\Config\ConfigSubject;
 8 | use ArtARTs36\GitHandler\Contracts\Config\SubjectConfigurator;
 9 | 
10 | class AliasConfigurator implements SubjectConfigurator
11 | {
12 |     public function parse(array $raw): ConfigSubject
13 |     {
14 |         $aliases = [];
15 | 
16 |         foreach ($raw as $name => $script) {
17 |             $aliases[$name] = new Alias($name, $script);
18 |         }
19 | 
20 |         return new AliasList($aliases);
21 |     }
22 | 
23 |     /**
24 |      * @codeCoverageIgnore
25 |      */
26 |     public function getPrefix(): string
27 |     {
28 |         return 'alias';
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Config/Configurators/BranchConfigurator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Config\Configurators;
 4 | 
 5 | use ArtARTs36\GitHandler\Config\Subjects\BranchList;
 6 | use ArtARTs36\GitHandler\Config\Subjects\Branch;
 7 | use ArtARTs36\GitHandler\Contracts\Config\ConfigSubject;
 8 | use ArtARTs36\GitHandler\Contracts\Config\SubjectConfigurator;
 9 | use ArtARTs36\Str\Str;
10 | 
11 | class BranchConfigurator implements SubjectConfigurator
12 | {
13 |     public function parse(array $raw): ConfigSubject
14 |     {
15 |         $parts = array_chunk($raw, 2, true);
16 |         $branches = [];
17 | 
18 |         foreach ($parts as $part) {
19 |             $branchName = '';
20 |             $links = [];
21 | 
22 |             foreach ($part as $identity => $url) {
23 |                 $nameParts = explode('.', $identity);
24 |                 $branchName = strlen($branchName) ? $branchName : $this->buildBranchName($nameParts);
25 |                 $links[end($nameParts)] = $url;
26 |             }
27 | 
28 |             $branches[$branchName] = Branch::fromLinks($branchName, $links);
29 |         }
30 | 
31 |         return new BranchList($branches);
32 |     }
33 | 
34 |     /**
35 |      * @codeCoverageIgnore
36 |      */
37 |     public function getPrefix(): string
38 |     {
39 |         return 'branch';
40 |     }
41 | 
42 |     /**
43 |      * @param array<string> $parts
44 |      */
45 |     protected function buildBranchName(array $parts): string
46 |     {
47 |         return Str::fromArray(array_slice($parts, 0, -1), '.')
48 |             ->cut(null, strlen($this->getPrefix()) + 1);
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/src/Config/Configurators/CommitConfigurator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Config\Configurators;
 4 | 
 5 | use ArtARTs36\GitHandler\Config\Subjects\ConfigCommit;
 6 | use ArtARTs36\GitHandler\Contracts\Config\ConfigSubject;
 7 | use ArtARTs36\GitHandler\Contracts\Config\SubjectConfigurator;
 8 | 
 9 | class CommitConfigurator implements SubjectConfigurator
10 | {
11 |     public function parse(array $raw): ConfigSubject
12 |     {
13 |         return new ConfigCommit($raw['template'] ?? '');
14 |     }
15 | 
16 |     /**
17 |      * @codeCoverageIgnore
18 |      */
19 |     public function getPrefix(): string
20 |     {
21 |         return 'commit';
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Config/Configurators/CoreConfigurator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Config\Configurators;
 4 | 
 5 | use ArtARTs36\GitHandler\Config\Subjects\Core;
 6 | use ArtARTs36\GitHandler\Contracts\Config\ConfigSubject;
 7 | use ArtARTs36\GitHandler\Contracts\Config\SubjectConfigurator;
 8 | use ArtARTs36\GitHandler\Support\TypeCaster;
 9 | 
10 | class CoreConfigurator implements SubjectConfigurator
11 | {
12 |     public function parse(array $raw): ConfigSubject
13 |     {
14 |         return new Core(
15 |             $raw['autocrlf'] ?? '',
16 |             TypeCaster::boolean($raw['ignorecase'] ?? ''),
17 |             TypeCaster::integer($raw, 'repositoryformatversion'),
18 |             TypeCaster::boolean($raw['bare'] ?? ''),
19 |             TypeCaster::boolean($raw['logallrefupdates'] ?? ''),
20 |             TypeCaster::boolean($raw['precomposeunicode'] ?? ''),
21 |             TypeCaster::boolean($raw['filemode'] ?? '')
22 |         );
23 |     }
24 | 
25 |     /**
26 |      * @inheritDoc
27 |      * @codeCoverageIgnore
28 |      */
29 |     public function getPrefix(): string
30 |     {
31 |         return 'core';
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/Config/Configurators/CredentialConfigurator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Config\Configurators;
 4 | 
 5 | use ArtARTs36\GitHandler\Config\Subjects\Credential;
 6 | use ArtARTs36\GitHandler\Contracts\Config\ConfigSubject;
 7 | use ArtARTs36\GitHandler\Contracts\Config\SubjectConfigurator;
 8 | 
 9 | class CredentialConfigurator implements SubjectConfigurator
10 | {
11 |     public function parse(array $raw): ConfigSubject
12 |     {
13 |         return new Credential($raw['helper'] ?? '');
14 |     }
15 | 
16 |     /**
17 |      * @inheritDoc
18 |      * @codeCoverageIgnore
19 |      */
20 |     public function getPrefix(): string
21 |     {
22 |         return 'credential';
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Config/Configurators/DiffConfigurator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Config\Configurators;
 4 | 
 5 | use ArtARTs36\GitHandler\Config\Subjects\ConfigDiff;
 6 | use ArtARTs36\GitHandler\Contracts\Config\ConfigSubject;
 7 | use ArtARTs36\GitHandler\Contracts\Config\SubjectConfigurator;
 8 | use ArtARTs36\GitHandler\Support\TypeCaster;
 9 | 
10 | class DiffConfigurator implements SubjectConfigurator
11 | {
12 |     public function parse(array $raw): ConfigSubject
13 |     {
14 |         return new ConfigDiff(TypeCaster::string($raw, 'external'), TypeCaster::boolean($raw['renames']));
15 |     }
16 | 
17 |     public function getPrefix(): string
18 |     {
19 |         return 'diff';
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Config/Configurators/InstawebConfigurator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Config\Configurators;
 4 | 
 5 | use ArtARTs36\GitHandler\Config\Subjects\Instaweb;
 6 | use ArtARTs36\GitHandler\Contracts\Config\ConfigSubject;
 7 | use ArtARTs36\GitHandler\Contracts\Config\SubjectConfigurator;
 8 | use ArtARTs36\GitHandler\Support\TypeCaster;
 9 | 
10 | class InstawebConfigurator implements SubjectConfigurator
11 | {
12 |     public function parse(array $raw): ConfigSubject
13 |     {
14 |         return new Instaweb(
15 |             TypeCaster::boolean($raw['local'] ?? ''),
16 |             $raw['httpd'] ?? '',
17 |             TypeCaster::integer($raw, 'port'),
18 |             $raw['browser'] ?? '',
19 |             $raw['modulePath'] ?? ''
20 |         );
21 |     }
22 | 
23 |     /**
24 |      * @codeCoverageIgnore
25 |      */
26 |     public function getPrefix(): string
27 |     {
28 |         return 'instaweb';
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Config/Configurators/PackConfigurator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Config\Configurators;
 4 | 
 5 | use ArtARTs36\GitHandler\Config\Subjects\Pack;
 6 | use ArtARTs36\GitHandler\Contracts\Config\ConfigSubject;
 7 | use ArtARTs36\GitHandler\Contracts\Config\SubjectConfigurator;
 8 | use ArtARTs36\GitHandler\Support\TypeCaster;
 9 | 
10 | class PackConfigurator implements SubjectConfigurator
11 | {
12 |     public function parse(array $raw): ConfigSubject
13 |     {
14 |         return new Pack(
15 |             $raw['windowmemory'] ?? '',
16 |             $raw['packsizelimit'] ?? '',
17 |             TypeCaster::integer($raw, 'threads'),
18 |             $raw['deltacachesize'] ?? '',
19 |             $raw['sizelimit'] ?? '',
20 |             TypeCaster::integer($raw, 'window')
21 |         );
22 |     }
23 | 
24 |     /**
25 |      * @inheritDoc
26 |      * @codeCoverageIgnore
27 |      */
28 |     public function getPrefix(): string
29 |     {
30 |         return 'pack';
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Config/Configurators/SubmoduleConfigurator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Config\Configurators;
 4 | 
 5 | use ArtARTs36\GitHandler\Config\Subjects\ConfigSubmodule;
 6 | use ArtARTs36\GitHandler\Config\Subjects\ConfigSubmoduleList;
 7 | use ArtARTs36\GitHandler\Contracts\Config\ConfigSubject;
 8 | use ArtARTs36\GitHandler\Contracts\Config\SubjectConfigurator;
 9 | use ArtARTs36\GitHandler\Support\TypeCaster;
10 | 
11 | class SubmoduleConfigurator implements SubjectConfigurator
12 | {
13 |     public function parse(array $raw): ConfigSubject
14 |     {
15 |         $modules = [];
16 |         $parts = array_chunk($raw, 2, true);
17 | 
18 |         foreach ($parts as $part) {
19 |             $name = explode('.', array_key_first($part))[0];
20 | 
21 |             $modules[$name] = new ConfigSubmodule(
22 |                 $name,
23 |                 $part[$name . '.url'],
24 |                 TypeCaster::boolean($part[$name . '.active'] ?? 'false'),
25 |             );
26 |         }
27 | 
28 |         return new ConfigSubmoduleList($modules);
29 |     }
30 | 
31 |     /**
32 |      * @codeCoverageIgnore
33 |      */
34 |     public function getPrefix(): string
35 |     {
36 |         return 'submodule';
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Config/Configurators/UserConfigurator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Config\Configurators;
 4 | 
 5 | use ArtARTs36\GitHandler\Config\Subjects\User;
 6 | use ArtARTs36\GitHandler\Contracts\Config\ConfigSubject;
 7 | use ArtARTs36\GitHandler\Contracts\Config\SubjectConfigurator;
 8 | 
 9 | class UserConfigurator implements SubjectConfigurator
10 | {
11 |     /**
12 |      * @param array<string, string> $raw
13 |      * @return User
14 |      */
15 |     public function parse(array $raw): ConfigSubject
16 |     {
17 |         return new User($raw['name'] ?? '', $raw['email'] ?? '');
18 |     }
19 | 
20 |     /**
21 |      * @inheritDoc
22 |      * @codeCoverageIgnore
23 |      */
24 |     public function getPrefix(): string
25 |     {
26 |         return 'user';
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Config/ConfiguratorsDict.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Config;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Config\SubjectConfigurator;
 6 | use ArtARTs36\GitHandler\Exceptions\SubjectConfiguratorNotFound;
 7 | 
 8 | /**
 9 |  * @template-implements \IteratorAggregate<string, SubjectConfigurator>
10 |  */
11 | class ConfiguratorsDict implements \IteratorAggregate
12 | {
13 |     protected $configurators;
14 | 
15 |     /**
16 |      * @param array<string, SubjectConfigurator> $configurators
17 |      * @codeCoverageIgnore
18 |      */
19 |     public function __construct(array $configurators)
20 |     {
21 |         $this->configurators = $configurators;
22 |     }
23 | 
24 |     /**
25 |      * @param list<SubjectConfigurator> $configurators
26 |      */
27 |     public static function make(iterable $configurators): self
28 |     {
29 |         $dict = [];
30 | 
31 |         foreach ($configurators as $configurator) {
32 |             $dict[$configurator->getPrefix()] = $configurator;
33 |         }
34 | 
35 |         return new self($dict);
36 |     }
37 | 
38 |     /**
39 |      * @throws SubjectConfiguratorNotFound
40 |      */
41 |     public function getOrFail(string $prefix): SubjectConfigurator
42 |     {
43 |         if (! $this->has($prefix)) {
44 |             throw new SubjectConfiguratorNotFound($prefix);
45 |         }
46 | 
47 |         return $this->configurators[$prefix];
48 |     }
49 | 
50 |     public function has(string $prefix): bool
51 |     {
52 |         return array_key_exists($prefix, $this->configurators);
53 |     }
54 | 
55 |     /**
56 |      * @return iterable<SubjectConfigurator>
57 |      */
58 |     public function getIterator(): iterable
59 |     {
60 |         return new \ArrayIterator($this->configurators);
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/src/Config/RegexConfigResultParser.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Config;
 4 | 
 5 | use ArtARTs36\GitHandler\Config\Subjects\SubjectsCollection;
 6 | use ArtARTs36\GitHandler\Contracts\Config\ConfigResultParser;
 7 | use ArtARTs36\GitHandler\Contracts\Config\ConfigSubject;
 8 | use ArtARTs36\GitHandler\Exceptions\ConfigDataNotFound;
 9 | use ArtARTs36\Str\Str;
10 | 
11 | /**
12 |  * @internal
13 |  */
14 | class RegexConfigResultParser implements ConfigResultParser
15 | {
16 |     protected $configurators;
17 | 
18 |     protected $regex = "/^(.*?)\.(.*)=(.*)/m";
19 | 
20 |     /**
21 |      * @codeCoverageIgnore
22 |      */
23 |     public function __construct(ConfiguratorsDict $configurators)
24 |     {
25 |         $this->configurators = $configurators;
26 |     }
27 | 
28 |     /**
29 |      * @inheritDoc
30 |      */
31 |     public function parse(Str $raw): SubjectsCollection
32 |     {
33 |         $grouped = $this->grouped($raw->globalMatch($this->regex), 1);
34 | 
35 |         //
36 | 
37 |         $data = [];
38 | 
39 |         foreach ($grouped as $scope => $item) {
40 |             if (! $this->configurators->has($scope)) {
41 |                 continue;
42 |             }
43 | 
44 |             $data[] = $this->configurators->getOrFail($scope)->parse($item);
45 |         }
46 | 
47 |         return new SubjectsCollection($data);
48 |     }
49 | 
50 |     /**
51 |      * @inheritDoc
52 |      */
53 |     public function parseByPrefix(Str $raw, string $prefix): ConfigSubject
54 |     {
55 |         $grouped = $this->grouped($raw->globalMatch($this->regex), 1);
56 | 
57 |         //
58 | 
59 |         if (! array_key_exists($prefix, $grouped)) {
60 |             throw new ConfigDataNotFound($prefix);
61 |         }
62 | 
63 |         return $this->configurators->getOrFail($prefix)->parse($grouped[$prefix]);
64 |     }
65 | 
66 |     /**
67 |      * @param array<array<string>> $matches
68 |      * @return array<string, array<string>>
69 |      */
70 |     protected function grouped(array $matches, int $matchOffset): array
71 |     {
72 |         $grouped = [];
73 | 
74 |         foreach ($matches as $match) {
75 |             [$scope, $field, $value] = array_slice($match, $matchOffset);
76 | 
77 |             $grouped[$scope][$field] = $value;
78 |         }
79 | 
80 |         return $grouped;
81 |     }
82 | }
83 | 


--------------------------------------------------------------------------------
/src/Config/Subjects/AbstractSubject.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Config\Subjects;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Config\ConfigSubject;
 6 | use ArtARTs36\GitHandler\Support\ToArray;
 7 | 
 8 | abstract class AbstractSubject implements ConfigSubject
 9 | {
10 |     use ToArray;
11 | 
12 |     public function name(): string
13 |     {
14 |         $parts = explode('\\', static::class);
15 | 
16 |         return mb_strtolower(end($parts));
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Config/Subjects/Alias.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Config\Subjects;
 4 | 
 5 | use ArtARTs36\GitHandler\Attributes\ConfigSectionName;
 6 | use ArtARTs36\GitHandler\Attributes\ConfigValue;
 7 | 
 8 | class Alias extends AbstractSubject
 9 | {
10 |     #[ConfigSectionName]
11 |     public $name;
12 | 
13 |     #[ConfigValue]
14 |     public $script;
15 | 
16 |     public function __construct(string $name, string $script)
17 |     {
18 |         $this->name = $name;
19 |         $this->script = $script;
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Config/Subjects/AliasList.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Config\Subjects;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Config\ConfigSubjectList;
 6 | 
 7 | class AliasList extends AbstractSubject implements ConfigSubjectList
 8 | {
 9 |     public $aliases;
10 | 
11 |     /**
12 |      * @param array<string, Alias> $aliases
13 |      */
14 |     public function __construct(array $aliases)
15 |     {
16 |         $this->aliases = $aliases;
17 |     }
18 | 
19 |     /**
20 |      * @return iterable<string, Alias>
21 |      */
22 |     public function getIterator(): iterable
23 |     {
24 |         return new \ArrayIterator($this->aliases);
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Config/Subjects/Branch.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Config\Subjects;
 4 | 
 5 | use ArtARTs36\GitHandler\Attributes\ConfigKey;
 6 | use JetBrains\PhpStorm\ArrayShape;
 7 | use ArtARTs36\GitHandler\Attributes\ConfigSectionName;
 8 | 
 9 | class Branch extends AbstractSubject
10 | {
11 |     #[ConfigSectionName()]
12 |     public $name;
13 | 
14 |     #[ConfigKey('remote')]
15 |     public $remote;
16 | 
17 |     #[ConfigKey('merge')]
18 |     public $merge;
19 | 
20 |     /**
21 |      * @codeCoverageIgnore
22 |      */
23 |     public function __construct(string $name, string $remote, string $merge)
24 |     {
25 |         $this->name = $name;
26 |         $this->remote = $remote;
27 |         $this->merge = $merge;
28 |     }
29 | 
30 |     /**
31 |      * @param array<string, string> $links
32 |      */
33 |     public static function fromLinks(
34 |         string $name,
35 |         #[ArrayShape(['remote' => 'string', 'merge' => 'string'])]
36 |         array $links
37 |     ): self {
38 |         return new self($name, $links['remote'] ?? '', $links['merge'] ?? '');
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Config/Subjects/BranchList.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Config\Subjects;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Config\ConfigSubjectList;
 6 | 
 7 | class BranchList extends AbstractSubject implements ConfigSubjectList
 8 | {
 9 |     public $branches;
10 | 
11 |     /**
12 |      * @param array<string, Branch> $branches
13 |      * @codeCoverageIgnore
14 |      */
15 |     public function __construct(array $branches)
16 |     {
17 |         $this->branches = $branches;
18 |     }
19 | 
20 |     public function get(string $name): ?Branch
21 |     {
22 |         return $this->branches[$name] ?? null;
23 |     }
24 | 
25 |     /**
26 |      * @return iterable<string, Branch>
27 |      */
28 |     public function getIterator(): iterable
29 |     {
30 |         return new \ArrayIterator($this->branches);
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Config/Subjects/ConfigCommit.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Config\Subjects;
 4 | 
 5 | use ArtARTs36\GitHandler\Attributes\ConfigKey;
 6 | 
 7 | class ConfigCommit extends AbstractSubject
 8 | {
 9 |     #[ConfigKey('template')]
10 |     public $templatePath;
11 | 
12 |     public function __construct(string $templatePath)
13 |     {
14 |         $this->templatePath = $templatePath;
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Config/Subjects/ConfigDiff.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Config\Subjects;
 4 | 
 5 | use ArtARTs36\GitHandler\Attributes\ConfigKey;
 6 | 
 7 | class ConfigDiff extends AbstractSubject
 8 | {
 9 |     #[ConfigKey('external')]
10 |     public $externalPath;
11 | 
12 |     #[ConfigKey('renames')]
13 |     public $renames;
14 | 
15 |     public function __construct(string $externalPath, bool $renames)
16 |     {
17 |         $this->externalPath = $externalPath;
18 |         $this->renames = $renames;
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Config/Subjects/ConfigSubmodule.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Config\Subjects;
 4 | 
 5 | use ArtARTs36\GitHandler\Attributes\ConfigKey;
 6 | use ArtARTs36\GitHandler\Attributes\ConfigSectionName;
 7 | 
 8 | class ConfigSubmodule extends AbstractSubject
 9 | {
10 |     #[ConfigSectionName()]
11 |     public $name;
12 | 
13 |     #[ConfigKey('url')]
14 |     public $url;
15 | 
16 |     #[ConfigKey('active')]
17 |     public $active;
18 | 
19 |     public function __construct(string $name, string $url, bool $active)
20 |     {
21 |         $this->name = $name;
22 |         $this->url = $url;
23 |         $this->active = $active;
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Config/Subjects/ConfigSubmoduleList.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Config\Subjects;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Config\ConfigSubjectList;
 6 | 
 7 | /**
 8 |  * @template-implements \IteratorAggregate<string, ConfigSubmodule>
 9 |  */
10 | class ConfigSubmoduleList extends AbstractSubject implements \IteratorAggregate
11 | {
12 |     public $submodules;
13 | 
14 |     /**
15 |      * @param array<string, ConfigSubmodule> $submodules
16 |      */
17 |     public function __construct(array $submodules)
18 |     {
19 |         $this->submodules = $submodules;
20 |     }
21 | 
22 |     public function get(string $name): ?ConfigSubmodule
23 |     {
24 |         return $this->submodules[$name] ?? null;
25 |     }
26 | 
27 |     /**
28 |      * @return iterable<string, ConfigSubmodule>
29 |      */
30 |     public function getIterator(): iterable
31 |     {
32 |         return new \ArrayIterator($this->submodules);
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Config/Subjects/Core.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Config\Subjects;
 4 | 
 5 | use ArtARTs36\GitHandler\Attributes\ConfigKey;
 6 | use JetBrains\PhpStorm\Immutable;
 7 | 
 8 | #[Immutable]
 9 | class Core extends AbstractSubject
10 | {
11 |     #[ConfigKey('autocrlf')]
12 |     public $autocrlf;
13 | 
14 |     #[ConfigKey('ignorecase')]
15 |     public $ignoreCase;
16 | 
17 |     #[ConfigKey('repositoryformatversion')]
18 |     public $repositoryFormatVersion;
19 | 
20 |     #[ConfigKey('bare')]
21 |     public $bare;
22 | 
23 |     #[ConfigKey('logallrefupdates')]
24 |     public $logAllRefUpdates;
25 | 
26 |     #[ConfigKey('precomposeunicode')]
27 |     public $preComposeUnicode;
28 | 
29 |     #[ConfigKey('filemode')]
30 |     public $fileMode;
31 | 
32 |     /**
33 |      * @codeCoverageIgnore
34 |      */
35 |     public function __construct(
36 |         string $autocrlf,
37 |         bool $ignoreCase,
38 |         int $repositoryFormatVersion,
39 |         bool $bare,
40 |         bool $logAllRefUpdates,
41 |         bool $preComposeUnicode,
42 |         bool $fileMode
43 |     ) {
44 |         $this->autocrlf = $autocrlf;
45 |         $this->ignoreCase = $ignoreCase;
46 |         $this->repositoryFormatVersion = $repositoryFormatVersion;
47 |         $this->bare = $bare;
48 |         $this->logAllRefUpdates = $logAllRefUpdates;
49 |         $this->preComposeUnicode = $preComposeUnicode;
50 |         $this->fileMode = $fileMode;
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/src/Config/Subjects/Credential.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Config\Subjects;
 4 | 
 5 | use ArtARTs36\GitHandler\Attributes\ConfigKey;
 6 | use JetBrains\PhpStorm\Immutable;
 7 | 
 8 | #[Immutable]
 9 | class Credential extends AbstractSubject
10 | {
11 |     #[ConfigKey('helper')]
12 |     public $helper;
13 | 
14 |     public function __construct(string $helper)
15 |     {
16 |         $this->helper = $helper;
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Config/Subjects/Instaweb.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Config\Subjects;
 4 | 
 5 | class Instaweb extends AbstractSubject
 6 | {
 7 |     public $local;
 8 | 
 9 |     public $httpd;
10 | 
11 |     public $port;
12 | 
13 |     public $browser;
14 | 
15 |     public $modulePath;
16 | 
17 |     public function __construct(
18 |         bool $local,
19 |         string $httpd,
20 |         int $port,
21 |         string $browser,
22 |         string $modulePath
23 |     ) {
24 |         $this->local = $local;
25 |         $this->httpd = $httpd;
26 |         $this->port = $port;
27 |         $this->browser = $browser;
28 |         $this->modulePath = $modulePath;
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Config/Subjects/Pack.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Config\Subjects;
 4 | 
 5 | use ArtARTs36\GitHandler\Attributes\ConfigKey;
 6 | use JetBrains\PhpStorm\Immutable;
 7 | 
 8 | #[Immutable]
 9 | class Pack extends AbstractSubject
10 | {
11 |     #[ConfigKey('windowmemory')]
12 |     public $windowMemory;
13 | 
14 |     #[ConfigKey('packsizelimit')]
15 |     public $packSizeLimit;
16 | 
17 |     #[ConfigKey('threads')]
18 |     public $threads;
19 | 
20 |     #[ConfigKey('deltacachesize')]
21 |     public $deltaCacheSize;
22 | 
23 |     #[ConfigKey('sizelimit')]
24 |     public $sizeLimit;
25 | 
26 |     #[ConfigKey('window')]
27 |     public $window;
28 | 
29 |     /**
30 |      * @codeCoverageIgnore
31 |      */
32 |     public function __construct(
33 |         string $windowMemory,
34 |         string $packSizeLimit,
35 |         int $threads,
36 |         string $deltaCacheSize,
37 |         string $sizeLimit,
38 |         int $window
39 |     ) {
40 |         $this->windowMemory = $windowMemory;
41 |         $this->packSizeLimit = $packSizeLimit;
42 |         $this->threads = $threads;
43 |         $this->deltaCacheSize = $deltaCacheSize;
44 |         $this->sizeLimit = $sizeLimit;
45 |         $this->window = $window;
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/src/Config/Subjects/SubjectsCollection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Config\Subjects;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Config\ConfigSubject;
 6 | 
 7 | /**
 8 |  * @template-implements \IteratorAggregate<int, ConfigSubject>
 9 |  */
10 | class SubjectsCollection implements \IteratorAggregate, \Countable
11 | {
12 |     protected $subjects;
13 | 
14 |     /**
15 |      * @param array<ConfigSubject> $subjects
16 |      * @codeCoverageIgnore
17 |      */
18 |     public function __construct(array $subjects)
19 |     {
20 |         $this->subjects = $subjects;
21 |     }
22 | 
23 |     public function count(): int
24 |     {
25 |         return count($this->subjects);
26 |     }
27 | 
28 |     /**
29 |      * @return iterable<ConfigSubject>
30 |      */
31 |     public function getIterator(): iterable
32 |     {
33 |         return new \ArrayIterator($this->subjects);
34 |     }
35 | 
36 |     /**
37 |      * @return ConfigSubject[]
38 |      */
39 |     public function all(): array
40 |     {
41 |         return $this->subjects;
42 |     }
43 | 
44 |     /**
45 |      * @return array<string, array<string, string>>
46 |      */
47 |     public function toArray(): array
48 |     {
49 |         $array = [];
50 | 
51 |         foreach ($this->subjects as $subject) {
52 |             $array[$subject->name()] = $subject->toArray();
53 |         }
54 | 
55 |         return $array;
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/src/Config/Subjects/User.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Config\Subjects;
 4 | 
 5 | use ArtARTs36\GitHandler\Attributes\ConfigKey;
 6 | use JetBrains\PhpStorm\Immutable;
 7 | 
 8 | #[Immutable]
 9 | class User extends AbstractSubject
10 | {
11 |     #[ConfigKey('name')]
12 |     public $name;
13 | 
14 |     #[ConfigKey('email')]
15 |     public $email;
16 | 
17 |     /**
18 |      * @codeCoverageIgnore
19 |      */
20 |     public function __construct(string $name, string $email)
21 |     {
22 |         $this->name = $name;
23 |         $this->email = $email;
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Contracts/Attribute/GitAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Attribute;
 4 | 
 5 | /**
 6 |  * Marker for self attributes
 7 |  */
 8 | interface GitAttribute
 9 | {
10 | 
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Contracts/AuthorHydrator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts;
 4 | 
 5 | use ArtARTs36\GitHandler\Data\Author;
 6 | use JetBrains\PhpStorm\ArrayShape;
 7 | 
 8 | interface AuthorHydrator
 9 | {
10 |     /**
11 |      * Hydrate raw array to Author object.
12 |      * @param array<string, mixed> $raw
13 |      */
14 |     public function hydrate(
15 |         #[ArrayShape(['name' => 'string', 'email' => 'string'])]
16 |         array $raw
17 |     ): Author;
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Contracts/Backup/BackupElement.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Backup;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Handler\GitHandler;
 6 | 
 7 | interface BackupElement
 8 | {
 9 |     /**
10 |      * Dump
11 |      * @return array<mixed>
12 |      */
13 |     public function dump(GitHandler $git): array;
14 | 
15 |     /**
16 |      * Restore dumped data from array
17 |      * @param array<mixed> $data
18 |      */
19 |     public function restore(GitHandler $git, array $data): void;
20 | 
21 |     /**
22 |      * Get this backup element identifier
23 |      */
24 |     public function identity(): string;
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Contracts/Backup/BackupElementDict.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Backup;
 4 | 
 5 | /**
 6 |  * @extends \IteratorAggregate<string, BackupElement>
 7 |  */
 8 | interface BackupElementDict extends \IteratorAggregate
 9 | {
10 |     /**
11 |      * @param array<class-string<BackupElement>|string> $classes
12 |      * @return array<BackupElement>
13 |      */
14 |     public function get(array $classes): array;
15 | 
16 |     /**
17 |      * @param array<class-string<BackupElement>> $classes
18 |      * @return static
19 |      */
20 |     public function only(array $classes);
21 | 
22 |     /**
23 |      * @return iterable<BackupElement>
24 |      */
25 |     public function getIterator();
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Contracts/Backup/GitBackup.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Backup;
 4 | 
 5 | /**
 6 |  * Git Backup (dump and restore git features)
 7 |  */
 8 | interface GitBackup
 9 | {
10 |     /**
11 |      * Dump backup
12 |      */
13 |     public function dump(string $path): void;
14 | 
15 |     /**
16 |      * Dump backup
17 |      * @param non-empty-list<class-string<BackupElement>|string> $elements
18 |      */
19 |     public function dumpOnly(string $path, array $elements): void;
20 | 
21 |     /**
22 |      * Restore backup
23 |      */
24 |     public function restore(string $path): void;
25 | 
26 |     /**
27 |      * Restore backup
28 |      * @param non-empty-list<class-string<BackupElement>|string> $elements
29 |      */
30 |     public function restoreOnly(string $path, array $elements): void;
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Contracts/Commands/FolderSwitchable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Commands;
 4 | 
 5 | /**
 6 |  * Switch folder
 7 |  */
 8 | interface FolderSwitchable
 9 | {
10 |     /**
11 |      * Switch folder to root (project dir)
12 |      * @return $this
13 |      */
14 |     public function seeToRoot();
15 | 
16 |     /**
17 |      * Switch folder
18 |      * @return $this
19 |      */
20 |     public function seeToFolder(string $folder);
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Contracts/Commands/GitArchiveCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Commands;
 4 | 
 5 | use ArtARTs36\GitHandler\Exceptions\PathIsDirectoryNotCould;
 6 | 
 7 | /**
 8 |  * Git Archive
 9 |  */
10 | interface GitArchiveCommand extends RefsPacker
11 | {
12 |     /**
13 |      * Create git archive
14 |      * @git-command git archive --output=$path HEAD
15 |      * @throws PathIsDirectoryNotCould
16 |      */
17 |     public function create(string $path): void;
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Contracts/Commands/GitAttributeCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Commands;
 4 | 
 5 | use ArtARTs36\GitHandler\Data\GitAttributes;
 6 | 
 7 | /**
 8 |  * Git Attributes
 9 |  */
10 | interface GitAttributeCommand extends FolderSwitchable
11 | {
12 |     /**
13 |      * Add git attribute
14 |      * @param array<string> $attributes
15 |      */
16 |     public function add(string $pattern, array $attributes): void;
17 | 
18 |     /**
19 |      * Find git attribute by pattern
20 |      */
21 |     public function find(string $pattern): ?GitAttributes;
22 | 
23 |     /**
24 |      * Delete git attribute by pattern
25 |      */
26 |     public function delete(string $pattern): bool;
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Contracts/Commands/GitBranchCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Commands;
 4 | 
 5 | use ArtARTs36\GitHandler\Exceptions\AlreadySwitched;
 6 | use ArtARTs36\GitHandler\Exceptions\BranchNotFound;
 7 | use ArtARTs36\GitHandler\Exceptions\ReferenceInvalid;
 8 | use ArtARTs36\Str\Str;
 9 | 
10 | /**
11 |  * Git Branches
12 |  */
13 | interface GitBranchCommand
14 | {
15 |     /**
16 |      * Delete Branch
17 |      * @git-command git branch -d {$branch}
18 |      * @throws BranchNotFound
19 |      */
20 |     public function delete(string $branch): bool;
21 | 
22 |     /**
23 |      * Create new Branch
24 |      * @git-command git branch {$branch}
25 |      */
26 |     public function create(string $branch): void;
27 | 
28 |     /**
29 |      * Get all Branches
30 |      * @git-command git branch -a
31 |      * @return array<string>
32 |      */
33 |     public function getAll(): array;
34 | 
35 |     /**
36 |      * Switch to Branch
37 |      * @git-command git switch {$branch}
38 |      * @throws ReferenceInvalid
39 |      * @throws AlreadySwitched
40 |      */
41 |     public function switch(string $branch): bool;
42 | 
43 |     /**
44 |      * Get current Branch
45 |      * @git-command git branch --show-current
46 |      */
47 |     public function current(): Str;
48 | }
49 | 


--------------------------------------------------------------------------------
/src/Contracts/Commands/GitCommitCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Commands;
 4 | 
 5 | use ArtARTs36\GitHandler\Data\Author;
 6 | 
 7 | /**
 8 |  * Git Commits
 9 |  */
10 | interface GitCommitCommand
11 | {
12 |     /**
13 |      * Execute commit
14 |      * @git-command git commit -m="{$message}"
15 |      * @git-command git commit -m="{$message}" --amend
16 |      * @git-command git commit -m="{$message}" --author="$author"
17 |      */
18 |     public function commit(string $message, bool $amend = false, ?Author $author = null): bool;
19 | 
20 |     /**
21 |      * @git-command git add (untracked files) && git commit -m $message
22 |      */
23 |     public function autoCommit(string $message, bool $amend = false): bool;
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Contracts/Commands/GitConfigCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Commands;
 4 | 
 5 | use ArtARTs36\GitHandler\Config\Subjects\SubjectsCollection;
 6 | use ArtARTs36\GitHandler\Contracts\Config\ConfigSubject;
 7 | use ArtARTs36\GitHandler\Exceptions\ConfigDataNotFound;
 8 | use ArtARTs36\GitHandler\Exceptions\SubjectConfiguratorNotFound;
 9 | 
10 | /**
11 |  * Git Config (set, get list, ...)
12 |  */
13 | interface GitConfigCommand
14 | {
15 |     /**
16 |      * Get config list
17 |      * @git-command git config --list
18 |      */
19 |     public function getAll(): SubjectsCollection;
20 | 
21 |     /**
22 |      * Get config subject
23 |      * @git-command git config --list
24 |      * @throws ConfigDataNotFound
25 |      * @throws SubjectConfiguratorNotFound
26 |      * @exampleArguments user
27 |      */
28 |     public function getSubject(string $prefix): ConfigSubject;
29 | 
30 |     /**
31 |      * Set git config
32 |      * @git-command git config $scope.$field=$value
33 |      * @git-command git config $scope.$field=$value --replace-all
34 |      * @exampleArguments user name ArtARTs36
35 |      */
36 |     public function set(string $scope, string $field, string $value, bool $replaceAll = false): bool;
37 | 
38 |     /**
39 |      * Unset git config
40 |      * @git-command git config --unset $scope.$field
41 |      * @git-command git config --unset $scope.$field
42 |      * @exampleArguments user name
43 |      */
44 |     public function unset(string $scope, string $field): void;
45 | }
46 | 


--------------------------------------------------------------------------------
/src/Contracts/Commands/GitFetchCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Commands;
 4 | 
 5 | /**
 6 |  * Git fetch (git fetch, git fetch --all, ...)
 7 |  */
 8 | interface GitFetchCommand
 9 | {
10 |     /**
11 |      * Git fetch
12 |      * @git-command git fetch
13 |      */
14 |     public function fetch(): void;
15 | 
16 |     /**
17 |      * Git fetch all
18 |      * @git-command git fetch --all
19 |      */
20 |     public function fetchAll(): void;
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Contracts/Commands/GitFileCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Commands;
 4 | 
 5 | use ArtARTs36\GitHandler\Exceptions\FileNotFound;
 6 | 
 7 | /**
 8 |  * Git Files
 9 |  */
10 | interface GitFileCommand
11 | {
12 |     /**
13 |      * Create file in git repository
14 |      * @return string - absolute path to file
15 |      */
16 |     public function createFile(string $name, string $content, ?string $folder = null): string;
17 | 
18 |     /**
19 |      * Create folder in git repository
20 |      */
21 |     public function createFolder(string $name): self;
22 | 
23 |     /**
24 |      * Get file content from git repository
25 |      * @throws FileNotFound
26 |      */
27 |     public function getContent(string $name): string;
28 | 
29 |     /**
30 |      * Create path to $name in this git repository
31 |      */
32 |     public function createPathTo(string $name): string;
33 | }
34 | 


--------------------------------------------------------------------------------
/src/Contracts/Commands/GitGarbageCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Commands;
 4 | 
 5 | use ArtARTs36\GitHandler\Enum\GarbageCollectMode;
 6 | 
 7 | /**
 8 |  * Git Garbage Collector
 9 |  */
10 | interface GitGarbageCommand
11 | {
12 |     /**
13 |      * Collect garbage
14 |      * @git-command git gc --$mode
15 |      */
16 |     public function collect(GarbageCollectMode $mode): bool;
17 | 
18 |     /**
19 |      * Collect garbage on older date
20 |      * @git-command git gc --$mode --prune=$date
21 |      */
22 |     public function collectOnDate(GarbageCollectMode $mode, \DateTimeInterface $date): bool;
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Contracts/Commands/GitGrepCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Commands;
 4 | 
 5 | use ArtARTs36\GitHandler\Data\FileMatch;
 6 | 
 7 | /**
 8 |  * Git Grep
 9 |  */
10 | interface GitGrepCommand
11 | {
12 |     /**
13 |      * Git grep
14 |      * @git-command git grep -n $term
15 |      * @return array<FileMatch>
16 |      */
17 |     public function grep(string $term): array;
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Contracts/Commands/GitHelpCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Commands;
 4 | 
 5 | /**
 6 |  * Git Help
 7 |  */
 8 | interface GitHelpCommand
 9 | {
10 |     /**
11 |      * Get git help information
12 |      * @git-command git --help
13 |      */
14 |     public function get(): string;
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Contracts/Commands/GitHookCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Commands;
 4 | 
 5 | use ArtARTs36\GitHandler\Data\Hook;
 6 | use ArtARTs36\GitHandler\Enum\HookName;
 7 | 
 8 | /**
 9 |  * Git Hooks
10 |  */
11 | interface GitHookCommand
12 | {
13 |     /**
14 |      * Add git Hook
15 |      */
16 |     public function add(HookName $name, string $script): bool;
17 | 
18 |     /**
19 |      * Check exists Hook
20 |      */
21 |     public function has(HookName $name): bool;
22 | 
23 |     /**
24 |      * Delete hook by name
25 |      * @covers \ArtARTs36\GitHandler\Exceptions\HookNotExists
26 |      */
27 |     public function delete(HookName $name): bool;
28 | 
29 |     /**
30 |      * Get hook information by name
31 |      * @throws \ArtARTs36\GitHandler\Exceptions\HookNotExists
32 |      */
33 |     public function get(HookName $name): Hook;
34 | 
35 |     /**
36 |      * Get all hooks
37 |      * @return array<string, Hook>
38 |      */
39 |     public function getAll(bool $onlyWorked = true): array;
40 | 
41 |     /**
42 |      * Get path to hooks storage
43 |      */
44 |     public function getHookPath(?string $name = null): string;
45 | }
46 | 


--------------------------------------------------------------------------------
/src/Contracts/Commands/GitIgnoreCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Commands;
 4 | 
 5 | /**
 6 |  * Git Ignore Files (.gitignore)
 7 |  */
 8 | interface GitIgnoreCommand extends FolderSwitchable
 9 | {
10 |     /**
11 |      * Get ignored files
12 |      * @return array<string>
13 |      */
14 |     public function files(): array;
15 | 
16 |     /**
17 |      * Add file to .gitignore
18 |      */
19 |     public function add(string $path): bool;
20 | 
21 |     /**
22 |      * Delete path from .gitignore
23 |      */
24 |     public function delete(string $path): bool;
25 | 
26 |     /**
27 |      * Has file in .gitignore
28 |      */
29 |     public function has(string $path): bool;
30 | 
31 |     /**
32 |      * Get full path to file ".gitignore"
33 |      */
34 |     public function getPath(): string;
35 | }
36 | 


--------------------------------------------------------------------------------
/src/Contracts/Commands/GitIndexCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Commands;
 4 | 
 5 | use ArtARTs36\GitHandler\Enum\ResetMode;
 6 | use ArtARTs36\GitHandler\Exceptions\BadRevision;
 7 | use ArtARTs36\GitHandler\Exceptions\BranchNotFound;
 8 | use ArtARTs36\GitHandler\Exceptions\PreviousCherryPickIsNowEmpty;
 9 | 
10 | /**
11 |  * Git Index: (git add, git reset, git rm, ...)
12 |  */
13 | interface GitIndexCommand
14 | {
15 |     /**
16 |      * Add file/files to git index
17 |      * @git-command git add $file
18 |      * @git-command git add $file $file $file
19 |      * @param string|array<string> $file - file name to git added
20 |      */
21 |     public function add($file, bool $force = false): bool;
22 | 
23 |     /**
24 |      * Remove file/files from git index
25 |      * @git-command git rm $file
26 |      * @git-command git rm $file1 $file2 ...
27 |      * @param string|array<string> $files
28 |      */
29 |     public function remove($files, bool $force = false): void;
30 | 
31 |     /**
32 |      * Remove cached file/files from git index
33 |      * @git-command git rm --cached $file
34 |      * @git-command git rm --cached $file1 $file2 ...
35 |      * @param string|array<string> $files
36 |      */
37 |     public function removeCached($files, bool $force = false): void;
38 | 
39 |     /**
40 |      * Git Reset
41 |      * @git-command git reset --$mode $subject
42 |      */
43 |     public function reset(ResetMode $mode, string $subject): void;
44 | 
45 |     /**
46 |      * Git Reset Head
47 |      * @git-command git reset --$mode HEAD~
48 |      */
49 |     public function resetHead(ResetMode $mode): void;
50 | 
51 |     /**
52 |      * Rollback files state
53 |      * @git-command git checkout HEAD $paths
54 |      * @param string|array<string> $paths
55 |      */
56 |     public function rollback($paths): void;
57 | 
58 |     /**
59 |      * Checkout to paths
60 |      * @git-command git checkout $path
61 |      * @param string $path
62 |      * @throws BranchNotFound
63 |      */
64 |     public function checkout(string $path, bool $merge = false): bool;
65 | 
66 |     /**
67 |      * Cherry pick
68 |      * @git-command git cherry-pick $commitSha
69 |      * @throws BadRevision
70 |      * @throws PreviousCherryPickIsNowEmpty
71 |      */
72 |     public function cherryPick(string $commitSha): void;
73 | }
74 | 


--------------------------------------------------------------------------------
/src/Contracts/Commands/GitLogCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Commands;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Log\LogQueryAction;
 6 | use ArtARTs36\GitHandler\Data\LogCollection;
 7 | 
 8 | /**
 9 |  * Git Log
10 |  */
11 | interface GitLogCommand
12 | {
13 |     /**
14 |      * Get all git logs
15 |      * @git-command git log
16 |      */
17 |     public function getAll(): ?LogCollection;
18 | 
19 |     /**
20 |      * Builds log on query
21 |      * @param LogQueryAction|callable $callback
22 |      */
23 |     public function get(callable $callback): ?LogCollection;
24 | 
25 |     /**
26 |      * Get count of logs.
27 |      * @param LogQueryAction|callable $callback
28 |      */
29 |     public function count(callable $callback): int;
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Contracts/Commands/GitMergeCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Commands;
 4 | 
 5 | use ArtARTs36\GitHandler\Exceptions\CannotMergeAbort;
 6 | use ArtARTs36\GitHandler\Exceptions\CannotMergeException;
 7 | 
 8 | /**
 9 |  * Git Merge
10 |  */
11 | interface GitMergeCommand
12 | {
13 |     /**
14 |      * Merge with branch
15 |      * @git-command git merge $branch
16 |      * @git-command git merge $branch -m=$message
17 |      * @throws CannotMergeException
18 |      */
19 |     public function merge(string $branch, ?string $message = null): void;
20 | 
21 |     /**
22 |      * Squash Merge with branch
23 |      * @git-command git merge $branch --squash
24 |      * @git-command git merge $branch -m=$message --squash
25 |      * @throws CannotMergeException
26 |      */
27 |     public function mergeSquash(string $branch, ?string $message = null): void;
28 | 
29 |     /**
30 |      * Abort merge
31 |      * @git-command git merge --abort
32 |      * @throws CannotMergeAbort
33 |      */
34 |     public function abort(): void;
35 | }
36 | 


--------------------------------------------------------------------------------
/src/Contracts/Commands/GitPathCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Commands;
 4 | 
 5 | /**
 6 |  * Git Paths (info-path, html-path, man-path, ...)
 7 |  */
 8 | interface GitPathCommand
 9 | {
10 |     /**
11 |      * Get git info path
12 |      * @git-command git --info-path
13 |      */
14 |     public function info(): string;
15 | 
16 |     /**
17 |      * Get git html path
18 |      * @git-command git --html-path
19 |      */
20 |     public function html(): string;
21 | 
22 |     /**
23 |      * Get git info path
24 |      * @git-command git --man-path
25 |      */
26 |     public function man(): string;
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Contracts/Commands/GitPullCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Commands;
 4 | 
 5 | /**
 6 |  * Git Pull
 7 |  */
 8 | interface GitPullCommand
 9 | {
10 |     /**
11 |      * Pull changes from git remote
12 |      * @git-command git pull
13 |      */
14 |     public function pull(): bool;
15 | 
16 |     /**
17 |      * Pull changes from git remote
18 |      * @git-command git pull $branch
19 |      */
20 |     public function pullBranch(string $branch): bool;
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Contracts/Commands/GitPushCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Commands;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\PushSetup;
 6 | use ArtARTs36\GitHandler\Exceptions\BranchHasNoUpstream;
 7 | 
 8 | /**
 9 |  * Git Push
10 |  */
11 | interface GitPushCommand
12 | {
13 |     /**
14 |      * Push to remote git
15 |      * @git-command git push
16 |      * @git-command git push --force
17 |      * @git-command git push --force set-upstream $upStream
18 |      * @throws BranchHasNoUpstream
19 |      */
20 |     public function push(bool $force = false, ?string $upStream = null): bool;
21 | 
22 |     /**
23 |      * Push to remote git through current-branch
24 |      * @git-command git push --set-upstream origin {current-branch}
25 |      */
26 |     public function pushOnAutoSetUpStream(bool $force = false): bool;
27 | 
28 |     /**
29 |      * Push all git tags
30 |      * @git-command git push --tags
31 |      * @return bool - have new tags been sent
32 |      */
33 |     public function pushAllTags(bool $force = false, ?string $upStream = null): bool;
34 | 
35 |     /**
36 |      * Push with making of callable
37 |      * @git-command git push (opts and args from $making)
38 |      * @param PushSetup|callable $making
39 |      */
40 |     public function send(callable $making): void;
41 | }
42 | 


--------------------------------------------------------------------------------
/src/Contracts/Commands/GitRemoteCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Commands;
 4 | 
 5 | use ArtARTs36\GitHandler\Data\Remotes;
 6 | use ArtARTs36\GitHandler\Exceptions\RemoteAlreadyExists;
 7 | use ArtARTs36\GitHandler\Exceptions\RemoteNotFound;
 8 | use ArtARTs36\GitHandler\Exceptions\RemoteRepositoryNotFound;
 9 | 
10 | /**
11 |  * Git Remote (add, show, remove, ...)
12 |  */
13 | interface GitRemoteCommand
14 | {
15 |     /**
16 |      * Git add remote
17 |      * @git-command git remote add $shortName $url
18 |      * @throws RemoteAlreadyExists
19 |      */
20 |     public function add(string $shortName, string $url): bool;
21 | 
22 |     /**
23 |      * Git show remote
24 |      * @git-command git remote -v
25 |      * @throws RemoteRepositoryNotFound
26 |      */
27 |     public function show(): Remotes;
28 | 
29 |     /**
30 |      * Remove git remote
31 |      * @git-command git remote remove $shortName
32 |      * @throws RemoteNotFound
33 |      */
34 |     public function remove(string $shortName): bool;
35 | 
36 |     /**
37 |      * Has push or fetch remote url
38 |      */
39 |     public function hasAnyRemoteUrl(string $url): bool;
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Contracts/Commands/GitSetupCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Commands;
 4 | 
 5 | use ArtARTs36\GitHandler\Exceptions\RemoteNotFilled;
 6 | use ArtARTs36\GitHandler\Exceptions\RepositoryAlreadyExists;
 7 | 
 8 | /**
 9 |  * Git Init
10 |  */
11 | interface GitSetupCommand
12 | {
13 |     /**
14 |      * Init git repository
15 |      * @git-command git init
16 |      * @throws RepositoryAlreadyExists
17 |      */
18 |     public function init(): bool;
19 | 
20 |     /**
21 |      * Check for init repository
22 |      */
23 |     public function isInit(): bool;
24 | 
25 |     /**
26 |      * Git Clone
27 |      * @git-command git clone $url
28 |      * @git-command git clone $url -b $branch
29 |      */
30 |     public function clone(string $url, ?string $branch = null, ?string $folder = null): bool;
31 | 
32 |     /**
33 |      * Delete this repository
34 |      */
35 |     public function delete(): bool;
36 | 
37 |     /**
38 |      * Delete local repository and fetch from origin
39 |      * @throws RemoteNotFilled
40 |      */
41 |     public function reinstall(?string $branch = null): void;
42 | }
43 | 


--------------------------------------------------------------------------------
/src/Contracts/Commands/GitStashCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Commands;
 4 | 
 5 | use ArtARTs36\GitHandler\Data\Stash;
 6 | 
 7 | /**
 8 |  * Git Stash
 9 |  */
10 | interface GitStashCommand
11 | {
12 |     /**
13 |      * Git stash changes
14 |      * @git-command git stash
15 |      * @git-command git stash save $message
16 |      */
17 |     public function stash(?string $message = null): bool;
18 | 
19 |     /**
20 |      * Git stash pop
21 |      * @git-command git stash pop
22 |      */
23 |     public function pop(): bool;
24 | 
25 |     /**
26 |      * Get all git stashes
27 |      * @git-command git stash --list
28 |      * @return array<Stash>
29 |      */
30 |     public function getList(): array;
31 | 
32 |     /**
33 |      * Git apply stash
34 |      * @git-command git apply stash stash@{$id}
35 |      */
36 |     public function apply(int $id): bool;
37 | }
38 | 


--------------------------------------------------------------------------------
/src/Contracts/Commands/GitStatusCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Commands;
 4 | 
 5 | use ArtARTs36\Str\Str;
 6 | 
 7 | /**
 8 |  * Git Status
 9 |  */
10 | interface GitStatusCommand
11 | {
12 |     /**
13 |      * Get git status
14 |      * @git-command git status
15 |      */
16 |     public function status(bool $short = false): Str;
17 | 
18 |     /**
19 |      * Check has changes
20 |      */
21 |     public function hasChanges(): bool;
22 | 
23 |     /**
24 |      * Get untracked files
25 |      * @return array<string>
26 |      */
27 |     public function getUntrackedFiles(): array;
28 | 
29 |     /**
30 |      * Get modified files
31 |      * @return array<string>
32 |      */
33 |     public function getModifiedFiles(): array;
34 | 
35 |     /**
36 |      * Get added files
37 |      * @return array<string>
38 |      */
39 |     public function getAddedFiles(): array;
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Contracts/Commands/GitSubmoduleCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Commands;
 4 | 
 5 | use ArtARTs36\GitHandler\Data\Submodule;
 6 | use ArtARTs36\GitHandler\Exceptions\FileNotFound;
 7 | use ArtARTs36\GitHandler\Exceptions\SubmoduleNotFound;
 8 | 
 9 | /**
10 |  * Git Submodule
11 |  */
12 | interface GitSubmoduleCommand
13 | {
14 |     /**
15 |      * Add git submodule
16 |      * @git-command git submodule add $url
17 |      */
18 |     public function add(string $url): void;
19 | 
20 |     /**
21 |      * Get all submodules
22 |      * @return array<string, Submodule>
23 |      */
24 |     public function getAll(): array;
25 | 
26 |     /**
27 |      * Remove submodule
28 |      * @throws FileNotFound
29 |      * @throws SubmoduleNotFound
30 |      */
31 |     public function remove(string $name): void;
32 | 
33 |     /**
34 |      * Determine is exists submodule
35 |      */
36 |     public function exists(string $name): bool;
37 | 
38 |     /**
39 |      * Sync git submodule
40 |      * @git-command git submodule sync $name
41 |      */
42 |     public function sync(string $name): void;
43 | 
44 |     /**
45 |      * Sync defines in .gitmodules from git config
46 |      */
47 |     public function syncDefinesFromConfig(): void;
48 | }
49 | 


--------------------------------------------------------------------------------
/src/Contracts/Commands/GitTagCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Commands;
 4 | 
 5 | use ArtARTs36\GitHandler\Data\Tag;
 6 | use ArtARTs36\GitHandler\Exceptions\TagAlreadyExists;
 7 | use ArtARTs36\GitHandler\Exceptions\TagNotFound;
 8 | 
 9 | /**
10 |  * Git Tags
11 |  */
12 | interface GitTagCommand
13 | {
14 |     /**
15 |      * Get all git tags
16 |      * @git-command git tag
17 |      * @git-command git tag -l=$pattern
18 |      * @return array<string>
19 |      */
20 |     public function getAll(?string $pattern = null): array;
21 | 
22 |     /**
23 |      * Add git tag
24 |      * @git-command git -a $tag
25 |      * @git-command git -a $tag -m $message
26 |      * @throws TagAlreadyExists
27 |      */
28 |     public function add(string $tag, ?string $message = null): bool;
29 | 
30 |     /**
31 |      * Check tag exists
32 |      */
33 |     public function exists(string $tag): bool;
34 | 
35 |     /**
36 |      * Get git tag information
37 |      * @git-command git show $tagName
38 |      * @throws TagNotFound
39 |      */
40 |     public function get(string $tagName): Tag;
41 | }
42 | 


--------------------------------------------------------------------------------
/src/Contracts/Commands/HasSubmodules.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Commands;
 4 | 
 5 | interface HasSubmodules
 6 | {
 7 |     /**
 8 |      * Git submodules
 9 |      */
10 |     public function submodules(): GitSubmoduleCommand;
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Contracts/Commands/RefsPacker.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Commands;
 4 | 
 5 | interface RefsPacker
 6 | {
 7 |     /**
 8 |      * Create archive with .git/refs
 9 |      */
10 |     public function packRefs(string $path): void;
11 | 
12 |     /**
13 |      * Unpack archive with .git/refs
14 |      */
15 |     public function unpackRefs(string $path): void;
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Contracts/Common/Arrayable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Common;
 4 | 
 5 | interface Arrayable
 6 | {
 7 |     /**
 8 |      * @return array<string, mixed>
 9 |      */
10 |     public function toArray(): array;
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Contracts/Config/ConfigAttribute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Config;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Attribute\GitAttribute;
 6 | 
 7 | interface ConfigAttribute extends GitAttribute
 8 | {
 9 |     public function __toString(): string;
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Contracts/Config/ConfigResultParser.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Config;
 4 | 
 5 | use ArtARTs36\GitHandler\Config\Subjects\SubjectsCollection;
 6 | use ArtARTs36\GitHandler\Exceptions\ConfigDataNotFound;
 7 | use ArtARTs36\Str\Str;
 8 | 
 9 | interface ConfigResultParser
10 | {
11 |     /**
12 |      * @param Str $raw - raw response from git
13 |      * @throws \ArtARTs36\GitHandler\Exceptions\SubjectConfiguratorNotFound
14 |      */
15 |     public function parse(Str $raw): SubjectsCollection;
16 | 
17 |     /**
18 |      * @throws ConfigDataNotFound
19 |      */
20 |     public function parseByPrefix(Str $raw, string $prefix): ConfigSubject;
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Contracts/Config/ConfigSubject.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Config;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Common\Arrayable;
 6 | 
 7 | interface ConfigSubject extends Arrayable
 8 | {
 9 |     public function isEmpty(): bool;
10 | 
11 |     public function name(): string;
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Contracts/Config/ConfigSubjectList.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Config;
 4 | 
 5 | interface ConfigSubjectList extends \IteratorAggregate, ConfigSubject
 6 | {
 7 |     /**
 8 |      * @return iterable<string, ConfigSubject>
 9 |      */
10 |     public function getIterator(): iterable;
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Contracts/Config/SubjectConfigurator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Config;
 4 | 
 5 | interface SubjectConfigurator
 6 | {
 7 |     /**
 8 |      * @param array<string, string> $raw
 9 |      */
10 |     public function parse(array $raw): ConfigSubject;
11 | 
12 |     /**
13 |      * @return string
14 |      */
15 |     public function getPrefix(): string;
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Contracts/Factory/GitHandlerFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Factory;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Handler\GitHandler;
 6 | 
 7 | interface GitHandlerFactory
 8 | {
 9 |     public function factory(string $dir, string $bin = 'git'): GitHandler;
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Contracts/Handler/GitHandler.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace ArtARTs36\GitHandler\Contracts\Handler;
  4 | 
  5 | use ArtARTs36\GitHandler\Contracts\Commands\GitArchiveCommand;
  6 | use ArtARTs36\GitHandler\Contracts\Commands\GitBranchCommand;
  7 | use ArtARTs36\GitHandler\Contracts\Commands\GitCommitCommand;
  8 | use ArtARTs36\GitHandler\Contracts\Commands\GitConfigCommand;
  9 | use ArtARTs36\GitHandler\Contracts\Commands\GitFetchCommand;
 10 | use ArtARTs36\GitHandler\Contracts\Commands\GitFileCommand;
 11 | use ArtARTs36\GitHandler\Contracts\Commands\GitGarbageCommand;
 12 | use ArtARTs36\GitHandler\Contracts\Commands\GitGrepCommand;
 13 | use ArtARTs36\GitHandler\Contracts\Commands\GitHelpCommand;
 14 | use ArtARTs36\GitHandler\Contracts\Commands\GitHookCommand;
 15 | use ArtARTs36\GitHandler\Contracts\Commands\GitIgnoreCommand;
 16 | use ArtARTs36\GitHandler\Contracts\Commands\GitIndexCommand;
 17 | use ArtARTs36\GitHandler\Contracts\Commands\GitMergeCommand;
 18 | use ArtARTs36\GitHandler\Contracts\Commands\GitSetupCommand;
 19 | use ArtARTs36\GitHandler\Contracts\Commands\GitLogCommand;
 20 | use ArtARTs36\GitHandler\Contracts\Commands\GitPathCommand;
 21 | use ArtARTs36\GitHandler\Contracts\Commands\GitPullCommand;
 22 | use ArtARTs36\GitHandler\Contracts\Commands\GitPushCommand;
 23 | use ArtARTs36\GitHandler\Contracts\Commands\GitStashCommand;
 24 | use ArtARTs36\GitHandler\Contracts\Commands\GitStatusCommand;
 25 | use ArtARTs36\GitHandler\Contracts\Commands\GitTagCommand;
 26 | use ArtARTs36\GitHandler\Contracts\Commands\HasSubmodules;
 27 | use ArtARTs36\GitHandler\Contracts\HasContext;
 28 | use ArtARTs36\GitHandler\Contracts\HasUrl;
 29 | use ArtARTs36\GitHandler\Contracts\Transaction\GitTransaction;
 30 | 
 31 | interface GitHandler extends Versionable, HasRemotes, HasAttributes, HasSubmodules, HasBackup, HasContext, HasUrl
 32 | {
 33 |     /**
 34 |      * Git Help
 35 |      */
 36 |     public function helps(): GitHelpCommand;
 37 | 
 38 |     /**
 39 |      * Git Paths
 40 |      */
 41 |     public function paths(): GitPathCommand;
 42 | 
 43 |     /**
 44 |      * Git Tags
 45 |      */
 46 |     public function tags(): GitTagCommand;
 47 | 
 48 |     /**
 49 |      * Git Hooks
 50 |      */
 51 |     public function hooks(): GitHookCommand;
 52 | 
 53 |     /**
 54 |      * Git Archives
 55 |      */
 56 |     public function archives(): GitArchiveCommand;
 57 | 
 58 |     /**
 59 |      * Git Logs
 60 |      */
 61 |     public function logs(): GitLogCommand;
 62 | 
 63 |     /**
 64 |      * Git Greps
 65 |      */
 66 |     public function greps(): GitGrepCommand;
 67 | 
 68 |     /**
 69 |      * Git Setup
 70 |      */
 71 |     public function setup(): GitSetupCommand;
 72 | 
 73 |     /**
 74 |      * Git Branches
 75 |      */
 76 |     public function branches(): GitBranchCommand;
 77 | 
 78 |     /**
 79 |      * Git Files
 80 |      */
 81 |     public function files(): GitFileCommand;
 82 | 
 83 |     /**
 84 |      * Git Index
 85 |      */
 86 |     public function index(): GitIndexCommand;
 87 | 
 88 |     /**
 89 |      * Git Pushes
 90 |      */
 91 |     public function pushes(): GitPushCommand;
 92 | 
 93 |     /**
 94 |      * Git Statuses
 95 |      */
 96 |     public function statuses(): GitStatusCommand;
 97 | 
 98 |     /**
 99 |      * Git Commits
100 |      */
101 |     public function commits(): GitCommitCommand;
102 | 
103 |     /**
104 |      * Git Stashes
105 |      */
106 |     public function stashes(): GitStashCommand;
107 | 
108 |     /**
109 |      * Git Config
110 |      */
111 |     public function config(): GitConfigCommand;
112 | 
113 |     /**
114 |      * Git Ignore
115 |      */
116 |     public function ignores(): GitIgnoreCommand;
117 | 
118 |     /**
119 |      * Git Pulls
120 |      */
121 |     public function pulls(): GitPullCommand;
122 | 
123 |     /**
124 |      * Git Transaction
125 |      */
126 |     public function transaction(): GitTransaction;
127 | 
128 |     /**
129 |      * Git Garbage collect
130 |      */
131 |     public function garbage(): GitGarbageCommand;
132 | 
133 |     /**
134 |      * Git Merges
135 |      */
136 |     public function merges(): GitMergeCommand;
137 | 
138 |     /**
139 |      * Git fetches
140 |      */
141 |     public function fetches(): GitFetchCommand;
142 | }
143 | 


--------------------------------------------------------------------------------
/src/Contracts/Handler/HasAttributes.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Handler;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Commands\GitAttributeCommand;
 6 | 
 7 | interface HasAttributes
 8 | {
 9 |     /**
10 |      * Git attributes
11 |      */
12 |     public function attributes(): GitAttributeCommand;
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Contracts/Handler/HasBackup.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Handler;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Backup\GitBackup;
 6 | 
 7 | interface HasBackup
 8 | {
 9 |     /**
10 |      * Get git backup manager
11 |      */
12 |     public function backup(): GitBackup;
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Contracts/Handler/HasRemotes.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Handler;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Commands\GitRemoteCommand;
 6 | 
 7 | interface HasRemotes
 8 | {
 9 |     public function remotes(): GitRemoteCommand;
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Contracts/Handler/Versionable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Handler;
 4 | 
 5 | use ArtARTs36\GitHandler\Data\Version;
 6 | 
 7 | interface Versionable
 8 | {
 9 |     public function version(): Version;
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Contracts/HasContext.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts;
 4 | 
 5 | use ArtARTs36\GitHandler\Data\GitContext;
 6 | 
 7 | interface HasContext
 8 | {
 9 |     /**
10 |      * Get context.
11 |      */
12 |     public function getContext(): GitContext;
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Contracts/HasUrl.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts;
 4 | 
 5 | use ArtARTs36\GitHandler\Origin\Url\GitUrl;
 6 | 
 7 | interface HasUrl
 8 | {
 9 |     /**
10 |      * Git urls.
11 |      * @param array<string, string> $domainMap
12 |      */
13 |     public function urls(array $domainMap = []): GitUrl;
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Contracts/Log/LogQuery.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Log;
 4 | 
 5 | interface LogQuery
 6 | {
 7 |     /**
 8 |      * @return $this
 9 |      */
10 |     public function offset(int $offset);
11 | 
12 |     /**
13 |      * @return $this
14 |      */
15 |     public function limit(int $limit);
16 | 
17 |     /**
18 |      * @return $this
19 |      */
20 |     public function before(\DateTimeInterface $date);
21 | 
22 |     /**
23 |      * @return $this
24 |      */
25 |     public function after(\DateTimeInterface $date);
26 | 
27 |     /**
28 |      * @return $this
29 |      */
30 |     public function file(string $filename);
31 | 
32 |     /**
33 |      * @return $this
34 |      */
35 |     public function author(string $author);
36 | 
37 |     /**
38 |      * @return $this
39 |      */
40 |     public function grep(string $pattern);
41 | 
42 |     /**
43 |      * @param LogQueryAction|callable $build
44 |      * @return $this
45 |      */
46 |     public function union(callable $build);
47 | 
48 |     /**
49 |      * @return $this
50 |      */
51 |     public function diff(string $src, string $dest);
52 | }
53 | 


--------------------------------------------------------------------------------
/src/Contracts/Log/LogQueryAction.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace ArtARTs36\GitHandler\Contracts\Log;
4 | 
5 | interface LogQueryAction
6 | {
7 |     public function __invoke(LogQuery $query): void;
8 | }
9 | 


--------------------------------------------------------------------------------
/src/Contracts/Log/LogQueryBuilder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Log;
 4 | 
 5 | use ArtARTs36\ShellCommand\Interfaces\ShellCommandInterface;
 6 | 
 7 | interface LogQueryBuilder extends LogQuery
 8 | {
 9 |     /**
10 |      * Build this query
11 |      */
12 |     public function build(ShellCommandInterface $command): ShellCommandInterface;
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Contracts/LogParser.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts;
 4 | 
 5 | use ArtARTs36\GitHandler\Data\LogCollection;
 6 | use ArtARTs36\Str\Str;
 7 | 
 8 | interface LogParser
 9 | {
10 |     public function parse(Str $raw): ?LogCollection;
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Contracts/Origin/OriginDownloader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Origin;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Handler\HasRemotes;
 6 | 
 7 | interface OriginDownloader
 8 | {
 9 |     /**
10 |      * @throws \Psr\Http\Client\ClientExceptionInterface
11 |      */
12 |     public function download(HasRemotes $git, string $pathToSave): bool;
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Contracts/Origin/OriginUrlBuilder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Origin;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Handler\HasRemotes;
 6 | use ArtARTs36\GitHandler\Data\Repo;
 7 | use ArtARTs36\GitHandler\Exceptions\GivenInvalidUri;
 8 | 
 9 | interface OriginUrlBuilder
10 | {
11 |     /**
12 |      * Build url to commit page on remote hosting
13 |      */
14 |     public function toCommit(HasRemotes $git, string $hash): string;
15 | 
16 |     /**
17 |      * Build url to archive page on remote hosting
18 |      */
19 |     public function toArchive(HasRemotes $git, string $branch = 'master'): string;
20 | 
21 |     /**
22 |      * Build url to commit page on remote hosting
23 |      */
24 |     public function toCommitFromFetchUrl(string $fetchUrl, string $hash): string;
25 | 
26 |     /**
27 |      * Build url to archive page on remote hosting
28 |      */
29 |     public function toArchiveFromFetchUrl(string $fetchUrl, string $branch = 'master'): string;
30 | 
31 |     /**
32 |      * Build url to tag page on remote hosting
33 |      */
34 |     public function toTagFromFetchUrl(string $fetchUrl, string $tag): string;
35 | 
36 |     /**
37 |      * @return array<string>
38 |      */
39 |     public function getAvailableDomains(): array;
40 | 
41 |     /**
42 |      * Create Data Object "Repo" by repository url
43 |      * @throws GivenInvalidUri
44 |      */
45 |     public function toRepoFromUrl(string $url): Repo;
46 | 
47 |     /**
48 |      * Build url to "tags/branches compare" page on remote hosting
49 |      */
50 |     public function toTagsCompareFromFetchUrl(string $fetchUrl, string $oneTag, string $twoTag): string;
51 | 
52 |     /**
53 |      * Build url to file page on remote hosting
54 |      */
55 |     public function toFileFromFetchUrl(string $fetchUrl, string $filePath, string $branch): string;
56 | }
57 | 


--------------------------------------------------------------------------------
/src/Contracts/PathGenerator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts;
 4 | 
 5 | use ArtARTs36\GitHandler\Enum\ArchiveFormat;
 6 | 
 7 | interface PathGenerator
 8 | {
 9 |     /**
10 |      * Generate temporary archive path
11 |      */
12 |     public function toArchive(ArchiveFormat $format): string;
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Contracts/PushSetup.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts;
 4 | 
 5 | use ArtARTs36\GitHandler\Making\MakingPush;
 6 | 
 7 | interface PushSetup
 8 | {
 9 |     /**
10 |      * @return void
11 |      */
12 |     public function __invoke(MakingPush $push);
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Contracts/Transaction/GitTransaction.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Transaction;
 4 | 
 5 | use ArtARTs36\GitHandler\Exceptions\GitHandlerException;
 6 | 
 7 | /**
 8 |  * Git Transactions
 9 |  */
10 | interface GitTransaction
11 | {
12 |     /**
13 |      * Execute transaction
14 |      * @param TransactionOperation|\Closure|callable $callback
15 |      * @throws \Throwable
16 |      * @throws GitHandlerException
17 |      * @return mixed
18 |      */
19 |     public function attempt(callable $callback);
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Contracts/Transaction/TransactionOperation.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Contracts\Transaction;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Handler\GitHandler;
 6 | 
 7 | interface TransactionOperation
 8 | {
 9 |     /**
10 |      * @return mixed
11 |      */
12 |     public function __invoke(GitHandler $handler);
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Data/Author.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Data;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Common\Arrayable;
 6 | use ArtARTs36\GitHandler\Support\ToArray;
 7 | use JetBrains\PhpStorm\Immutable;
 8 | 
 9 | #[Immutable]
10 | class Author implements Arrayable
11 | {
12 |     use ToArray;
13 | 
14 |     public $name;
15 | 
16 |     public $email;
17 | 
18 |     public function __construct(string $name, string $email)
19 |     {
20 |         $this->name = $name;
21 |         $this->email = $email;
22 |     }
23 | 
24 |     public function equals(self $author): bool
25 |     {
26 |         return $this->name === $author->name && $this->email === $author->email;
27 |     }
28 | 
29 |     public function __toString(): string
30 |     {
31 |         return "$this->name <$this->email>";
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/Data/Author/CacheableHydrator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Data\Author;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\AuthorHydrator;
 6 | use ArtARTs36\GitHandler\Data\Author;
 7 | 
 8 | class CacheableHydrator implements AuthorHydrator
 9 | {
10 |     protected $hydrator;
11 | 
12 |     /** @var array<string, Author> */
13 |     protected $authors = [];
14 | 
15 |     public function __construct(AuthorHydrator $hydrator)
16 |     {
17 |         $this->hydrator = $hydrator;
18 |     }
19 | 
20 |     public function hydrate(array $raw): Author
21 |     {
22 |         if (! array_key_exists($raw['email'], $this->authors)) {
23 |             $this->authors[$raw['email']] = $this->hydrator->hydrate($raw);
24 |         }
25 | 
26 |         return $this->authors[$raw['email']];
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Data/Author/Hydrator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Data\Author;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\AuthorHydrator;
 6 | use ArtARTs36\GitHandler\Data\Author;
 7 | 
 8 | class Hydrator implements AuthorHydrator
 9 | {
10 |     public function hydrate(array $raw): Author
11 |     {
12 |         return new Author($raw['name'], $raw['email']);
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Data/Commit.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Data;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Common\Arrayable;
 6 | use ArtARTs36\GitHandler\Support\ToArray;
 7 | 
 8 | class Commit implements Arrayable
 9 | {
10 |     use ToArray;
11 | 
12 |     public $hash;
13 | 
14 |     public function __construct(string $hash)
15 |     {
16 |         $this->hash = $hash;
17 |     }
18 | 
19 |     public function getAbbreviatedHash(): string
20 |     {
21 |         return mb_substr($this->hash, 0, 6);
22 |     }
23 | 
24 |     public function __toString(): string
25 |     {
26 |         return $this->hash;
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Data/CommitsAuthor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Data;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Common\Arrayable;
 6 | use ArtARTs36\GitHandler\Support\ToArray;
 7 | use JetBrains\PhpStorm\ArrayShape;
 8 | 
 9 | class CommitsAuthor implements \IteratorAggregate, \Countable, Arrayable
10 | {
11 |     use ToArray;
12 | 
13 |     public $author;
14 | 
15 |     public $commits;
16 | 
17 |     /**
18 |      * @param array<Commit> $commits
19 |      */
20 |     public function __construct(Author $author, array $commits)
21 |     {
22 |         $this->author = $author;
23 |         $this->commits = $commits;
24 |     }
25 | 
26 |     /**
27 |      * @param array<string, Author|array<Commit>> $data
28 |      */
29 |     public static function fromArray(
30 |         #[ArrayShape(['author' => Author::class, 'commits' => 'array'])]
31 |         array $data
32 |     ): self {
33 |         return new self($data['author'], $data['commits']);
34 |     }
35 | 
36 |     public function count(): int
37 |     {
38 |         return count($this->commits);
39 |     }
40 | 
41 |     /**
42 |      * @return iterable<Commit>
43 |      */
44 |     public function getIterator(): iterable
45 |     {
46 |         return new \ArrayIterator($this->commits);
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/src/Data/FileMatch.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Data;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Common\Arrayable;
 6 | use ArtARTs36\GitHandler\Support\ToArray;
 7 | use JetBrains\PhpStorm\ArrayShape;
 8 | 
 9 | class FileMatch implements Arrayable
10 | {
11 |     use ToArray;
12 | 
13 |     public $file;
14 | 
15 |     public $line;
16 | 
17 |     public $content;
18 | 
19 |     public function __construct(string $file, int $line, string $content)
20 |     {
21 |         $this->file = $file;
22 |         $this->line = $line;
23 |         $this->content = $content;
24 |     }
25 | 
26 |     /**
27 |      * @param array<string, string|int> $data
28 |      */
29 |     public static function fromArray(
30 |         #[ArrayShape(['file' => 'string', 'line' => 'int', 'content' => 'string'])]
31 |         array $data
32 |     ): self {
33 |         return new self($data['file'], $data['line'], $data['content']);
34 |     }
35 | 
36 |     public function getReference(): string
37 |     {
38 |         return $this->file . ':' . $this->line;
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Data/GitAttributes.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Data;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Common\Arrayable;
 6 | use ArtARTs36\GitHandler\Support\ToArray;
 7 | use ArtARTs36\Str\Str;
 8 | 
 9 | class GitAttributes implements Arrayable
10 | {
11 |     use ToArray;
12 | 
13 |     public $pattern;
14 | 
15 |     public $attributes;
16 | 
17 |     /**
18 |      * @param array<string|Str> $attributes
19 |      */
20 |     public function __construct(string $pattern, array $attributes)
21 |     {
22 |         $this->pattern = $pattern;
23 |         $this->attributes = $attributes;
24 |     }
25 | 
26 |     public function has(string $attribute): bool
27 |     {
28 |         return in_array($attribute, $this->attributes);
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Data/GitContext.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Data;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Common\Arrayable;
 6 | use ArtARTs36\GitHandler\Support\ToArray;
 7 | 
 8 | class GitContext implements Arrayable
 9 | {
10 |     use ToArray;
11 | 
12 |     protected $rootDir;
13 | 
14 |     protected $gitDir;
15 | 
16 |     public function __construct(string $rootDir, string $gitDir)
17 |     {
18 |         $this->rootDir = $rootDir;
19 |         $this->gitDir = $gitDir;
20 |     }
21 | 
22 |     public static function make(string $rootDir, ?string $gitFolder = '.git'): self
23 |     {
24 |         return new self($rootDir, $rootDir . DIRECTORY_SEPARATOR . $gitFolder);
25 |     }
26 | 
27 |     public function getRootDir(): string
28 |     {
29 |         return $this->rootDir;
30 |     }
31 | 
32 |     public function getRootFolder(): string
33 |     {
34 |         return pathinfo($this->rootDir, PATHINFO_BASENAME);
35 |     }
36 | 
37 |     public function getGitDir(): string
38 |     {
39 |         return $this->gitDir;
40 |     }
41 | 
42 |     public function getRefsDir(): string
43 |     {
44 |         return $this->gitDir . DIRECTORY_SEPARATOR . 'refs';
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/src/Data/Hook.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Data;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Common\Arrayable;
 6 | use ArtARTs36\GitHandler\Support\ToArray;
 7 | 
 8 | class Hook implements Arrayable
 9 | {
10 |     use ToArray;
11 | 
12 |     public $name;
13 | 
14 |     public $script;
15 | 
16 |     public $lastUpdateDate;
17 | 
18 |     public function __construct(string $name, string $script, \DateTimeInterface $lastUpdateDate)
19 |     {
20 |         $this->name = $name;
21 |         $this->script = $script;
22 |         $this->lastUpdateDate = $lastUpdateDate;
23 |     }
24 | 
25 |     public static function now(string $name, string $script): self
26 |     {
27 |         return new self($name, $script, new \DateTime());
28 |     }
29 | 
30 |     public function isSample(): bool
31 |     {
32 |         return pathinfo($this->name, PATHINFO_EXTENSION) === 'sample';
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Data/Log.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Data;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Common\Arrayable;
 6 | use ArtARTs36\GitHandler\Support\ToArray;
 7 | use JetBrains\PhpStorm\Immutable;
 8 | 
 9 | #[Immutable]
10 | class Log implements Arrayable
11 | {
12 |     use ToArray;
13 | 
14 |     public $commit;
15 | 
16 |     public $author;
17 | 
18 |     public $date;
19 | 
20 |     public $message;
21 | 
22 |     public function __construct(Commit $commit, \DateTimeInterface $date, Author $author, string $message)
23 |     {
24 |         $this->commit = $commit;
25 |         $this->author = $author;
26 |         $this->date = $date;
27 |         $this->message = $message;
28 |     }
29 | 
30 |     public function equalsDate(\DateTimeInterface $date): bool
31 |     {
32 |         return $this->date->format('Y-m-d') === $date->format('Y-m-d');
33 |     }
34 | 
35 |     /**
36 |      * @return array<string, string|array>
37 |      */
38 |     public function toArray(): array
39 |     {
40 |         return [
41 |             'commit' => $this->commit->toArray(),
42 |             'date' => $this->date->format('Y-m-d H:i:s'),
43 |             'author' => $this->author->toArray(),
44 |             'message' => $this->message,
45 |         ];
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/src/Data/LogCollection.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace ArtARTs36\GitHandler\Data;
  4 | 
  5 | use JetBrains\PhpStorm\Immutable;
  6 | 
  7 | /**
  8 |  * @template-implements \IteratorAggregate<int, Log>
  9 |  */
 10 | #[Immutable]
 11 | class LogCollection implements \IteratorAggregate, \Countable
 12 | {
 13 |     protected $logs;
 14 | 
 15 |     /**
 16 |      * @param non-empty-array<Log> $logs
 17 |      */
 18 |     public function __construct(array $logs)
 19 |     {
 20 |         $this->logs = $logs;
 21 |     }
 22 | 
 23 |     /**
 24 |      * Get first Log from collection.
 25 |      */
 26 |     public function first(): Log
 27 |     {
 28 |         return $this->logs[array_key_first($this->logs)];
 29 |     }
 30 | 
 31 |     /**
 32 |      * Get last Log from collection.
 33 |      */
 34 |     public function last(): Log
 35 |     {
 36 |         $logs = $this->logs;
 37 | 
 38 |         return end($logs);
 39 |     }
 40 | 
 41 |     public function filterByAuthorName(string $name): ?self
 42 |     {
 43 |         return $this->filter(function (Log $log) use ($name) {
 44 |             return $log->author->name === $name;
 45 |         });
 46 |     }
 47 | 
 48 |     public function filterByDate(\DateTimeInterface $date): ?self
 49 |     {
 50 |         return $this->filter(function (Log $log) use ($date) {
 51 |             return $log->equalsDate($date);
 52 |         });
 53 |     }
 54 | 
 55 |     public function filter(\Closure $callback): ?self
 56 |     {
 57 |         $logs = array_filter($this->logs, $callback);
 58 | 
 59 |         if (count($logs) === 0) {
 60 |             return null;
 61 |         }
 62 | 
 63 |         return new self(array_values($logs));
 64 |     }
 65 | 
 66 |     /**
 67 |      * @return iterable<Log>
 68 |      */
 69 |     public function getIterator(): iterable
 70 |     {
 71 |         return new \ArrayIterator($this->logs);
 72 |     }
 73 | 
 74 |     /**
 75 |      * Get count of logs.
 76 |      */
 77 |     public function count(): int
 78 |     {
 79 |         return count($this->logs);
 80 |     }
 81 | 
 82 |     /**
 83 |      * @return Log[]
 84 |      */
 85 |     public function all(): array
 86 |     {
 87 |         return $this->logs;
 88 |     }
 89 | 
 90 |     /**
 91 |      * @param array<string, string> $aliases - emails
 92 |      * @return array<string, CommitsAuthor>
 93 |      */
 94 |     public function getAuthorsWithCommits(array $aliases = []): array
 95 |     {
 96 |         $authors = [];
 97 | 
 98 |         foreach ($this->logs as $log) {
 99 |             $identity = $aliases[$log->author->email] ?? $log->author->email;
100 | 
101 |             if (! array_key_exists($identity, $authors)) {
102 |                 $authors[$identity]['author'] = $log->author;
103 |                 $authors[$identity]['commits'] = [];
104 |             }
105 | 
106 |             $authors[$identity]['commits'][] = $log->commit;
107 |         }
108 | 
109 |         return array_map([CommitsAuthor::class, 'fromArray'], $authors);
110 |     }
111 | }
112 | 


--------------------------------------------------------------------------------
/src/Data/Remotes.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Data;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Common\Arrayable;
 6 | use ArtARTs36\GitHandler\Support\ToArray;
 7 | use ArtARTs36\Str\Str;
 8 | use JetBrains\PhpStorm\Immutable;
 9 | 
10 | #[Immutable]
11 | class Remotes implements Arrayable
12 | {
13 |     use ToArray;
14 | 
15 |     public $fetch;
16 | 
17 |     public $push;
18 | 
19 |     public function __construct(Str $fetch, Str $push)
20 |     {
21 |         $this->fetch = $fetch;
22 |         $this->push = $push;
23 |     }
24 | 
25 |     public static function createEmpty(): self
26 |     {
27 |         return new self(Str::fromEmpty(), Str::fromEmpty());
28 |     }
29 | 
30 |     public function isEmpty(): bool
31 |     {
32 |         return $this->fetch->isEmpty() && $this->push->isEmpty();
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Data/Repo.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Data;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Common\Arrayable;
 6 | use ArtARTs36\GitHandler\Support\ToArray;
 7 | 
 8 | class Repo implements Arrayable
 9 | {
10 |     use ToArray;
11 | 
12 |     public $name;
13 | 
14 |     public $user;
15 | 
16 |     public $url;
17 | 
18 |     /**
19 |      * @codeCoverageIgnore
20 |      */
21 |     public function __construct(string $name, string $user, string $url)
22 |     {
23 |         $this->name = $name;
24 |         $this->user = $user;
25 |         $this->url = $url;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Data/Stash.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Data;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Common\Arrayable;
 6 | use ArtARTs36\GitHandler\Support\ToArray;
 7 | 
 8 | class Stash implements Arrayable
 9 | {
10 |     use ToArray;
11 | 
12 |     public $id;
13 | 
14 |     public $branch;
15 | 
16 |     public $name;
17 | 
18 |     /**
19 |      * @codeCoverageIgnore
20 |      */
21 |     public function __construct(int $id, string $branch, string $name)
22 |     {
23 |         $this->id = $id;
24 |         $this->branch = $branch;
25 |         $this->name = $name;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Data/Submodule.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Data;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Common\Arrayable;
 6 | use ArtARTs36\GitHandler\Support\ToArray;
 7 | use JetBrains\PhpStorm\ArrayShape;
 8 | 
 9 | class Submodule implements Arrayable
10 | {
11 |     use ToArray;
12 | 
13 |     public $name;
14 | 
15 |     public $path;
16 | 
17 |     public $url;
18 | 
19 |     final public function __construct(string $name, string $path, string $url)
20 |     {
21 |         $this->name = $name;
22 |         $this->path = $path;
23 |         $this->url = $url;
24 |     }
25 | 
26 |     /**
27 |      * @param array<string, string> $array
28 |      */
29 |     public static function fromArray(
30 |         #[ArrayShape(['name' => 'string', 'path' => 'string', 'url' => 'string'])]
31 |         array $array
32 |     ): self {
33 |         return new self($array['name'], $array['path'], $array['url']);
34 |     }
35 | 
36 |     public function equals(self $other): bool
37 |     {
38 |         return $this->name === $other->name;
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Data/Tag.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Data;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Common\Arrayable;
 6 | use ArtARTs36\GitHandler\Support\ToArray;
 7 | 
 8 | class Tag implements Arrayable
 9 | {
10 |     use ToArray;
11 | 
12 |     public $author;
13 | 
14 |     public $date;
15 | 
16 |     public $commit;
17 | 
18 |     public $message;
19 | 
20 |     /**
21 |      * @codeCoverageIgnore
22 |      */
23 |     public function __construct(Author $author, \DateTime $date, Commit $commit, string $message)
24 |     {
25 |         $this->author = $author;
26 |         $this->date = $date;
27 |         $this->commit = $commit;
28 |         $this->message = $message;
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Data/Version.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Data;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Common\Arrayable;
 6 | use ArtARTs36\GitHandler\Support\ToArray;
 7 | 
 8 | class Version implements Arrayable
 9 | {
10 |     use ToArray;
11 | 
12 |     public $full;
13 | 
14 |     public $major;
15 | 
16 |     public $minor;
17 | 
18 |     public $patch;
19 | 
20 |     public function __construct(string $full, int $major, int $minor, int $patch)
21 |     {
22 |         $this->full = $full;
23 |         $this->major = $major;
24 |         $this->minor = $minor;
25 |         $this->patch = $patch;
26 |     }
27 | 
28 |     public function __toString(): string
29 |     {
30 |         return $this->full;
31 |     }
32 | 
33 |     /**
34 |      * @param static|string $comparedVersion
35 |      * @return bool|int
36 |      */
37 |     public function compare($comparedVersion)
38 |     {
39 |         if ($comparedVersion instanceof static) {
40 |             $comparedVersion = $comparedVersion->toTag();
41 |         }
42 | 
43 |         return version_compare($this->toTag(), $comparedVersion);
44 |     }
45 | 
46 |     public function toTag(): string
47 |     {
48 |         return implode('.', [
49 |             $this->major,
50 |             $this->minor,
51 |             $this->patch,
52 |         ]);
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/src/Enum/ArchiveFormat.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Enum;
 4 | 
 5 | class ArchiveFormat
 6 | {
 7 |     use Enumerable;
 8 | 
 9 |     public const ZIP = 'zip';
10 |     public const GZ = 'gz';
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Enum/BranchBadName.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Enum;
 4 | 
 5 | use ArtARTs36\Str\Str;
 6 | 
 7 | class BranchBadName
 8 | {
 9 |     use Enumerable;
10 | 
11 |     public const NAME_HEAD = 'HEAD';
12 | 
13 |     public static function is(Str $branch): bool
14 |     {
15 |         return in_array($branch, static::cases()) || $branch->containsAny([
16 |             '[', '..',
17 |         ]);
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Enum/ConfigSectionName.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Enum;
 4 | 
 5 | class ConfigSectionName
 6 | {
 7 |     use Enumerable;
 8 | 
 9 |     public const SUBMODULE = 'submodule';
10 |     public const BRANCH = 'branch';
11 |     public const USER = 'user';
12 |     public const REMOTE = 'remote';
13 |     public const CORE = 'core';
14 |     public const PACK = 'pack';
15 |     public const COMMIT = 'commit';
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Enum/Enumerable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Enum;
 4 | 
 5 | trait Enumerable
 6 | {
 7 |     /** @var string */
 8 |     public $value;
 9 | 
10 |     /**
11 |      * @codeCoverageIgnore
12 |      * @return array<string, string>
13 |      */
14 |     public static function cases(): array
15 |     {
16 |         static $cases = [];
17 | 
18 |         if (! array_key_exists(static::class, $cases)) {
19 |             $cases[static::class] = (new \ReflectionClass(static::class))->getConstants();
20 |         }
21 | 
22 |         return $cases[static::class];
23 |     }
24 | 
25 |     /**
26 |      * @codeCoverageIgnore
27 |      */
28 |     public static function from(string $value): self
29 |     {
30 |         if (! static::has($value)) {
31 |             throw new \InvalidArgumentException('Invalid Enum Value');
32 |         }
33 | 
34 |         $enum = new self();
35 |         $enum->value = $value;
36 | 
37 |         return $enum;
38 |     }
39 | 
40 |     /**
41 |      * @codeCoverageIgnore
42 |      */
43 |     protected static function has(string $value): bool
44 |     {
45 |         return array_key_exists($value, array_flip(static::cases()));
46 |     }
47 | 
48 |     /**
49 |      * @codeCoverageIgnore
50 |      */
51 |     public function __toString()
52 |     {
53 |         return $this->value;
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/src/Enum/FormatPlaceholder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Enum;
 4 | 
 5 | /**
 6 |  * @link https://git-scm.com/docs/pretty-formats
 7 |  */
 8 | class FormatPlaceholder
 9 | {
10 |     use Enumerable;
11 | 
12 |     public const COMMIT_HASH = '%H';
13 |     public const BODY = '%b';
14 | 
15 |     public const SUBJECT = '%s';
16 | 
17 |     public const REF_NAME = '%d'; // ref names, like the --decorate option of git-log(1)
18 | 
19 |     public const REFLOG_SUBJECT = '%gs';
20 |     public const REFLOG_SELECTOR = '%gD'; // reflog selector, e.g., refs/stash@{1}
21 |     public const REFLOG_SHORTENED_SELECTOR = '%gd'; // shortened reflog selector, e.g., stash@{1}
22 | 
23 |     public const AUTHOR_NAME = '%an';
24 |     public const AUTHOR_EMAIL = '%ae';
25 | 
26 |     public const AUTHOR_DATE_RFC2822 = '%aD';
27 | 
28 |     public const NEW_LINE = '%n';
29 | 
30 |     public const TREE_HASH = '%T';
31 |     public const TREE_ABBREVIATED_HASH = '%t';
32 | 
33 |     /**
34 |      * @codeCoverageIgnore
35 |      * @param non-empty-list<string> $holders
36 |      */
37 |     public static function format(array $holders, string $separator = '|'): string
38 |     {
39 |         return "format:'" . implode($separator, $holders) . "'";
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/Enum/GarbageCollectMode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Enum;
 4 | 
 5 | final class GarbageCollectMode
 6 | {
 7 |     public const AUTO = 'auto';
 8 |     public const AGGRESSIVE = 'aggressive';
 9 | 
10 |     use Enumerable;
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Enum/HookName.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Enum;
 4 | 
 5 | class HookName
 6 | {
 7 |     use Enumerable;
 8 | 
 9 |     public const APPLY_PATH_MSG = 'applypatch-msg'; // git am
10 |     public const COMMIT_MSG = 'commit-msg';
11 |     public const FS_MONITOR_WATCHMAN = 'fsmonitor-watchman';
12 |     public const PRE_APPLY_PATCH = 'pre-applypatch';
13 |     public const PRE_COMMIT = 'pre-commit'; // git commit: before commit
14 |     public const PREPARE_COMMIT_MSG = 'prepare-commit-msg';
15 |     public const PRE_PUSH = 'pre-push'; // git push: before push
16 |     public const PRE_REBASE = 'pre-rebase';
17 |     public const POST_UPDATE = 'post-update'; // git push: after push
18 |     public const PRE_RECEIVE = 'pre-receive';
19 |     public const UPDATE = 'update';
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Enum/ResetMode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Enum;
 4 | 
 5 | class ResetMode
 6 | {
 7 |     use Enumerable;
 8 | 
 9 |     public const SOFT = 'soft';
10 |     public const HARD = 'hard';
11 |     public const MIXED = 'mixed';
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Enum/StatusResult.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Enum;
 4 | 
 5 | class StatusResult
 6 | {
 7 |     use Enumerable;
 8 | 
 9 |     public const GROUP_MODIFIED = 'M';
10 |     public const GROUP_ADDED = 'AM';
11 |     public const GROUP_UNTRACKED = '??';
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Exceptions/AlreadySwitched.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Exceptions;
 4 | 
 5 | use JetBrains\PhpStorm\Immutable;
 6 | use Throwable;
 7 | 
 8 | class AlreadySwitched extends GitHandlerException
 9 | {
10 |     #[Immutable]
11 |     public $errorBranch;
12 | 
13 |     public function __construct(string $branch)
14 |     {
15 |         $this->errorBranch = $branch;
16 | 
17 |         parent::__construct('Already on '. $branch);
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Exceptions/BadRevision.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Exceptions;
 4 | 
 5 | class BadRevision extends GitHandlerException
 6 | {
 7 |     public $failedRevision;
 8 | 
 9 |     public function __construct(string $failedRevision)
10 |     {
11 |         $this->failedRevision = $failedRevision;
12 | 
13 |         parent::__construct("Bad revision: $failedRevision");
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Exceptions/BranchAlreadyExists.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Exceptions;
 4 | 
 5 | class BranchAlreadyExists extends GitHandlerException
 6 | {
 7 |     public $errorBranch;
 8 | 
 9 |     public function __construct(string $branch)
10 |     {
11 |         $this->errorBranch = $branch;
12 | 
13 |         $message = "Branch {$branch} already exists";
14 | 
15 |         parent::__construct($message);
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Exceptions/BranchDoesNotHaveCommits.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Exceptions;
 4 | 
 5 | class BranchDoesNotHaveCommits extends GitHandlerException
 6 | {
 7 |     public $errorBranch;
 8 | 
 9 |     public function __construct(string $errorBranch)
10 |     {
11 |         $this->errorBranch = $errorBranch;
12 | 
13 |         $message = "branch '$errorBranch' does not have any commits yet";
14 | 
15 |         parent::__construct($message);
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Exceptions/BranchHasNoUpstream.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Exceptions;
 4 | 
 5 | class BranchHasNoUpstream extends GitHandlerException
 6 | {
 7 |     public $errorBranch;
 8 | 
 9 |     public function __construct(string $branch)
10 |     {
11 |         $this->errorBranch = $branch;
12 | 
13 |         parent::__construct($this->prepareMessage());
14 |     }
15 | 
16 |     /**
17 |      * @codeCoverageIgnore
18 |      */
19 |     public static function patternStdError(): string
20 |     {
21 |         return "The current branch (.*) has no upstream branch";
22 |     }
23 | 
24 |     protected function prepareMessage(): string
25 |     {
26 |         return "The current branch $this->errorBranch has no upstream branch";
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Exceptions/BranchNotFound.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Exceptions;
 4 | 
 5 | class BranchNotFound extends GitHandlerException
 6 | {
 7 |     public $errorBranch;
 8 | 
 9 |     public function __construct(string $branch)
10 |     {
11 |         $this->errorBranch = $branch;
12 | 
13 |         $message = "Git Branch '{$branch}' Not Found";
14 | 
15 |         parent::__construct($message);
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Exceptions/CannotMergeAbort.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Exceptions;
 4 | 
 5 | class CannotMergeAbort extends GitHandlerException
 6 | {
 7 |     public function __construct(string $reason)
 8 |     {
 9 |         $message = 'fatal: There is no merge to abort ('. $reason . ')';
10 | 
11 |         parent::__construct($message);
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Exceptions/CannotMergeException.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace ArtARTs36\GitHandler\Exceptions;
4 | 
5 | class CannotMergeException extends GitHandlerException
6 | {
7 |     public $failedMergeBranch;
8 | }
9 | 


--------------------------------------------------------------------------------
/src/Exceptions/ConfigDataNotFound.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Exceptions;
 4 | 
 5 | class ConfigDataNotFound extends GitHandlerException
 6 | {
 7 |     public $errorPrefix;
 8 | 
 9 |     public function __construct(string $prefix)
10 |     {
11 |         $this->errorPrefix = $prefix;
12 | 
13 |         $message = "Config Data by prefix $prefix not found";
14 | 
15 |         parent::__construct($message);
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Exceptions/ConfigSectionNotFound.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Exceptions;
 4 | 
 5 | use Throwable;
 6 | 
 7 | class ConfigSectionNotFound extends GitHandlerException
 8 | {
 9 |     public $failedConfigSection;
10 | 
11 |     public function __construct(string $failedConfigSection)
12 |     {
13 |         $this->failedConfigSection = $failedConfigSection;
14 | 
15 |         parent::__construct("Key does not contain a section: $failedConfigSection");
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Exceptions/ConfigVariableNotFound.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Exceptions;
 4 | 
 5 | final class ConfigVariableNotFound extends GitHandlerException
 6 | {
 7 |     public $failedConfigVariable;
 8 | 
 9 |     public function __construct(string $failedConfigVariable)
10 |     {
11 |         $this->failedConfigVariable = $failedConfigVariable;
12 | 
13 |         parent::__construct("key does not contain a section: $failedConfigVariable");
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Exceptions/FileNotFound.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Exceptions;
 4 | 
 5 | use ArtARTs36\Str\Str;
 6 | 
 7 | class FileNotFound extends GitHandlerException implements \ArtARTs36\FileSystem\Contracts\FileNotFound
 8 | {
 9 |     protected $invalidFilePath;
10 | 
11 |     public function __construct(string $file)
12 |     {
13 |         $this->invalidFilePath = $file;
14 | 
15 |         $message = "File '{$file}' Not Found";
16 | 
17 |         parent::__construct($message);
18 |     }
19 | 
20 |     public static function handleIfSo(Str $err): void
21 |     {
22 |         $path = $err->match("/pathspec '(.*)' did not match any/i");
23 |         if ($path->isNotEmpty()) {
24 |             throw new self($path);
25 |         }
26 |     }
27 | 
28 |     public function getInvalidFilePath(): string
29 |     {
30 |         return $this->invalidFilePath;
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Exceptions/GitHandlerException.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace ArtARTs36\GitHandler\Exceptions;
4 | 
5 | abstract class GitHandlerException extends \LogicException
6 | {
7 |     //
8 | }
9 | 


--------------------------------------------------------------------------------
/src/Exceptions/GivenInvalidUri.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Exceptions;
 4 | 
 5 | class GivenInvalidUri extends GitHandlerException
 6 | {
 7 |     public $failedUrl;
 8 | 
 9 |     public function __construct(string $url)
10 |     {
11 |         $this->failedUrl = $url;
12 | 
13 |         parent::__construct("Given invalid uri: ". $url);
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Exceptions/HookNotExists.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Exceptions;
 4 | 
 5 | class HookNotExists extends GitHandlerException
 6 | {
 7 |     public $errorHookName;
 8 | 
 9 |     /**
10 |      * @codeCoverageIgnore
11 |      */
12 |     public function __construct(string $errorHookName)
13 |     {
14 |         $this->errorHookName = $errorHookName;
15 | 
16 |         parent::__construct("Hook $errorHookName not exists!");
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Exceptions/MergeHeadMissing.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Exceptions;
 4 | 
 5 | class MergeHeadMissing extends CannotMergeAbort
 6 | {
 7 |     public function __construct()
 8 |     {
 9 |         parent::__construct('MERGE_HEAD missing');
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/src/Exceptions/NotSomethingWeCanMerge.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Exceptions;
 4 | 
 5 | final class NotSomethingWeCanMerge extends CannotMergeException
 6 | {
 7 |     public function __construct(string $branch)
 8 |     {
 9 |         $this->failedMergeBranch = $branch;
10 | 
11 |         parent::__construct("merge: $branch - not something we can merge");
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Exceptions/NothingToCommit.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace ArtARTs36\GitHandler\Exceptions;
4 | 
5 | class NothingToCommit extends GitHandlerException
6 | {
7 |     //
8 | }
9 | 


--------------------------------------------------------------------------------
/src/Exceptions/ObjectNameNotValid.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Exceptions;
 4 | 
 5 | use JetBrains\PhpStorm\Immutable;
 6 | use Throwable;
 7 | 
 8 | class ObjectNameNotValid extends GitHandlerException
 9 | {
10 |     #[Immutable]
11 |     public $errorObjectName;
12 | 
13 |     public function __construct(string $objectName)
14 |     {
15 |         $this->errorObjectName = $objectName;
16 | 
17 |         parent::__construct("Not a valid object name: '$objectName'");
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Exceptions/OriginUrlNotFound.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace ArtARTs36\GitHandler\Exceptions;
4 | 
5 | class OriginUrlNotFound extends GitHandlerException
6 | {
7 |     //
8 | }
9 | 


--------------------------------------------------------------------------------
/src/Exceptions/PathAlreadyExists.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Exceptions;
 4 | 
 5 | use ArtARTs36\Str\Str;
 6 | 
 7 | class PathAlreadyExists extends GitHandlerException
 8 | {
 9 |     public $errorPath;
10 | 
11 |     final public function __construct(string $path)
12 |     {
13 |         $this->errorPath = $path;
14 | 
15 |         $message = "Path '$path' already exists";
16 | 
17 |         parent::__construct($message);
18 |     }
19 | 
20 |     /**
21 |      * @codeCoverageIgnore
22 |      */
23 |     public static function patternStdError(string $path): string
24 |     {
25 |         return "destination path '{$path}' already exists";
26 |     }
27 | 
28 |     public static function handleIfSo(string $path, Str $stdout): void
29 |     {
30 |         if ($stdout->contains(static::patternStdError($path))) {
31 |             throw new static($path);
32 |         }
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Exceptions/PathIncorrect.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Exceptions;
 4 | 
 5 | class PathIncorrect extends GitHandlerException
 6 | {
 7 |     public $incorrectPath;
 8 | 
 9 |     public function __construct(string $path)
10 |     {
11 |         $this->incorrectPath = $path;
12 | 
13 |         $message = "Path {$path} incorrect!";
14 | 
15 |         parent::__construct($message);
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Exceptions/PathIsDirectoryNotCould.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace ArtARTs36\GitHandler\Exceptions;
4 | 
5 | class PathIsDirectoryNotCould extends GitHandlerException
6 | {
7 |     //
8 | }
9 | 


--------------------------------------------------------------------------------
/src/Exceptions/PreviousCherryPickIsNowEmpty.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace ArtARTs36\GitHandler\Exceptions;
4 | 
5 | class PreviousCherryPickIsNowEmpty extends GitHandlerException
6 | {
7 |     //
8 | }
9 | 


--------------------------------------------------------------------------------
/src/Exceptions/ReferenceInvalid.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Exceptions;
 4 | 
 5 | class ReferenceInvalid extends GitHandlerException
 6 | {
 7 |     public $errorReference;
 8 | 
 9 |     public function __construct(string $errorReference)
10 |     {
11 |         $this->errorReference = $errorReference;
12 | 
13 |         parent::__construct("Invalid reference: ". $errorReference);
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Exceptions/RemoteAlreadyExists.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Exceptions;
 4 | 
 5 | class RemoteAlreadyExists extends GitHandlerException
 6 | {
 7 |     public $remoteName;
 8 | 
 9 |     public function __construct(string $remoteName)
10 |     {
11 |         $this->remoteName = $remoteName;
12 | 
13 |         $message = "Remote $remoteName already exists";
14 | 
15 |         parent::__construct($message);
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Exceptions/RemoteNotFilled.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace ArtARTs36\GitHandler\Exceptions;
4 | 
5 | class RemoteNotFilled extends GitHandlerException
6 | {
7 |     //
8 | }
9 | 


--------------------------------------------------------------------------------
/src/Exceptions/RemoteNotFound.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Exceptions;
 4 | 
 5 | class RemoteNotFound extends GitHandlerException
 6 | {
 7 |     public $remoteName;
 8 | 
 9 |     public function __construct(string $remoteName)
10 |     {
11 |         $this->remoteName = $remoteName;
12 | 
13 |         parent::__construct("No such remote: $remoteName");
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Exceptions/RemoteRepositoryNotFound.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Exceptions;
 4 | 
 5 | class RemoteRepositoryNotFound extends GitHandlerException
 6 | {
 7 |     public $errorRemoteRepository;
 8 | 
 9 |     public function __construct(string $errorRemoteRepository)
10 |     {
11 |         $this->errorRemoteRepository = $errorRemoteRepository;
12 | 
13 |         parent::__construct("Remote Repository $errorRemoteRepository not found");
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Exceptions/RepositoryAlreadyExists.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace ArtARTs36\GitHandler\Exceptions;
4 | 
5 | class RepositoryAlreadyExists extends PathAlreadyExists
6 | {
7 |     //
8 | }
9 | 


--------------------------------------------------------------------------------
/src/Exceptions/StashDoesNotExists.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Exceptions;
 4 | 
 5 | class StashDoesNotExists extends GitHandlerException
 6 | {
 7 |     public $errorStashId;
 8 | 
 9 |     public function __construct(int $errorStashId)
10 |     {
11 |         $this->errorStashId = $errorStashId;
12 | 
13 |         parent::__construct("Stash by id $errorStashId does not exists!");
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Exceptions/SubjectConfiguratorNotFound.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Exceptions;
 4 | 
 5 | class SubjectConfiguratorNotFound extends GitHandlerException
 6 | {
 7 |     public function __construct(string $prefix)
 8 |     {
 9 |         $message = "Subject Configurator by prefix $prefix not found";
10 | 
11 |         parent::__construct($message);
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Exceptions/SubmoduleNotFound.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Exceptions;
 4 | 
 5 | class SubmoduleNotFound extends GitHandlerException
 6 | {
 7 |     public $failedSubmoduleName;
 8 | 
 9 |     public function __construct(string $failedSubmoduleName)
10 |     {
11 |         parent::__construct('Module '. $failedSubmoduleName . ' not found!');
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Exceptions/TagAlreadyExists.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Exceptions;
 4 | 
 5 | final class TagAlreadyExists extends GitHandlerException
 6 | {
 7 |     public function __construct(string $tag)
 8 |     {
 9 |         $message = "Tag \"{$tag}\" already exists!";
10 | 
11 |         parent::__construct($message);
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Exceptions/TagNotFound.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Exceptions;
 4 | 
 5 | class TagNotFound extends GitHandlerException
 6 | {
 7 |     public $errorTag;
 8 | 
 9 |     /**
10 |      * @codeCoverageIgnore
11 |      */
12 |     public function __construct(string $errorTag)
13 |     {
14 |         $this->errorTag = $errorTag;
15 | 
16 |         parent::__construct("Tag '$errorTag' not found!");
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Exceptions/UnexpectedException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Exceptions;
 4 | 
 5 | class UnexpectedException extends GitHandlerException
 6 | {
 7 |     public $errorCommand;
 8 | 
 9 |     public function __construct(string $command)
10 |     {
11 |         $this->errorCommand = $command;
12 | 
13 |         $message = "Unexpected exception after execution command: ". $command;
14 | 
15 |         parent::__construct($message);
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Exceptions/UnknownRevisionInWorkingTree.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Exceptions;
 4 | 
 5 | /**
 6 |  * Unknown revision or path not in the working tree
 7 |  */
 8 | class UnknownRevisionInWorkingTree extends GitHandlerException
 9 | {
10 |     public $failedRevisionOrPath;
11 | 
12 |     public function __construct(string $revisionOrPath)
13 |     {
14 |         $this->failedRevisionOrPath = $revisionOrPath;
15 | 
16 |         parent::__construct("$revisionOrPath: unknown revision or path not in the working tree.");
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Factory/CachedGitFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Factory;
 4 | 
 5 | use ArtARTs36\GitHandler\CachedGit;
 6 | use ArtARTs36\GitHandler\Contracts\Factory\GitHandlerFactory;
 7 | use ArtARTs36\GitHandler\Contracts\Handler\GitHandler;
 8 | 
 9 | class CachedGitFactory implements GitHandlerFactory
10 | {
11 |     protected $factory;
12 | 
13 |     public function __construct(GitHandlerFactory $factory)
14 |     {
15 |         $this->factory = $factory;
16 |     }
17 | 
18 |     public function factory(string $dir, string $bin = 'git'): GitHandler
19 |     {
20 |         return new CachedGit($this->factory->factory($dir, $bin));
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Factory/DownloaderFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Factory;
 4 | 
 5 | use ArtARTs36\FileSystem\Contracts\FileSystem;
 6 | use ArtARTs36\GitHandler\Contracts\Origin\OriginDownloader;
 7 | use ArtARTs36\GitHandler\Origin\Downloader;
 8 | use ArtARTs36\GitHandler\Origin\Url\BitbucketOriginUrlBuilder;
 9 | use ArtARTs36\GitHandler\Origin\Url\GithubOriginUrlBuilder;
10 | use ArtARTs36\GitHandler\Origin\Url\GitlabOriginUrlBuilder;
11 | use ArtARTs36\GitHandler\Origin\Url\OriginUrlSelector;
12 | use ArtARTs36\FileSystem\Local\LocalFileSystem;
13 | use ArtARTs36\GitHandler\Support\SimpleHttpClient;
14 | use Psr\Http\Client\ClientInterface;
15 | 
16 | class DownloaderFactory
17 | {
18 |     public function factory(?ClientInterface $client = null, ?FileSystem $files = null): OriginDownloader
19 |     {
20 |         return new Downloader(
21 |             OriginUrlSelector::make([
22 |                 new GithubOriginUrlBuilder(),
23 |                 new GitlabOriginUrlBuilder(),
24 |                 new BitbucketOriginUrlBuilder(),
25 |             ]),
26 |             $client ?? new SimpleHttpClient(),
27 |             $files ?? new LocalFileSystem()
28 |         );
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Factory/LocalGitFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Factory;
 4 | 
 5 | use ArtARTs36\GitHandler\Command\GitCommandBuilder;
 6 | use ArtARTs36\GitHandler\Contracts\Factory\GitHandlerFactory;
 7 | use ArtARTs36\GitHandler\Contracts\Handler\GitHandler;
 8 | use ArtARTs36\GitHandler\Data\GitContext;
 9 | use ArtARTs36\GitHandler\Git;
10 | use ArtARTs36\FileSystem\Local\LocalFileSystem;
11 | use ArtARTs36\ShellCommand\Executors\ProcOpenExecutor;
12 | use ArtARTs36\ShellCommand\ShellCommander;
13 | 
14 | class LocalGitFactory implements GitHandlerFactory
15 | {
16 |     public function factory(string $dir, string $bin = 'git'): GitHandler
17 |     {
18 |         return new Git(
19 |             new GitCommandBuilder(new ShellCommander(), $bin, $dir),
20 |             new ProcOpenExecutor(),
21 |             new LocalFileSystem(),
22 |             GitContext::make($dir)
23 |         );
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Files/AttributesFile.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Files;
 4 | 
 5 | use ArtARTs36\Str\Str;
 6 | use ArtARTs36\Str\Tab;
 7 | 
 8 | class AttributesFile
 9 | {
10 |     /**
11 |      * @return array<string, array<\ArtARTs36\Str\Str>>
12 |      */
13 |     public function buildMap(string $content): array
14 |     {
15 |         if (empty(trim($content))) {
16 |             return [];
17 |         }
18 | 
19 |         $map = [];
20 | 
21 |         foreach (Str::make($content)->trim()->lines() as $match) {
22 |             $parts = $match->deleteUnnecessarySpaces()->words();
23 | 
24 |             $map[(string) $parts->first()] = $parts->slice(1)->toArray();
25 |         }
26 | 
27 |         return $map;
28 |     }
29 | 
30 |     /**
31 |      * @param non-empty-array<string, array<string>> $map
32 |      */
33 |     public function buildContent(array $map): string
34 |     {
35 |         $patterns = array_keys($map);
36 |         $tabs = Tab::addSpaces($patterns);
37 |         $content = '';
38 | 
39 |         foreach ($patterns as $index => $pattern) {
40 |             $content .= $tabs[$index] . implode(' ', $map[$pattern]);
41 |             $content .= "\n";
42 |         }
43 | 
44 |         return $content;
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/src/Files/SubmodulesFile.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Files;
 4 | 
 5 | use ArtARTs36\GitHandler\Data\Submodule;
 6 | use ArtARTs36\Str\Str;
 7 | 
 8 | class SubmodulesFile
 9 | {
10 |     private $regex = '#\[submodule "(?<name>.*)"\]\s*path = (?<path>.*)\n\s*url = (?<url>.*)\n?#';
11 | 
12 |     /**
13 |      * @return array<string, Submodule>
14 |      */
15 |     public function buildMap(string $content): array
16 |     {
17 |         $modules = [];
18 | 
19 |         foreach (Str::make($content)->globalMatch($this->regex) as $item) {
20 |             $modules[$item['name']] = Submodule::fromArray($item);
21 |         }
22 | 
23 |         return $modules;
24 |     }
25 | 
26 |     /**
27 |      * @param array<Submodule> $map
28 |      */
29 |     public function buildContent(array $map): string
30 |     {
31 |         return implode('', array_map([$this, 'buildSubmoduleContent'], $map));
32 |     }
33 | 
34 |     protected function buildSubmoduleContent(Submodule $submodule): string
35 |     {
36 |         return <<<HTML
37 | [submodule "$submodule->name"]
38 | 	path = $submodule->path
39 | 	url = $submodule->url
40 | HTML;
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/src/Git.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler;
 4 | 
 5 | use ArtARTs36\GitHandler\Config\Configurators\AliasConfigurator;
 6 | use ArtARTs36\GitHandler\Config\Configurators\CommitConfigurator;
 7 | use ArtARTs36\GitHandler\Config\Configurators\DiffConfigurator;
 8 | use ArtARTs36\GitHandler\Config\Configurators\InstawebConfigurator;
 9 | use ArtARTs36\GitHandler\Config\Configurators\SubmoduleConfigurator;
10 | use ArtARTs36\GitHandler\Config\Configurators\BranchConfigurator;
11 | use ArtARTs36\GitHandler\Config\Configurators\CoreConfigurator;
12 | use ArtARTs36\GitHandler\Config\Configurators\CredentialConfigurator;
13 | use ArtARTs36\GitHandler\Config\Configurators\PackConfigurator;
14 | use ArtARTs36\GitHandler\Config\Configurators\UserConfigurator;
15 | use ArtARTs36\GitHandler\Contracts\LogParser;
16 | use ArtARTs36\GitHandler\Contracts\Origin\OriginUrlBuilder;
17 | use ArtARTs36\GitHandler\Contracts\PathGenerator;
18 | use ArtARTs36\GitHandler\Data\Author\CacheableHydrator;
19 | use ArtARTs36\GitHandler\Data\Author\Hydrator;
20 | use ArtARTs36\GitHandler\Origin\Url\BitbucketOriginUrlBuilder;
21 | use ArtARTs36\GitHandler\Origin\Url\GithubOriginUrlBuilder;
22 | use ArtARTs36\GitHandler\Origin\Url\GitlabOriginUrlBuilder;
23 | use ArtARTs36\GitHandler\Origin\Url\GitUrl;
24 | use ArtARTs36\GitHandler\Origin\Url\OriginUrlSelector;
25 | use ArtARTs36\GitHandler\Support\Logger;
26 | use ArtARTs36\GitHandler\Support\TemporaryPathGenerator;
27 | use ArtARTs36\GitHandler\Backup\Elements\ConfigBackupElement;
28 | use ArtARTs36\GitHandler\Backup\Elements\HookBackupElement;
29 | use ArtARTs36\GitHandler\Backup\Elements\UntrackedFilesBackupElement;
30 | 
31 | class Git extends AbstractGit
32 | {
33 |     protected function createSubjectsConfigurators(): iterable
34 |     {
35 |         return [
36 |             new UserConfigurator(),
37 |             new CoreConfigurator(),
38 |             new PackConfigurator(),
39 |             new CredentialConfigurator(),
40 |             new BranchConfigurator(),
41 |             new SubmoduleConfigurator(),
42 |             new CommitConfigurator(),
43 |             new AliasConfigurator(),
44 |             new InstawebConfigurator(),
45 |             new DiffConfigurator(),
46 |         ];
47 |     }
48 | 
49 |     protected function createBackupElements(): array
50 |     {
51 |         return [
52 |             new ConfigBackupElement(),
53 |             new HookBackupElement(),
54 |             new UntrackedFilesBackupElement(),
55 |         ];
56 |     }
57 | 
58 |     protected function createPathGenerator(): PathGenerator
59 |     {
60 |         return new TemporaryPathGenerator($this->fileSystem);
61 |     }
62 | 
63 |     protected function createLogParser(): LogParser
64 |     {
65 |         return new Logger(new CacheableHydrator(new Hydrator()));
66 |     }
67 | 
68 |     /**
69 |      * @param array<string, string> $domainMap
70 |      */
71 |     public function urls(array $domainMap = []): GitUrl
72 |     {
73 |         $builders = [
74 |             new GithubOriginUrlBuilder($domainMap[GithubOriginUrlBuilder::NAME] ?? []),
75 |             new GitlabOriginUrlBuilder($domainMap[GitlabOriginUrlBuilder::NAME] ?? []),
76 |             new BitbucketOriginUrlBuilder($domainMap[BitbucketOriginUrlBuilder::NAME] ?? []),
77 |         ];
78 | 
79 |         $url = $this->remotes()->show()->fetch;
80 | 
81 |         return new GitUrl(
82 |             OriginUrlSelector::make($builders)->selectByUrl($url),
83 |             $url,
84 |         );
85 |     }
86 | }
87 | 


--------------------------------------------------------------------------------
/src/Making/MakingPush.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Making;
 4 | 
 5 | use ArtARTs36\ShellCommand\Interfaces\ShellCommandInterface;
 6 | use Psr\Http\Message\UriInterface;
 7 | 
 8 | class MakingPush
 9 | {
10 |     protected $remote;
11 | 
12 |     protected $branch = null;
13 | 
14 |     protected $isForce = false;
15 | 
16 |     protected $setUpStream = false;
17 | 
18 |     protected $tags = false;
19 | 
20 |     public function __construct(UriInterface $remote)
21 |     {
22 |         $this->remote = $remote;
23 |     }
24 | 
25 |     public function onRemote(callable $setup): self
26 |     {
27 |         $this->remote = $setup($this->remote);
28 | 
29 |         return $this;
30 |     }
31 | 
32 |     public function onBranch(string $branch): self
33 |     {
34 |         $this->branch = $branch;
35 | 
36 |         return $this;
37 |     }
38 | 
39 |     public function onBranchHead(string $branch): self
40 |     {
41 |         return $this->onBranch('HEAD:' . $branch);
42 |     }
43 | 
44 |     public function force(): self
45 |     {
46 |         $this->isForce = true;
47 | 
48 |         return $this;
49 |     }
50 | 
51 |     public function onCurrentBranchHead(): self
52 |     {
53 |         return $this->onBranch('HEAD');
54 |     }
55 | 
56 |     public function onSetUpStream(): self
57 |     {
58 |         $this->setUpStream = true;
59 | 
60 |         return $this;
61 |     }
62 | 
63 |     public function tags(): self
64 |     {
65 |         $this->tags = true;
66 | 
67 |         return $this;
68 |     }
69 | 
70 |     public function buildCommand(ShellCommandInterface $command): ShellCommandInterface
71 |     {
72 |         return $command
73 |             ->addArgument('push')
74 |             ->addArgument($this->remote->__toString())
75 |             ->when($this->setUpStream === true, function (ShellCommandInterface $command) {
76 |                 $command->addCutOption('u');
77 |             })
78 |             ->when($this->branch !== null, function (ShellCommandInterface $command) {
79 |                 $command->addArgument($this->branch);
80 |             })
81 |             ->when($this->isForce, function (ShellCommandInterface $command) {
82 |                 $command->addOption('force');
83 |             })
84 |             ->when($this->tags, function (ShellCommandInterface $command) {
85 |                 $command->addOption('tags');
86 |             });
87 |     }
88 | }
89 | 


--------------------------------------------------------------------------------
/src/Origin/Downloader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Origin;
 4 | 
 5 | use ArtARTs36\FileSystem\Contracts\FileSystem;
 6 | use ArtARTs36\GitHandler\Contracts\Handler\HasRemotes;
 7 | use ArtARTs36\GitHandler\Contracts\Origin\OriginDownloader;
 8 | use ArtARTs36\GitHandler\Exceptions\OriginUrlNotFound;
 9 | use ArtARTs36\GitHandler\Origin\Url\OriginUrlSelector;
10 | use GuzzleHttp\Psr7\Request;
11 | use Psr\Http\Client\ClientInterface;
12 | use Psr\Http\Message\RequestInterface;
13 | 
14 | class Downloader implements OriginDownloader
15 | {
16 |     protected $url;
17 | 
18 |     protected $client;
19 | 
20 |     protected $fileSystem;
21 | 
22 |     /**
23 |      * @codeCoverageIgnore
24 |      */
25 |     public function __construct(OriginUrlSelector $url, ClientInterface $client, FileSystem $fileSystem)
26 |     {
27 |         $this->url = $url;
28 |         $this->client = $client;
29 |         $this->fileSystem = $fileSystem;
30 |     }
31 | 
32 |     /**
33 |      * @throws \Psr\Http\Client\ClientExceptionInterface
34 |      */
35 |     public function download(HasRemotes $git, string $pathToSave): bool
36 |     {
37 |         return $this->fileSystem->createFile($pathToSave, $this->fetch($git));
38 |     }
39 | 
40 |     /**
41 |      * @throws \Psr\Http\Client\ClientExceptionInterface
42 |      * @throws OriginUrlNotFound
43 |      */
44 |     protected function fetch(HasRemotes $git): string
45 |     {
46 |         return $this->client->sendRequest($this->createRequestOnFetch($git))->getBody()->getContents();
47 |     }
48 | 
49 |     protected function createRequestOnFetch(HasRemotes $git): RequestInterface
50 |     {
51 |         return new Request('GET', $this->url->select($git)->toArchive($git));
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/src/Origin/Url/AbstractOriginUrlBuilder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Origin\Url;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Handler\HasRemotes;
 6 | use ArtARTs36\GitHandler\Contracts\Origin\OriginUrlBuilder;
 7 | use ArtARTs36\GitHandler\Data\Repo;
 8 | use ArtARTs36\GitHandler\Exceptions\GivenInvalidUri;
 9 | use ArtARTs36\GitHandler\Support\Uri;
10 | use ArtARTs36\Str\Str;
11 | 
12 | abstract class AbstractOriginUrlBuilder implements OriginUrlBuilder
13 | {
14 |     /** @var list<string> */
15 |     protected $domains = [];
16 | 
17 |     private const URL_REGEX = '/((git@|http(s)?:\/\/)(?<host>[\w\.@]+)(\/|:))(?<owner>([\w,\-,\_]+))\/' .
18 |     '(?<repo>([\w,\-,\_]+))(.git){0,1}((\/){0,1})/m';
19 | 
20 |     /**
21 |      * @param array<string> $domains
22 |      */
23 |     public function __construct(array $domains = [])
24 |     {
25 |         $this->domains = array_merge($this->domains, $domains);
26 |     }
27 | 
28 |     public function toCommit(HasRemotes $git, string $hash): string
29 |     {
30 |         return $this->toCommitFromFetchUrl($git->remotes()->show()->fetch, $hash);
31 |     }
32 | 
33 |     public function toArchive(HasRemotes $git, string $branch = 'master'): string
34 |     {
35 |         return $this->toArchiveFromFetchUrl($git->remotes()->show()->fetch, $branch);
36 |     }
37 | 
38 |     public function getAvailableDomains(): array
39 |     {
40 |         return $this->domains;
41 |     }
42 | 
43 |     public function toRepoFromUrl(string $url): Repo
44 |     {
45 |         $parsed = [];
46 | 
47 |         preg_match(self::URL_REGEX, $url, $parsed);
48 | 
49 |         if (! isset($parsed['repo']) || ! isset($parsed['owner']) || ! isset($parsed['host'])) {
50 |             throw new GivenInvalidUri($url);
51 |         }
52 | 
53 |         $newUrl = Uri::unParse([
54 |             'scheme' => 'https',
55 |             'host' => $parsed['host'],
56 |             'path' => $parsed['owner'] . '/' . $parsed['repo'],
57 |         ]);
58 | 
59 |         return new Repo($parsed['repo'], $parsed['owner'], $newUrl);
60 |     }
61 | 
62 |     /**
63 |      * @param Str|string $fetchUrl
64 |      */
65 |     protected function toGitFolder($fetchUrl): Str
66 |     {
67 |         if (is_string($fetchUrl)) {
68 |             $fetchUrl = Str::make($fetchUrl);
69 |         }
70 | 
71 |         return $fetchUrl->delete(['.git']);
72 |     }
73 | }
74 | 


--------------------------------------------------------------------------------
/src/Origin/Url/BitbucketOriginUrlBuilder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Origin\Url;
 4 | 
 5 | class BitbucketOriginUrlBuilder extends AbstractOriginUrlBuilder
 6 | {
 7 |     public const NAME = 'bitbucket';
 8 | 
 9 |     /** @var list<string> */
10 |     protected $domains = [
11 |         'bitbucket.org',
12 |     ];
13 | 
14 |     public function toCommitFromFetchUrl(string $fetchUrl, string $hash): string
15 |     {
16 |         return $this->toGitFolder($fetchUrl)->append('/commits/'. $hash);
17 |     }
18 | 
19 |     public function toArchiveFromFetchUrl(string $fetchUrl, string $branch = 'master'): string
20 |     {
21 |         return $this->toGitFolder($fetchUrl)->append("/get/$branch.zip");
22 |     }
23 | 
24 |     public function toTagFromFetchUrl(string $fetchUrl, string $tag): string
25 |     {
26 |         return $this->toGitFolder($fetchUrl)->append('/src/')->append($tag);
27 |     }
28 | 
29 |     public function toTagsCompareFromFetchUrl(string $fetchUrl, string $oneTag, string $twoTag): string
30 |     {
31 |         return $this->toGitFolder($fetchUrl)->append("/branches/compare/$oneTag%0D$twoTag");
32 |     }
33 | 
34 |     public function toFileFromFetchUrl(string $fetchUrl, string $filePath, string $branch): string
35 |     {
36 |         return $this->toGitFolder($fetchUrl)->append("/src/$branch/$filePath");
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Origin/Url/GitUrl.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Origin\Url;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Origin\OriginUrlBuilder;
 6 | use ArtARTs36\GitHandler\Data\Repo;
 7 | 
 8 | class GitUrl
 9 | {
10 |     /** @var OriginUrlBuilder */
11 |     private $builder;
12 | 
13 |     /** @var string */
14 |     private $fetchUrl;
15 | 
16 |     public function __construct(
17 |         OriginUrlBuilder $builder,
18 |         string $fetchUrl
19 |     ) {
20 |         $this->builder = $builder;
21 |         $this->fetchUrl = $fetchUrl;
22 |     }
23 | 
24 |     public function toCommit(string $hash): string
25 |     {
26 |         return $this->builder->toCommitFromFetchUrl($this->fetchUrl, $hash);
27 |     }
28 | 
29 |     public function toArchive(string $branch = 'master'): string
30 |     {
31 |         return $this->builder->toArchiveFromFetchUrl($this->fetchUrl, $branch);
32 |     }
33 | 
34 |     public function toTag(string $tag): string
35 |     {
36 |         return $this->builder->toTagFromFetchUrl($this->fetchUrl, $tag);
37 |     }
38 | 
39 |     public function toTagsCompare(string $oneTag, string $twoTag): string
40 |     {
41 |         return $this->builder->toTagsCompareFromFetchUrl($this->fetchUrl, $oneTag, $twoTag);
42 |     }
43 | 
44 |     public function toFile(string $filePath, string $branch): string
45 |     {
46 |         return $this->builder->toFileFromFetchUrl($this->fetchUrl, $filePath, $branch);
47 |     }
48 | 
49 |     public function toRepo(): Repo
50 |     {
51 |         return $this->builder->toRepoFromUrl($this->fetchUrl);
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/src/Origin/Url/GithubOriginUrlBuilder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Origin\Url;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Origin\OriginUrlBuilder;
 6 | use ArtARTs36\GitHandler\Support\Uri;
 7 | 
 8 | class GithubOriginUrlBuilder extends AbstractOriginUrlBuilder implements OriginUrlBuilder
 9 | {
10 |     public const NAME = 'github';
11 | 
12 |     protected $archiveSubdomain = 'codeload';
13 | 
14 |     /** @var list<string> */
15 |     protected $domains = [
16 |         'github.com',
17 |     ];
18 | 
19 |     public function toCommitFromFetchUrl(string $fetchUrl, string $hash): string
20 |     {
21 |         return $this->toGitFolder($fetchUrl)->append('/commit/'. $hash);
22 |     }
23 | 
24 |     public function toArchiveFromFetchUrl(string $fetchUrl, string $branch = 'master'): string
25 |     {
26 |         $host = Uri::host($fetchUrl);
27 | 
28 |         return $this
29 |             ->toGitFolder($fetchUrl)
30 |             ->replace([
31 |                 $host => $this->buildArchiveDomain($host),
32 |             ])
33 |             ->append("/zip/refs/heads/$branch");
34 |     }
35 | 
36 |     public function toTagFromFetchUrl(string $fetchUrl, string $tag): string
37 |     {
38 |         return $this->toGitFolder($fetchUrl)->append('/releases/tag/')->append($tag);
39 |     }
40 | 
41 |     public function toTagsCompareFromFetchUrl(string $fetchUrl, string $oneTag, string $twoTag): string
42 |     {
43 |         return $this->toGitFolder($fetchUrl)->append("/compare/$oneTag...$twoTag");
44 |     }
45 | 
46 |     public function toFileFromFetchUrl(string $fetchUrl, string $filePath, string $branch): string
47 |     {
48 |         return $this->toGitFolder($fetchUrl)->append("/blob/$branch/$filePath");
49 |     }
50 | 
51 |     protected function buildArchiveDomain(string $host): string
52 |     {
53 |         return $this->archiveSubdomain . '.' . $host;
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/src/Origin/Url/GitlabOriginUrlBuilder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Origin\Url;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Origin\OriginUrlBuilder;
 6 | 
 7 | class GitlabOriginUrlBuilder extends AbstractOriginUrlBuilder implements OriginUrlBuilder
 8 | {
 9 |     public const NAME = 'gitlab';
10 | 
11 |     /** @var list<string> */
12 |     protected $domains = [
13 |         'gitlab.com',
14 |     ];
15 | 
16 |     public function toCommitFromFetchUrl(string $fetchUrl, string $hash): string
17 |     {
18 |         return $this->toGitFolder($fetchUrl)->append('/-/commit/'. $hash);
19 |     }
20 | 
21 |     public function toArchiveFromFetchUrl(string $fetchUrl, string $branch = 'master'): string
22 |     {
23 |         $folder = $this->toGitFolder($fetchUrl);
24 |         $repoName = pathinfo($folder, PATHINFO_BASENAME);
25 | 
26 |         return $folder->append("/-/archive/$branch/$repoName-$branch.zip");
27 |     }
28 | 
29 |     public function toTagFromFetchUrl(string $fetchUrl, string $tag): string
30 |     {
31 |         return $this->toGitFolder($fetchUrl)->append('/-/tags/'. $tag);
32 |     }
33 | 
34 |     public function toTagsCompareFromFetchUrl(string $fetchUrl, string $oneTag, string $twoTag): string
35 |     {
36 |         return $this->toGitFolder($fetchUrl)->append("-/compare/$oneTag...$twoTag");
37 |     }
38 | 
39 |     public function toFileFromFetchUrl(string $fetchUrl, string $filePath, string $branch): string
40 |     {
41 |         return $this->toGitFolder($fetchUrl)->append("/-/blob/$branch/$filePath");
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/Origin/Url/OriginUrlSelector.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Origin\Url;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\Handler\HasRemotes;
 6 | use ArtARTs36\GitHandler\Contracts\Origin\OriginUrlBuilder;
 7 | use ArtARTs36\GitHandler\Exceptions\OriginUrlNotFound;
 8 | use ArtARTs36\GitHandler\Support\Uri;
 9 | 
10 | class OriginUrlSelector
11 | {
12 |     protected $map = [];
13 | 
14 |     /**
15 |      * @param array<string, OriginUrlBuilder> $map
16 |      * @codeCoverageIgnore
17 |      */
18 |     public function __construct(array $map)
19 |     {
20 |         $this->map = $map;
21 |     }
22 | 
23 |     /**
24 |      * @param array<OriginUrlBuilder> $urls
25 |      */
26 |     public static function make(array $urls): self
27 |     {
28 |         $map = [];
29 | 
30 |         foreach ($urls as $url) {
31 |             foreach ($url->getAvailableDomains() as $domain) {
32 |                 $map[$domain] = $url;
33 |             }
34 |         }
35 | 
36 |         return new self($map);
37 |     }
38 | 
39 |     /**
40 |      * @throws OriginUrlNotFound
41 |      */
42 |     public function select(HasRemotes $git): OriginUrlBuilder
43 |     {
44 |         return $this->selectByUrl($git->remotes()->show()->fetch);
45 |     }
46 | 
47 |     public function selectByUrl(string $url): OriginUrlBuilder
48 |     {
49 |         return $this->selectByDomain(Uri::host($url));
50 |     }
51 | 
52 |     /**
53 |      * @throws OriginUrlNotFound
54 |      */
55 |     public function selectByDomain(string $domain): OriginUrlBuilder
56 |     {
57 |         if (! $this->has($domain)) {
58 |             throw new OriginUrlNotFound();
59 |         }
60 | 
61 |         return $this->map[$domain];
62 |     }
63 | 
64 |     public function has(string $domain): bool
65 |     {
66 |         return array_key_exists($domain, $this->map);
67 |     }
68 | }
69 | 


--------------------------------------------------------------------------------
/src/Support/Chmod.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Support;
 4 | 
 5 | use ArtARTs36\ShellCommand\Interfaces\ShellCommandInterface;
 6 | use ArtARTs36\ShellCommand\ShellCommand;
 7 | 
 8 | class Chmod
 9 | {
10 |     /**
11 |      * @codeCoverageIgnore
12 |      */
13 |     public static function executable(string $path): ShellCommandInterface
14 |     {
15 |         return (new ShellCommand('chmod'))->addArgument('+x')->addArgument($path);
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Support/LocalFileSystem.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Support;
 4 | 
 5 | use ArtARTs36\FileSystem\Contracts\FileSystem;
 6 | use ArtARTs36\GitHandler\Exceptions\FileNotFound;
 7 | 
 8 | class LocalFileSystem extends \ArtARTs36\FileSystem\Local\LocalFileSystem implements FileSystem
 9 | {
10 |     protected function raiseFileNotFoundIfNotExists(string $path): void
11 |     {
12 |         if (! $this->exists($path)) {
13 |             throw new FileNotFound($path);
14 |         }
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Support/LogBuilder.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace ArtARTs36\GitHandler\Support;
  4 | 
  5 | use ArtARTs36\GitHandler\Contracts\Log\LogQuery;
  6 | use ArtARTs36\GitHandler\Contracts\Log\LogQueryBuilder;
  7 | use ArtARTs36\ShellCommand\Interfaces\ShellCommandInterface;
  8 | 
  9 | class LogBuilder implements LogQueryBuilder
 10 | {
 11 |     /** @var array<string> */
 12 |     protected $filenames = [];
 13 | 
 14 |     /** @var list<string> */
 15 |     protected $authors = [];
 16 | 
 17 |     /** @var array<callable|self> */
 18 |     protected $unions = [];
 19 | 
 20 |     /** @var array<string, array<string>> */
 21 |     protected $optionValues = [];
 22 | 
 23 |     /** @var array<string> */
 24 |     protected $diff = null;
 25 | 
 26 |     public function offset(int $offset): self
 27 |     {
 28 |         if ($offset === 0) {
 29 |             return $this;
 30 |         }
 31 | 
 32 |         return $this->setOptionValue('skip', (string) $offset);
 33 |     }
 34 | 
 35 |     public function limit(int $limit): self
 36 |     {
 37 |         return $this->setOptionValue('max-count', (string) $limit);
 38 |     }
 39 | 
 40 |     public function before(\DateTimeInterface $date): self
 41 |     {
 42 |         return $this->setOptionValueDate('before', $date);
 43 |     }
 44 | 
 45 |     public function after(\DateTimeInterface $date): self
 46 |     {
 47 |         return $this->setOptionValueDate('after', $date);
 48 |     }
 49 | 
 50 |     public function file(string $filename): self
 51 |     {
 52 |         $this->filenames[] = $filename;
 53 | 
 54 |         return $this;
 55 |     }
 56 | 
 57 |     public function author(string $author): self
 58 |     {
 59 |         $this->authors[] = $author;
 60 | 
 61 |         return $this;
 62 |     }
 63 | 
 64 |     public function grep(string $pattern): self
 65 |     {
 66 |         $this->optionValues['grep'][] = $pattern;
 67 | 
 68 |         return $this;
 69 |     }
 70 | 
 71 |     public function union(callable $build): self
 72 |     {
 73 |         $this->unions[] = [$build, new self()];
 74 | 
 75 |         return $this;
 76 |     }
 77 | 
 78 |     /**
 79 |      * @return $this
 80 |      */
 81 |     public function diff(string $src, string $dest)
 82 |     {
 83 |         $this->diff = [$src, $dest];
 84 | 
 85 |         return $this;
 86 |     }
 87 | 
 88 |     public function build(ShellCommandInterface $command): ShellCommandInterface
 89 |     {
 90 |         $pureCommand = clone $command;
 91 | 
 92 |         return $command
 93 |             ->when(count($this->authors) > 0, function (ShellCommandInterface $command) {
 94 |                 $command->addOptionWithValue('author', implode('|', $this->authors), true);
 95 |             })
 96 |             ->addArguments($this->filenames)
 97 |             ->when($this->diff !== null, function (ShellCommandInterface $command) {
 98 |                 $command->addArgument($this->diff[0] . '..' . $this->diff[1], false);
 99 |             })
100 |             ->when(count($this->optionValues) > 0, function (ShellCommandInterface $command) {
101 |                 foreach ($this->optionValues as $option => $values) {
102 |                     foreach ($values as $value) {
103 |                         $command->addOptionWithValue($option, $value, true);
104 |                     }
105 |                 }
106 |             })
107 |             ->when(count($this->unions) > 0, function (ShellCommandInterface $command) use ($pureCommand) {
108 |                 foreach ($this->unions as [$callback, $builder]) {
109 |                     $callback($builder);
110 | 
111 |                     $command->joinAnd($builder->build($pureCommand));
112 |                 }
113 |             });
114 |     }
115 | 
116 |     protected function setOptionValueDate(string $option, \DateTimeInterface $date): self
117 |     {
118 |         return $this->setOptionValue($option, $date->format('Y-m-d H:i:s'));
119 |     }
120 | 
121 |     protected function setOptionValue(string $option, string $value): self
122 |     {
123 |         $this->optionValues[$option][0] = $value;
124 | 
125 |         return $this;
126 |     }
127 | }
128 | 


--------------------------------------------------------------------------------
/src/Support/Logger.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Support;
 4 | 
 5 | use ArtARTs36\GitHandler\Contracts\AuthorHydrator;
 6 | use ArtARTs36\GitHandler\Contracts\LogParser;
 7 | use ArtARTs36\GitHandler\Data\Author;
 8 | use ArtARTs36\GitHandler\Data\Commit;
 9 | use ArtARTs36\GitHandler\Data\Log;
10 | use ArtARTs36\GitHandler\Data\LogCollection;
11 | use ArtARTs36\Str\Str;
12 | 
13 | class Logger implements LogParser
14 | {
15 |     protected $regex = '/\|log-entry\|(.*?)\|(.*?)\|(.*?)\|(.*?)\|(.*?)\|/m';
16 | 
17 |     protected $authorHydrator;
18 | 
19 |     public function __construct(AuthorHydrator $authorHydrator)
20 |     {
21 |         $this->authorHydrator = $authorHydrator;
22 |     }
23 | 
24 |     public function parse(Str $raw): ?LogCollection
25 |     {
26 |         $logs = [];
27 | 
28 |         foreach ($raw->globalMatch($this->regex) as $match) {
29 |             $logs[] = new Log(
30 |                 new Commit(trim($match[1])),
31 |                 new \DateTime($match[2]),
32 |                 $this->createAuthor($match),
33 |                 trim($match[5])
34 |             );
35 |         }
36 | 
37 |         if (count($logs) === 0) {
38 |             return null;
39 |         }
40 | 
41 |         return new LogCollection($logs);
42 |     }
43 | 
44 |     /**
45 |      * @param array<int, mixed> $raw
46 |      */
47 |     protected function createAuthor(array $raw): Author
48 |     {
49 |         return $this->authorHydrator->hydrate([
50 |             'name' => $raw[3],
51 |             'email' => $raw[4],
52 |         ]);
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/src/Support/SimpleHttpClient.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Support;
 4 | 
 5 | use GuzzleHttp\Psr7\Response;
 6 | use Psr\Http\Client\ClientInterface;
 7 | use Psr\Http\Message\RequestInterface;
 8 | use Psr\Http\Message\ResponseInterface;
 9 | 
10 | class SimpleHttpClient implements ClientInterface
11 | {
12 |     public function sendRequest(RequestInterface $request): ResponseInterface
13 |     {
14 |         $content = file_get_contents($request->getUri()->__toString());
15 | 
16 |         $status = $content ? 200 : 404;
17 | 
18 |         return new Response($status, [], $content);
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Support/TemporaryPathGenerator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Support;
 4 | 
 5 | use ArtARTs36\FileSystem\Contracts\FileSystem;
 6 | use ArtARTs36\GitHandler\Contracts\PathGenerator;
 7 | use ArtARTs36\GitHandler\Enum\ArchiveFormat;
 8 | 
 9 | class TemporaryPathGenerator implements PathGenerator
10 | {
11 |     protected $files;
12 | 
13 |     private static $counter = 0;
14 | 
15 |     public function __construct(FileSystem $files)
16 |     {
17 |         $this->files = $files;
18 |     }
19 | 
20 |     public function toArchive(ArchiveFormat $format): string
21 |     {
22 |         return $this->files->getTmpDir()
23 |             . DIRECTORY_SEPARATOR
24 |             . $this->buildArchiveName()
25 |             . '.' . $format->value;
26 |     }
27 | 
28 |     protected function buildArchiveName(): string
29 |     {
30 |         return implode('-', [
31 |             'git',
32 |             'handler',
33 |             time(),
34 |             'archive',
35 |             static::$counter++,
36 |         ]);
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Support/ToArray.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Support;
 4 | 
 5 | trait ToArray
 6 | {
 7 |     /**
 8 |      * @return array<string, string>
 9 |      */
10 |     public function toArray(): array
11 |     {
12 |         return get_object_vars($this);
13 |     }
14 | 
15 |     public function isEmpty(): bool
16 |     {
17 |         return count(array_filter($this->toArray())) === 0;
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Support/TypeCaster.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Support;
 4 | 
 5 | class TypeCaster
 6 | {
 7 |     public static function boolean(string $raw): bool
 8 |     {
 9 |         return $raw === 'true';
10 |     }
11 | 
12 |     /**
13 |      * @param array<string, mixed> $raw
14 |      */
15 |     public static function string(array $raw, string $key): string
16 |     {
17 |         return array_key_exists($key, $raw) ? $raw[$key] : '';
18 |     }
19 | 
20 |     /**
21 |      * @param array<string, mixed> $raw
22 |      */
23 |     public static function integer(array $raw, string $key, int $default = 0): int
24 |     {
25 |         return array_key_exists($key, $raw) ? (int) $raw[$key] : $default;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Support/Uri.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Support;
 4 | 
 5 | use ArtARTs36\GitHandler\Exceptions\GivenInvalidUri;
 6 | use ArtARTs36\Str\Str;
 7 | use JetBrains\PhpStorm\ArrayShape;
 8 | 
 9 | class Uri
10 | {
11 |     /**
12 |      * @param array<string, string> $parts
13 |      */
14 |     public static function unParse(
15 |         #[ArrayShape(['scheme' => 'string', 'host' => 'string', 'path' => 'string'])]
16 |         array $parts
17 |     ): string {
18 |         return implode('/', array_filter([
19 |             array_key_exists('scheme', $parts) ? $parts['scheme'] . ':/' : null,
20 |             ($parts['host'] ?? ''),
21 |             $parts['path'],
22 |         ]));
23 |     }
24 | 
25 |     public static function host(string $uri): string
26 |     {
27 |         $host = parse_url($uri, PHP_URL_HOST);
28 | 
29 |         if ($host !== null) {
30 |             return $host;
31 |         }
32 | 
33 |         $find = Str::make($uri)
34 |             ->trim()
35 |             ->match('/([a-zA-Z0-9\-\.]+)\.(com|org|net|mil|edu|ru|COM|ORG|NET|MIL|EDU|RU)/', 0, 0, false);
36 | 
37 |         if ($find->isNotEmpty()) {
38 |             return $find;
39 |         }
40 | 
41 |         throw new GivenInvalidUri($uri);
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/Transactions/ArchiveTransaction.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace ArtARTs36\GitHandler\Transactions;
 4 | 
 5 | use ArtARTs36\FileSystem\Contracts\FileSystem;
 6 | use ArtARTs36\GitHandler\Contracts\Handler\GitHandler;
 7 | use ArtARTs36\GitHandler\Contracts\PathGenerator;
 8 | use ArtARTs36\GitHandler\Contracts\Transaction\GitTransaction;
 9 | use ArtARTs36\GitHandler\Data\GitContext;
10 | use ArtARTs36\GitHandler\Enum\ArchiveFormat;
11 | use ArtARTs36\GitHandler\Enum\GarbageCollectMode;
12 | 
13 | class ArchiveTransaction implements GitTransaction
14 | {
15 |     protected $context;
16 | 
17 |     protected $git;
18 | 
19 |     protected $files;
20 | 
21 |     protected $paths;
22 | 
23 |     /**
24 |      * @codeCoverageIgnore
25 |      */
26 |     public function __construct(GitContext $context, GitHandler $git, FileSystem $files, PathGenerator $paths)
27 |     {
28 |         $this->context = $context;
29 |         $this->git = $git;
30 |         $this->files = $files;
31 |         $this->paths = $paths;
32 |     }
33 | 
34 |     public function attempt(callable $callback)
35 |     {
36 |         $archivePath = $this->paths->toArchive(ArchiveFormat::from(ArchiveFormat::ZIP));
37 | 
38 |         $this->git->archives()->packRefs($archivePath);
39 | 
40 |         try {
41 |             $result = $callback($this->git);
42 | 
43 |             $this->files->removeFile($archivePath);
44 | 
45 |             return $result;
46 |         } catch (\Throwable $e) {
47 |             $this->files->removeDir($this->context->getRefsDir());
48 |             $this->git->archives()->unPackRefs($archivePath);
49 |             $this->git->garbage()->collect(GarbageCollectMode::from(GarbageCollectMode::AUTO));
50 | 
51 |             throw $e;
52 |         }
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------