hiqdev\chkipper\history\History

Complexity

Total Complexity

85

Size/Duplication

Total Lines	384
Duplicated Lines	1.56 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

66.83%

Importance

Changes

0

39 Methods

Rating	Name	Duplication	Size	Complexity
B	removeEmptyFirstTag()	0	15	5
B	addInitTag()	6	19	8
A	setTagDates()	0	10	4
A	addCommitLinks()	0	8	3
A	generateHashHref()	0	6	1
B	removeCommitLinks()	0	10	5
A	setProject()	0	4	1
A	getProject()	0	8	2
A	detectProject()	0	8	3
A	addHeader()	0	4	1
A	addHeaders()	0	6	2
A	setHeaders()	0	5	1
A	getHeaders()	0	4	1
A	hasLink()	0	4	1
A	removeLink()	0	4	1
A	addLink()	0	4	1
A	addLinks()	0	6	2
A	setLinks()	0	4	1
A	getLinks()	0	4	1
A	hasHash()	0	4	1
A	addHash()	0	4	1
A	addHashes()	0	6	2
A	setHashes()	0	5	1
A	getHashes()	0	4	1
A	getFirstTag()	0	4	1
A	setFirstTag()	0	4	1
A	countTags()	0	4	1
A	initTags()	0	6	2
A	getTags()	0	4	1
A	addTags()	0	6	2
A	setTags()	0	5	1
B	findTag()	0	12	5
A	hasTag()	0	4	1
A	removeTag()	0	10	3
A	addTag()	0	4	1
A	merge()	0	6	1
A	mergeTags()	0	12	3
A	normalize()	0	17	3
D	prettifyUserLinks()	0	25	9

<?php
/**
 * Changelog keeper
 *
 * @link      https://github.com/hiqdev/chkipper
 * @package   chkipper
 * @license   BSD-3-Clause
 * @copyright Copyright (c) 2016, HiQDev (http://hiqdev.com/)
 */

namespace hiqdev\chkipper\history;

/**
 * History class.
 *
 * @property array $headers: header => header
 * @property array $hashes:  hash => hash
 * @property array $links:   link => href
 * @property array $tags:    tag name => tag object
 *
 * @author Andrii Vasyliev <sol@hiqdev.com>
 */
class History
{
    public $lastTag = 'Under development';

    public $initTag = 'Development started';

    protected $_project;
    protected $_headers = [];
    protected $_hashes  = [];
    protected $_links   = [];
    protected $_tags    = [];

    public function setProject($value)
    {
        $this->_project = $value;
    }

    public function getProject()
    {
        if ($this->_project === null) {
            $this->_project = $this->detectProject();
        }

        return $this->_project;
    }

    public function detectProject()
    {
        foreach ($this->getHeaders() as $line) {
            if (preg_match('/\b([a-z0-9._-]{2,}\/[a-z0-9._-]{2,})\b/i', $line, $m)) {
                return $m[1];
            }
        }
    }

    public function addHeader($str)
    {
        $this->_headers[$str] = $str;
    }

    public function addHeaders(array $headers)
    {
        foreach ($headers as $header) {
            $this->addHeader($header);
        }
    }

    public function setHeaders(array $headers)
    {
        $this->_headers = [];
        $this->addHeaders($headers);
    }

    public function getHeaders()
    {
        return $this->_headers;
    }

    public function hasLink($link)
    {
        return isset($this->_links[$link]);
    }

    public function removeLink($link)
    {
        unset($this->_links[$link]);
    }

    public function addLink($link, $href)
    {
        $this->_links[$link] = $href;
    }

    public function addLinks(array $links)
    {
        foreach ($links as $link => $href) {
            $this->addLink($link, $href);
        }
    }

    public function setLinks(array $links)
    {
        $this->_links = $links;
    }

    public function getLinks()
    {
        return $this->_links;
    }

    public function hasHash($hash)
    {
        return isset($this->_hashes[(string) $hash]);
    }

    public function addHash($hash)
    {
        $this->_hashes[(string) $hash] = $hash;
    }

    public function addHashes(array $hashes)
    {
        foreach ($hashes as $hash) {
            $this->addHash($hash);
        }
    }

    public function setHashes(array $hashes)
    {
        $this->_hashes = [];
        $this->addHashes($hashes);
    }

    public function getHashes()
    {
        return $this->_hashes;
    }

    public function getFirstTag()
    {
        return reset($this->_tags);
    }

    public function setFirstTag($name)
    {
        $this->getFirstTag()->setName($name);
    }

    public function countTags()
    {
        return count($this->_tags);
    }

    public function initTags()
    {
        if (!$this->countTags()) {
            $this->addTag(new Tag($this->lastTag));
        }
    }

    public function getTags()
    {
        return $this->_tags;
    }

    /**
     * Adds given tags to the history.
     * @param Tag[] $tags
     * @param boolean $prependNotes default is append
     */
    public function addTags(array $tags, $prependNotes = false)
    {
        foreach ($tags as $name => $tag) {
            $this->addTag($tag, $prependNotes);
        }
    }

    public function setTags(array $tags)
    {
        $this->_tags = [];
        $this->addTags($tags);
    }

    /**
     * Returns tag by name.
     * Creates if not exists.
     * Returns first tag when given empty name.
     * @param string|Tag $tag tag name or tag object
     * @return Tag
     */
    public function findTag($tag)
    {
        if (!$tag) {
            $tag = reset($this->_tags) ?: $this->lastTag;
        }
        $name = $tag instanceof Tag ? $tag->getName() : $tag;
        if (!$this->hasTag($name)) {
            $this->_tags[$name] = new Tag($name);
        }

        return $this->_tags[$name];
    }

