VersionControl\GitCommandBundle\GitCommands\Command\GitLogCommand

Complexity

Total Complexity

57

Size/Duplication

Total Lines	500
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

35 Methods

Rating	Name	Duplication	Size	Complexity
A	setPath()	0	5	1
A	setNotRemote()	0	5	1
A	setCommitHash()	0	5	1
A	execute()	0	13	3
A	getFilterByDateAfter()	0	3	1
A	getPath()	0	3	1
A	getLogCount()	0	3	1
A	setBranch()	0	7	2
F	getLogCommand()	0	56	14
A	setFilterByMessage()	0	5	1
A	getTotalCount()	0	3	1
A	getFilterByContent()	0	3	1
A	getBranch()	0	3	1
A	setFilterByAuthor()	0	5	1
A	setPage()	0	5	1
A	getNotRemote()	0	3	1
A	getShowReferences()	0	3	1
A	getPage()	0	3	1
A	getFilterByAuthor()	0	3	1
A	setFilterByDateBefore()	0	5	1
A	getTotalPages()	0	3	1
A	setFilterByDateAfter()	0	5	1
A	getFirstResult()	0	11	3
A	setLimit()	0	5	1
A	getResults()	0	19	5
A	setFilterByContent()	0	5	1
A	paginate()	0	9	1
A	setShowReferences()	0	5	1
A	getLimit()	0	3	1
A	setTotalPages()	0	5	1
A	setLogCount()	0	5	1
A	setTotalCount()	0	5	1
A	getCommitHash()	0	3	1
A	getFilterByMessage()	0	3	1
A	getFilterByDateBefore()	0	3	1

<?php

/*
 * This file is part of the GitCommandBundle package.
 *
 * (c) Paul Schweppe <paulschweppe@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace VersionControl\GitCommandBundle\GitCommands\Command;

use Exception;
use RuntimeException;
use VersionControl\GitCommandBundle\Entity\GitLog;

/**
 * @author Paul Schweppe <paulschweppe@gmail.com>
 */
class GitLogCommand extends AbstractGitCommand
{
    /**
     * @var string Log format
     */
    protected $format = '%H | %h | %T | %t | %P | %p | %an | %ae | %ad | %ar | %cn | %ce | %cd | %cr | %s';

    /**
     * Limit the number of commits return from command.
     *
     * @var int
     */
    protected $logCount = 9999999;

    /**
     * Pagination: Number of results to return.
     *
     * @var int
     */
    protected $limit = 30;

    /**
     * Pagintation: Current Page.
     *
     * @var int
     */
    protected $page = 0;

    /**
     * Pagintation: Total Number of results.
     *
     * @var int
     */
    protected $totalCount = 0;

    /**
     * Pagintation: Total Number of pages.
     *
     * @var int
     */
    protected $totalPages = 0;

    /**
     * Git log command.
     *
     * @var string
     */
    protected $logCommand;

    /**
     * Filter log by commit hash. Only returns logs with this hash. Should be only one result.
     *
     * @var string
     */
    protected $commitHash;

    /**
     * Filter log by branch name. Only returns commits form this branch.
     *
     * @var string
     */
    protected $branch;

    /**
     * Filter log by path. File name should include the path relative to git folder. Only returns commits
     * that effect this file.
     *
     * @var string
     */
    protected $path;

    /**
     * Enables the --not --remotes flags. Returns commits that have not been
     * pushed to a remote server.
     *
     * @var bool
     */
    protected $notRemote;

    /**
     * Enables the --decorate flag. The --decorate flag makes git log display all of the
     * references (e.g., branches, tags, etc) that point to each commit.
     *
     * This lets you know that the top commit is also checked out (denoted by HEAD) and
     * that it is also the tip of the master branch. The second commit has another branch
     * pointing to it called feature, and finally the 4th commit is tagged as v0.9.
     *
     * Branches, tags, HEAD, and the commit history are almost all of the information contained
     * in your Git repository, so this gives you a more complete view of the logical
     * structure of your repository.
     *
     * @var bool
     */
    protected $showReferences;

    /**
     * Array of log lines.
     *
     * @var array|string
     */
    protected $logData = array();

    /**
     * Filter By Message.
     *
     * To filter commits by their commit message, use the --grep flag.
     *
     * @var string
     */
    protected $filterByMessage;

