.-.-.-.-.-

diff/src/v3_0/TimeEfficientLongestCommonSubsequenceCalculator.php000077700000003352151323542320021172 0ustar00<?php
/*
 * 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 PhpCsFixer\Diff\v3_0;

final class TimeEfficientLongestCommonSubsequenceCalculator implements LongestCommonSubsequenceCalculator
{
    /**
     * {@inheritdoc}
     */
    public function calculate(array $from, array $to)
    {
        $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);
    }
}
diff/src/v3_0/Parser.php000077700000005567151323542320011003 0ustar00<?php
/*
 * 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 PhpCsFixer\Diff\v3_0;

/**
 * Unified diff parser.
 */
final class Parser
{
    /**
     * @param string $string
     *
     * @return Diff[]
     */
    public function parse($string)
    {
        $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);
    }
}
diff/src/v3_0/Diff.php000077700000002132151323542320010400 0ustar00<?php
/*
 * 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 PhpCsFixer\Diff\v3_0;

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($from, $to, array $chunks = [])
    {
        $this->from   = $from;
        $this->to     = $to;
        $this->chunks = $chunks;
    }

public function getFrom()
    {
        return $this->from;
    }

public function getTo()
    {
        return $this->to;
    }

/**
     * @return Chunk[]
     */
    public function getChunks()
    {
        return $this->chunks;
    }

/**
     * @param Chunk[] $chunks
     */
    public function setChunks(array $chunks)
    {
        $this->chunks = $chunks;
    }
}
diff/src/v3_0/Line.php000077700000001407151323542320010423 0ustar00<?php
/*
 * 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 PhpCsFixer\Diff\v3_0;

final class Line
{
    const ADDED     = 1;
    const REMOVED   = 2;
    const UNCHANGED = 3;

/**
     * @var int
     */
    private $type;

/**
     * @var string
     */
    private $content;

public function __construct($type = self::UNCHANGED, $content = '')
    {
        $this->type    = $type;
        $this->content = $content;
    }

public function getContent()
    {
        return $this->content;
    }

public function getType()
    {
        return $this->type;
    }
}
diff/src/v3_0/LongestCommonSubsequenceCalculator.php000077700000001032151323542320016527 0ustar00<?php
/*
 * 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 PhpCsFixer\Diff\v3_0;

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);
}
diff/src/v3_0/Chunk.php000077700000002463151323542320010607 0ustar00<?php
/*
 * 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 PhpCsFixer\Diff\v3_0;

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($start = 0, $startRange = 1, $end = 0, $endRange = 1, array $lines = [])
    {
        $this->start      = $start;
        $this->startRange = $startRange;
        $this->end        = $end;
        $this->endRange   = $endRange;
        $this->lines      = $lines;
    }

public function getStart()
    {
        return $this->start;
    }

public function getStartRange()
    {
        return $this->startRange;
    }

public function getEnd()
    {
        return $this->end;
    }

public function getEndRange()
    {
        return $this->endRange;
    }

public function getLines()
    {
        return $this->lines;
    }

public function setLines(array $lines)
    {
        $this->lines = $lines;
    }
}
diff/src/v3_0/MemoryEfficientLongestCommonSubsequenceCalculator.php000077700000004055151323542320021545 0ustar00<?php
/*
 * 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 PhpCsFixer\Diff\v3_0;

final class MemoryEfficientLongestCommonSubsequenceCalculator implements LongestCommonSubsequenceCalculator
{
    /**
     * {@inheritdoc}
     */
    public function calculate(array $from, array $to)
    {
        $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)
    {
        $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;
    }
}
diff/src/v3_0/Exception/ConfigurationException.php000077700000002026151323542320016156 0ustar00<?php
/*
 * 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 PhpCsFixer\Diff\v3_0;

final class ConfigurationException extends InvalidArgumentException
{
    /**
     * @param string          $option
     * @param string          $expected
     * @param mixed           $value
     * @param int             $code
     * @param null|\Exception $previous
     */
    public function __construct(
        $option,
        $expected,
        $value,
        $code = 0,
        \Exception $previous = null
    ) {
        parent::__construct(
            \sprintf(
                'Option "%s" must be %s, got "%s".',
                $option,
                $expected,
                \is_object($value) ? \get_class($value) : (null === $value ? '<null>' : \gettype($value) . '#' . $value)
            ),
            $code,
            $previous
        );
    }
}
diff/src/v3_0/Exception/InvalidArgumentException.php000077700000000547151323542320016446 0ustar00<?php
/*
 * 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 PhpCsFixer\Diff\v3_0;

class InvalidArgumentException extends \InvalidArgumentException implements Exception
{
}
diff/src/v3_0/Exception/Exception.php000077700000000445151323542320013431 0ustar00<?php
/*
 * 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 PhpCsFixer\Diff\v3_0;

interface Exception
{
}
diff/src/v3_0/Exception/.htaccess000077700000000177151323542320012562 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>diff/src/v3_0/Differ.php000077700000022234151323542320010734 0ustar00<?php
/*
 * 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 PhpCsFixer\Diff\v3_0;

use PhpCsFixer\Diff\v3_0\Output\DiffOutputBuilderInterface;
use PhpCsFixer\Diff\v3_0\Output\UnifiedDiffOutputBuilder;

/**
 * Diff implementation.
 */
