Hunk::getAddedLines() - Code Metrics - bircher/php-merge - Measure and Improve Code Quality continuously with Scrutinizer

Hunk::getAddedLines() A
last analyzed 2019-03-21 22:09 UTC

↳ Parent: Hunk

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	1

Importance

Changes

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

<?php
/**
 * This file is part of the php-merge package.
 *
 * (c) Fabian Bircher <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace PhpMerge\internal;

/**
 * Class Hunk
 *
 * This represents a collection of changed lines.
 *
 * @package    PhpMerge
 * @author     Fabian Bircher <[email protected]>
 * @copyright  Fabian Bircher <[email protected]>
 * @license    https://opensource.org/licenses/MIT
 * @version    Release: @package_version@
 * @link       http://github.com/bircher/php-merge
 * @internal   This class is not part of the public api.
 */
final class Hunk
{

    const ADDED = 1;
    const REMOVED = 2;
    const REPLACED = 3;

    /**
     * @var int
     */
    protected $start;
    /**
     * @var int
     */
    protected $end;
    /**
     * @var Line[]
     */
    protected $lines;
    /**
     * @var int
     */
    protected $type;

    /**
     * The Hunk constructor.
     *
     * @param Line|Line[] $lines
     *   The lines belonging to the hunk.
     * @param int $type
     *   The type of the hunk: Hunk::ADDED Hunk::REMOVED Hunk::REPLACED
     * @param int $start
     *   The line index where the hunk starts.
     * @param int $end
     *   The line index where the hunk stops.
     */
    public function __construct($lines, $type, $start, $end = null)
    {
        $this->start = $start;
        if ($end === null) {
            $end = $start;
        }
        $this->end = $end;
        if (!is_array($lines)) {
            $lines = array($lines);
        }
        $this->lines = $lines;
        $this->type = $type;
    }

    /**
     * Add a new line to the hunk.
     *
     * @param \PhpMerge\Line $line
filter:
    dependency_paths: ["lib/*"]
     *   The line to add.
     */
    public function addLine(Line $line)
    {
        $this->lines[] = $line;
        $this->end = $line->getIndex();
    }

    /**
     * Create an array of hunks out of an array of lines.
     *
     * @param Line[] $lines
     *   The lines of the diff.
     * @return Hunk[]
     *   The hunks in the lines.
     */
    public static function createArray($lines)
    {
        $op = Line::UNCHANGED;
        $hunks = [];
        /** @var Hunk $current */
        $current = null;
        foreach ($lines as $line) {
            switch ($line->getType()) {
                case Line::REMOVED:
                    if ($op != Line::REMOVED) {
                        // The last line was not removed so we start a new hunk.
                        $current = new Hunk($line, Hunk::REMOVED, $line->getIndex());
                    } else {
                        // continue adding the line to the hunk.
                        $current->addLine($line);
                    }
                    break;
                case Line::ADDED:
                    switch ($op) {
                        case Line::REMOVED:
                            // The hunk is a replacement.
                            $current->setType(Hunk::REPLACED);
                            $current->addLine($line);
                            break;
                        case Line::ADDED:
                            $current->addLine($line);
                            break;
                        case Line::UNCHANGED:
                            // Add a new hunk with the added type.
                            $current = new Hunk($line, Hunk::ADDED, $line->getIndex());
                            break;
                    }
                    break;
                case Line::UNCHANGED:
                    if ($current) {
                        // The hunk exists so add it to the array.
                        $hunks[] = $current;
                        $current = null;
                    }
                    break;
            }
            $op = $line->getType();
        }
        if ($current) {
            // The last line was part of a hunk, so add it.
            $hunks[] = $current;
        }

        return $hunks;
    }

    /**
     * Set the type of the hunk.
     *
     * @param int $type
     */
    protected function setType($type)
    {
        $this->type = $type;
    }

    /**
     * Get the line index where the hunk starts.
     *
     * @return int
     */
    public function getStart()
    {
        return $this->start;
    }

    /**
     * Get the line index where the hunk ends.
     *
     * @return int
     */
    public function getEnd()
    {
        return $this->end;
    }

    /**
     * Get the type of the hunk.
     *
     * @return int
     */
    public function getType()
    {
        return $this->type;
    }

    /**
     * Get the lines of the hunk.
     *
     * @return Line[]
     */
    public function getLines()
    {
        return $this->lines;
    }

    /**
     * Get the removed lines.
     *
     * @return Line[]
     */
    public function getRemovedLines()
    {
        return array_values(array_filter(
            $this->lines,
            function (Line $line) {
                return $line->getType() == Line::REMOVED;
            }
        ));
    }