    /**
     * Filter by Date After
     * If you’re looking for a commit from a specific time frame, you can use
     * the --after or --before flags for filtering commits by date.
     * These both accept a variety of date formats as a parameter.
     *      git log --after="2014-7-1"
     *      git log --after="yesterday"
     *      git log --after="2014-7-1" --before="2014-7-4".
     *
     * @var string
     */
    protected $filterByDateAfter;

    /**
     * Filter by Date After
     * If you’re looking for a commit from a specific time frame, you can use
     * the --after or --before flags for filtering commits by date.
     * These both accept a variety of date formats as a parameter.
     *      git log --after="2014-7-1"
     *      git log --after="yesterday"
     *      git log --after="2014-7-1" --before="2014-7-4".
     *
     * @var string
     */
    protected $filterByDateBefore;

    /**
     * Filter By Author
     * When you’re only looking for commits created by a particular user, use the --author flag.
     * This accepts a regular expression, and returns all commits whose author matches that
     * pattern. If you know exactly who you’re looking for, you can use a plain old string
     * instead of a regular expression: --author="John".
     *
     * @var string
     */
    protected $filterByAuthor;

    /**
     * Filter By Content
     * Used to search for commits that introduce or remove a particular line of source code.
     * This is called a pickaxe, and it takes the form of -S"<string>". For example, if you
     * want to know when the string Hello, World! was added to any file in the project,
     * you would use the following command:
     *      git log -S"Hello, World!".
     *
     * @var string
     */
    protected $filterByContent;

    /**
     * @return string
     */
    public function getLogCommand(): string
    {
        $this->logCommand = 'git --no-pager log -m "--pretty=format:\'' . $this->format . '\'"';
        if ($this->logCount) {
            $this->logCommand .= ' -' . (int)$this->logCount . ' ';
        }

        if ($this->showReferences === true) {
            $this->logCommand .= ' --decorate ';
        }

        if ($this->commitHash && $this->branch == false) {

It seems like you are loosely comparing $this->branch of type string to the boolean false. If you are specifically checking for an empty string, consider using the more explicit === '' instead.

            $this->logCommand .= ' ' . escapeshellarg($this->commitHash);
        }

        //Filters
        if ($this->filterByMessage) {
            $this->logCommand .= ' --grep=' . escapeshellarg($this->filterByMessage) . ' -i';
        }

        if ($this->filterByDateAfter) {
            $this->logCommand .= ' --after=' . escapeshellarg($this->filterByDateAfter);
        }

        if ($this->filterByDateBefore) {
            $this->logCommand .= ' --before=' . escapeshellarg($this->filterByDateBefore);
        }

        if ($this->filterByAuthor) {
            $this->logCommand .= ' --author=' . escapeshellarg($this->filterByAuthor);
        }

        if ($this->filterByContent) {
            $this->logCommand .= ' -S' . escapeshellarg($this->filterByContent);
        }

        if ($this->branch) {
            $this->logCommand .= ' ' . escapeshellarg(trim($this->branch));
        } elseif (!$this->commitHash) {
            $this->logCommand .= ' --all';
        }

        if ($this->notRemote) {
            $this->logCommand .= ' --not --remotes';
        }

        // To prevent confusion with options and branch names, paths may need to be prefixed with "-- " to separate
        // them from options or refnames.
        $this->logCommand .= ' --';

        //Show only commits that affect any of the specified paths.
        if ($this->path) {
            $this->logCommand .= ' ' . escapeshellarg(trim($this->path));
        }

        return $this->logCommand;
    }

    /**
     * Executes the git log command.
     *
     * @return GitLogCommand
     * @throws Exception
     */
    public function execute(): GitLogCommand
    {
        try {
            $logCommand = $this->getLogCommand();
            $this->logData = $this->command->runCommand($logCommand);
        } catch (RuntimeException $e) {
            if ($this->getObjectCount() !== 0) {
                throw new RuntimeException('Error in getting log: ' . $e->getMessage());
            }
            $this->logData = '';
        }

        return $this;
    }

    /**
     * Gets the results. Runs any pagination on the log data that is need and
     * converts the log lines into GitLog objects.
     *
     * @return array of GitLog objects
     */
    public function getResults(): array
    {
        $logs = array();
        if (is_array($this->logData)) {
            return [];
        }

        $lines = $this->splitOnNewLine($this->logData);

        if (is_array($lines)) {

The condition is_array($lines) is always true.

            $paginatedLines = $this->paginate($lines);
            foreach ($paginatedLines as $line) {
                if (trim($line)) {
                    $logs[] = new GitLog($line);
                }
            }
        }

        return $logs;
    }