final class Differ
{
    const OLD                     = 0;
    const ADDED                   = 1;
    const REMOVED                 = 2;
    const DIFF_LINE_END_WARNING   = 3;
    const NO_LINE_END_EOF_WARNING = 4;

/**
     * @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 null|LongestCommonSubsequenceCalculator $lcs
     *
     * @return string
     */
    public function diff($from, $to, LongestCommonSubsequenceCalculator $lcs = null)
    {
        $diff = $this->diffToArray(
            $this->normalizeDiffInput($from),
            $this->normalizeDiffInput($to),
            $lcs
        );

return $this->outputBuilder->getDiff($diff);
    }

/**
     * 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)
    {
        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, self::OLD];
        }

\reset($from);
        \reset($to);

foreach ($common as $token) {
            while (($fromToken = \reset($from)) !== $token) {
                $diff[] = [\array_shift($from), self::REMOVED];
            }

while (($toToken = \reset($to)) !== $token) {
                $diff[] = [\array_shift($to), self::ADDED];
            }

$diff[] = [$token, self::OLD];

\array_shift($from);
            \array_shift($to);
        }

while (($token = \array_shift($from)) !== null) {
            $diff[] = [$token, self::REMOVED];
        }

while (($token = \array_shift($to)) !== null) {
            $diff[] = [$token, self::ADDED];
        }

foreach ($end as $token) {
            $diff[] = [$token, self::OLD];
        }

if ($this->detectUnmatchedLineEndings($diff)) {
            \array_unshift($diff, ["#Warnings contain different line endings!\n", self::DIFF_LINE_END_WARNING]);
        }

return $diff;
    }

/**
     * Casts variable to string if it is not a string or array.
     *
     * @param mixed $input
     *
     * @return array|string
     */
    private function normalizeDiffInput($input)
    {
        if (!\is_array($input) && !\is_string($input)) {
            return (string) $input;
        }

return $input;
    }

/**
     * Checks if input is string, if so it will split it line-by-line.
     *
     * @param string $input
     *
     * @return array
     */
    private function splitStringByLines($input)
    {
        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)
    {
        // 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 float|int
     */
    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)
    {
        $newLineBreaks = ['' => true];
        $oldLineBreaks = ['' => true];

foreach ($diff as $entry) {
            if (self::OLD === $entry[1]) {
                $ln                 = $this->getLinebreak($entry[0]);
                $oldLineBreaks[$ln] = true;
                $newLineBreaks[$ln] = true;
            } elseif (self::ADDED === $entry[1]) {
                $newLineBreaks[$this->getLinebreak($entry[0])] = true;
            } elseif (self::REMOVED === $entry[1]) {
                $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)
    {
        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)
    {
        $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];
    }
}
diff/src/v3_0/Output/StrictUnifiedDiffOutputBuilder.php000077700000024177151323542320017142 0ustar00<?php
/*
 * 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 PhpCsFixer\Diff\v3_0\Output;

use PhpCsFixer\Diff\v3_0\ConfigurationException;
use PhpCsFixer\Diff\v3_0\Differ;

/**
 * Strict Unified diff output builder.
 *
 * Generates (strict) Unified diff's (unidiffs) with hunks.
 */
final class StrictUnifiedDiffOutputBuilder implements DiffOutputBuilderInterface
{
    /**
     * @var bool
     */
    private $changed;

/**
     * @var bool
     */
    private $collapseRanges;

/**
     * @var int >= 0
     */
    private $commonLineThreshold;

/**
     * @var string
     */
    private $header;

/**
     * @var int >= 0
     */
    private $contextLines;

private static $default = [
        'collapseRanges'      => true, // ranges of length one are rendered with the trailing `,1`
        'commonLineThreshold' => 6,    // number of same lines before ending a new hunk and creating a new one (if needed)
        'contextLines'        => 3,    // like `diff:  -u, -U NUM, --unified[=NUM]`, for patch/git apply compatibility best to keep at least @ 3
        'fromFile'            => null,
        'fromFileDate'        => null,
        'toFile'              => null,
        'toFileDate'          => null,
    ];

public function __construct(array $options = [])
    {
        $options = \array_merge(self::$default, $options);

if (!\is_bool($options['collapseRanges'])) {
            throw new ConfigurationException('collapseRanges', 'a bool', $options['collapseRanges']);
        }

if (!\is_int($options['contextLines']) || $options['contextLines'] < 0) {
            throw new ConfigurationException('contextLines', 'an int >= 0', $options['contextLines']);
        }

if (!\is_int($options['commonLineThreshold']) || $options['commonLineThreshold'] <= 0) {
            throw new ConfigurationException('commonLineThreshold', 'an int > 0', $options['commonLineThreshold']);
        }

foreach (['fromFile', 'toFile'] as $option) {
            if (!\is_string($options[$option])) {
                throw new ConfigurationException($option, 'a string', $options[$option]);
            }
        }

foreach (['fromFileDate', 'toFileDate'] as $option) {
            if (null !== $options[$option] && !\is_string($options[$option])) {
                throw new ConfigurationException($option, 'a string or <null>', $options[$option]);
            }
        }

$this->header = \sprintf(
            "--- %s%s\n+++ %s%s\n",
            $options['fromFile'],
            null === $options['fromFileDate'] ? '' : "\t" . $options['fromFileDate'],
            $options['toFile'],
            null === $options['toFileDate'] ? '' : "\t" . $options['toFileDate']
        );

$this->collapseRanges      = $options['collapseRanges'];
        $this->commonLineThreshold = $options['commonLineThreshold'];
        $this->contextLines        = $options['contextLines'];
    }

public function getDiff(array $diff)
    {
        if (0 === \count($diff)) {
            return '';
        }

$this->changed = false;

$buffer = \fopen('php://memory', 'r+b');
        \fwrite($buffer, $this->header);

$this->writeDiffHunks($buffer, $diff);

if (!$this->changed) {
            \fclose($buffer);

return '';
        }

$diff = \stream_get_contents($buffer, -1, 0);

\fclose($buffer);

// If the last char is not a linebreak: add it.
        // This might happen when both the `from` and `to` do not have a trailing linebreak
        $last = \substr($diff, -1);

return "\n" !== $last && "\r" !== $last
            ? $diff . "\n"
            : $diff
        ;
    }

private function writeDiffHunks($output, array $diff)
    {
        // detect "No newline at end of file" and insert into `$diff` if needed

$upperLimit = \count($diff);

if (0 === $diff[$upperLimit - 1][1]) {
            $lc = \substr($diff[$upperLimit - 1][0], -1);
            if ("\n" !== $lc) {
                \array_splice($diff, $upperLimit, 0, [["\n\\ No newline at end of file\n", Differ::NO_LINE_END_EOF_WARNING]]);
            }
        } else {
            // search back for the last `+` and `-` line,
            // check if has trailing linebreak, else add under it warning under it
            $toFind = [1 => true, 2 => true];
            for ($i = $upperLimit - 1; $i >= 0; --$i) {
                if (isset($toFind[$diff[$i][1]])) {
                    unset($toFind[$diff[$i][1]]);
                    $lc = \substr($diff[$i][0], -1);
                    if ("\n" !== $lc) {
                        \array_splice($diff, $i + 1, 0, [["\n\\ No newline at end of file\n", Differ::NO_LINE_END_EOF_WARNING]]);
                    }

if (!\count($toFind)) {
                        break;
                    }
                }
            }
        }

// write hunks to output buffer

$cutOff      = \max($this->commonLineThreshold, $this->contextLines);
        $hunkCapture = false;
        $sameCount   = $toRange = $fromRange = 0;
        $toStart     = $fromStart = 1;

foreach ($diff as $i => $entry) {
            if (0 === $entry[1]) { // same
                if (false === $hunkCapture) {
                    ++$fromStart;
                    ++$toStart;

continue;
                }

++$sameCount;
                ++$toRange;
                ++$fromRange;

if ($sameCount === $cutOff) {
                    $contextStartOffset = ($hunkCapture - $this->contextLines) < 0
                        ? $hunkCapture
                        : $this->contextLines
                    ;

// note: $contextEndOffset = $this->contextLines;
                    //
                    // because we never go beyond the end of the diff.
                    // with the cutoff/contextlines here the follow is never true;
                    //
                    // if ($i - $cutOff + $this->contextLines + 1 > \count($diff)) {
                    //    $contextEndOffset = count($diff) - 1;
                    // }
                    //
                    // ; that would be true for a trailing incomplete hunk case which is dealt with after this loop

$this->writeHunk(
                        $diff,
                        $hunkCapture - $contextStartOffset,
                        $i - $cutOff + $this->contextLines + 1,
                        $fromStart - $contextStartOffset,
                        $fromRange - $cutOff + $contextStartOffset + $this->contextLines,
                        $toStart - $contextStartOffset,
                        $toRange - $cutOff + $contextStartOffset + $this->contextLines,
                        $output
                    );

$fromStart += $fromRange;
                    $toStart += $toRange;

$hunkCapture = false;
                    $sameCount   = $toRange = $fromRange = 0;
                }

continue;
            }

$sameCount = 0;

if ($entry[1] === Differ::NO_LINE_END_EOF_WARNING) {
                continue;
            }

$this->changed = true;

if (false === $hunkCapture) {
                $hunkCapture = $i;
            }

if (Differ::ADDED === $entry[1]) { // added
                ++$toRange;
            }

if (Differ::REMOVED === $entry[1]) { // removed
                ++$fromRange;
            }
        }

if (false === $hunkCapture) {
            return;
        }

// we end here when cutoff (commonLineThreshold) was not reached, but we where capturing a hunk,
        // do not render hunk till end automatically because the number of context lines might be less than the commonLineThreshold

$contextStartOffset = $hunkCapture - $this->contextLines < 0
            ? $hunkCapture
            : $this->contextLines
        ;

// prevent trying to write out more common lines than there are in the diff _and_
        // do not write more than configured through the context lines
        $contextEndOffset = \min($sameCount, $this->contextLines);

$fromRange -= $sameCount;
        $toRange -= $sameCount;

$this->writeHunk(
            $diff,
            $hunkCapture - $contextStartOffset,
            $i - $sameCount + $contextEndOffset + 1,
            $fromStart - $contextStartOffset,
            $fromRange + $contextStartOffset + $contextEndOffset,
            $toStart - $contextStartOffset,
            $toRange + $contextStartOffset + $contextEndOffset,
            $output
        );
    }

private function writeHunk(
        array $diff,
        $diffStartIndex,
        $diffEndIndex,
        $fromStart,
        $fromRange,
        $toStart,
        $toRange,
        $output
    ) {
        \fwrite($output, '@@ -' . $fromStart);

if (!$this->collapseRanges || 1 !== $fromRange) {
            \fwrite($output, ',' . $fromRange);
        }

\fwrite($output, ' +' . $toStart);
        if (!$this->collapseRanges || 1 !== $toRange) {
            \fwrite($output, ',' . $toRange);
        }

\fwrite($output, " @@\n");

for ($i = $diffStartIndex; $i < $diffEndIndex; ++$i) {
            if ($diff[$i][1] === Differ::ADDED) {
                $this->changed = true;
                \fwrite($output, '+' . $diff[$i][0]);
            } elseif ($diff[$i][1] === Differ::REMOVED) {
                $this->changed = true;
                \fwrite($output, '-' . $diff[$i][0]);
            } elseif ($diff[$i][1] === Differ::OLD) {
                \fwrite($output, ' ' . $diff[$i][0]);
            } elseif ($diff[$i][1] === Differ::NO_LINE_END_EOF_WARNING) {
                $this->changed = true;
                \fwrite($output, $diff[$i][0]);
            }
            //} elseif ($diff[$i][1] === Differ::DIFF_LINE_END_WARNING) { // custom comment inserted by PHPUnit/diff package
                //  skip
            //} else {
                //  unknown/invalid
            //}
        }
    }
}
diff/src/v3_0/Output/DiffOutputBuilderInterface.php000077700000000747151323542320016263 0ustar00<?php
/*
 * 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 PhpCsFixer\Diff\v3_0\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);
}
diff/src/v3_0/Output/UnifiedDiffOutputBuilder.php000077700000017755151323542320015755 0ustar00<?php
/*
 * 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 PhpCsFixer\Diff\v3_0\Output;

use PhpCsFixer\Diff\v3_0\Differ;

/**
 * Builds a diff string representation in unified diff format in chunks.
 */
final class UnifiedDiffOutputBuilder extends AbstractChunkOutputBuilder
{
    /**
     * @var bool
     */
    private $collapseRanges = true;

/**
     * @var int >= 0
     */
    private $commonLineThreshold = 6;

/**
     * @var int >= 0
     */
    private $contextLines = 3;

/**
     * @var string
     */
    private $header;

/**
     * @var bool
     */
    private $addLineNumbers;

public function __construct($header = "--- Original\n+++ New\n", $addLineNumbers = false)
    {
        $this->header         = $header;
        $this->addLineNumbers = $addLineNumbers;
    }

public function getDiff(array $diff)
    {
        $buffer = \fopen('php://memory', 'r+b');

if ('' !== $this->header) {
            \fwrite($buffer, $this->header);
            if ("\n" !== \substr($this->header, -1, 1)) {
                \fwrite($buffer, "\n");
            }
        }

if (0 !== \count($diff)) {
            $this->writeDiffHunks($buffer, $diff);
        }

$diff = \stream_get_contents($buffer, -1, 0);

\fclose($buffer);

// If the diff is non-empty and a linebreak: add it.
        // This might happen when both the `from` and `to` do not have a trailing linebreak
        $last = \substr($diff, -1);

return 0 !== \strlen($diff) && "\n" !== $last && "\r" !== $last
            ? $diff . "\n"
            : $diff
        ;
    }

private function writeDiffHunks($output, array $diff)
    {
        // detect "No newline at end of file" and insert into `$diff` if needed

$upperLimit = \count($diff);

if (!\count($toFind)) {
                        break;
                    }
                }
            }
        }