    /**
     * Get the added lines.
     *
     * @return Line[]
     */
    public function getAddedLines()
    {
        return array_values(array_filter(
            $this->lines,
            function (Line $line) {
                return $line->getType() == Line::ADDED;
            }
        ));
    }

    /**
     * Get the lines content.
     *
     * @return string[]
     */
    public function getLinesContent()
    {
        return array_map(
            function (Line $line) {
                return $line->getContent();
            },
            $this->getAddedLines()
        );
    }

    /**
     * Test whether the hunk is to be considered for a conflict resolution.
     *
     * @param int $line
     *   The line number in the original text to test.
     *
     * @return bool
     *   Whether the line is affected by the hunk.
     */
    public function isLineNumberAffected($line)
    {
        // Added lines also affect the ones afterwards in conflict resolution,
        // because they are added in between.
        $bleed = ($this->type == self::ADDED ? 1 : 0);
        return ($line >= $this->start && $line <= $this->end + $bleed);
    }

    /**
     * @param \PhpMerge\Hunk|null $hunk
filter:
    dependency_paths: ["lib/*"]
     * @return bool
     */
    public function hasIntersection(Hunk $hunk = null)
    {
        if (!$hunk) {
            return false;
        }
        if ($this->type == self::ADDED && $hunk->type == self::ADDED) {
            return $this->start == $hunk->start;
        }
        return $this->isLineNumberAffected($hunk->start) || $this->isLineNumberAffected($hunk->end)
          || $hunk->isLineNumberAffected($this->start) || $hunk->isLineNumberAffected($this->end);
    }
}


