History::setProject() - Code Metrics - Inspection of "bump" - hiqdev/chkipper - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 1b355d...2cadce )

by Andrii

created 2016-07-02 12:25 UTC

History::setProject() A

↳ Parent: History

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
c	1
b	0
f	1
dl	0
loc	4
ccs	3
cts	3
cp	1
rs	10
cc	1
eloc	2
nc	1
nop	1
crap	1

<?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 <[email protected]>
 */
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;
    }

    public function addTags(array $tags)
    {
        foreach ($tags as $name => $tag) {
            $this->addTag($tag);
        }
    }

    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 or tag name
     * @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;
            }
        }
    }

    public function addTag(Tag $tag)
    {
        return $this->findTag($tag->getName())->setDate($tag->getDate())->addNotes($tag->getNotes());
    }

    /**
     * Merges given history into the current.
     * @param History $history
     */
    public function merge(History $history)
    {
        $this->mergeTags($history->getTags());
        $this->addLinks($history->getLinks());
        $this->addHashes($history->getHashes());
    }

    /**
     * Merge given tags into the current history.
     * @param Tag[] $tags
     */
    public function mergeTags(array $tags)
    {
        foreach ($tags as $tag) {
            foreach ($tag->getNotes() as $note) {
                $note->removeCommits($this->getHashes());
            }
        }
        $olds = $this->getTags();
        $this->_tags = $tags;
        foreach ($olds as $tag) {
            $this->addTag($tag);
        }
    }

    /**
     * Normalizes the history.
     */
    public function normalize()
    {
        $this->removeEmptyFirstTag();
    }

    /**
     * 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());
    }
}


1		<?php
2
3		/*
4		* Changelog keeper
5		*
6		* @link https://github.com/hiqdev/chkipper
7		* @package chkipper
8		* @license BSD-3-Clause
9		* @copyright Copyright (c) 2016, HiQDev (http://hiqdev.com/)
10		*/
11
12		namespace hiqdev\chkipper\history;
13
14		/**
15		* History class.
16		*
17		* @property array $headers: header => header
18		* @property array $hashes: hash => hash
19		* @property array $links: link => href
20		* @property array $tags: tag name => tag object
21		*
22		* @author Andrii Vasyliev <[email protected]>
23		*/
24		class History
25		{
26		public $lastTag = 'Under development';
27
28		public $initTag = 'Development started';
29
30		protected $_project;
31		protected $_headers = [];
32		protected $_hashes = [];
33		protected $_links = [];
34		protected $_tags = [];
35
36	1	public function setProject($value)
37		{
38	1	$this->_project = $value;
39	1	}
40
41	1	public function getProject()
42		{
43	1	if ($this->_project === null) {
44		$this->_project = $this->detectProject();
45		}
46		return $this->_project;
47	1	}
48
49		public function detectProject()
50		{
51		foreach ($this->getHeaders() as $line) {
52		if (preg_match('/\b([a-z0-9._-]{2,}\/[a-z0-9._-]{2,})\b/i', $line, $m)) {
53		return $m[1];
54		}
55		}
56		}
57
58		public function addHeader($str)
59	2	{
60		$this->_headers[$str] = $str;
61	2	}
62	2
63		public function addHeaders(array $headers)
64	1	{
65		foreach ($headers as $header) {
66	1	$this->addHeader($header);
67	1	}
68		}
69	1
70		public function setHeaders(array $headers)
71	1	{
72		$this->_headers = [];
73	1	$this->addHeaders($headers);
74	1	}
75	1
76		public function getHeaders()
77	2	{
78		return $this->_headers;
79	2	}
80
81		public function hasLink($link)
82	2	{
83		return isset($this->_links[$link]);
84	2	}
85
86		public function removeLink($link)
87		{
88		unset($this->_links[$link]);
89		}
90
91		public function addLink($link, $href)
92	3	{
93		$this->_links[$link] = $href;
94	3	}
95	3
96		public function addLinks(array $links)
97		{
98		foreach ($links as $link => $href) {
99		$this->addLink($link, $href);
100		}
101		}
102
103		public function setLinks(array $links)
104	1	{
105		$this->_links = $links;
106	1	}
107	1
108		public function getLinks()
109	2	{
110		return $this->_links;
111	2	}
112
113		public function hasHash($hash)
114	2	{
115		return isset($this->_hashes[(string) $hash]);
116	2	}
117
118		public function addHash($hash)
119	3	{
120		$this->_hashes[(string) $hash] = $hash;
121	3	}
122	3
123		public function addHashes(array $hashes)
124		{
125		foreach ($hashes as $hash) {
126		$this->addHash($hash);
127		}
128		}
129
130		public function setHashes(array $hashes)
131		{
132		$this->_hashes = [];
133		$this->addHashes($hashes);
134		}
135
136		public function getHashes()
137	2	{
138		return $this->_hashes;
139	2	}
140
141		public function getFirstTag()
142	2	{
143		return reset($this->_tags);
144	2	}
145
146		public function setFirstTag($name)
147		{
148		$this->getFirstTag()->setName($name);
149		}
150
151		public function countTags()
152	3	{
153		return count($this->_tags);
154	3	}
155
156		public function initTags()
157	3	{
158		if (!$this->countTags()) {
159	3	$this->addTag(new Tag($this->lastTag));
160	3	}
161		}
162	3
163		public function getTags()
164	2	{
165		return $this->_tags;
166	2	}
167
168		public function addTags(array $tags)
169	1	{
170		foreach ($tags as $name => $tag) {
171	1	$this->addTag($tag);
172	1	}
173		}
174	1
175		public function setTags(array $tags)
176	1	{
177		$this->_tags = [];
178	1	$this->addTags($tags);
179	1	}
180	1
181		/**
182		* Returns tag by name.
183		* Creates if not exists.
184		* Returns first tag when given empty name.
185		* @param string\|Tag $tag tag or tag name
186		* @return Tag
187		*/
188		public function findTag($tag)
189	3	{
190		if (!$tag) {
191	3	$tag = reset($this->_tags) ?: $this->lastTag;
192	1	}
193		$name = $tag instanceof Tag ? $tag->getName() : $tag;
194	3	if (!$this->hasTag($name)) {
195	3	$this->_tags[$name] = new Tag($name);
196	3	}
197
198		return $this->_tags[$name];
199	3	}
200
201		public function hasTag($tag)
202	3	{
203		return isset($this->_tags[$tag]);
204	3	}
205
206		public function removeTag($name)
207		{
208		foreach ($this->_tags as $k => $tag) {
209		if ($tag->getName() == $name) {
210		unset($this->_tags[$k]);
211		return;
212		}
213		}
214		}
215
216		public function addTag(Tag $tag)
217		{
218	3	return $this->findTag($tag->getName())->setDate($tag->getDate())->addNotes($tag->getNotes());
219		}
220	3
221		/**
222		* Merges given history into the current.
223		* @param History $history
224		*/
225		public function merge(History $history)
226		{
227		$this->mergeTags($history->getTags());
228		$this->addLinks($history->getLinks());
229		$this->addHashes($history->getHashes());
230		}
231
232		/**
233		* Merge given tags into the current history.
234		* @param Tag[] $tags
235		*/
236		public function mergeTags(array $tags)
237		{
238		foreach ($tags as $tag) {
239		foreach ($tag->getNotes() as $note) {
240		$note->removeCommits($this->getHashes());
241		}
242		}
243		$olds = $this->getTags();
244		$this->_tags = $tags;
245		foreach ($olds as $tag) {
246		$this->addTag($tag);
247		}
248		}
249
250		/**
251		* Normalizes the history.
252		*/
253		public function normalize()
254		{
255	2	$this->removeEmptyFirstTag();
256		}
257	2
258	2	/**
259		* Removes first tag if it is empty: has no notes and no commits.
260		*/
261		public function removeEmptyFirstTag()
262		{
263	2	$tag = $this->getFirstTag();
264		$notes = $tag->getNotes();
265	2	if (count($notes)>1) {
266	2	return;
267	2	}
268		if (count($notes)>0) {
269		$note = reset($notes);
270	2	if ($note->getNote() \|\| count($note->getCommits())>0) {
271	2	return;
272	2	}
273	2	}
274		$this->removeTag($tag->getName());
275		}
276		}
277

hiqdev / chkipper

Push — master ( 1b355d...2cadce )

History::setProject() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like