// write hunks to output buffer

$cutOff      = \max($this->commonLineThreshold, $this->contextLines);
        $hunkCapture = false;
        $sameCount   = $toRange   = $fromRange = 0;
        $toStart     = $fromStart = 1;

foreach ($diff as $i => $entry) {
            if (0 === $entry[1]) { // same
                if (false === $hunkCapture) {
                    ++$fromStart;
                    ++$toStart;

continue;
                }

++$sameCount;
                ++$toRange;
                ++$fromRange;

$fromStart += $fromRange;
                    $toStart += $toRange;

$hunkCapture = false;
                    $sameCount   = $toRange = $fromRange = 0;
                }

continue;
            }

$sameCount = 0;

if ($entry[1] === Differ::NO_LINE_END_EOF_WARNING) {
                continue;
            }

if (false === $hunkCapture) {
                $hunkCapture = $i;
            }

if (Differ::ADDED === $entry[1]) {
                ++$toRange;
            }

if (Differ::REMOVED === $entry[1]) {
                ++$fromRange;
            }
        }

if (false === $hunkCapture) {
            return;
        }

$contextStartOffset = $hunkCapture - $this->contextLines < 0
            ? $hunkCapture
            : $this->contextLines
        ;

$fromRange -= $sameCount;
        $toRange -= $sameCount;

