Added Laravel project
This commit is contained in:
78
Laravel/vendor/sebastian/diff/src/Chunk.php
vendored
Normal file
78
Laravel/vendor/sebastian/diff/src/Chunk.php
vendored
Normal file
@@ -0,0 +1,78 @@
|
||||
<?php declare(strict_types=1);
|
||||
/*
|
||||
* This file is part of sebastian/diff.
|
||||
*
|
||||
* (c) Sebastian Bergmann <sebastian@phpunit.de>
|
||||
*
|
||||
* For the full copyright and license information, please view the LICENSE
|
||||
* file that was distributed with this source code.
|
||||
*/
|
||||
|
||||
namespace SebastianBergmann\Diff;
|
||||
|
||||
final class Chunk
|
||||
{
|
||||
/**
|
||||
* @var int
|
||||
*/
|
||||
private $start;
|
||||
|
||||
/**
|
||||
* @var int
|
||||
*/
|
||||
private $startRange;
|
||||
|
||||
/**
|
||||
* @var int
|
||||
*/
|
||||
private $end;
|
||||
|
||||
/**
|
||||
* @var int
|
||||
*/
|
||||
private $endRange;
|
||||
|
||||
/**
|
||||
* @var array
|
||||
*/
|
||||
private $lines;
|
||||
|
||||
public function __construct(int $start = 0, int $startRange = 1, int $end = 0, int $endRange = 1, array $lines = [])
|
||||
{
|
||||
$this->start = $start;
|
||||
$this->startRange = $startRange;
|
||||
$this->end = $end;
|
||||
$this->endRange = $endRange;
|
||||
$this->lines = $lines;
|
||||
}
|
||||
|
||||
public function getStart(): int
|
||||
{
|
||||
return $this->start;
|
||||
}
|
||||
|
||||
public function getStartRange(): int
|
||||
{
|
||||
return $this->startRange;
|
||||
}
|
||||
|
||||
public function getEnd(): int
|
||||
{
|
||||
return $this->end;
|
||||
}
|
||||
|
||||
public function getEndRange(): int
|
||||
{
|
||||
return $this->endRange;
|
||||
}
|
||||
|
||||
public function getLines(): array
|
||||
{
|
||||
return $this->lines;
|
||||
}
|
||||
|
||||
public function setLines(array $lines)
|
||||
{
|
||||
$this->lines = $lines;
|
||||
}
|
||||
}
|
67
Laravel/vendor/sebastian/diff/src/Diff.php
vendored
Normal file
67
Laravel/vendor/sebastian/diff/src/Diff.php
vendored
Normal file
@@ -0,0 +1,67 @@
|
||||
<?php declare(strict_types=1);
|
||||
/*
|
||||
* This file is part of sebastian/diff.
|
||||
*
|
||||
* (c) Sebastian Bergmann <sebastian@phpunit.de>
|
||||
*
|
||||
* For the full copyright and license information, please view the LICENSE
|
||||
* file that was distributed with this source code.
|
||||
*/
|
||||
|
||||
namespace SebastianBergmann\Diff;
|
||||
|
||||
final class Diff
|
||||
{
|
||||
/**
|
||||
* @var string
|
||||
*/
|
||||
private $from;
|
||||
|
||||
/**
|
||||
* @var string
|
||||
*/
|
||||
private $to;
|
||||
|
||||
/**
|
||||
* @var Chunk[]
|
||||
*/
|
||||
private $chunks;
|
||||
|
||||
/**
|
||||
* @param string $from
|
||||
* @param string $to
|
||||
* @param Chunk[] $chunks
|
||||
*/
|
||||
public function __construct(string $from, string $to, array $chunks = [])
|
||||
{
|
||||
$this->from = $from;
|
||||
$this->to = $to;
|
||||
$this->chunks = $chunks;
|
||||
}
|
||||
|
||||
public function getFrom(): string
|
||||
{
|
||||
return $this->from;
|
||||
}
|
||||
|
||||
public function getTo(): string
|
||||
{
|
||||
return $this->to;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return Chunk[]
|
||||
*/
|
||||
public function getChunks(): array
|
||||
{
|
||||
return $this->chunks;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param Chunk[] $chunks
|
||||
*/
|
||||
public function setChunks(array $chunks)
|
||||
{
|
||||
$this->chunks = $chunks;
|
||||
}
|
||||
}
|
321
Laravel/vendor/sebastian/diff/src/Differ.php
vendored
Normal file
321
Laravel/vendor/sebastian/diff/src/Differ.php
vendored
Normal file
@@ -0,0 +1,321 @@
|
||||
<?php declare(strict_types=1);
|
||||
/*
|
||||
* This file is part of sebastian/diff.
|
||||
*
|
||||
* (c) Sebastian Bergmann <sebastian@phpunit.de>
|
||||
*
|
||||
* For the full copyright and license information, please view the LICENSE
|
||||
* file that was distributed with this source code.
|
||||
*/
|
||||
|
||||
namespace SebastianBergmann\Diff;
|
||||
|
||||
use SebastianBergmann\Diff\Output\DiffOutputBuilderInterface;
|
||||
use SebastianBergmann\Diff\Output\UnifiedDiffOutputBuilder;
|
||||
|
||||
/**
|
||||
* Diff implementation.
|
||||
*/
|
||||
final class Differ
|
||||
{
|
||||
/**
|
||||
* @var DiffOutputBuilderInterface
|
||||
*/
|
||||
private $outputBuilder;
|
||||
|
||||
/**
|
||||
* @param DiffOutputBuilderInterface $outputBuilder
|
||||
*
|
||||
* @throws InvalidArgumentException
|
||||
*/
|
||||
public function __construct($outputBuilder = null)
|
||||
{
|
||||
if ($outputBuilder instanceof DiffOutputBuilderInterface) {
|
||||
$this->outputBuilder = $outputBuilder;
|
||||
} elseif (null === $outputBuilder) {
|
||||
$this->outputBuilder = new UnifiedDiffOutputBuilder;
|
||||
} elseif (\is_string($outputBuilder)) {
|
||||
// PHPUnit 6.1.4, 6.2.0, 6.2.1, 6.2.2, and 6.2.3 support
|
||||
// @see https://github.com/sebastianbergmann/phpunit/issues/2734#issuecomment-314514056
|
||||
// @deprecated
|
||||
$this->outputBuilder = new UnifiedDiffOutputBuilder($outputBuilder);
|
||||
} else {
|
||||
throw new InvalidArgumentException(
|
||||
\sprintf(
|
||||
'Expected builder to be an instance of DiffOutputBuilderInterface, <null> or a string, got %s.',
|
||||
\is_object($outputBuilder) ? 'instance of "' . \get_class($outputBuilder) . '"' : \gettype($outputBuilder) . ' "' . $outputBuilder . '"'
|
||||
)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the diff between two arrays or strings as string.
|
||||
*
|
||||
* @param array|string $from
|
||||
* @param array|string $to
|
||||
* @param LongestCommonSubsequenceCalculator|null $lcs
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
public function diff($from, $to, LongestCommonSubsequenceCalculator $lcs = null): string
|
||||
{
|
||||
$from = $this->validateDiffInput($from);
|
||||
$to = $this->validateDiffInput($to);
|
||||
$diff = $this->diffToArray($from, $to, $lcs);
|
||||
|
||||
return $this->outputBuilder->getDiff($diff);
|
||||
}
|
||||
|
||||
/**
|
||||
* Casts variable to string if it is not a string or array.
|
||||
*
|
||||
* @param mixed $input
|
||||
*
|
||||
* @return string
|
||||
*/
|
||||
private function validateDiffInput($input): string
|
||||
{
|
||||
if (!\is_array($input) && !\is_string($input)) {
|
||||
return (string) $input;
|
||||
}
|
||||
|
||||
return $input;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the diff between two arrays or strings as array.
|
||||
*
|
||||
* Each array element contains two elements:
|
||||
* - [0] => mixed $token
|
||||
* - [1] => 2|1|0
|
||||
*
|
||||
* - 2: REMOVED: $token was removed from $from
|
||||
* - 1: ADDED: $token was added to $from
|
||||
* - 0: OLD: $token is not changed in $to
|
||||
*
|
||||
* @param array|string $from
|
||||
* @param array|string $to
|
||||
* @param LongestCommonSubsequenceCalculator $lcs
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public function diffToArray($from, $to, LongestCommonSubsequenceCalculator $lcs = null): array
|
||||
{
|
||||
if (\is_string($from)) {
|
||||
$from = $this->splitStringByLines($from);
|
||||
} elseif (!\is_array($from)) {
|
||||
throw new \InvalidArgumentException('"from" must be an array or string.');
|
||||
}
|
||||
|
||||
if (\is_string($to)) {
|
||||
$to = $this->splitStringByLines($to);
|
||||
} elseif (!\is_array($to)) {
|
||||
throw new \InvalidArgumentException('"to" must be an array or string.');
|
||||
}
|
||||
|
||||
list($from, $to, $start, $end) = self::getArrayDiffParted($from, $to);
|
||||
|
||||
if ($lcs === null) {
|
||||
$lcs = $this->selectLcsImplementation($from, $to);
|
||||
}
|
||||
|
||||
$common = $lcs->calculate(\array_values($from), \array_values($to));
|
||||
$diff = [];
|
||||
|
||||
foreach ($start as $token) {
|
||||
$diff[] = [$token, 0 /* OLD */];
|
||||
}
|
||||
|
||||
\reset($from);
|
||||
\reset($to);
|
||||
|
||||
foreach ($common as $token) {
|
||||
while (($fromToken = \reset($from)) !== $token) {
|
||||
$diff[] = [\array_shift($from), 2 /* REMOVED */];
|
||||
}
|
||||
|
||||
while (($toToken = \reset($to)) !== $token) {
|
||||
$diff[] = [\array_shift($to), 1 /* ADDED */];
|
||||
}
|
||||
|
||||
$diff[] = [$token, 0 /* OLD */];
|
||||
|
||||
\array_shift($from);
|
||||
\array_shift($to);
|
||||
}
|
||||
|
||||
while (($token = \array_shift($from)) !== null) {
|
||||
$diff[] = [$token, 2 /* REMOVED */];
|
||||
}
|
||||
|
||||
while (($token = \array_shift($to)) !== null) {
|
||||
$diff[] = [$token, 1 /* ADDED */];
|
||||
}
|
||||
|
||||
foreach ($end as $token) {
|
||||
$diff[] = [$token, 0 /* OLD */];
|
||||
}
|
||||
|
||||
if ($this->detectUnmatchedLineEndings($diff)) {
|
||||
\array_unshift($diff, ["#Warning: Strings contain different line endings!\n", 3]);
|
||||
}
|
||||
|
||||
return $diff;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if input is string, if so it will split it line-by-line.
|
||||
*
|
||||
* @param string $input
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
private function splitStringByLines(string $input): array
|
||||
{
|
||||
return \preg_split('/(.*\R)/', $input, -1, PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_NO_EMPTY);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param array $from
|
||||
* @param array $to
|
||||
*
|
||||
* @return LongestCommonSubsequenceCalculator
|
||||
*/
|
||||
private function selectLcsImplementation(array $from, array $to): LongestCommonSubsequenceCalculator
|
||||
{
|
||||
// We do not want to use the time-efficient implementation if its memory
|
||||
// footprint will probably exceed this value. Note that the footprint
|
||||
// calculation is only an estimation for the matrix and the LCS method
|
||||
// will typically allocate a bit more memory than this.
|
||||
$memoryLimit = 100 * 1024 * 1024;
|
||||
|
||||
if ($this->calculateEstimatedFootprint($from, $to) > $memoryLimit) {
|
||||
return new MemoryEfficientLongestCommonSubsequenceCalculator;
|
||||
}
|
||||
|
||||
return new TimeEfficientLongestCommonSubsequenceCalculator;
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculates the estimated memory footprint for the DP-based method.
|
||||
*
|
||||
* @param array $from
|
||||
* @param array $to
|
||||
*
|
||||
* @return int|float
|
||||
*/
|
||||
private function calculateEstimatedFootprint(array $from, array $to)
|
||||
{
|
||||
$itemSize = PHP_INT_SIZE === 4 ? 76 : 144;
|
||||
|
||||
return $itemSize * \min(\count($from), \count($to)) ** 2;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns true if line ends don't match in a diff.
|
||||
*
|
||||
* @param array $diff
|
||||
*
|
||||
* @return bool
|
||||
*/
|
||||
private function detectUnmatchedLineEndings(array $diff): bool
|
||||
{
|
||||
$newLineBreaks = ['' => true];
|
||||
$oldLineBreaks = ['' => true];
|
||||
|
||||
foreach ($diff as $entry) {
|
||||
if (0 === $entry[1]) { /* OLD */
|
||||
$ln = $this->getLinebreak($entry[0]);
|
||||
$oldLineBreaks[$ln] = true;
|
||||
$newLineBreaks[$ln] = true;
|
||||
} elseif (1 === $entry[1]) { /* ADDED */
|
||||
$newLineBreaks[$this->getLinebreak($entry[0])] = true;
|
||||
} elseif (2 === $entry[1]) { /* REMOVED */
|
||||
$oldLineBreaks[$this->getLinebreak($entry[0])] = true;
|
||||
}
|
||||
}
|
||||
|
||||
// if either input or output is a single line without breaks than no warning should be raised
|
||||
if (['' => true] === $newLineBreaks || ['' => true] === $oldLineBreaks) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// two way compare
|
||||
foreach ($newLineBreaks as $break => $set) {
|
||||
if (!isset($oldLineBreaks[$break])) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
foreach ($oldLineBreaks as $break => $set) {
|
||||
if (!isset($newLineBreaks[$break])) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
private function getLinebreak($line): string
|
||||
{
|
||||
if (!\is_string($line)) {
|
||||
return '';
|
||||
}
|
||||
|
||||
$lc = \substr($line, -1);
|
||||
if ("\r" === $lc) {
|
||||
return "\r";
|
||||
}
|
||||
|
||||
if ("\n" !== $lc) {
|
||||
return '';
|
||||
}
|
||||
|
||||
if ("\r\n" === \substr($line, -2)) {
|
||||
return "\r\n";
|
||||
}
|
||||
|
||||
return "\n";
|
||||
}
|
||||
|
||||
private static function getArrayDiffParted(array &$from, array &$to): array
|
||||
{
|
||||
$start = [];
|
||||
$end = [];
|
||||
|
||||
\reset($to);
|
||||
|
||||
foreach ($from as $k => $v) {
|
||||
$toK = \key($to);
|
||||
|
||||
if ($toK === $k && $v === $to[$k]) {
|
||||
$start[$k] = $v;
|
||||
|
||||
unset($from[$k], $to[$k]);
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
\end($from);
|
||||
\end($to);
|
||||
|
||||
do {
|
||||
$fromK = \key($from);
|
||||
$toK = \key($to);
|
||||
|
||||
if (null === $fromK || null === $toK || \current($from) !== \current($to)) {
|
||||
break;
|
||||
}
|
||||
|
||||
\prev($from);
|
||||
\prev($to);
|
||||
|
||||
$end = [$fromK => $from[$fromK]] + $end;
|
||||
unset($from[$fromK], $to[$toK]);
|
||||
} while (true);
|
||||
|
||||
return [$from, $to, $start, $end];
|
||||
}
|
||||
}
|
15
Laravel/vendor/sebastian/diff/src/Exception/Exception.php
vendored
Normal file
15
Laravel/vendor/sebastian/diff/src/Exception/Exception.php
vendored
Normal file
@@ -0,0 +1,15 @@
|
||||
<?php declare(strict_types=1);
|
||||
/*
|
||||
* This file is part of sebastian/diff.
|
||||
*
|
||||
* (c) Sebastian Bergmann <sebastian@phpunit.de>
|
||||
*
|
||||
* For the full copyright and license information, please view the LICENSE
|
||||
* file that was distributed with this source code.
|
||||
*/
|
||||
|
||||
namespace SebastianBergmann\Diff;
|
||||
|
||||
interface Exception
|
||||
{
|
||||
}
|
15
Laravel/vendor/sebastian/diff/src/Exception/InvalidArgumentException.php
vendored
Normal file
15
Laravel/vendor/sebastian/diff/src/Exception/InvalidArgumentException.php
vendored
Normal file
@@ -0,0 +1,15 @@
|
||||
<?php declare(strict_types=1);
|
||||
/*
|
||||
* This file is part of sebastian/diff.
|
||||
*
|
||||
* (c) Sebastian Bergmann <sebastian@phpunit.de>
|
||||
*
|
||||
* For the full copyright and license information, please view the LICENSE
|
||||
* file that was distributed with this source code.
|
||||
*/
|
||||
|
||||
namespace SebastianBergmann\Diff;
|
||||
|
||||
class InvalidArgumentException extends \InvalidArgumentException implements Exception
|
||||
{
|
||||
}
|
44
Laravel/vendor/sebastian/diff/src/Line.php
vendored
Normal file
44
Laravel/vendor/sebastian/diff/src/Line.php
vendored
Normal file
@@ -0,0 +1,44 @@
|
||||
<?php declare(strict_types=1);
|
||||
/*
|
||||
* This file is part of sebastian/diff.
|
||||
*
|
||||
* (c) Sebastian Bergmann <sebastian@phpunit.de>
|
||||
*
|
||||
* For the full copyright and license information, please view the LICENSE
|
||||
* file that was distributed with this source code.
|
||||
*/
|
||||
|
||||
namespace SebastianBergmann\Diff;
|
||||
|
||||
final class Line
|
||||
{
|
||||
const ADDED = 1;
|
||||
const REMOVED = 2;
|
||||
const UNCHANGED = 3;
|
||||
|
||||
/**
|
||||
* @var int
|
||||
*/
|
||||
private $type;
|
||||
|
||||
/**
|
||||
* @var string
|
||||
*/
|
||||
private $content;
|
||||
|
||||
public function __construct(int $type = self::UNCHANGED, string $content = '')
|
||||
{
|
||||
$this->type = $type;
|
||||
$this->content = $content;
|
||||
}
|
||||
|
||||
public function getContent(): string
|
||||
{
|
||||
return $this->content;
|
||||
}
|
||||
|
||||
public function getType(): int
|
||||
{
|
||||
return $this->type;
|
||||
}
|
||||
}
|
24
Laravel/vendor/sebastian/diff/src/LongestCommonSubsequenceCalculator.php
vendored
Normal file
24
Laravel/vendor/sebastian/diff/src/LongestCommonSubsequenceCalculator.php
vendored
Normal file
@@ -0,0 +1,24 @@
|
||||
<?php declare(strict_types=1);
|
||||
/*
|
||||
* This file is part of sebastian/diff.
|
||||
*
|
||||
* (c) Sebastian Bergmann <sebastian@phpunit.de>
|
||||
*
|
||||
* For the full copyright and license information, please view the LICENSE
|
||||
* file that was distributed with this source code.
|
||||
*/
|
||||
|
||||
namespace SebastianBergmann\Diff;
|
||||
|
||||
interface LongestCommonSubsequenceCalculator
|
||||
{
|
||||
/**
|
||||
* Calculates the longest common subsequence of two arrays.
|
||||
*
|
||||
* @param array $from
|
||||
* @param array $to
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
public function calculate(array $from, array $to): array;
|
||||
}
|
81
Laravel/vendor/sebastian/diff/src/MemoryEfficientLongestCommonSubsequenceCalculator.php
vendored
Normal file
81
Laravel/vendor/sebastian/diff/src/MemoryEfficientLongestCommonSubsequenceCalculator.php
vendored
Normal file
@@ -0,0 +1,81 @@
|
||||
<?php declare(strict_types=1);
|
||||
/*
|
||||
* This file is part of sebastian/diff.
|
||||
*
|
||||
* (c) Sebastian Bergmann <sebastian@phpunit.de>
|
||||
*
|
||||
* For the full copyright and license information, please view the LICENSE
|
||||
* file that was distributed with this source code.
|
||||
*/
|
||||
|
||||
namespace SebastianBergmann\Diff;
|
||||
|
||||
final class MemoryEfficientLongestCommonSubsequenceCalculator implements LongestCommonSubsequenceCalculator
|
||||
{
|
||||
/**
|
||||
* {@inheritdoc}
|
||||
*/
|
||||
public function calculate(array $from, array $to): array
|
||||
{
|
||||
$cFrom = \count($from);
|
||||
$cTo = \count($to);
|
||||
|
||||
if ($cFrom === 0) {
|
||||
return [];
|
||||
}
|
||||
|
||||
if ($cFrom === 1) {
|
||||
if (\in_array($from[0], $to, true)) {
|
||||
return [$from[0]];
|
||||
}
|
||||
|
||||
return [];
|
||||
}
|
||||
|
||||
$i = (int) ($cFrom / 2);
|
||||
$fromStart = \array_slice($from, 0, $i);
|
||||
$fromEnd = \array_slice($from, $i);
|
||||
$llB = $this->length($fromStart, $to);
|
||||
$llE = $this->length(\array_reverse($fromEnd), \array_reverse($to));
|
||||
$jMax = 0;
|
||||
$max = 0;
|
||||
|
||||
for ($j = 0; $j <= $cTo; $j++) {
|
||||
$m = $llB[$j] + $llE[$cTo - $j];
|
||||
|
||||
if ($m >= $max) {
|
||||
$max = $m;
|
||||
$jMax = $j;
|
||||
}
|
||||
}
|
||||
|
||||
$toStart = \array_slice($to, 0, $jMax);
|
||||
$toEnd = \array_slice($to, $jMax);
|
||||
|
||||
return \array_merge(
|
||||
$this->calculate($fromStart, $toStart),
|
||||
$this->calculate($fromEnd, $toEnd)
|
||||
);
|
||||
}
|
||||
|
||||
private function length(array $from, array $to): array
|
||||
{
|
||||
$current = \array_fill(0, \count($to) + 1, 0);
|
||||
$cFrom = \count($from);
|
||||
$cTo = \count($to);
|
||||
|
||||
for ($i = 0; $i < $cFrom; $i++) {
|
||||
$prev = $current;
|
||||
|
||||
for ($j = 0; $j < $cTo; $j++) {
|
||||
if ($from[$i] === $to[$j]) {
|
||||
$current[$j + 1] = $prev[$j] + 1;
|
||||
} else {
|
||||
$current[$j + 1] = \max($current[$j], $prev[$j + 1]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return $current;
|
||||
}
|
||||
}
|
56
Laravel/vendor/sebastian/diff/src/Output/AbstractChunkOutputBuilder.php
vendored
Normal file
56
Laravel/vendor/sebastian/diff/src/Output/AbstractChunkOutputBuilder.php
vendored
Normal file
@@ -0,0 +1,56 @@
|
||||
<?php declare(strict_types=1);
|
||||
/*
|
||||
* This file is part of sebastian/diff.
|
||||
*
|
||||
* (c) Sebastian Bergmann <sebastian@phpunit.de>
|
||||
*
|
||||
* For the full copyright and license information, please view the LICENSE
|
||||
* file that was distributed with this source code.
|
||||
*/
|
||||
|
||||
namespace SebastianBergmann\Diff\Output;
|
||||
|
||||
abstract class AbstractChunkOutputBuilder implements DiffOutputBuilderInterface
|
||||
{
|
||||
/**
|
||||
* Takes input of the diff array and returns the common parts.
|
||||
* Iterates through diff line by line.
|
||||
*
|
||||
* @param array $diff
|
||||
* @param int $lineThreshold
|
||||
*
|
||||
* @return array
|
||||
*/
|
||||
protected function getCommonChunks(array $diff, int $lineThreshold = 5): array
|
||||
{
|
||||
$diffSize = \count($diff);
|
||||
$capturing = false;
|
||||
$chunkStart = 0;
|
||||
$chunkSize = 0;
|
||||
$commonChunks = [];
|
||||
|
||||
for ($i = 0; $i < $diffSize; ++$i) {
|
||||
if ($diff[$i][1] === 0 /* OLD */) {
|
||||
if ($capturing === false) {
|
||||
$capturing = true;
|
||||
$chunkStart = $i;
|
||||
$chunkSize = 0;
|
||||
} else {
|
||||
++$chunkSize;
|
||||
}
|
||||
} elseif ($capturing !== false) {
|
||||
if ($chunkSize >= $lineThreshold) {
|
||||
$commonChunks[$chunkStart] = $chunkStart + $chunkSize;
|
||||
}
|
||||
|
||||
$capturing = false;
|
||||
}
|
||||
}
|
||||
|
||||
if ($capturing !== false && $chunkSize >= $lineThreshold) {
|
||||
$commonChunks[$chunkStart] = $chunkStart + $chunkSize;
|
||||
}
|
||||
|
||||
return $commonChunks;
|
||||
}
|
||||
}
|
63
Laravel/vendor/sebastian/diff/src/Output/DiffOnlyOutputBuilder.php
vendored
Normal file
63
Laravel/vendor/sebastian/diff/src/Output/DiffOnlyOutputBuilder.php
vendored
Normal file
@@ -0,0 +1,63 @@
|
||||
<?php declare(strict_types=1);
|
||||
/*
|
||||
* This file is part of sebastian/diff.
|
||||
*
|
||||
* (c) Sebastian Bergmann <sebastian@phpunit.de>
|
||||
*
|
||||
* For the full copyright and license information, please view the LICENSE
|
||||
* file that was distributed with this source code.
|
||||
*/
|
||||
namespace SebastianBergmann\Diff\Output;
|
||||
|
||||
/**
|
||||
* Builds a diff string representation in a loose unified diff format
|
||||
* listing only changes lines. Does not include line numbers.
|
||||
*/
|
||||
final class DiffOnlyOutputBuilder implements DiffOutputBuilderInterface
|
||||
{
|
||||
/**
|
||||
* @var string
|
||||
*/
|
||||
private $header;
|
||||
|
||||
public function __construct(string $header = "--- Original\n+++ New\n")
|
||||
{
|
||||
$this->header = $header;
|
||||
}
|
||||
|
||||
public function getDiff(array $diff): string
|
||||
{
|
||||
$buffer = \fopen('php://memory', 'r+b');
|
||||
|
||||
if ('' !== $this->header) {
|
||||
\fwrite($buffer, $this->header);
|
||||
if ("\n" !== \substr($this->header, -1, 1)) {
|
||||
\fwrite($buffer, "\n");
|
||||
}
|
||||
}
|
||||
|
||||
foreach ($diff as $diffEntry) {
|
||||
if ($diffEntry[1] === 1 /* ADDED */) {
|
||||
\fwrite($buffer, '+' . $diffEntry[0]);
|
||||
} elseif ($diffEntry[1] === 2 /* REMOVED */) {
|
||||
\fwrite($buffer, '-' . $diffEntry[0]);
|
||||
} elseif ($diffEntry[1] === 3 /* WARNING */) {
|
||||
\fwrite($buffer, ' ' . $diffEntry[0]);
|
||||
|
||||
continue; // Warnings should not be tested for line break, it will always be there
|
||||
} else { /* Not changed (old) 0 */
|
||||
continue; // we didn't write the non changs line, so do not add a line break either
|
||||
}
|
||||
|
||||
$lc = \substr($diffEntry[0], -1);
|
||||
if ($lc !== "\n" && $lc !== "\r") {
|
||||
\fwrite($buffer, "\n"); // \No newline at end of file
|
||||
}
|
||||
}
|
||||
|
||||
$diff = \stream_get_contents($buffer, -1, 0);
|
||||
\fclose($buffer);
|
||||
|
||||
return $diff;
|
||||
}
|
||||
}
|
19
Laravel/vendor/sebastian/diff/src/Output/DiffOutputBuilderInterface.php
vendored
Normal file
19
Laravel/vendor/sebastian/diff/src/Output/DiffOutputBuilderInterface.php
vendored
Normal file
@@ -0,0 +1,19 @@
|
||||
<?php declare(strict_types=1);
|
||||
/*
|
||||
* This file is part of sebastian/diff.
|
||||
*
|
||||
* (c) Sebastian Bergmann <sebastian@phpunit.de>
|
||||
*
|
||||
* For the full copyright and license information, please view the LICENSE
|
||||
* file that was distributed with this source code.
|
||||
*/
|
||||
namespace SebastianBergmann\Diff\Output;
|
||||
|
||||
/**
|
||||
* Defines how an output builder should take a generated
|
||||
* diff array and return a string representation of that diff.
|
||||
*/
|
||||
interface DiffOutputBuilderInterface
|
||||
{
|
||||
public function getDiff(array $diff): string;
|
||||
}
|
165
Laravel/vendor/sebastian/diff/src/Output/UnifiedDiffOutputBuilder.php
vendored
Normal file
165
Laravel/vendor/sebastian/diff/src/Output/UnifiedDiffOutputBuilder.php
vendored
Normal file
@@ -0,0 +1,165 @@
|
||||
<?php declare(strict_types=1);
|
||||
/*
|
||||
* This file is part of sebastian/diff.
|
||||
*
|
||||
* (c) Sebastian Bergmann <sebastian@phpunit.de>
|
||||
*
|
||||
* For the full copyright and license information, please view the LICENSE
|
||||
* file that was distributed with this source code.
|
||||
*/
|
||||
|
||||
namespace SebastianBergmann\Diff\Output;
|
||||
|
||||
/**
|
||||
* Builds a diff string representation in unified diff format in chunks.
|
||||
*/
|
||||
final class UnifiedDiffOutputBuilder extends AbstractChunkOutputBuilder
|
||||
{
|
||||
/**
|
||||
* @var string
|
||||
*/
|
||||
private $header;
|
||||
|
||||
/**
|
||||
* @var bool
|
||||
*/
|
||||
private $addLineNumbers;
|
||||
|
||||
public function __construct(string $header = "--- Original\n+++ New\n", bool $addLineNumbers = false)
|
||||
{
|
||||
$this->header = $header;
|
||||
$this->addLineNumbers = $addLineNumbers;
|
||||
}
|
||||
|
||||
public function getDiff(array $diff): string
|
||||
{
|
||||
$buffer = \fopen('php://memory', 'r+b');
|
||||
|
||||
if ('' !== $this->header) {
|
||||
\fwrite($buffer, $this->header);
|
||||
if ("\n" !== \substr($this->header, -1, 1)) {
|
||||
\fwrite($buffer, "\n");
|
||||
}
|
||||
}
|
||||
|
||||
$this->writeDiffChunked($buffer, $diff, $this->getCommonChunks($diff));
|
||||
|
||||
$diff = \stream_get_contents($buffer, -1, 0);
|
||||
|
||||
\fclose($buffer);
|
||||
|
||||
return $diff;
|
||||
}
|
||||
|
||||
// `old` is an array with key => value pairs . Each pair represents a start and end index of `diff`
|
||||
// of a list of elements all containing `same` (0) entries.
|
||||
private function writeDiffChunked($output, array $diff, array $old)
|
||||
{
|
||||
$upperLimit = \count($diff);
|
||||
$start = 0;
|
||||
$fromStart = 0;
|
||||
$toStart = 0;
|
||||
|
||||
if (\count($old)) { // no common parts, list all diff entries
|
||||
\reset($old);
|
||||
|
||||
// iterate the diff, go from chunk to chunk skipping common chunk of lines between those
|
||||
do {
|
||||
$commonStart = \key($old);
|
||||
$commonEnd = \current($old);
|
||||
|
||||
if ($commonStart !== $start) {
|
||||
list($fromRange, $toRange) = $this->getChunkRange($diff, $start, $commonStart);
|
||||
$this->writeChunk($output, $diff, $start, $commonStart, $fromStart, $fromRange, $toStart, $toRange);
|
||||
|
||||
$fromStart += $fromRange;
|
||||
$toStart += $toRange;
|
||||
}
|
||||
|
||||
$start = $commonEnd + 1;
|
||||
$commonLength = $commonEnd - $commonStart + 1; // calculate number of non-change lines in the common part
|
||||
$fromStart += $commonLength;
|
||||
$toStart += $commonLength;
|
||||
} while (false !== \next($old));
|
||||
|
||||
\end($old); // short cut for finding possible last `change entry`
|
||||
$tmp = \key($old);
|
||||
\reset($old);
|
||||
if ($old[$tmp] === $upperLimit - 1) {
|
||||
$upperLimit = $tmp;
|
||||
}
|
||||
}
|
||||
|
||||
if ($start < $upperLimit - 1) { // check for trailing (non) diff entries
|
||||
do {
|
||||
--$upperLimit;
|
||||
} while (isset($diff[$upperLimit][1]) && $diff[$upperLimit][1] === 0);
|
||||
++$upperLimit;
|
||||
|
||||
list($fromRange, $toRange) = $this->getChunkRange($diff, $start, $upperLimit);
|
||||
$this->writeChunk($output, $diff, $start, $upperLimit, $fromStart, $fromRange, $toStart, $toRange);
|
||||
}
|
||||
}
|
||||
|
||||
private function writeChunk(
|
||||
$output,
|
||||
array $diff,
|
||||
int $diffStartIndex,
|
||||
int $diffEndIndex,
|
||||
int $fromStart,
|
||||
int $fromRange,
|
||||
int $toStart,
|
||||
int $toRange
|
||||
) {
|
||||
if ($this->addLineNumbers) {
|
||||
\fwrite($output, '@@ -' . (1 + $fromStart));
|
||||
|
||||
if ($fromRange > 1) {
|
||||
\fwrite($output, ',' . $fromRange);
|
||||
}
|
||||
|
||||
\fwrite($output, ' +' . (1 + $toStart));
|
||||
if ($toRange > 1) {
|
||||
\fwrite($output, ',' . $toRange);
|
||||
}
|
||||
|
||||
\fwrite($output, " @@\n");
|
||||
} else {
|
||||
\fwrite($output, "@@ @@\n");
|
||||
}
|
||||
|
||||
for ($i = $diffStartIndex; $i < $diffEndIndex; ++$i) {
|
||||
if ($diff[$i][1] === 1 /* ADDED */) {
|
||||
\fwrite($output, '+' . $diff[$i][0]);
|
||||
} elseif ($diff[$i][1] === 2 /* REMOVED */) {
|
||||
\fwrite($output, '-' . $diff[$i][0]);
|
||||
} else { /* Not changed (old) 0 or Warning 3 */
|
||||
\fwrite($output, ' ' . $diff[$i][0]);
|
||||
}
|
||||
|
||||
$lc = \substr($diff[$i][0], -1);
|
||||
if ($lc !== "\n" && $lc !== "\r") {
|
||||
\fwrite($output, "\n"); // \No newline at end of file
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private function getChunkRange(array $diff, int $diffStartIndex, int $diffEndIndex): array
|
||||
{
|
||||
$toRange = 0;
|
||||
$fromRange = 0;
|
||||
|
||||
for ($i = $diffStartIndex; $i < $diffEndIndex; ++$i) {
|
||||
if ($diff[$i][1] === 1) { // added
|
||||
++$toRange;
|
||||
} elseif ($diff[$i][1] === 2) { // removed
|
||||
++$fromRange;
|
||||
} elseif ($diff[$i][1] === 0) { // same
|
||||
++$fromRange;
|
||||
++$toRange;
|
||||
}
|
||||
}
|
||||
|
||||
return [$fromRange, $toRange];
|
||||
}
|
||||
}
|
106
Laravel/vendor/sebastian/diff/src/Parser.php
vendored
Normal file
106
Laravel/vendor/sebastian/diff/src/Parser.php
vendored
Normal file
@@ -0,0 +1,106 @@
|
||||
<?php declare(strict_types=1);
|
||||
/*
|
||||
* This file is part of sebastian/diff.
|
||||
*
|
||||
* (c) Sebastian Bergmann <sebastian@phpunit.de>
|
||||
*
|
||||
* For the full copyright and license information, please view the LICENSE
|
||||
* file that was distributed with this source code.
|
||||
*/
|
||||
|
||||
namespace SebastianBergmann\Diff;
|
||||
|
||||
/**
|
||||
* Unified diff parser.
|
||||
*/
|
||||
final class Parser
|
||||
{
|
||||
/**
|
||||
* @param string $string
|
||||
*
|
||||
* @return Diff[]
|
||||
*/
|
||||
public function parse(string $string): array
|
||||
{
|
||||
$lines = \preg_split('(\r\n|\r|\n)', $string);
|
||||
|
||||
if (!empty($lines) && $lines[\count($lines) - 1] === '') {
|
||||
\array_pop($lines);
|
||||
}
|
||||
|
||||
$lineCount = \count($lines);
|
||||
$diffs = [];
|
||||
$diff = null;
|
||||
$collected = [];
|
||||
|
||||
for ($i = 0; $i < $lineCount; ++$i) {
|
||||
if (\preg_match('(^---\\s+(?P<file>\\S+))', $lines[$i], $fromMatch) &&
|
||||
\preg_match('(^\\+\\+\\+\\s+(?P<file>\\S+))', $lines[$i + 1], $toMatch)) {
|
||||
if ($diff !== null) {
|
||||
$this->parseFileDiff($diff, $collected);
|
||||
|
||||
$diffs[] = $diff;
|
||||
$collected = [];
|
||||
}
|
||||
|
||||
$diff = new Diff($fromMatch['file'], $toMatch['file']);
|
||||
|
||||
++$i;
|
||||
} else {
|
||||
if (\preg_match('/^(?:diff --git |index [\da-f\.]+|[+-]{3} [ab])/', $lines[$i])) {
|
||||
continue;
|
||||
}
|
||||
|
||||
$collected[] = $lines[$i];
|
||||
}
|
||||
}
|
||||
|
||||
if ($diff !== null && \count($collected)) {
|
||||
$this->parseFileDiff($diff, $collected);
|
||||
|
||||
$diffs[] = $diff;
|
||||
}
|
||||
|
||||
return $diffs;
|
||||
}
|
||||
|
||||
private function parseFileDiff(Diff $diff, array $lines)
|
||||
{
|
||||
$chunks = [];
|
||||
$chunk = null;
|
||||
|
||||
foreach ($lines as $line) {
|
||||
if (\preg_match('/^@@\s+-(?P<start>\d+)(?:,\s*(?P<startrange>\d+))?\s+\+(?P<end>\d+)(?:,\s*(?P<endrange>\d+))?\s+@@/', $line, $match)) {
|
||||
$chunk = new Chunk(
|
||||
(int) $match['start'],
|
||||
isset($match['startrange']) ? \max(1, (int) $match['startrange']) : 1,
|
||||
(int) $match['end'],
|
||||
isset($match['endrange']) ? \max(1, (int) $match['endrange']) : 1
|
||||
);
|
||||
|
||||
$chunks[] = $chunk;
|
||||
$diffLines = [];
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
if (\preg_match('/^(?P<type>[+ -])?(?P<line>.*)/', $line, $match)) {
|
||||
$type = Line::UNCHANGED;
|
||||
|
||||
if ($match['type'] === '+') {
|
||||
$type = Line::ADDED;
|
||||
} elseif ($match['type'] === '-') {
|
||||
$type = Line::REMOVED;
|
||||
}
|
||||
|
||||
$diffLines[] = new Line($type, $match['line']);
|
||||
|
||||
if (null !== $chunk) {
|
||||
$chunk->setLines($diffLines);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
$diff->setChunks($chunks);
|
||||
}
|
||||
}
|
66
Laravel/vendor/sebastian/diff/src/TimeEfficientLongestCommonSubsequenceCalculator.php
vendored
Normal file
66
Laravel/vendor/sebastian/diff/src/TimeEfficientLongestCommonSubsequenceCalculator.php
vendored
Normal file
@@ -0,0 +1,66 @@
|
||||
<?php declare(strict_types=1);
|
||||
/*
|
||||
* This file is part of sebastian/diff.
|
||||
*
|
||||
* (c) Sebastian Bergmann <sebastian@phpunit.de>
|
||||
*
|
||||
* For the full copyright and license information, please view the LICENSE
|
||||
* file that was distributed with this source code.
|
||||
*/
|
||||
|
||||
namespace SebastianBergmann\Diff;
|
||||
|
||||
final class TimeEfficientLongestCommonSubsequenceCalculator implements LongestCommonSubsequenceCalculator
|
||||
{
|
||||
/**
|
||||
* {@inheritdoc}
|
||||
*/
|
||||
public function calculate(array $from, array $to): array
|
||||
{
|
||||
$common = [];
|
||||
$fromLength = \count($from);
|
||||
$toLength = \count($to);
|
||||
$width = $fromLength + 1;
|
||||
$matrix = new \SplFixedArray($width * ($toLength + 1));
|
||||
|
||||
for ($i = 0; $i <= $fromLength; ++$i) {
|
||||
$matrix[$i] = 0;
|
||||
}
|
||||
|
||||
for ($j = 0; $j <= $toLength; ++$j) {
|
||||
$matrix[$j * $width] = 0;
|
||||
}
|
||||
|
||||
for ($i = 1; $i <= $fromLength; ++$i) {
|
||||
for ($j = 1; $j <= $toLength; ++$j) {
|
||||
$o = ($j * $width) + $i;
|
||||
$matrix[$o] = \max(
|
||||
$matrix[$o - 1],
|
||||
$matrix[$o - $width],
|
||||
$from[$i - 1] === $to[$j - 1] ? $matrix[$o - $width - 1] + 1 : 0
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
$i = $fromLength;
|
||||
$j = $toLength;
|
||||
|
||||
while ($i > 0 && $j > 0) {
|
||||
if ($from[$i - 1] === $to[$j - 1]) {
|
||||
$common[] = $from[$i - 1];
|
||||
--$i;
|
||||
--$j;
|
||||
} else {
|
||||
$o = ($j * $width) + $i;
|
||||
|
||||
if ($matrix[$o - $width] > $matrix[$o - 1]) {
|
||||
--$j;
|
||||
} else {
|
||||
--$i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return \array_reverse($common);
|
||||
}
|
||||
}
|
Reference in New Issue
Block a user