Commit 0f1af0ad authored by catch's avatar catch

Issue #1848266 by alexpott: Convert Diff into a proper, PSR-0-compatible PHP component.

parent 0ad74d11
...@@ -114,6 +114,9 @@ services: ...@@ -114,6 +114,9 @@ services:
cron: cron:
class: Drupal\Core\Cron class: Drupal\Core\Cron
arguments: ['@module_handler', '@lock', '@queue', '@state', '@current_user', '@session_manager'] arguments: ['@module_handler', '@lock', '@queue', '@state', '@current_user', '@session_manager']
diff.formatter:
class: Drupal\Core\Diff\DiffFormatter
arguments: ['@config.factory']
database: database:
class: Drupal\Core\Database\Connection class: Drupal\Core\Database\Connection
factory_class: Drupal\Core\Database\Database factory_class: Drupal\Core\Database\Database
......
<?php
namespace Drupal\Component\Diff;
use Drupal\Component\Diff\Engine\DiffEngine;
/**
* Class representing a 'diff' between two sequences of strings.
* @todo document
* @subpackage DifferenceEngine
*
* Copied from https://drupal.org/project/diff which was based PHP diff engine
* for phpwiki. (Taken from phpwiki-1.3.3) The original code in phpwiki was
* copyright (C) 2000, 2001 Geoffrey T. Dairiki <dairiki@dairiki.org> and
* licensed under GPL.
*/
class Diff {
/**
* The list of differences as an array of diff operations.
*
* @var \Drupal\Component\Diff\Engine\DiffOp[]
*/
protected $edits;
/**
* Constructor.
* Computes diff between sequences of strings.
*
* @param $from_lines array An array of strings.
* (Typically these are lines from a file.)
* @param $to_lines array An array of strings.
*/
public function __construct($from_lines, $to_lines) {
$eng = new DiffEngine();
$this->edits = $eng->diff($from_lines, $to_lines);
//$this->_check($from_lines, $to_lines);
}
/**
* Compute reversed Diff.
*
* SYNOPSIS:
*
* $diff = new Diff($lines1, $lines2);
* $rev = $diff->reverse();
* @return object A Diff object representing the inverse of the
* original diff.
*/
public function reverse() {
$rev = $this;
$rev->edits = array();
foreach ($this->edits as $edit) {
$rev->edits[] = $edit->reverse();
}
return $rev;
}
/**
* Check for empty diff.
*
* @return bool True iff two sequences were identical.
*/
public function isEmpty() {
foreach ($this->edits as $edit) {
if ($edit->type != 'copy') {
return FALSE;
}
}
return TRUE;
}
/**
* Compute the length of the Longest Common Subsequence (LCS).
*
* This is mostly for diagnostic purposed.
*
* @return int The length of the LCS.
*/
public function lcs() {
$lcs = 0;
foreach ($this->edits as $edit) {
if ($edit->type == 'copy') {
$lcs += sizeof($edit->orig);
}
}
return $lcs;
}
/**
* Get the original set of lines.
*
* This reconstructs the $from_lines parameter passed to the
* constructor.
*
* @return array The original sequence of strings.
*/
public function orig() {
$lines = array();
foreach ($this->edits as $edit) {
if ($edit->orig) {
array_splice($lines, sizeof($lines), 0, $edit->orig);
}
}
return $lines;
}
/**
* Get the closing set of lines.
*
* This reconstructs the $to_lines parameter passed to the
* constructor.
*
* @return array The sequence of strings.
*/
public function closing() {
$lines = array();
foreach ($this->edits as $edit) {
if ($edit->closing) {
array_splice($lines, sizeof($lines), 0, $edit->closing);
}
}
return $lines;
}
/**
* Check a Diff for validity.
*
* This is here only for debugging purposes.
*/
public function check($from_lines, $to_lines) {
if (serialize($from_lines) != serialize($this->orig())) {
trigger_error("Reconstructed original doesn't match", E_USER_ERROR);
}
if (serialize($to_lines) != serialize($this->closing())) {
trigger_error("Reconstructed closing doesn't match", E_USER_ERROR);
}
$rev = $this->reverse();
if (serialize($to_lines) != serialize($rev->orig())) {
trigger_error("Reversed original doesn't match", E_USER_ERROR);
}
if (serialize($from_lines) != serialize($rev->closing())) {
trigger_error("Reversed closing doesn't match", E_USER_ERROR);
}
$prevtype = 'none';
foreach ($this->edits as $edit) {
if ( $prevtype == $edit->type ) {
trigger_error("Edit sequence is non-optimal", E_USER_ERROR);
}
$prevtype = $edit->type;
}
$lcs = $this->lcs();
trigger_error('Diff okay: LCS = ' . $lcs, E_USER_NOTICE);
}
/**
* Gets the list of differences as an array of diff operations.
*
* @return \Drupal\Component\Diff\Engine\DiffOp[]
* The list of differences as an array of diff operations.
*/
public function getEdits() {
return $this->edits;
}
}
<?php
namespace Drupal\Component\Diff;
use Drupal\Component\Diff\Engine\DiffOpCopy;
/**
* A class to format Diffs
*
* This class formats the diff in classic diff format.
* It is intended that this class be customized via inheritance,
* to obtain fancier outputs.
* @todo document
* @private
* @subpackage DifferenceEngine
*/
class DiffFormatter {
/**
* Should a block header be shown?
*/
var $show_header = TRUE;
/**
* Number of leading context "lines" to preserve.
*
* This should be left at zero for this class, but subclasses
* may want to set this to other values.
*/
var $leading_context_lines = 0;
/**
* Number of trailing context "lines" to preserve.
*
* This should be left at zero for this class, but subclasses
* may want to set this to other values.
*/
var $trailing_context_lines = 0;
/**
* Format a diff.
*
* @param \Drupal\Component\Diff\Diff $diff
* A Diff object.
*
* @return string
* The formatted output.
*/
public function format(Diff $diff) {
$xi = $yi = 1;
$block = FALSE;
$context = array();
$nlead = $this->leading_context_lines;
$ntrail = $this->trailing_context_lines;
$this->_start_diff();
foreach ($diff->getEdits() as $edit) {
if ($edit->type == 'copy') {
if (is_array($block)) {
if (sizeof($edit->orig) <= $nlead + $ntrail) {
$block[] = $edit;
}
else {
if ($ntrail) {
$context = array_slice($edit->orig, 0, $ntrail);
$block[] = new DiffOpCopy($context);
}
$this->_block($x0, $ntrail + $xi - $x0, $y0, $ntrail + $yi - $y0, $block);
$block = FALSE;
}
}
$context = $edit->orig;
}
else {
if (! is_array($block)) {
$context = array_slice($context, sizeof($context) - $nlead);
$x0 = $xi - sizeof($context);
$y0 = $yi - sizeof($context);
$block = array();
if ($context) {
$block[] = new DiffOpCopy($context);
}
}
$block[] = $edit;
}
if ($edit->orig) {
$xi += sizeof($edit->orig);
}
if ($edit->closing) {
$yi += sizeof($edit->closing);
}
}
if (is_array($block)) {
$this->_block($x0, $xi - $x0, $y0, $yi - $y0, $block);
}
$end = $this->_end_diff();
if (!empty($xi)) {
$this->line_stats['counter']['x'] += $xi;
}
if (!empty($yi)) {
$this->line_stats['counter']['y'] += $yi;
}
return $end;
}
protected function _block($xbeg, $xlen, $ybeg, $ylen, &$edits) {
$this->_start_block($this->_block_header($xbeg, $xlen, $ybeg, $ylen));
foreach ($edits as $edit) {
if ($edit->type == 'copy') {
$this->_context($edit->orig);
}
elseif ($edit->type == 'add') {
$this->_added($edit->closing);
}
elseif ($edit->type == 'delete') {
$this->_deleted($edit->orig);
}
elseif ($edit->type == 'change') {
$this->_changed($edit->orig, $edit->closing);
}
else {
trigger_error('Unknown edit type', E_USER_ERROR);
}
}
$this->_end_block();
}
protected function _start_diff() {
ob_start();
}
protected function _end_diff() {
$val = ob_get_contents();
ob_end_clean();
return $val;
}
protected function _block_header($xbeg, $xlen, $ybeg, $ylen) {
if ($xlen > 1) {
$xbeg .= "," . ($xbeg + $xlen - 1);
}
if ($ylen > 1) {
$ybeg .= "," . ($ybeg + $ylen - 1);
}
return $xbeg . ($xlen ? ($ylen ? 'c' : 'd') : 'a') . $ybeg;
}
protected function _start_block($header) {
if ($this->show_header) {
echo $header . "\n";
}
}
protected function _end_block() {
}
protected function _lines($lines, $prefix = ' ') {
foreach ($lines as $line) {
echo "$prefix $line\n";
}
}
protected function _context($lines) {
$this->_lines($lines);
}
protected function _added($lines) {
$this->_lines($lines, '>');
}
protected function _deleted($lines) {
$this->_lines($lines, '<');
}
protected function _changed($orig, $closing) {
$this->_deleted($orig);
echo "---\n";
$this->_added($closing);
}
}
<?php
namespace Drupal\Component\Diff\Engine;
/**
* @todo document
* @private
* @subpackage DifferenceEngine
*/
class DiffOp {
var $type;
var $orig;
var $closing;
public function reverse() {
trigger_error('pure virtual', E_USER_ERROR);
}
public function norig() {
return $this->orig ? sizeof($this->orig) : 0;
}
public function nclosing() {
return $this->closing ? sizeof($this->closing) : 0;
}
}
<?php
namespace Drupal\Component\Diff\Engine;
/**
* @todo document
* @private
* @subpackage DifferenceEngine
*/
class DiffOpAdd extends DiffOp {
var $type = 'add';
public function __construct($lines) {
$this->closing = $lines;
$this->orig = FALSE;
}
public function reverse() {
return new DiffOpDelete($this->closing);
}
}
<?php
namespace Drupal\Component\Diff\Engine;
/**
* @todo document
* @private
* @subpackage DifferenceEngine
*/
class DiffOpChange extends DiffOp {
var $type = 'change';
public function __construct($orig, $closing) {
$this->orig = $orig;
$this->closing = $closing;
}
public function reverse() {
return new DiffOpChange($this->closing, $this->orig);
}
}
<?php
namespace Drupal\Component\Diff\Engine;
/**
* @todo document
* @private
* @subpackage DifferenceEngine
*/
class DiffOpCopy extends DiffOp {
var $type = 'copy';
public function __construct($orig, $closing = FALSE) {
if (!is_array($closing)) {
$closing = $orig;
}
$this->orig = $orig;
$this->closing = $closing;
}
public function reverse() {
return new DiffOpCopy($this->closing, $this->orig);
}
}
<?php
namespace Drupal\Component\Diff\Engine;
/**
* @todo document
* @private
* @subpackage DifferenceEngine
*/
class DiffOpDelete extends DiffOp {
var $type = 'delete';
public function __construct($lines) {
$this->orig = $lines;
$this->closing = FALSE;
}
public function reverse() {
return new DiffOpAdd($this->orig);
}
}
<?php
namespace Drupal\Component\Diff\Engine;
use Drupal\Component\Utility\String;
use Drupal\Component\Utility\Unicode;
/**
* Additions by Axel Boldt follow, partly taken from diff.php, phpwiki-1.3.3
*
*/
/**
* @todo document
* @private
* @subpackage DifferenceEngine
*/
class HWLDFWordAccumulator {
/**
* An iso-8859-x non-breaking space.
*/
const NBSP = '&#160;';
protected $lines = array();
protected $line = '';
protected $group = '';
protected $tag = '';
protected function _flushGroup($new_tag) {
if ($this->group !== '') {
if ($this->tag == 'mark') {
$this->line .= '<span class="diffchange">' . String::checkPlain($this->group) . '</span>';
}
else {
$this->line .= String::checkPlain($this->group);
}
}
$this->group = '';
$this->tag = $new_tag;
}
protected function _flushLine($new_tag) {
$this->_flushGroup($new_tag);
if ($this->line != '') {
array_push($this->lines, $this->line);
}
else {
// make empty lines visible by inserting an NBSP
array_push($this->lines, $this::NBSP);
}
$this->line = '';
}
public function addWords($words, $tag = '') {
if ($tag != $this->tag) {
$this->_flushGroup($tag);
}
foreach ($words as $word) {
// new-line should only come as first char of word.
if ($word == '') {
continue;
}
if ($word[0] == "\n") {
$this->_flushLine($tag);
$word = Unicode::substr($word, 1);
}
assert(!strstr($word, "\n"));
$this->group .= $word;
}
}
public function getLines() {
$this->_flushLine('~done');
return $this->lines;
}
}
<?php
namespace Drupal\Component\Diff;
/**
* FIXME: bad name.
* @todo document
* @private
* @subpackage DifferenceEngine
*/
class MappedDiff extends Diff {
/**
* Constructor.
*
* Computes diff between sequences of strings.
*
* This can be used to compute things like
* case-insensitive diffs, or diffs which ignore
* changes in white-space.
*
* @param $from_lines array An array of strings.
* (Typically these are lines from a file.)
*
* @param $to_lines array An array of strings.
*
* @param $mapped_from_lines array This array should
* have the same size number of elements as $from_lines.
* The elements in $mapped_from_lines and
* $mapped_to_lines are what is actually compared
* when computing the diff.
*
* @param $mapped_to_lines array This array should
* have the same number of elements as $to_lines.
*/
public function __construct($from_lines, $to_lines, $mapped_from_lines, $mapped_to_lines) {
assert(sizeof($from_lines) == sizeof($mapped_from_lines));
assert(sizeof($to_lines) == sizeof($mapped_to_lines));
parent::__construct($mapped_from_lines, $mapped_to_lines);
$xi = $yi = 0;
for ($i = 0; $i < sizeof($this->edits); $i++) {
$orig = &$this->edits[$i]->orig;
if (is_array($orig)) {
$orig = array_slice($from_lines, $xi, sizeof($orig));
$xi += sizeof($orig);
}
$closing = &$this->edits[$i]->closing;
if (is_array($closing)) {
$closing = array_slice($to_lines, $yi, sizeof($closing));
$yi += sizeof($closing);
}
}
}
}
<?php
namespace Drupal\Component\Diff;
use Drupal\Component\Diff\Engine\HWLDFWordAccumulator;
use Drupal\Component\Utility\Unicode;
/**
* @todo document
* @private
* @subpackage DifferenceEngine
*/
class WordLevelDiff extends MappedDiff {
const MAX_LINE_LENGTH = 10000;
public function __construct($orig_lines, $closing_lines) {
list($orig_words, $orig_stripped) = $this->_split($orig_lines);
list($closing_words, $closing_stripped) = $this->_split($closing_lines);
parent::__construct($orig_words, $closing_words, $orig_stripped, $closing_stripped);
}
protected function _split($lines) {
$words = array();
$stripped = array();
$first = TRUE;
foreach ($lines as $line) {
// If the line is too long, just pretend the entire line is one big word
// This prevents resource exhaustion problems
if ( $first ) {
$first = FALSE;
}
else {
$words[] = "\n";
$stripped[] = "\n";
}
if (Unicode::strlen($line) > $this::MAX_LINE_LENGTH) {
$words[] = $line;
$stripped[] = $line;
}
else {
if (preg_match_all('/ ( [^\S\n]+ | [0-9_A-Za-z\x80-\xff]+ | . ) (?: (?!< \n) [^\S\n])? /xs', $line, $m)) {
$words = array_merge($words, $m[0]);
$stripped = array_merge($stripped, $m[1]);
}
}
}
return array($words, $stripped);
}
public function orig() {
$orig = new HWLDFWordAccumulator();
foreach ($this->edits as $edit) {
if ($edit->type == 'copy') {
$orig->addWords($edit->orig);
}
elseif ($edit->orig) {
$orig->addWords($edit->orig, 'mark');
}
}
$lines = $orig->getLines();
return $lines;
}
public function closing() {
$closing = new HWLDFWordAccumulator();
foreach ($this->edits as $edit) {
if ($edit->type == 'copy') {
$closing->addWords($edit->closing);
}
elseif ($edit->closing) {
$closing->addWords($edit->closing, 'mark');
}
}
$lines = $closing->getLines();
return $lines;
}
}
...@@ -7,6 +7,7 @@ ...@@ -7,6 +7,7 @@
namespace Drupal\Core\Config; namespace Drupal\Core\Config;
use Drupal\Component\Diff\Diff;
use Drupal\Component\Serialization\Yaml; use Drupal\Component\Serialization\Yaml;
use Drupal\Core\Config\Entity\ConfigDependencyManager;