private function writeHunk(
        array $diff,
        $diffStartIndex,
        $diffEndIndex,
        $fromStart,
        $fromRange,
        $toStart,
        $toRange,
        $output
    ) {
        if ($this->addLineNumbers) {
            \fwrite($output, '@@ -' . $fromStart);

if (!$this->collapseRanges || 1 !== $fromRange) {
                \fwrite($output, ',' . $fromRange);
            }

\fwrite($output, ' +' . $toStart);
            if (!$this->collapseRanges || 1 !== $toRange) {
                \fwrite($output, ',' . $toRange);
            }

\fwrite($output, " @@\n");
        } else {
            \fwrite($output, "@@ @@\n");
        }

for ($i = $diffStartIndex; $i < $diffEndIndex; ++$i) {
            if ($diff[$i][1] === Differ::ADDED) {
                \fwrite($output, '+' . $diff[$i][0]);
            } elseif ($diff[$i][1] === Differ::REMOVED) {
                \fwrite($output, '-' . $diff[$i][0]);
            } elseif ($diff[$i][1] === Differ::OLD) {
                \fwrite($output, ' ' . $diff[$i][0]);
            } elseif ($diff[$i][1] === Differ::NO_LINE_END_EOF_WARNING) {
                \fwrite($output, "\n"); // $diff[$i][0]
            } else { /* Not changed (old) Differ::OLD or Warning Differ::DIFF_LINE_END_WARNING */
                \fwrite($output, ' ' . $diff[$i][0]);
            }
        }
    }
}
diff/src/v3_0/Output/AbstractChunkOutputBuilder.php000077700000003051151323542320016315 0ustar00<?php
/*
 * 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 PhpCsFixer\Diff\v3_0\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, $lineThreshold = 5)
    {
        $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;
    }
}
diff/src/v3_0/Output/.htaccess000077700000000177151323542320012124 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>diff/src/v3_0/Output/DiffOnlyOutputBuilder.php000077700000003633151323542320015301 0ustar00<?php
/*
 * 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 PhpCsFixer\Diff\v3_0\Output;

use PhpCsFixer\Diff\v3_0\Differ;

/**
 * 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($header = "--- Original\n+++ New\n")
    {
        $this->header = $header;
    }

public function getDiff(array $diff)
    {
        $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] === Differ::ADDED) {
                \fwrite($buffer, '+' . $diffEntry[0]);
            } elseif ($diffEntry[1] === Differ::REMOVED) {
                \fwrite($buffer, '-' . $diffEntry[0]);
            } elseif ($diffEntry[1] === Differ::DIFF_LINE_END_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;
    }
}
diff/src/v3_0/.htaccess000077700000000177151323542320010624 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>diff/src/v1_4/Parser.php000077700000005666151323542320011005 0ustar00<?php
/*
 * 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 PhpCsFixer\Diff\v1_4;

/**
 * Unified diff parser.
 */
class Parser
{
    /**
     * @param string $string
     *
     * @return Diff[]
     */
    public function parse($string)
    {
        $lines = \preg_split('(\r\n|\r|\n)', $string);

if (!empty($lines) && $lines[\count($lines) - 1] == '') {
            \array_pop($lines);
        }

$lineCount = \count($lines);
        $diffs     = array();
        $diff      = null;
        $collected = array();

$diffs[]   = $diff;
                    $collected = array();
                }

$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;
    }

/**
     * @param Diff  $diff
     * @param array $lines
     */
    private function parseFileDiff(Diff $diff, array $lines)
    {
        $chunks = array();
        $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(
                    $match['start'],
                    isset($match['startrange']) ? \max(1, $match['startrange']) : 1,
                    $match['end'],
                    isset($match['endrange']) ? \max(1, $match['endrange']) : 1
                );

$chunks[]  = $chunk;
                $diffLines = array();

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);
    }
}
diff/src/v1_4/Diff.php000077700000002245151323542320010407 0ustar00<?php
/*
 * 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 PhpCsFixer\Diff\v1_4;

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($from, $to, array $chunks = array())
    {
        $this->from   = $from;
        $this->to     = $to;
        $this->chunks = $chunks;
    }

/**
     * @return string
     */
    public function getFrom()
    {
        return $this->from;
    }

/**
     * @return string
     */
    public function getTo()
    {
        return $this->to;
    }

/**
     * @return Chunk[]
     */
    public function getChunks()
    {
        return $this->chunks;
    }

/**
     * @param Chunk[] $chunks
     */
    public function setChunks(array $chunks)
    {
        $this->chunks = $chunks;
    }
}
diff/src/v1_4/Line.php000077700000001623151323542320010425 0ustar00<?php
/*
 * 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 PhpCsFixer\Diff\v1_4;

class Line
{
    const ADDED     = 1;
    const REMOVED   = 2;
    const UNCHANGED = 3;

/**
     * @var int
     */
    private $type;

/**
     * @var string
     */
    private $content;

/**
     * @param int    $type
     * @param string $content
     */
    public function __construct($type = self::UNCHANGED, $content = '')
    {
        $this->type    = $type;
        $this->content = $content;
    }

/**
     * @return string
     */
    public function getContent()
    {
        return $this->content;
    }

/**
     * @return int
     */
    public function getType()
    {
        return $this->type;
    }
}
diff/src/v1_4/Chunk.php000077700000003303151323542320010603 0ustar00<?php
/*
 * 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 PhpCsFixer\Diff\v1_4;

class Chunk
{
    /**
     * @var int
     */
    private $start;

/**
     * @var int
     */
    private $startRange;

/**
     * @var int
     */
    private $end;

/**
     * @var int
     */
    private $endRange;

/**
     * @var array
     */
    private $lines;

/**
     * @param int   $start
     * @param int   $startRange
     * @param int   $end
     * @param int   $endRange
     * @param array $lines
     */
    public function __construct($start = 0, $startRange = 1, $end = 0, $endRange = 1, array $lines = array())
    {
        $this->start      = (int) $start;
        $this->startRange = (int) $startRange;
        $this->end        = (int) $end;
        $this->endRange   = (int) $endRange;
        $this->lines      = $lines;
    }

/**
     * @return int
     */
    public function getStart()
    {
        return $this->start;
    }

/**
     * @return int
     */
    public function getStartRange()
    {
        return $this->startRange;
    }

/**
     * @return int
     */
    public function getEnd()
    {
        return $this->end;
    }

/**
     * @return int
     */
    public function getEndRange()
    {
        return $this->endRange;
    }

/**
     * @return array
     */
    public function getLines()
    {
        return $this->lines;
    }

/**
     * @param array $lines
     */
    public function setLines(array $lines)
    {
        $this->lines = $lines;
    }
}
diff/src/v1_4/LCS/TimeEfficientLongestCommonSubsequenceImplementation.php000077700000003643151323542320022514 0ustar00<?php
/*
 * 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 PhpCsFixer\Diff\v1_4\LCS;

/**
 * Time-efficient implementation of longest common subsequence calculation.
 */
class TimeEfficientImplementation implements LongestCommonSubsequence
{
    /**
     * Calculates the longest common subsequence of two arrays.
     *
     * @param array $from
     * @param array $to
     *
     * @return array
     */
    public function calculate(array $from, array $to)
    {
        $common     = array();
        $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;
        }

$i = $fromLength;
        $j = $toLength;

if ($matrix[$o - $width] > $matrix[$o - 1]) {
                    --$j;
                } else {
                    --$i;
                }
            }
        }

return \array_reverse($common);
    }
}
diff/src/v1_4/LCS/MemoryEfficientLongestCommonSubsequenceImplementation.php000077700000004520151323542320023061 0ustar00<?php
/*
 * 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 PhpCsFixer\Diff\v1_4\LCS;

/**
 * Memory-efficient implementation of longest common subsequence calculation.
 */
class MemoryEfficientImplementation implements LongestCommonSubsequence
{
    /**
     * Calculates the longest common subsequence of two arrays.
     *
     * @param array $from
     * @param array $to
     *
     * @return array
     */
    public function calculate(array $from, array $to)
    {
        $cFrom = \count($from);
        $cTo   = \count($to);

if ($cFrom === 0) {
            return array();
        }

if ($cFrom === 1) {
            if (\in_array($from[0], $to, true)) {
                return array($from[0]);
            }

return array();
        }

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)
        );
    }