    public function hasTag($tag)
    {
        return isset($this->_tags[$tag]);
    }

    public function removeTag($name)
    {
        foreach ($this->_tags as $k => $tag) {
            if ($tag->getName() === $name) {
                unset($this->_tags[$k]);

                return;
            }
        }
    }

    /**
     * Adds tag.
     * @param Tag $tag
     * @param boolean $prependNotes default is append
     * @return Tag the added tag
     */
    public function addTag(Tag $tag, $prependNotes = false)
    {
        return $this->findTag($tag->getName())->setDate($tag->getDate())->addNotes($tag->getNotes(), $prependNotes);
    }

    /**
     * Merges given history into the current.
     * @param History $history
     * @param boolean $prependNotes default is append
     */
    public function merge(History $history, $prependNotes = false)
    {
        $this->mergeTags($history->getTags(), $prependNotes);
        $this->addLinks($history->getLinks());
        $this->addHashes($history->getHashes());
    }

    /**
     * Merge given tags into the current history.
     * @param Tag[] $tags
     * @param boolean $prependNotes default is append
     */
    public function mergeTags(array $tags, $prependNotes = false)
    {
        foreach ($tags as $tag) {
            foreach ($tag->getNotes() as $note) {
                $note->removeCommits($this->getHashes());
            }
        }
        $this->addTags($tags, $prependNotes);
        //$olds = $this->getTags();

60% of this comment could be valid code. Did you maybe forget this after debugging?

        //$this->_tags = $tags;

50% of this comment could be valid code. Did you maybe forget this after debugging?

        //$this->addTags($$olds);

88% of this comment could be valid code. Did you maybe forget this after debugging?

    }

    /**
     * Normalizes the history.
     */
    public function normalize($options = [])
    {
        static $defaults = [
            'removeEmptyFirstTag' => [],
            'addInitTag'          => [],
            'setTagDates'         => [],
            'addCommitLinks'      => [],
            'removeCommitLinks'   => [],
            'prettifyUserLinks'   => [],
        ];
        $options = array_merge($defaults, $options);
        foreach ($options as $func => $args) {
            if (is_array($args)) {
                call_user_func_array([$this, $func], $args);
            }
        }
    }

    /**
     * Removes first tag if it is empty: has no notes and no commits.
     */
    public function removeEmptyFirstTag()
    {
        $tag = $this->getFirstTag();
        $notes = $tag->getNotes();
        if (count($notes) > 1) {
            return;
        }
        if (count($notes) > 0) {
            $note = reset($notes);
            if ($note->getNote() || count($note->getCommits()) > 0) {
                return;
            }
        }
        $this->removeTag($tag->getName());
    }

    /**
     * Adds init tag with oldest commit date.
     */
    public function addInitTag()
    {
        if (!$this->hasTag($this->initTag)) {
            $min = '';
            foreach ($this->getTags() as $tag) {
                foreach ($tag->getNotes() as $note) {
                    foreach ($note->getCommits() as $commit) {

This code seems to be duplicated across your project.

                        $date = $commit->getDate();
                        if (!$min || strcmp($date, $min) < 0) {
                            $min = $date;
                        }
                    }
                }
            }
            if ($min) {
                $this->addTag(new Tag($this->initTag, $min));
            }
        }
    }

    /**
     * Normalizes dates to all the tags.
     * Drops date for the last tag and sets for others.
     */
    public function setTagDates()
    {
        foreach ($this->getTags() as $tag) {
            if ($tag->getName() === $this->lastTag) {
                $tag->unsetDate();
            } elseif (!$tag->getDate()) {
                $tag->setDate($tag->findDate());
            }
        }
    }

    /**
     * Adds links for commits not having ones.
     */
    public function addCommitLinks()
    {
        foreach ($this->getHashes() as $hash) {
            if (!$this->hasLink($hash)) {
                $this->addLink($hash, $this->generateHashHref($hash));
            }
        }
    }

    public function generateHashHref($hash)
    {
        $project = $this->getProject();

        return "https://github.com/$project/commit/$hash";
    }

    /**
     * Removes commit links that are not present in the history.
     */
    public function removeCommitLinks($all = false)
    {
        foreach ($this->getLinks() as $link => $href) {
            if (preg_match('/^[0-9a-f]{7}$/', $link)) {
                if ($all || !$this->hasHash($link)) {
                    $this->removeLink($link);
                }
            }
        }
    }

    /**
     * Converts user links to given links.
     * Usage: add 2 links to `history.md` like this:
     *
     * [@hiqsol]: https://github.com/hiqsol
     * [sol@hiqdev.com]: https://github.com/hiqsol
     */
    public function prettifyUserLinks()
    {
        $users = [];
        $subs = [];
        foreach ($this->getLinks() as $link => $href) {
            if ($link[0] === '@') {
                $users[$href] = $link;
            } else if (isset($users[$href])) {
                $subs[$link] = $users[$href];
            }
        }
        if (!$subs) {

The expression $subs of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

            return;
        }
        foreach ($this->getTags() as $tag) {
            foreach ($tag->getNotes() as $note) {
                foreach ($note->getCommits() as $commit) {
                    $author = $commit->getAuthor();
                    if (isset($subs[$author])) {
                        $commit->setAuthor($subs[$author]);
                    }
                }
            }
        }
    }
}