Gitilicious\GitClient\Git\Repository

Complexity

Total Complexity

16

Size/Duplication

Total Lines	116
Duplicated Lines	18.1 %

Coupling/Cohesion

Components	1
Dependencies	10

Test Coverage

Coverage

54.9%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	createBare()	0	6	1
A	create()	0	6	1
A	clone()	0	11	1
A	getPath()	0	4	1
A	getActiveBranch()	0	14	4
A	getBranches()	0	12	2
A	createBranch()	11	11	1
A	checkout()	10	10	1
A	add()	0	4	1
A	commit()	0	11	1
A	push()	0	4	1

<?php declare(strict_types=1);

namespace Gitilicious\GitClient\Git;

use Gitilicious\GitClient\Cli\Input\LongFlag;
use Gitilicious\GitClient\Cli\Input\PlainArgument;
use Gitilicious\GitClient\Cli\Input\ShortFlag;
use Gitilicious\GitClient\Client;
use Gitilicious\GitClient\FileSystem\Directory;
use Gitilicious\GitClient\FileSystem\File;

class Repository
{
    private $client;

    private $directory;

    public function __construct(Client $client, Directory $directory)
    {
        $this->client    = $client;
        $this->directory = $directory;
    }

    public static function createBare(Client $client, Directory $directory): Repository
    {
        $client->run($directory, new PlainArgument('init'), new LongFlag('bare'));

        return new self($client, $directory);
    }

    public static function create(Client $client, Directory $directory): Repository
    {
        $client->run($directory, new PlainArgument('init'));

        return new self($client, $directory);
    }

    public function clone(Directory $directory): Repository
    {
        $this->client->run(
            $directory,
            new PlainArgument('clone'),
            new PlainArgument($this->directory->getPath()),
            new PlainArgument($directory->getPath())
        );

        return new self($this->client, $directory);
    }

    public function getPath(): string
    {
        return $this->directory->getPath();
    }

    public function getActiveBranch(): Branch
    {
        $branches = $this->getBranches();

        if (!count($branches)) {
            return new Branch('* master');
        }

        foreach ($branches as $branch) {
            if ($branch->isActive()) {
                return $branch;
            }
        }
    }

    public function getBranches(): Branches
    {
        $result = $this->client->run($this->directory, new PlainArgument('branch'));

        $branches = new Branches($this->client);

The call to Branches::__construct() has too many arguments starting with $this->client.

        foreach ($result->getOutput() as $branch) {

The expression $result->getOutput() of type object<Gitilicious\GitClient\Cli\Output\Output> is not traversable.

            $branches->add(new Branch($branch));
        }

        return $branches;
    }

    public function createBranch(string $name): Branch

This method seems to be duplicated in your project.

    {
        $this->client->run(
            $this->directory,
            new PlainArgument('checkout'),
            new ShortFlag('b'),
            new PlainArgument($name)
        );

        return new Branch($name);
    }

    public function checkout(string $name): Branch

This method seems to be duplicated in your project.

    {
        $this->client->run(
            $this->directory,
            new PlainArgument('checkout'),
            new PlainArgument($name)
        );

        return new Branch('* ' . $name);
    }

    public function add(File $file)
    {
        $this->client->run($this->directory, new PlainArgument('add'), new PlainArgument($file->getPath()));
    }

    public function commit(Author $author, string $message)
    {
        $this->client->run(
            $this->directory,
            new PlainArgument('commit'),
            new ShortFlag('m'),
            new PlainArgument($message),
            new LongFlag('author'),
            new PlainArgument($author->getFormatted())
        );
    }

    public function push()
    {
        $this->client->run($this->directory, new PlainArgument('push'));
    }
}