/**
     * @param array $from
     * @param array $to
     *
     * @return array
     */
    private function length(array $from, array $to)
    {
        $current = \array_fill(0, \count($to) + 1, 0);
        $cFrom   = \count($from);
        $cTo     = \count($to);

for ($i = 0; $i < $cFrom; $i++) {
            $prev = $current;

return $current;
    }
}
diff/src/v1_4/LCS/.htaccess000077700000000177151323542320011247 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>diff/src/v1_4/LCS/LongestCommonSubsequence.php000077700000001150151323542320015141 0ustar00<?php
/*
 * 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 PhpCsFixer\Diff\v1_4\LCS;

/**
 * Interface for implementations of longest common subsequence calculation.
 */
interface LongestCommonSubsequence
{
    /**
     * Calculates the longest common subsequence of two arrays.
     *
     * @param array $from
     * @param array $to
     *
     * @return array
     */
    public function calculate(array $from, array $to);
}
diff/src/v1_4/Differ.php000077700000024410151323542320010734 0ustar00<?php
/*
 * 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 PhpCsFixer\Diff\v1_4;

use PhpCsFixer\Diff\v1_4\LCS\LongestCommonSubsequence;
use PhpCsFixer\Diff\v1_4\LCS\TimeEfficientImplementation;
use PhpCsFixer\Diff\v1_4\LCS\MemoryEfficientImplementation;

/**
 * Diff implementation.
 */
class Differ
{
    /**
     * @var string
     */
    private $header;

/**
     * @var bool
     */
    private $showNonDiffLines;

/**
     * @param string $header
     * @param bool   $showNonDiffLines
     */
    public function __construct($header = "--- Original\n+++ New\n", $showNonDiffLines = true)
    {
        $this->header           = $header;
        $this->showNonDiffLines = $showNonDiffLines;
    }

/**
     * Returns the diff between two arrays or strings as string.
     *
     * @param array|string             $from
     * @param array|string             $to
     * @param LongestCommonSubsequence $lcs
     *
     * @return string
     */
    public function diff($from, $to, LongestCommonSubsequence $lcs = null)
    {
        $from  = $this->validateDiffInput($from);
        $to    = $this->validateDiffInput($to);
        $diff  = $this->diffToArray($from, $to, $lcs);
        $old   = $this->checkIfDiffInOld($diff);
        $start = isset($old[0]) ? $old[0] : 0;
        $end   = \count($diff);

if ($tmp = \array_search($end, $old)) {
            $end = $tmp;
        }

return $this->getBuffer($diff, $old, $start, $end);
    }

/**
     * Casts variable to string if it is not a string or array.
     *
     * @param mixed $input
     *
     * @return string
     */
    private function validateDiffInput($input)
    {
        if (!\is_array($input) && !\is_string($input)) {
            return (string) $input;
        }

return $input;
    }

/**
     * Takes input of the diff array and returns the old array.
     * Iterates through diff line by line,
     *
     * @param array $diff
     *
     * @return array
     */
    private function checkIfDiffInOld(array $diff)
    {
        $inOld = false;
        $i     = 0;
        $old   = array();

foreach ($diff as $line) {
            if ($line[1] === 0 /* OLD */) {
                if ($inOld === false) {
                    $inOld = $i;
                }
            } elseif ($inOld !== false) {
                if (($i - $inOld) > 5) {
                    $old[$inOld] = $i - 1;
                }

$inOld = false;
            }

++$i;
        }

return $old;
    }

/**
     * Generates buffer in string format, returning the patch.
     *
     * @param array $diff
     * @param array $old
     * @param int   $start
     * @param int   $end
     *
     * @return string
     */
    private function getBuffer(array $diff, array $old, $start, $end)
    {
        $buffer = $this->header;

if (!isset($old[$start])) {
            $buffer = $this->getDiffBufferElementNew($diff, $buffer, $start);
            ++$start;
        }

for ($i = $start; $i < $end; $i++) {
            if (isset($old[$i])) {
                $i      = $old[$i];
                $buffer = $this->getDiffBufferElementNew($diff, $buffer, $i);
            } else {
                $buffer = $this->getDiffBufferElement($diff, $buffer, $i);
            }
        }

return $buffer;
    }

/**
     * Gets individual buffer element.
     *
     * @param array  $diff
     * @param string $buffer
     * @param int    $diffIndex
     *
     * @return string
     */
    private function getDiffBufferElement(array $diff, $buffer, $diffIndex)
    {
        if ($diff[$diffIndex][1] === 1 /* ADDED */) {
            $buffer .= '+' . $diff[$diffIndex][0] . "\n";
        } elseif ($diff[$diffIndex][1] === 2 /* REMOVED */) {
            $buffer .= '-' . $diff[$diffIndex][0] . "\n";
        } elseif ($this->showNonDiffLines === true) {
            $buffer .= ' ' . $diff[$diffIndex][0] . "\n";
        }

return $buffer;
    }

/**
     * Gets individual buffer element with opening.
     *
     * @param array  $diff
     * @param string $buffer
     * @param int    $diffIndex
     *
     * @return string
     */
    private function getDiffBufferElementNew(array $diff, $buffer, $diffIndex)
    {
        if ($this->showNonDiffLines === true) {
            $buffer .= "@@ @@\n";
        }

return $this->getDiffBufferElement($diff, $buffer, $diffIndex);
    }

/**
     * 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 LongestCommonSubsequence $lcs
     *
     * @return array
     */
    public function diffToArray($from, $to, LongestCommonSubsequence $lcs = null)
    {
        if (\is_string($from)) {
            $fromMatches = $this->getNewLineMatches($from);
            $from        = $this->splitStringByLines($from);
        } elseif (\is_array($from)) {
            $fromMatches = array();
        } else {
            throw new \InvalidArgumentException('"from" must be an array or string.');
        }

if (\is_string($to)) {
            $toMatches = $this->getNewLineMatches($to);
            $to        = $this->splitStringByLines($to);
        } elseif (\is_array($to)) {
            $toMatches = array();
        } else {
            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   = array();

if ($this->detectUnmatchedLineEndings($fromMatches, $toMatches)) {
            $diff[] = array(
                '#Warnings contain different line endings!',
                0
            );
        }

foreach ($start as $token) {
            $diff[] = array($token, 0 /* OLD */);
        }

\reset($from);
        \reset($to);

foreach ($common as $token) {
            while (($fromToken = \reset($from)) !== $token) {
                $diff[] = array(\array_shift($from), 2 /* REMOVED */);
            }

while (($toToken = \reset($to)) !== $token) {
                $diff[] = array(\array_shift($to), 1 /* ADDED */);
            }

$diff[] = array($token, 0 /* OLD */);

\array_shift($from);
            \array_shift($to);
        }

while (($token = \array_shift($from)) !== null) {
            $diff[] = array($token, 2 /* REMOVED */);
        }

while (($token = \array_shift($to)) !== null) {
            $diff[] = array($token, 1 /* ADDED */);
        }

foreach ($end as $token) {
            $diff[] = array($token, 0 /* OLD */);
        }

return $diff;
    }

/**
     * Get new strings denoting new lines from a given string.
     *
     * @param string $string
     *
     * @return array
     */
    private function getNewLineMatches($string)
    {
        \preg_match_all('(\r\n|\r|\n)', $string, $stringMatches);

return $stringMatches;
    }

/**
     * @param array $from
     * @param array $to
     *
     * @return LongestCommonSubsequence
     */
    private function selectLcsImplementation(array $from, array $to)
    {
        // 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 MemoryEfficientImplementation;
        }

return new TimeEfficientImplementation;
    }

/**
     * 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 * \pow(\min(\count($from), \count($to)), 2);
    }

/**
     * Returns true if line ends don't match on fromMatches and toMatches.
     *
     * @param array $fromMatches
     * @param array $toMatches
     *
     * @return bool
     */
    private function detectUnmatchedLineEndings(array $fromMatches, array $toMatches)
    {
        return isset($fromMatches[0], $toMatches[0]) &&
               \count($fromMatches[0]) === \count($toMatches[0]) &&
               $fromMatches[0] !== $toMatches[0];
    }

/**
     * @param array $from
     * @param array $to
     *
     * @return array
     */
    private static function getArrayDiffParted(array &$from, array &$to)
    {
        $start = array();
        $end   = array();

\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 = array($fromK => $from[$fromK]) + $end;
            unset($from[$fromK], $to[$toK]);
        } while (true);

return array($from, $to, $start, $end);
    }
}
diff/src/v1_4/.htaccess000077700000000177151323542320010626 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>diff/src/GeckoPackages/DiffOutputBuilder/ConfigurationException.php000077700000001550151323542320021541 0ustar00<?php