1		<?php
2		/**
3		* This file is part of the php-merge package.
4		*
5		* (c) Fabian Bircher <[email protected]>
6		*
7		* For the full copyright and license information, please view the LICENSE
8		* file that was distributed with this source code.
9		*/
10
11		namespace PhpMerge\internal;
12
13		/**
14		* Class Hunk
15		*
16		* This represents a collection of changed lines.
17		*
18		* @package PhpMerge
19		* @author Fabian Bircher <[email protected]>
20		* @copyright Fabian Bircher <[email protected]>
21		* @license https://opensource.org/licenses/MIT
22		* @version Release: @package_version@
23		* @link http://github.com/bircher/php-merge
24		* @internal This class is not part of the public api.
25		*/
26		final class Hunk
27		{
28
29		const ADDED = 1;
30		const REMOVED = 2;
31		const REPLACED = 3;
32
33		/**
34		* @var int
35		*/
36		protected $start;
37		/**
38		* @var int
39		*/
40		protected $end;
41		/**
42		* @var Line[]
43		*/
44		protected $lines;
45		/**
46		* @var int
47		*/
48		protected $type;
49
50		/**
51		* The Hunk constructor.
52		*
53		* @param Line\|Line[] $lines
54		* The lines belonging to the hunk.
55		* @param int $type
56		* The type of the hunk: Hunk::ADDED Hunk::REMOVED Hunk::REPLACED
57		* @param int $start
58		* The line index where the hunk starts.
59		* @param int $end
60		* The line index where the hunk stops.
61		*/
62	13	public function __construct($lines, $type, $start, $end = null)
63		{
64	13	$this->start = $start;
65	13	if ($end === null) {
66	13	$end = $start;
67		}
68	13	$this->end = $end;
69	13	if (!is_array($lines)) {
70	13	$lines = array($lines);
71		}
72	13	$this->lines = $lines;
73	13	$this->type = $type;
74	13	}
75
76		/**
77		* Add a new line to the hunk.
78		*
79		* @param \PhpMerge\Line $line
		0 ignored issues – show Bug introduced 2019-03-15 20:03 UTC by Report Bug Copy Issue Report The type `PhpMerge\Line` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
80		* The line to add.
81		*/
82	11	public function addLine(Line $line)
83		{
84	11	$this->lines[] = $line;
85	11	$this->end = $line->getIndex();
86	11	}
87
88		/**
89		* Create an array of hunks out of an array of lines.
90		*
91		* @param Line[] $lines
92		* The lines of the diff.
93		* @return Hunk[]
94		* The hunks in the lines.
95		*/
96	13	public static function createArray($lines)
97		{
98	13	$op = Line::UNCHANGED;
99	13	$hunks = [];
100		/** @var Hunk $current */
101	13	$current = null;
102	13	foreach ($lines as $line) {
103	13	switch ($line->getType()) {
104	13	case Line::REMOVED:
105	13	if ($op != Line::REMOVED) {
106		// The last line was not removed so we start a new hunk.
107	13	$current = new Hunk($line, Hunk::REMOVED, $line->getIndex());
108		} else {
109		// continue adding the line to the hunk.
110	2	$current->addLine($line);
111		}
112	13	break;
113	13	case Line::ADDED:
114		switch ($op) {
115	13	case Line::REMOVED:
116		// The hunk is a replacement.
117	11	$current->setType(Hunk::REPLACED);
118	11	$current->addLine($line);
119	11	break;
120	12	case Line::ADDED:
121	5	$current->addLine($line);
122	5	break;
123	12	case Line::UNCHANGED:
124		// Add a new hunk with the added type.
125	12	$current = new Hunk($line, Hunk::ADDED, $line->getIndex());
126	12	break;
127		}
128	13	break;
129	13	case Line::UNCHANGED:
130	13	if ($current) {
131		// The hunk exists so add it to the array.
132	11	$hunks[] = $current;
133	11	$current = null;
134		}
135	13	break;
136		}
137	13	$op = $line->getType();
138		}
139	13	if ($current) {
140		// The last line was part of a hunk, so add it.
141	9	$hunks[] = $current;
142		}
143
144	13	return $hunks;
145		}
146
147		/**
148		* Set the type of the hunk.
149		*
150		* @param int $type
151		*/
152	11	protected function setType($type)
153		{
154	11	$this->type = $type;
155	11	}
156
157		/**
158		* Get the line index where the hunk starts.
159		*
160		* @return int
161		*/
162	12	public function getStart()
163		{
164	12	return $this->start;
165		}
166
167		/**
168		* Get the line index where the hunk ends.
169		*
170		* @return int
171		*/
172	7	public function getEnd()
173		{
174	7	return $this->end;
175		}
176
177		/**
178		* Get the type of the hunk.
179		*
180		* @return int
181		*/
182	9	public function getType()
183		{
184	9	return $this->type;
185		}
186
187		/**
188		* Get the lines of the hunk.
189		*
190		* @return Line[]
191		*/
192	1	public function getLines()
193		{
194	1	return $this->lines;
195		}
196
197		/**
198		* Get the removed lines.
199		*
200		* @return Line[]
201		*/
202	2	public function getRemovedLines()
203		{
204	2	return array_values(array_filter(
205	2	$this->lines,
206		function (Line $line) {
207	2	return $line->getType() == Line::REMOVED;
208	2	}
209		));
210		}
211
212		/**
213		* Get the added lines.
214		*
215		* @return Line[]
216		*/
217	9	public function getAddedLines()
218		{
219	9	return array_values(array_filter(
220	9	$this->lines,
221		function (Line $line) {
222	9	return $line->getType() == Line::ADDED;
223	9	}
224		));
225		}
226
227		/**
228		* Get the lines content.
229		*
230		* @return string[]
231		*/
232	6	public function getLinesContent()
233		{
234	6	return array_map(
235		function (Line $line) {
236	6	return $line->getContent();
237	6	},
238	6	$this->getAddedLines()
239		);
240		}
241
242		/**
243		* Test whether the hunk is to be considered for a conflict resolution.
244		*
245		* @param int $line
246		* The line number in the original text to test.
247		*
248		* @return bool
249		* Whether the line is affected by the hunk.
250		*/
251	7	public function isLineNumberAffected($line)
252		{
253		// Added lines also affect the ones afterwards in conflict resolution,
254		// because they are added in between.
255	7	$bleed = ($this->type == self::ADDED ? 1 : 0);
256	7	return ($line >= $this->start && $line <= $this->end + $bleed);
257		}
258
259		/**
260		* @param \PhpMerge\Hunk\|null $hunk
		0 ignored issues – show Bug introduced 2019-03-15 20:03 UTC by Report Bug Copy Issue Report The type `PhpMerge\Hunk` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
261		* @return bool
262		*/
263	7	public function hasIntersection(Hunk $hunk = null)
264		{
265	7	if (!$hunk) {
266	5	return false;
267		}
268	7	if ($this->type == self::ADDED && $hunk->type == self::ADDED) {
269	1	return $this->start == $hunk->start;
270		}
271	7	return $this->isLineNumberAffected($hunk->start) \|\| $this->isLineNumberAffected($hunk->end)
272	7	\|\| $hunk->isLineNumberAffected($this->start) \|\| $hunk->isLineNumberAffected($this->end);
273		}
274		}
275

bircher / php-merge

Hunk::getAddedLines() A last analyzed 2019-03-21 22:09 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Hunk::getAddedLines() A
last analyzed 2019-03-21 22:09 UTC