    /**
     * Gets the first result. Does not run pagination.
     * Used mostly for commit hash data
     * converts the log lines into GitLog objects.
     *
     * @return GitLog
     */
    public function getFirstResult(): GitLog
    {
        $log = null;
        $lines = $this->splitOnNewLine($this->logData);

It seems like $this->logData can also be of type array; however, parameter $text of VersionControl\GitCommandBundle\GitCommands\Command\AbstractGitCommand::splitOnNewLine() does only seem to accept string, maybe add an additional type check?

        if (is_array($lines) && count($lines) > 0) {
            $line = trim($lines[0]);
            $log = new GitLog($line);
        }

        return $log;

The expression return $log could return the type null which is incompatible with the type-hinted return VersionControl\GitCommandBundle\Entity\GitLog. Consider adding an additional type-check to rule them out.

    }

    /**
     * Paginates log lines using array_slice.
     *
     * @param array $lines
     *
     * @return array of lines
     */
    protected function paginate($lines): array
    {
        $this->totalCount = count($lines);
        $this->totalPages = ceil($this->totalCount / $this->limit);

        $page = min($this->page, $this->totalPages);
        $splitOn = $page * $this->limit;

        return array_slice($lines, $splitOn, $this->limit);
    }

    public function getLogCount(): int
    {
        return $this->logCount;
    }

    public function getLimit(): int
    {
        return $this->limit;
    }

    public function getPage(): int
    {
        return $this->page;
    }

    public function getTotalCount(): int
    {
        return $this->totalCount;
    }

    public function getTotalPages(): int
    {
        return $this->totalPages;
    }

    public function getCommitHash(): string
    {
        return $this->commitHash;
    }

    public function getBranch(): string
    {
        return $this->branch;
    }

    public function getNotRemote(): bool
    {
        return $this->notRemote;
    }

    public function getShowReferences(): bool
    {
        return $this->showReferences;
    }

    public function getFilterByMessage(): string
    {
        return $this->filterByMessage;
    }

    public function getFilterByDateAfter(): string
    {
        return $this->filterByDateAfter;
    }

    public function getFilterByDateBefore(): string
    {
        return $this->filterByDateBefore;
    }

    public function getFilterByAuthor(): string
    {
        return $this->filterByAuthor;
    }

    public function getFilterByContent(): string
    {
        return $this->filterByContent;
    }

    public function setLogCount($logCount)
    {
        $this->logCount = $logCount;

        return $this;
    }

    public function setLimit($limit)
    {
        $this->limit = $limit;

        return $this;
    }

    public function setPage($page)
    {
        $this->page = $page;

        return $this;
    }

    public function setTotalCount($totalCount)
    {
        $this->totalCount = $totalCount;

        return $this;
    }

    public function setTotalPages($totalPages)
    {
        $this->totalPages = $totalPages;

        return $this;
    }

    public function setCommitHash($commitHash)
    {
        $this->commitHash = $commitHash;

        return $this;
    }

    public function setBranch($branch)
    {
        if ($branch !== '(No Branch)') {
            $this->branch = $branch;
        }

        return $this;
    }

    public function setNotRemote($notRemote)
    {
        $this->notRemote = $notRemote;

        return $this;
    }

    public function setShowReferences($showReferences)
    {
        $this->showReferences = $showReferences;

        return $this;
    }

    public function setFilterByMessage($filterByMessage)
    {
        $this->filterByMessage = $filterByMessage;

        return $this;
    }

    public function setFilterByDateAfter($filterByDateAfter)
    {
        $this->filterByDateAfter = $filterByDateAfter;

        return $this;
    }

    public function setFilterByDateBefore($filterByDateBefore)
    {
        $this->filterByDateBefore = $filterByDateBefore;

        return $this;
    }

    public function setFilterByAuthor($filterByAuthor)
    {
        $this->filterByAuthor = $filterByAuthor;

        return $this;
    }

    /**
     * @param string $filterByContent
     *
     * @return GitLogCommand
     */
    public function setFilterByContent($filterByContent): GitLogCommand
    {
        $this->filterByContent = $filterByContent;

        return $this;
    }

    /**
     * @return string
     */
    public function getPath(): string
    {
        return $this->path;
    }

    /**
     * @param $path
     *
     * @return GitLogCommand
     */
    public function setPath($path): self
    {
        $this->path = $path;

        return $this;
    }
}