/*
 * This file is part of the GeckoPackages.
 *
 * (c) GeckoPackages https://github.com/GeckoPackages
 *
 * This source file is subject to the MIT license that is bundled
 * with this source code in the file LICENSE.
 */

namespace PhpCsFixer\Diff\GeckoPackages\DiffOutputBuilder;

use Exception;

final class ConfigurationException extends \InvalidArgumentException
{
    public function __construct(
        $option,
        $expected,
        $value,
        $code = 0,
        Exception $previous = null
    ) {
        parent::__construct(
            \sprintf(
                'Option "%s" must be %s, got "%s".',
                $option,
                $expected,
                \is_object($value) ? \get_class($value) : (null === $value ? '<null>' : \gettype($value).'#'.$value)
            ),
            $code,
            $previous
        );
    }
}
diff/src/GeckoPackages/DiffOutputBuilder/UnifiedDiffOutputBuilder.php000077700000021340151323542320021756 0ustar00<?php

namespace PhpCsFixer\Diff\GeckoPackages\DiffOutputBuilder;

use PhpCsFixer\Diff\v2_0\Output\DiffOutputBuilderInterface;

/**
 * Strict Unified diff output builder.
 *
 * @name Unified diff output builder
 *
 * @description Generates (strict) Unified diff's (unidiffs) with hunks.
 *
 * @author SpacePossum
 *
 * @api
 */
final class UnifiedDiffOutputBuilder implements DiffOutputBuilderInterface
{
    /**
     * @var int
     */
    private static $noNewlineAtOEFid = 998877;

/**
     * @var bool
     */
    private $changed;

/**
     * @var bool
     */
    private $collapseRanges;

/**
     * @var int >= 0
     */
    private $commonLineThreshold;

/**
     * @var string
     */
    private $header;

/**
     * @var int >= 0
     */
    private $contextLines;

private static $default = [
        'contextLines' => 3, // like `diff:  -u, -U NUM, --unified[=NUM]`, for patch/git apply compatibility best to keep at least @ 3
        'collapseRanges' => true, // ranges of length one are rendered with the trailing `,1`
        'fromFile' => null,
        'fromFileDate' => null,
        'toFile' => null,
        'toFileDate' => null,
        'commonLineThreshold' => 6, // number of same lines before ending a new hunk and creating a new one (if needed)
    ];

public function __construct(array $options = [])
    {
        $options = \array_merge(self::$default, $options);

if (!\is_bool($options['collapseRanges'])) {
            throw new ConfigurationException('collapseRanges', 'a bool', $options['collapseRanges']);
        }

if (!\is_int($options['contextLines']) || $options['contextLines'] < 0) {
            throw new ConfigurationException('contextLines', 'an int >= 0', $options['contextLines']);
        }

if (!\is_int($options['commonLineThreshold']) || $options['commonLineThreshold'] < 1) {
            throw new ConfigurationException('commonLineThreshold', 'an int > 0', $options['commonLineThreshold']);
        }

$this->header = \sprintf(
            "--- %s%s\n+++ %s%s\n",
            $options['fromFile'],
            null === $options['fromFileDate'] ? '' : "\t".$options['fromFileDate'],
            $options['toFile'],
            null === $options['toFileDate'] ? '' : "\t".$options['toFileDate']
        );

$this->collapseRanges = $options['collapseRanges'];
        $this->commonLineThreshold = $options['commonLineThreshold'];
        $this->contextLines = $options['contextLines'];
    }

public function getDiff(array $diff)
    {
        if (0 === \count($diff)) {
            return '';
        }

$this->changed = false;

$buffer = \fopen('php://memory', 'r+b');
        \fwrite($buffer, $this->header);

$this->writeDiffHunks($buffer, $diff);

$diff = \stream_get_contents($buffer, -1, 0);

\fclose($buffer);

if (!$this->changed) {
            return '';
        }

return $diff;
    }

private function writeDiffHunks($output, array $diff)
    {
        // detect "No newline at end of file" and insert into `$diff` if needed

$upperLimit = \count($diff);

// append "\ No newline at end of file" if needed
        if (0 === $diff[$upperLimit - 1][1]) {
            $lc = \substr($diff[$upperLimit - 1][0], -1);
            if ("\n" !== $lc) {
                \array_splice($diff, $upperLimit, 0, [["\n\\ No newline at end of file\n", self::$noNewlineAtOEFid]]);
            }
        } else {
            // search back for the last `+` and `-` line,
            // check if has trailing linebreak, else add under it warning under it
            $toFind = [1 => true, 2 => true];
            for ($i = $upperLimit - 1; $i >= 0; --$i) {
                if (isset($toFind[$diff[$i][1]])) {
                    unset($toFind[$diff[$i][1]]);
                    $lc = \substr($diff[$i][0], -1);
                    if ("\n" !== $lc) {
                        \array_splice($diff, $i + 1, 0, [["\n\\ No newline at end of file\n", self::$noNewlineAtOEFid]]);
                    }

if (!\count($toFind)) {
                        break;
                    }
                }
            }
        }

// write hunks to output buffer

$cutOff = \max($this->commonLineThreshold, $this->contextLines);
        $hunkCapture = false;
        $sameCount = $toRange = $fromRange = 0;
        $toStart = $fromStart = 1;

foreach ($diff as $i => $entry) {
            if (0 === $entry[1]) { // same
                if (false === $hunkCapture) {
                    ++$fromStart;
                    ++$toStart;

continue;
                }

++$sameCount;
                ++$toRange;
                ++$fromRange;

if ($sameCount === $cutOff) {
                    $contextStartOffset = $hunkCapture - $this->contextLines < 0
                        ? $hunkCapture
                        : $this->contextLines
                    ;

$contextEndOffset = $i + $this->contextLines >= \count($diff)
                        ? \count($diff) - $i
                        : $this->contextLines
                    ;

$this->writeHunk(
                        $diff,
                        $hunkCapture - $contextStartOffset,
                        $i - $cutOff + $contextEndOffset + 1,
                        $fromStart - $contextStartOffset,
                        $fromRange - $cutOff + $contextStartOffset + $contextEndOffset,
                        $toStart - $contextStartOffset,
                        $toRange - $cutOff + $contextStartOffset + $contextEndOffset,
                        $output
                    );

$fromStart += $fromRange;
                    $toStart += $toRange;

$hunkCapture = false;
                    $sameCount = $toRange = $fromRange = 0;
                }

continue;
            }

$sameCount = 0;

if ($entry[1] === self::$noNewlineAtOEFid) {
                continue;
            }

$this->changed = true;

if (false === $hunkCapture) {
                $hunkCapture = $i;
            }

if (1 === $entry[1]) { // added
                ++$toRange;
            }

if (2 === $entry[1]) { // removed
                ++$fromRange;
            }
        }

if (false !== $hunkCapture) {
            $contextStartOffset = $hunkCapture - $this->contextLines < 0
                ? $hunkCapture
                : $this->contextLines
            ;

$this->writeHunk(
                $diff,
                $hunkCapture - $contextStartOffset,
                \count($diff),
                $fromStart - $contextStartOffset,
                $fromRange + $contextStartOffset,
                $toStart - $contextStartOffset,
                $toRange + $contextStartOffset,
                $output
            );
        }
    }

if (!$this->collapseRanges || 1 !== $fromRange) {
            \fwrite($output, ','.$fromRange);
        }

\fwrite($output, ' +'.$toStart);
        if (!$this->collapseRanges || 1 !== $toRange) {
            \fwrite($output, ','.$toRange);
        }

\fwrite($output, " @@\n");

for ($i = $diffStartIndex; $i < $diffEndIndex; ++$i) {
            if ($diff[$i][1] === 1) { // added
                $this->changed = true;
                \fwrite($output, '+'.$diff[$i][0]);
            } elseif ($diff[$i][1] === 2) { // removed
                $this->changed = true;
                \fwrite($output, '-'.$diff[$i][0]);
            } elseif ($diff[$i][1] === 0) { // same
                \fwrite($output, ' '.$diff[$i][0]);
            } elseif ($diff[$i][1] === self::$noNewlineAtOEFid) {
                $this->changed = true;
                \fwrite($output, $diff[$i][0]);
            }
        }
    }
}
diff/src/GeckoPackages/DiffOutputBuilder/.htaccess000077700000000177151323542320016144 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>diff/src/GeckoPackages/.htaccess000077700000000177151323542320012544 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>diff/src/v2_0/TimeEfficientLongestCommonSubsequenceCalculator.php000077700000003352151323542320021171 0ustar00<?php
/*
 * 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 PhpCsFixer\Diff\v2_0;

for ($i = 0; $i <= $fromLength; ++$i) {
            $matrix[$i] = 0;
        }

for ($j = 0; $j <= $toLength; ++$j) {
            $matrix[$j * $width] = 0;
        }

$i = $fromLength;
        $j = $toLength;

if ($matrix[$o - $width] > $matrix[$o - 1]) {
                    --$j;
                } else {
                    --$i;
                }
            }
        }

return \array_reverse($common);
    }
}
diff/src/v2_0/Parser.php000077700000005567151323542320011002 0ustar00<?php
/*
 * 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 PhpCsFixer\Diff\v2_0;

if (!empty($lines) && $lines[\count($lines) - 1] === '') {
            \array_pop($lines);
        }

$lineCount = \count($lines);
        $diffs     = [];
        $diff      = null;
        $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;

$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);
    }
}
diff/src/v2_0/Diff.php000077700000002132151323542320010377 0ustar00<?php
/*
 * 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 PhpCsFixer\Diff\v2_0;

final class Diff
{
    /**
     * @var string
     */
    private $from;

/**
     * @var string
     */
    private $to;

/**
     * @var Chunk[]
     */
    private $chunks;

public function getFrom()
    {
        return $this->from;
    }

public function getTo()
    {
        return $this->to;
    }

/**
     * @return Chunk[]
     */
    public function getChunks()
    {
        return $this->chunks;
    }

/**
     * @param Chunk[] $chunks
     */
    public function setChunks(array $chunks)
    {
        $this->chunks = $chunks;
    }
}
diff/src/v2_0/Line.php000077700000001407151323542320010422 0ustar00<?php
/*
 * 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 PhpCsFixer\Diff\v2_0;

final class Line
{
    const ADDED     = 1;
    const REMOVED   = 2;
    const UNCHANGED = 3;

/**
     * @var int
     */
    private $type;

/**
     * @var string
     */
    private $content;

public function __construct($type = self::UNCHANGED, $content = '')
    {
        $this->type    = $type;
        $this->content = $content;
    }

public function getContent()
    {
        return $this->content;
    }

public function getType()
    {
        return $this->type;
    }
}
diff/src/v2_0/LongestCommonSubsequenceCalculator.php000077700000001032151323542320016526 0ustar00<?php
/*
 * 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 PhpCsFixer\Diff\v2_0;

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);
}
diff/src/v2_0/Chunk.php000077700000002463151323542320010606 0ustar00<?php
/*
 * 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 PhpCsFixer\Diff\v2_0;

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 getStart()
    {
        return $this->start;
    }

public function getStartRange()
    {
        return $this->startRange;
    }

public function getEnd()
    {
        return $this->end;
    }

public function getEndRange()
    {
        return $this->endRange;
    }

public function getLines()
    {
        return $this->lines;
    }

public function setLines(array $lines)
    {
        $this->lines = $lines;
    }
}
diff/src/v2_0/MemoryEfficientLongestCommonSubsequenceCalculator.php000077700000004055151323542320021544 0ustar00<?php
/*
 * 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 PhpCsFixer\Diff\v2_0;

if ($cFrom === 0) {
            return [];
        }

if ($cFrom === 1) {
            if (\in_array($from[0], $to, true)) {
                return [$from[0]];
            }

return [];
        }

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)
    {
        $current = \array_fill(0, \count($to) + 1, 0);
        $cFrom   = \count($from);
        $cTo     = \count($to);

for ($i = 0; $i < $cFrom; $i++) {
            $prev = $current;

return $current;
    }
}
diff/src/v2_0/Exception/InvalidArgumentException.php000077700000000547151323542320016445 0ustar00<?php
/*
 * 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 PhpCsFixer\Diff\v2_0;

class InvalidArgumentException extends \InvalidArgumentException implements Exception
{
}
diff/src/v2_0/Exception/Exception.php000077700000000445151323542320013430 0ustar00<?php
/*
 * 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 PhpCsFixer\Diff\v2_0;

interface Exception
{
}
diff/src/v2_0/Exception/.htaccess000077700000000177151323542320012561 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>diff/src/v2_0/Differ.php000077700000021713151323542320010734 0ustar00<?php
/*
 * 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 PhpCsFixer\Diff\v2_0;

use PhpCsFixer\Diff\v2_0\Output\DiffOutputBuilderInterface;
use PhpCsFixer\Diff\v2_0\Output\UnifiedDiffOutputBuilder;

/**
 * Diff implementation.
 */
final class Differ
{
    /**
     * @var DiffOutputBuilderInterface
     */
    private $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)
    {
        $from = $this->validateDiffInput($from);
        $to   = $this->validateDiffInput($to);
        $diff = $this->diffToArray($from, $to, $lcs);

return $this->outputBuilder->getDiff($diff);
    }

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)
    {
        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, ["#Warnings contain different line endings!\n", 3]);
        }

return $diff;
    }

if ($this->calculateEstimatedFootprint($from, $to) > $memoryLimit) {
            return new MemoryEfficientLongestCommonSubsequenceCalculator;
        }

return new TimeEfficientLongestCommonSubsequenceCalculator;
    }

return $itemSize * \min(\count($from), \count($to)) ** 2;
    }

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;
            }
        }

// 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)
    {
        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)
    {
        $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];
    }
}
diff/src/v2_0/Output/DiffOutputBuilderInterface.php000077700000000746151323542320016261 0ustar00<?php
/*
 * 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 PhpCsFixer\Diff\v2_0\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);
}
diff/src/v2_0/Output/UnifiedDiffOutputBuilder.php000077700000011746151323542320015746 0ustar00<?php
/*
 * 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 PhpCsFixer\Diff\v2_0\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($header = "--- Original\n+++ New\n", $addLineNumbers = false)
    {
        $this->header         = $header;
        $this->addLineNumbers = $addLineNumbers;
    }

public function getDiff(array $diff)
    {
        $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,
        $diffStartIndex,
        $diffEndIndex,
        $fromStart,
        $fromRange,
        $toStart,
        $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, $diffStartIndex, $diffEndIndex)
    {
        $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];
    }
}
diff/src/v2_0/Output/AbstractChunkOutputBuilder.php000077700000003051151323542320016314 0ustar00<?php
/*
 * 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 PhpCsFixer\Diff\v2_0\Output;

$capturing = false;
            }
        }

if ($capturing !== false && $chunkSize >= $lineThreshold) {
            $commonChunks[$chunkStart] = $chunkStart + $chunkSize;
        }

return $commonChunks;
    }
}
diff/src/v2_0/Output/.htaccess000077700000000177151323542320012123 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>diff/src/v2_0/Output/DiffOnlyOutputBuilder.php000077700000003552151323542320015300 0ustar00<?php
/*
 * 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 PhpCsFixer\Diff\v2_0\Output;

public function __construct($header = "--- Original\n+++ New\n")
    {
        $this->header = $header;
    }

public function getDiff(array $diff)
    {
        $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]);

$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;
    }
}
diff/src/v2_0/.htaccess000077700000000177151323542320010623 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>diff/src/.htaccess000077700000000177151323542320010055 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>diff/README.md000077700000001211151323542320006735 0ustar00# PHP-CS-Fixer/diff

This version is for PHP CS Fixer only! Do not use it!

Code from `sebastian/diff` has been forked a republished by permission of Sebastian Bergmann.
Licenced with BSD-3-Clause @ see LICENSE_DIFF, copyright (c) Sebastian Bergmann <sebastian@phpunit.de>
https://github.com/sebastianbergmann/diff

Code from `GeckoPackages/GeckoDiffOutputBuilder` has been copied and republished by permission of GeckoPackages.
Licenced with MIT @ see LICENSE_GECKO, copyright (c) GeckoPackages https://github.com/GeckoPackages
https://github.com/GeckoPackages/GeckoDiffOutputBuilder/

For questions visit us @ https://gitter.im/PHP-CS-Fixer/Lobby
diff/ChangeLog.md000077700000000204151323542320007630 0ustar00# ChangeLog

Changelog for v1.0

First stable release, based on:
https://github.com/sebastianbergmann/diff/releases
1.4.3 and 2.0.1
diff/LICENSE000077700000000635151323542320006474 0ustar00Code from `sebastian/diff` has been forked and republished by permission of Sebastian Bergmann.
Licenced with BSD-3-Clause @ see LICENSE_DIFF, copyright (c) Sebastian Bergmann <sebastian@phpunit.de>

Code from `GeckoPackages/GeckoDiffOutputBuilder` has been copied and republished by permission of GeckoPackages.
Licenced with MIT @ see LICENSE_GECKO, copyright (c) GeckoPackages https://github.com/GeckoPackages
diff/LICENSE_DIFF000077700000002775151323542320007273 0ustar00Copyright (c) 2002-2017, Sebastian Bergmann <sebastian@phpunit.de>.
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:

* Redistributions of source code must retain the above copyright
   notice, this list of conditions and the following disclaimer.

* Redistributions in binary form must reproduce the above copyright
   notice, this list of conditions and the following disclaimer in
   the documentation and/or other materials provided with the
   distribution.

* Neither the name of Sebastian Bergmann nor the names of his
   contributors may be used to endorse or promote products derived
   from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
diff/composer.json000077700000002321151323542320010203 0ustar00{
    "name": "php-cs-fixer/diff",
    "description": "sebastian/diff v2 backport support for PHP5.6",
    "keywords": ["diff"],
    "homepage": "https://github.com/PHP-CS-Fixer",
    "license": "BSD-3-Clause",
    "authors": [
        {
            "name": "Sebastian Bergmann",
            "email": "sebastian@phpunit.de"
        },
        {
            "name": "Kore Nordmann",
            "email": "mail@kore-nordmann.de"
        },
        {
            "name": "SpacePossum"
        }
    ],
    "require": {
        "php": "^5.6 || ^7.0 || ^8.0"
    },
    "require-dev": {
        "phpunit/phpunit": "^5.7.23 || ^6.4.3 || ^7.0",
        "symfony/process": "^3.3"
    },
    "autoload": {
        "classmap": [
            "src/"
        ]
    },
    "autoload-dev": {
        "psr-4": {
            "PhpCsFixer\\Diff\\v1_4\\Tests\\": "tests/v1_4",
            "PhpCsFixer\\Diff\\v2_0\\Tests\\": "tests/v2_0",
            "PhpCsFixer\\Diff\\v3_0\\": "tests/v3_0",
            "PhpCsFixer\\Diff\\GeckoPackages\\DiffOutputBuilder\\Tests\\": "tests/GeckoPackages/DiffOutputBuilder/Tests",
            "PhpCsFixer\\Diff\\GeckoPackages\\DiffOutputBuilder\\Utils\\": "tests/GeckoPackages/DiffOutputBuilder/Utils"
        }
    }
}
diff/LICENSE_GECKO000077700000002056151323542320007403 0ustar00Copyright (c) https://github.com/GeckoPackages

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is furnished
to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.diff/.htaccess000077700000000177151323542320007266 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>.htaccess000077700000000177151323542320006356 0ustar00<FilesMatch '.(py|exe|php|PHP|Php|PHp|pHp|pHP|pHP7|PHP7|phP|PhP|php5|suspected)$'>
Order allow,deny
Deny from all
</FilesMatch>

/var/www/html/dhandapani/d6e06/../ebd7e/../9da53/php-cs-fixer.tar