? files
? mw.patch
? sites/all/diffbak
? sites/all/modules
? sites/default/files
Index: modules/node/content_types.inc
===================================================================
RCS file: /cvs/drupal/drupal/modules/node/content_types.inc,v
retrieving revision 1.57
diff -u -F^f -p -r1.57 content_types.inc
--- modules/node/content_types.inc 16 Jul 2008 21:59:27 -0000 1.57
+++ modules/node/content_types.inc 5 Oct 2008 01:04:32 -0000
@@ -138,6 +138,11 @@ function node_type_form(&$form_state, $t
'#options' => drupal_map_assoc(array(0, 10, 25, 50, 75, 100, 125, 150, 175, 200)),
'#description' => t('The minimum number of words for the body field to be considered valid for this content type. This can be useful to rule out submissions that do not meet the site\'s standards, such as short test posts.')
);
+ $form['submission']['node_show_view_changes'] = array(
+ '#type' => 'checkbox',
+ '#title' => t('Show %view_changes button on edit form', array('%view_changes' => t('View changes'))),
+ '#default_value' => variable_get('node_show_view_changes_'. $form['#node_type']->type, FALSE),
+ );
$form['submission']['help'] = array(
'#type' => 'textarea',
'#title' => t('Explanation or submission guidelines'),
Index: modules/node/node.css
===================================================================
RCS file: /cvs/drupal/drupal/modules/node/node.css,v
retrieving revision 1.5
diff -u -F^f -p -r1.5 node.css
--- modules/node/node.css 25 Jan 2008 21:21:44 -0000 1.5
+++ modules/node/node.css 5 Oct 2008 01:04:32 -0000
@@ -42,3 +42,60 @@ td.revision-current {
.terms-inline {
display: inline;
}
+
+/* Diff styles */
+table.diff {
+ border-spacing: 4px;
+ margin-bottom: 20px;
+ table-layout: fixed;
+ width: 100%;
+}
+table.diff tr.even, table.diff tr.odd {
+ background-color: inherit;
+ border: none;
+}
+td.diff-prevlink {
+ text-align: left;
+}
+td.diff-nextlink {
+ text-align: right;
+}
+td.diff-section-title, div.diff-section-title {
+ background-color: #f0f0ff;
+ font-size: 0.83em;
+ font-weight: bold;
+ padding: 0.1em 1em;
+}
+td.diff-deletedline {
+ background-color: #ffa;
+ width: 50%;
+}
+td.diff-addedline {
+ background-color: #afa;
+ width: 50%;
+}
+td.diff-context {
+ background-color: #fafafa;
+}
+span.diffchange {
+ color: #f00;
+ font-weight: bold;
+}
+
+table.diff col.diff-marker {
+ width: 1.4em;
+}
+table.diff col.diff-content {
+ width: 50%;
+}
+table.diff th {
+ padding-right: inherit;
+}
+table.diff td div {
+ overflow: auto;
+ padding: 0.1ex 0.5em;
+ word-wrap: break-word;
+}
+table.diff td {
+ padding: 0.1ex 0.4em;
+}
\ No newline at end of file
Index: modules/node/node.diff.inc
===================================================================
RCS file: modules/node/node.diff.inc
diff -N modules/node/node.diff.inc
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ modules/node/node.diff.inc 5 Oct 2008 01:04:32 -0000
@@ -0,0 +1,1205 @@
+
+ * You may copy this code freely under the conditions of the GPL.
+ */
+
+define('USE_ASSERTS', FALSE);
+
+/**
+ * @todo document
+ * @private
+ * @subpackage DifferenceEngine
+ */
+class _DiffOp {
+ var $type;
+ var $orig;
+ var $closing;
+
+ function reverse() {
+ trigger_error('pure virtual', E_USER_ERROR);
+ }
+
+ function norig() {
+ return $this->orig ? sizeof($this->orig) : 0;
+ }
+
+ function nclosing() {
+ return $this->closing ? sizeof($this->closing) : 0;
+ }
+}
+
+/**
+ * @todo document
+ * @private
+ * @subpackage DifferenceEngine
+ */
+class _DiffOp_Copy extends _DiffOp {
+ var $type = 'copy';
+
+ function _DiffOp_Copy($orig, $closing = FALSE) {
+ if (!is_array($closing)) {
+ $closing = $orig;
+ }
+ $this->orig = $orig;
+ $this->closing = $closing;
+ }
+
+ function reverse() {
+ return new _DiffOp_Copy($this->closing, $this->orig);
+ }
+}
+
+/**
+ * @todo document
+ * @private
+ * @subpackage DifferenceEngine
+ */
+class _DiffOp_Delete extends _DiffOp {
+ var $type = 'delete';
+
+ function _DiffOp_Delete($lines) {
+ $this->orig = $lines;
+ $this->closing = FALSE;
+ }
+
+ function reverse() {
+ return new _DiffOp_Add($this->orig);
+ }
+}
+
+/**
+ * @todo document
+ * @private
+ * @subpackage DifferenceEngine
+ */
+class _DiffOp_Add extends _DiffOp {
+ var $type = 'add';
+
+ function _DiffOp_Add($lines) {
+ $this->closing = $lines;
+ $this->orig = FALSE;
+ }
+
+ function reverse() {
+ return new _DiffOp_Delete($this->closing);
+ }
+}
+
+/**
+ * @todo document
+ * @private
+ * @subpackage DifferenceEngine
+ */
+class _DiffOp_Change extends _DiffOp {
+ var $type = 'change';
+
+ function _DiffOp_Change($orig, $closing) {
+ $this->orig = $orig;
+ $this->closing = $closing;
+ }
+
+ function reverse() {
+ return new _DiffOp_Change($this->closing, $this->orig);
+ }
+}
+
+
+/**
+ * Class used internally by Diff to actually compute the diffs.
+ *
+ * The algorithm used here is mostly lifted from the perl module
+ * Algorithm::Diff (version 1.06) by Ned Konz, which is available at:
+ * http://www.perl.com/CPAN/authors/id/N/NE/NEDKONZ/Algorithm-Diff-1.06.zip
+ *
+ * More ideas are taken from:
+ * http://www.ics.uci.edu/~eppstein/161/960229.html
+ *
+ * Some ideas are (and a bit of code) are from from analyze.c, from GNU
+ * diffutils-2.7, which can be found at:
+ * ftp://gnudist.gnu.org/pub/gnu/diffutils/diffutils-2.7.tar.gz
+ *
+ * closingly, some ideas (subdivision by NCHUNKS > 2, and some optimizations)
+ * are my own.
+ *
+ * Line length limits for robustness added by Tim Starling, 2005-08-31
+ *
+ * @author Geoffrey T. Dairiki, Tim Starling
+ * @private
+ * @subpackage DifferenceEngine
+ */
+class _DiffEngine {
+ function MAX_XREF_LENGTH() {
+ return 10000;
+ }
+
+ function diff($from_lines, $to_lines) {
+
+ $n_from = sizeof($from_lines);
+ $n_to = sizeof($to_lines);
+
+ $this->xchanged = $this->ychanged = array();
+ $this->xv = $this->yv = array();
+ $this->xind = $this->yind = array();
+ unset($this->seq);
+ unset($this->in_seq);
+ unset($this->lcs);
+
+ // Skip leading common lines.
+ for ($skip = 0; $skip < $n_from && $skip < $n_to; $skip++) {
+ if ($from_lines[$skip] !== $to_lines[$skip]) {
+ break;
+ }
+ $this->xchanged[$skip] = $this->ychanged[$skip] = FALSE;
+ }
+ // Skip trailing common lines.
+ $xi = $n_from;
+ $yi = $n_to;
+ for ($endskip = 0; --$xi > $skip && --$yi > $skip; $endskip++) {
+ if ($from_lines[$xi] !== $to_lines[$yi]) {
+ break;
+ }
+ $this->xchanged[$xi] = $this->ychanged[$yi] = FALSE;
+ }
+
+ // Ignore lines which do not exist in both files.
+ for ($xi = $skip; $xi < $n_from - $endskip; $xi++) {
+ $xhash[$this->_line_hash($from_lines[$xi])] = 1;
+ }
+
+ for ($yi = $skip; $yi < $n_to - $endskip; $yi++) {
+ $line = $to_lines[$yi];
+ if ($this->ychanged[$yi] = empty($xhash[$this->_line_hash($line)])) {
+ continue;
+ }
+ $yhash[$this->_line_hash($line)] = 1;
+ $this->yv[] = $line;
+ $this->yind[] = $yi;
+ }
+ for ($xi = $skip; $xi < $n_from - $endskip; $xi++) {
+ $line = $from_lines[$xi];
+ if ($this->xchanged[$xi] = empty($yhash[$this->_line_hash($line)])) {
+ continue;
+ }
+ $this->xv[] = $line;
+ $this->xind[] = $xi;
+ }
+
+ // Find the LCS.
+ $this->_compareseq(0, sizeof($this->xv), 0, sizeof($this->yv));
+
+ // Merge edits when possible
+ $this->_shift_boundaries($from_lines, $this->xchanged, $this->ychanged);
+ $this->_shift_boundaries($to_lines, $this->ychanged, $this->xchanged);
+
+ // Compute the edit operations.
+ $edits = array();
+ $xi = $yi = 0;
+ while ($xi < $n_from || $yi < $n_to) {
+ USE_ASSERTS && assert($yi < $n_to || $this->xchanged[$xi]);
+ USE_ASSERTS && assert($xi < $n_from || $this->ychanged[$yi]);
+
+ // Skip matching "snake".
+ $copy = array();
+ while ( $xi < $n_from && $yi < $n_to && !$this->xchanged[$xi] && !$this->ychanged[$yi]) {
+ $copy[] = $from_lines[$xi++];
+ ++$yi;
+ }
+ if ($copy) {
+ $edits[] = new _DiffOp_Copy($copy);
+ }
+ // Find deletes & adds.
+ $delete = array();
+ while ($xi < $n_from && $this->xchanged[$xi]) {
+ $delete[] = $from_lines[$xi++];
+ }
+ $add = array();
+ while ($yi < $n_to && $this->ychanged[$yi]) {
+ $add[] = $to_lines[$yi++];
+ }
+ if ($delete && $add) {
+ $edits[] = new _DiffOp_Change($delete, $add);
+ }
+ elseif ($delete) {
+ $edits[] = new _DiffOp_Delete($delete);
+ }
+ elseif ($add) {
+ $edits[] = new _DiffOp_Add($add);
+ }
+ }
+ return $edits;
+ }
+
+ /**
+ * Returns the whole line if it's small enough, or the MD5 hash otherwise.
+ */
+ function _line_hash($line) {
+ if (strlen($line) > $this->MAX_XREF_LENGTH()) {
+ return md5( line);
+ }
+ else {
+ return $line;
+ }
+ }
+
+
+ /**
+ * Divide the Largest Common Subsequence (LCS) of the sequences
+ * [XOFF, XLIM) and [YOFF, YLIM) into NCHUNKS approximately equally
+ * sized segments.
+ *
+ * Returns (LCS, PTS). LCS is the length of the LCS. PTS is an
+ * array of NCHUNKS+1 (X, Y) indexes giving the diving points between
+ * sub sequences. The first sub-sequence is contained in [X0, X1),
+ * [Y0, Y1), the second in [X1, X2), [Y1, Y2) and so on. Note
+ * that (X0, Y0) == (XOFF, YOFF) and
+ * (X[NCHUNKS], Y[NCHUNKS]) == (XLIM, YLIM).
+ *
+ * This function assumes that the first lines of the specified portions
+ * of the two files do not match, and likewise that the last lines do not
+ * match. The caller must trim matching lines from the beginning and end
+ * of the portions it is going to specify.
+ */
+ function _diag($xoff, $xlim, $yoff, $ylim, $nchunks) {
+ $flip = FALSE;
+
+ if ($xlim - $xoff > $ylim - $yoff) {
+ // Things seems faster (I'm not sure I understand why)
+ // when the shortest sequence in X.
+ $flip = TRUE;
+ list($xoff, $xlim, $yoff, $ylim) = array($yoff, $ylim, $xoff, $xlim);
+ }
+
+ if ($flip) {
+ for ($i = $ylim - 1; $i >= $yoff; $i--) {
+ $ymatches[$this->xv[$i]][] = $i;
+ }
+ }
+ else {
+ for ($i = $ylim - 1; $i >= $yoff; $i--) {
+ $ymatches[$this->yv[$i]][] = $i;
+ }
+ }
+ $this->lcs = 0;
+ $this->seq[0]= $yoff - 1;
+ $this->in_seq = array();
+ $ymids[0] = array();
+
+ $numer = $xlim - $xoff + $nchunks - 1;
+ $x = $xoff;
+ for ($chunk = 0; $chunk < $nchunks; $chunk++) {
+ if ($chunk > 0) {
+ for ($i = 0; $i <= $this->lcs; $i++) {
+ $ymids[$i][$chunk-1] = $this->seq[$i];
+ }
+ }
+
+ $x1 = $xoff + (int)(($numer + ($xlim-$xoff)*$chunk) / $nchunks);
+ for ( ; $x < $x1; $x++) {
+ $line = $flip ? $this->yv[$x] : $this->xv[$x];
+ if (empty($ymatches[$line])) {
+ continue;
+ }
+ $matches = $ymatches[$line];
+ reset($matches);
+ while (list ($junk, $y) = each($matches)) {
+ if (empty($this->in_seq[$y])) {
+ $k = $this->_lcs_pos($y);
+ USE_ASSERTS && assert($k > 0);
+ $ymids[$k] = $ymids[$k-1];
+ break;
+ }
+ }
+ while (list ($junk, $y) = each($matches)) {
+ if ($y > $this->seq[$k-1]) {
+ USE_ASSERTS && assert($y < $this->seq[$k]);
+ // Optimization: this is a common case:
+ // next match is just replacing previous match.
+ $this->in_seq[$this->seq[$k]] = FALSE;
+ $this->seq[$k] = $y;
+ $this->in_seq[$y] = 1;
+ }
+ elseif (empty($this->in_seq[$y])) {
+ $k = $this->_lcs_pos($y);
+ USE_ASSERTS && assert($k > 0);
+ $ymids[$k] = $ymids[$k-1];
+ }
+ }
+ }
+ }
+
+ $seps[] = $flip ? array($yoff, $xoff) : array($xoff, $yoff);
+ $ymid = $ymids[$this->lcs];
+ for ($n = 0; $n < $nchunks - 1; $n++) {
+ $x1 = $xoff + (int)(($numer + ($xlim - $xoff) * $n) / $nchunks);
+ $y1 = $ymid[$n] + 1;
+ $seps[] = $flip ? array($y1, $x1) : array($x1, $y1);
+ }
+ $seps[] = $flip ? array($ylim, $xlim) : array($xlim, $ylim);
+
+ return array($this->lcs, $seps);
+ }
+
+ function _lcs_pos($ypos) {
+
+ $end = $this->lcs;
+ if ($end == 0 || $ypos > $this->seq[$end]) {
+ $this->seq[++$this->lcs] = $ypos;
+ $this->in_seq[$ypos] = 1;
+ return $this->lcs;
+ }
+
+ $beg = 1;
+ while ($beg < $end) {
+ $mid = (int)(($beg + $end) / 2);
+ if ($ypos > $this->seq[$mid]) {
+ $beg = $mid + 1;
+ }
+ else {
+ $end = $mid;
+ }
+ }
+
+ USE_ASSERTS && assert($ypos != $this->seq[$end]);
+
+ $this->in_seq[$this->seq[$end]] = FALSE;
+ $this->seq[$end] = $ypos;
+ $this->in_seq[$ypos] = 1;
+ return $end;
+ }
+
+ /**
+ * Find LCS of two sequences.
+ *
+ * The results are recorded in the vectors $this->{x,y}changed[], by
+ * storing a 1 in the element for each line that is an insertion
+ * or deletion (ie. is not in the LCS).
+ *
+ * The subsequence of file 0 is [XOFF, XLIM) and likewise for file 1.
+ *
+ * Note that XLIM, YLIM are exclusive bounds.
+ * All line numbers are origin-0 and discarded lines are not counted.
+ */
+ function _compareseq($xoff, $xlim, $yoff, $ylim) {
+
+ // Slide down the bottom initial diagonal.
+ while ($xoff < $xlim && $yoff < $ylim && $this->xv[$xoff] == $this->yv[$yoff]) {
+ ++$xoff;
+ ++$yoff;
+ }
+
+ // Slide up the top initial diagonal.
+ while ($xlim > $xoff && $ylim > $yoff && $this->xv[$xlim - 1] == $this->yv[$ylim - 1]) {
+ --$xlim;
+ --$ylim;
+ }
+
+ if ($xoff == $xlim || $yoff == $ylim) {
+ $lcs = 0;
+ }
+ else {
+ // This is ad hoc but seems to work well.
+ //$nchunks = sqrt(min($xlim - $xoff, $ylim - $yoff) / 2.5);
+ //$nchunks = max(2, min(8, (int)$nchunks));
+ $nchunks = min(7, $xlim - $xoff, $ylim - $yoff) + 1;
+ list($lcs, $seps)
+ = $this->_diag($xoff, $xlim, $yoff, $ylim, $nchunks);
+ }
+
+ if ($lcs == 0) {
+ // X and Y sequences have no common subsequence:
+ // mark all changed.
+ while ($yoff < $ylim) {
+ $this->ychanged[$this->yind[$yoff++]] = 1;
+ }
+ while ($xoff < $xlim) {
+ $this->xchanged[$this->xind[$xoff++]] = 1;
+ }
+ }
+ else {
+ // Use the partitions to split this problem into subproblems.
+ reset($seps);
+ $pt1 = $seps[0];
+ while ($pt2 = next($seps)) {
+ $this->_compareseq ($pt1[0], $pt2[0], $pt1[1], $pt2[1]);
+ $pt1 = $pt2;
+ }
+ }
+ }
+
+ /**
+ * Adjust inserts/deletes of identical lines to join changes
+ * as much as possible.
+ *
+ * We do something when a run of changed lines include a
+ * line at one end and has an excluded, identical line at the other.
+ * We are free to choose which identical line is included.
+ * `compareseq' usually chooses the one at the beginning,
+ * but usually it is cleaner to consider the following identical line
+ * to be the "change".
+ *
+ * This is extracted verbatim from analyze.c (GNU diffutils-2.7).
+ */
+ function _shift_boundaries($lines, &$changed, $other_changed) {
+ $i = 0;
+ $j = 0;
+
+ USE_ASSERTS && assert('sizeof($lines) == sizeof($changed)');
+ $len = sizeof($lines);
+ $other_len = sizeof($other_changed);
+
+ while (1) {
+ /*
+ * Scan forwards to find beginning of another run of changes.
+ * Also keep track of the corresponding point in the other file.
+ *
+ * Throughout this code, $i and $j are adjusted together so that
+ * the first $i elements of $changed and the first $j elements
+ * of $other_changed both contain the same number of zeros
+ * (unchanged lines).
+ * Furthermore, $j is always kept so that $j == $other_len or
+ * $other_changed[$j] == FALSE.
+ */
+ while ($j < $other_len && $other_changed[$j]) {
+ $j++;
+ }
+ while ($i < $len && ! $changed[$i]) {
+ USE_ASSERTS && assert('$j < $other_len && ! $other_changed[$j]');
+ $i++;
+ $j++;
+ while ($j < $other_len && $other_changed[$j]) {
+ $j++;
+ }
+ }
+
+ if ($i == $len) {
+ break;
+ }
+ $start = $i;
+
+ // Find the end of this run of changes.
+ while (++$i < $len && $changed[$i]) {
+ continue;
+ }
+
+ do {
+ /*
+ * Record the length of this run of changes, so that
+ * we can later determine whether the run has grown.
+ */
+ $runlength = $i - $start;
+
+ /*
+ * Move the changed region back, so long as the
+ * previous unchanged line matches the last changed one.
+ * This merges with previous changed regions.
+ */
+ while ($start > 0 && $lines[$start - 1] == $lines[$i - 1]) {
+ $changed[--$start] = 1;
+ $changed[--$i] = FALSE;
+ while ($start > 0 && $changed[$start - 1]) {
+ $start--;
+ }
+ USE_ASSERTS && assert('$j > 0');
+ while ($other_changed[--$j]) {
+ continue;
+ }
+ USE_ASSERTS && assert('$j >= 0 && !$other_changed[$j]');
+ }
+
+ /*
+ * Set CORRESPONDING to the end of the changed run, at the last
+ * point where it corresponds to a changed run in the other file.
+ * CORRESPONDING == LEN means no such point has been found.
+ */
+ $corresponding = $j < $other_len ? $i : $len;
+
+ /*
+ * Move the changed region forward, so long as the
+ * first changed line matches the following unchanged one.
+ * This merges with following changed regions.
+ * Do this second, so that if there are no merges,
+ * the changed region is moved forward as far as possible.
+ */
+ while ($i < $len && $lines[$start] == $lines[$i]) {
+ $changed[$start++] = FALSE;
+ $changed[$i++] = 1;
+ while ($i < $len && $changed[$i]) {
+ $i++;
+ }
+ USE_ASSERTS && assert('$j < $other_len && ! $other_changed[$j]');
+ $j++;
+ if ($j < $other_len && $other_changed[$j]) {
+ $corresponding = $i;
+ while ($j < $other_len && $other_changed[$j]) {
+ $j++;
+ }
+ }
+ }
+ } while ($runlength != $i - $start);
+
+ /*
+ * If possible, move the fully-merged run of changes
+ * back to a corresponding run in the other file.
+ */
+ while ($corresponding < $i) {
+ $changed[--$start] = 1;
+ $changed[--$i] = 0;
+ USE_ASSERTS && assert('$j > 0');
+ while ($other_changed[--$j]) {
+ continue;
+ }
+ USE_ASSERTS && assert('$j >= 0 && !$other_changed[$j]');
+ }
+ }
+ }
+}
+
+/**
+ * Class representing a 'diff' between two sequences of strings.
+ * @todo document
+ * @private
+ * @subpackage DifferenceEngine
+ */
+class Diff {
+ var $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.
+ */
+ function Diff($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.
+ */
+ 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.
+ */
+ 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.
+ */
+ 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.
+ */
+ 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.
+ */
+ 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.
+ */
+ 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);
+ }
+}
+
+/**
+ * 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-insensitve 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.
+ */
+ function MappedDiff($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));
+
+ $this->Diff($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);
+ }
+ }
+ }
+}
+
+/**
+ * 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 $diff object A Diff object.
+ * @return string The formatted output.
+ */
+ function format($diff) {
+
+ $xi = $yi = 1;
+ $block = FALSE;
+ $context = array();
+
+ $nlead = $this->leading_context_lines;
+ $ntrail = $this->trailing_context_lines;
+
+ $this->_start_diff();
+
+ foreach ($diff->edits 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 _DiffOp_Copy($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 _DiffOp_Copy($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();
+ return $end;
+ }
+
+ 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();
+ }
+
+ function _start_diff() {
+ ob_start();
+ }
+
+ function _end_diff() {
+ $val = ob_get_contents();
+ ob_end_clean();
+ return $val;
+ }
+
+ 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;
+ }
+
+ function _start_block($header) {
+ if ($this->show_header) {
+ echo $header;
+ }
+ }
+
+ function _end_block() {
+ }
+
+ function _lines($lines, $prefix = ' ') {
+ foreach ($lines as $line) {
+ echo "$prefix $line\n";
+ }
+ }
+
+ function _context($lines) {
+ $this->_lines($lines);
+ }
+
+ function _added($lines) {
+ $this->_lines($lines, '>');
+ }
+ function _deleted($lines) {
+ $this->_lines($lines, '<');
+ }
+
+ function _changed($orig, $closing) {
+ $this->_deleted($orig);
+ echo "---\n";
+ $this->_added($closing);
+ }
+}
+
+
+/**
+ * Additions by Axel Boldt follow, partly taken from diff.php, phpwiki-1.3.3
+ *
+ */
+
+define('NBSP', ' '); // iso-8859-x non-breaking space.
+
+/**
+ * @todo document
+ * @private
+ * @subpackage DifferenceEngine
+ */
+class _HWLDF_WordAccumulator {
+ function _HWLDF_WordAccumulator() {
+ $this->_lines = array();
+ $this->_line = '';
+ $this->_group = '';
+ $this->_tag = '';
+ }
+
+ function _flushGroup($new_tag) {
+ if ($this->_group !== '') {
+ if ($this->_tag == 'mark') {
+ $this->_line .= ''. check_plain($this->_group) .'';
+ }
+ else {
+ $this->_line .= check_plain($this->_group);
+ }
+ }
+ $this->_group = '';
+ $this->_tag = $new_tag;
+ }
+
+ 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, NBSP);
+ }
+ $this->_line = '';
+ }
+
+ 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 = substr($word, 1);
+ }
+ assert(!strstr($word, "\n"));
+ $this->_group .= $word;
+ }
+ }
+
+ function getLines() {
+ $this->_flushLine('~done');
+ return $this->_lines;
+ }
+}
+
+/**
+ * @todo document
+ * @private
+ * @subpackage DifferenceEngine
+ */
+class WordLevelDiff extends MappedDiff {
+ function MAX_LINE_LENGTH() {
+ return 10000;
+ }
+
+ function WordLevelDiff($orig_lines, $closing_lines) {
+ list($orig_words, $orig_stripped) = $this->_split($orig_lines);
+ list($closing_words, $closing_stripped) = $this->_split($closing_lines);
+
+ $this->MappedDiff($orig_words, $closing_words, $orig_stripped, $closing_stripped);
+ }
+
+ 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 ( 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);
+ }
+
+ function orig() {
+ $orig = new _HWLDF_WordAccumulator;
+
+ 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;
+ }
+
+ function closing() {
+ $closing = new _HWLDF_WordAccumulator;
+
+ 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;
+ }
+}
+
+/**
+ * Diff formatter which uses Drupal theme functions.
+ * @private
+ * @subpackage DifferenceEngine
+ */
+class DrupalDiffFormatter extends DiffFormatter {
+
+ var $rows;
+
+ function DrupalDiffFormatter() {
+ $this->leading_context_lines = 2;
+ $this->trailing_context_lines = 2;
+ }
+
+ function _start_diff() {
+ $this->rows = array();
+ }
+
+ function _end_diff() {
+ return $this->rows;
+ }
+
+ function _block_header($xbeg, $xlen, $ybeg, $ylen) {
+ return array(
+ array(
+ 'data' => theme('diff_header_line', $xbeg),
+ 'colspan' => 2,
+ ),
+ array(
+ 'data' => theme('diff_header_line', $ybeg),
+ 'colspan' => 2,
+ )
+ );
+ }
+
+ function _start_block($header) {
+ if ($this->show_header) {
+ $this->rows[] = $header;
+ }
+ }
+
+ function _end_block() {
+ }
+
+ function _lines($lines, $prefix=' ', $color='white') {
+ }
+
+ /**
+ * Note: you should HTML-escape parameter before calling this.
+ */
+ function addedLine($line) {
+ return array(
+ '+',
+ array(
+ 'data' => theme('diff_content_line', $line),
+ 'class' => 'diff-addedline',
+ )
+ );
+ }
+
+ /**
+ * Note: you should HTML-escape parameter before calling this.
+ */
+ function deletedLine($line) {
+ return array(
+ '-',
+ array(
+ 'data' => theme('diff_content_line', $line),
+ 'class' => 'diff-deletedline',
+ )
+ );
+ }
+
+ /**
+ * Note: you should HTML-escape parameter before calling this.
+ */
+ function contextLine($line) {
+ return array(
+ ' ',
+ array(
+ 'data' => theme('diff_content_line', $line),
+ 'class' => 'diff-context',
+ )
+ );
+ }
+
+ function emptyLine() {
+ return array(
+ ' ',
+ theme('diff_empty_line', ' '),
+ );
+ }
+
+ function _added($lines) {
+ foreach ($lines as $line) {
+ $this->rows[] = array_merge($this->emptyLine(), $this->addedLine(check_plain($line)));
+ }
+ }
+
+ function _deleted($lines) {
+ foreach ($lines as $line) {
+ $this->rows[] = array_merge($this->deletedLine(check_plain($line)), $this->emptyLine());
+ }
+ }
+
+ function _context($lines) {
+ foreach ($lines as $line) {
+ $this->rows[] = array_merge($this->contextLine(check_plain($line)), $this->contextLine(check_plain($line)));
+ }
+ }
+
+ function _changed($orig, $closing) {
+ $diff = new WordLevelDiff($orig, $closing);
+ $del = $diff->orig();
+ $add = $diff->closing();
+
+ // Notice that WordLevelDiff returns HTML-escaped output.
+ // Hence, we will be calling addedLine/deletedLine without HTML-escaping.
+
+ while ($line = array_shift($del)) {
+ $aline = array_shift( $add );
+ $this->rows[] = array_merge($this->deletedLine($line), $this->addedLine($aline));
+ }
+ foreach ($add as $line) { // If any leftovers
+ $this->rows[] = array_merge($this->emptyLine(), $this->addedLine($line));
+ }
+ }
+}
Index: modules/node/node.info
===================================================================
RCS file: /cvs/drupal/drupal/modules/node/node.info,v
retrieving revision 1.6
diff -u -F^f -p -r1.6 node.info
--- modules/node/node.info 6 May 2008 12:18:48 -0000 1.6
+++ modules/node/node.info 5 Oct 2008 01:04:32 -0000
@@ -8,3 +8,4 @@ files[] = node.module
files[] = content_types.inc
files[] = node.admin.inc
files[] = node.pages.inc
+files[] = node.pages-diff.inc
Index: modules/node/node.module
===================================================================
RCS file: /cvs/drupal/drupal/modules/node/node.module,v
retrieving revision 1.978
diff -u -F^f -p -r1.978 node.module
--- modules/node/node.module 27 Sep 2008 19:47:43 -0000 1.978
+++ modules/node/node.module 5 Oct 2008 01:04:32 -0000
@@ -135,6 +135,23 @@ function node_theme() {
'node_submitted' => array(
'arguments' => array('node' => NULL),
),
+ 'node_revisions_overview' => array(
+ 'arguments' => array('form' => NULL),
+ 'file' => 'node.pages-diff.inc',
+ ),
+ 'diff_header_line' => array(
+ 'arguments' => array('lineno' => NULL),
+ 'file' => 'node.pages-diff.inc',
+ ),
+ 'diff_content_line' => array(
+ 'arguments' => array('line' => NULL),
+ 'file' => 'node.pages-diff.inc',
+ ),
+ 'diff_empty_line' => array(
+ 'arguments' => array('line' => NULL),
+ 'file' => 'node.pages-diff.inc',
+ ),
+
);
}
@@ -1609,8 +1626,8 @@ function node_menu() {
'type' => MENU_CALLBACK);
$items['node/%node/revisions'] = array(
'title' => 'Revisions',
- 'page callback' => 'node_revision_overview',
- 'page arguments' => array(1),
+ 'page callback' => 'drupal_get_form',
+ 'page arguments' => array('node_revisions_overview', 1),
'access callback' => '_node_revision_access',
'access arguments' => array(1),
'weight' => 2,
@@ -1625,6 +1642,22 @@ function node_menu() {
'access arguments' => array(1),
'type' => MENU_CALLBACK,
);
+ $items['node/%node/revisions/view/%/%'] = array(
+ 'title' => 'View differences',
+ 'page callback' => 'node_diffs_show',
+ 'page arguments' => array(1, 4, 5),
+ 'type' => MENU_CALLBACK,
+ 'access callback' => '_node_revision_access',
+ 'access arguments' => array(1),
+ );
+ $items['node/%node/revisions/view/latest'] = array(
+ 'title' => 'View differences',
+ 'page callback' => 'node_diff_latest',
+ 'page arguments' => array(1),
+ 'type' => MENU_CALLBACK,
+ 'access callback' => '_node_revision_access',
+ 'access arguments' => array(1),
+ );
$items['node/%node/revisions/%/revert'] = array(
'title' => 'Revert to earlier revision',
'load arguments' => array(3),
@@ -1960,7 +1993,6 @@ function node_form_alter(&$form, $form_s
);
}
-
$form['#validate'][] = 'node_search_validate';
}
}
@@ -2879,3 +2911,29 @@ function node_list_permissions($type) {
return $perms;
}
+
+/**
+ * Implementation of hook_diff() - body and title fields.
+ */
+function node_diff(&$old_node, &$new_node) {
+
+ $result = array();
+ $type = node_get_types('type', $new_node);
+ $result['title'] = array(
+ '#name' => $type->title_label,
+ '#old' => array($old_node->title),
+ '#new' => array($new_node->title),
+ '#weight' => -5,
+ '#format' => array(
+ 'show_header' => FALSE,
+ )
+ );
+ if ($type->has_body) {
+ $result['body'] = array(
+ '#name' => $type->body_label,
+ '#old' => explode("\n", $old_node->body),
+ '#new' => explode("\n", $new_node->body),
+ );
+ }
+ return $result;
+}
Index: modules/node/node.pages-diff.inc
===================================================================
RCS file: modules/node/node.pages-diff.inc
diff -N modules/node/node.pages-diff.inc
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ modules/node/node.pages-diff.inc 5 Oct 2008 01:04:32 -0000
@@ -0,0 +1,457 @@
+nid/revisions/view/$old->vid/$new->vid");
+}
+
+/**
+ * Menu callback. Show differences between two node revisions.
+ *
+ * @param $node
+ * Node on which to perform comparison
+ * @param $old_vid
+ * Version ID of the old revision.
+ * @param $new_vid
+ * Version ID of the new revision.
+ */
+function node_diffs_show($node, $old_vid, $new_vid) {
+
+ // Set same title as on the 'Revisions' tab for consistency
+ drupal_set_title(t('Revisions for %title', array('%title' => $node->title)));
+
+ $node_revisions = node_revision_list($node);
+
+ $old_node = node_load($node->nid, $old_vid);
+ $new_node = node_load($node->nid, $new_vid);
+
+ // Generate table header (date, username, logmessage).
+ $old_header = t('!date by !username', array(
+ '!date' => l(format_date($old_node->revision_timestamp), "node/$node->nid/revisions/$old_node->vid/view"),
+ '!username' => theme('username', $node_revisions[$old_vid]),
+ ));
+ $new_header = t('!date by !username', array(
+ '!date' => l(format_date($new_node->revision_timestamp), "node/$node->nid/revisions/$new_node->vid/view"),
+ '!username' => theme('username', $node_revisions[$new_vid]),
+ ));
+
+ $old_log = $old_node->log != '' ? ''. filter_xss($old_node->log) .'
' : '';
+ $new_log = $new_node->log != '' ? ''. filter_xss($new_node->log) .'
' : '';
+
+ // Generate previous diff/next diff links.
+ $next_vid = _diff_get_next_vid($node_revisions, $new_vid);
+ if ($next_vid) {
+ $next_link = l(t('next diff >'), 'node/'. $node->nid .'/revisions/view/'. $new_vid .'/'. $next_vid);
+ }
+ else {
+ $next_link = '';
+ }
+ $prev_vid = _diff_get_previous_vid($node_revisions, $old_vid);
+ if ($prev_vid) {
+ $prev_link = l(t('< previous diff'), 'node/'. $node->nid .'/revisions/view/'. $prev_vid .'/'. $old_vid);
+ }
+ else {
+ $prev_link = '';
+ }
+
+ $cols = _diff_default_cols();
+ $header = _diff_default_header($old_header, $new_header);
+ $rows = array();
+ if ($old_log || $new_log) {
+ $rows[] = array(
+ array(
+ 'data' => $old_log,
+ 'colspan' => 2
+ ),
+ array(
+ 'data' => $new_log,
+ 'colspan' => 2
+ )
+ );
+ }
+ $rows[] = array(
+ array(
+ 'data' => $prev_link,
+ 'class' => 'diff-prevlink',
+ 'colspan' => 2
+ ),
+ array(
+ 'data' => $next_link,
+ 'class' => 'diff-nextlink',
+ 'colspan' => 2
+ )
+ );
+ $rows = array_merge($rows, _diff_body_rows($old_node, $new_node));
+ $output = theme('table', $header, $rows, array('class' => 'diff'), NULL, $cols);
+
+ if ($node->vid == $new_vid) {
+ $output .= ''. t('Current revision:') .'
';
+ }
+ else {
+ $output .= ''. t('Revision of !new_date:', array('!new_date' => format_date($new_node->revision_timestamp))) .'
';
+ }
+ // Don't include node links (final argument) when viewing the diff.
+ $output .= node_view($new_node, FALSE, FALSE, FALSE);
+ return $output;
+}
+
+/**
+ * Generate an overview table of older revisions of a node.
+ */
+function node_revisions_overview($form_state, $node) {
+ $form = array();
+
+ $form['nid'] = array(
+ '#type' => 'hidden',
+ '#value' => $node->nid,
+ );
+
+ $revision_list = node_revision_list($node);
+
+ if (count($revision_list) > REVISION_LIST_SIZE) {
+ // If the list of revisions is longer than the number shown on one page split the array.
+ $page = isset($_GET['page']) ? $_GET['page'] : '0';
+ $revision_chunks = array_chunk(node_revision_list($node), REVISION_LIST_SIZE);
+ $revisions = $revision_chunks[$page];
+ // Set up global pager variables as would 'pager_query' do.
+ // These variables are then used in the theme('pager') call later.
+ global $pager_page_array, $pager_total, $pager_total_items;
+ $pager_total_items[0] = count($revision_list);
+ $pager_total[0] = ceil(count($revision_list) / REVISION_LIST_SIZE);
+ $pager_page_array[0] = max(0, min($page, ((int)$pager_total[0]) - 1));
+ }
+ else {
+ $revisions = $revision_list;
+ }
+
+ $revert_permission = FALSE;
+ if ((user_access('revert revisions') || user_access('administer nodes')) && node_access('update', $node)) {
+ $revert_permission = TRUE;
+ }
+ $delete_permission = FALSE;
+ if (user_access('administer nodes')) {
+ $delete_permission = TRUE;
+ }
+
+ foreach ($revisions as $revision) {
+ $operations = array();
+ $revision_ids[$revision->vid] = '';
+ if ($revision->current_vid > 0) {
+ $form['info'][$revision->vid] = array(
+ '#markup' => t('!date by !username', array(
+ '!date' => l(format_date($revision->timestamp, 'small'), "node/$node->nid"),
+ '!username' => theme('username', $revision)))
+ . (($revision->log != '') ? ''. filter_xss($revision->log) .'
' : ''),
+ );
+ }
+ else {
+ $form['info'][$revision->vid] = array(
+ '#markup' => t('!date by !username', array(
+ '!date' => l(format_date($revision->timestamp, 'small'), "node/$node->nid/revisions/$revision->vid/view"),
+ '!username' => theme('username', $revision)))
+ . (($revision->log != '') ? ''. filter_xss($revision->log) .'
' : '')
+ );
+ if ($revert_permission) {
+ $operations[] = array('#markup' => l(t('revert'), "node/$node->nid/revisions/$revision->vid/revert"));
+ }
+ if ($delete_permission) {
+ $operations[] = array('#markup' => l(t('delete'), "node/$node->nid/revisions/$revision->vid/delete"));
+ }
+ // Set a dummy, even if the user has no permission for the other
+ // operations, so that we can check if the operations array is
+ // empty to know if the row denotes the current revision.
+ $operations[] = array();
+ }
+ $form['operations'][$revision->vid] = $operations;
+
+ }
+ $new_vid = key($revision_ids);
+ next($revision_ids);
+ $old_vid = key($revision_ids);
+ $form['diff']['old'] = array(
+ '#type' => 'radios',
+ '#options' => $revision_ids,
+ '#default_value' => $old_vid
+ );
+ $form['diff']['new'] = array(
+ '#type' => 'radios',
+ '#options' => $revision_ids,
+ '#default_value' => $new_vid
+ );
+ $form['submit'] = array(
+ '#type' => 'submit',
+ '#value' => t('Show diff')
+ );
+
+ if (count($revision_list) > REVISION_LIST_SIZE) {
+ $form['#suffix'] = theme('pager', NULL, REVISION_LIST_SIZE, 0);
+ }
+
+ return $form;
+}
+
+/**
+ * Theme function to display the revisions table with means to select
+ * two revisions.
+ */
+function theme_node_revisions_overview($form) {
+ $output = '';
+
+ // Overview table:
+ $header = array(
+ t('Revision'),
+ array('data' => drupal_render($form['submit']), 'colspan' => 2),
+ array('data' => t('Operations'), 'colspan' => 2)
+ );
+ if (isset($form['info']) && is_array($form['info'])) {
+ foreach (element_children($form['info']) as $key) {
+ $row = array();
+ if (isset($form['operations'][$key][0])) {
+ // Note: even if the commands for revert and delete are not permitted,
+ // the array is not empty since we set a dummy in this case.
+ $row[] = drupal_render($form['info'][$key]);
+ $row[] = drupal_render($form['diff']['old'][$key]);
+ $row[] = drupal_render($form['diff']['new'][$key]);
+ $row[] = drupal_render($form['operations'][$key][0]);
+ $row[] = drupal_render($form['operations'][$key][1]);
+ $rows[] = $row;
+ }
+ else {
+ // its the current revision (no commands to revert or delete)
+ $row[] = array('data' => drupal_render($form['info'][$key]), 'class' => 'revision-current');
+ $row[] = array('data' => drupal_render($form['diff']['old'][$key]), 'class' => 'revision-current');
+ $row[] = array('data' => drupal_render($form['diff']['new'][$key]), 'class' => 'revision-current');
+ $row[] = array('data' => theme('placeholder', t('current revision')), 'class' => 'revision-current', 'colspan' => '2');
+ $rows[] = array(
+ 'data' => $row,
+ 'class' => 'error',
+ );
+ }
+ }
+ }
+ $output .= theme('table', $header, $rows);
+ $output .= drupal_render($form);
+ return $output;
+}
+
+/**
+ * Validation for input form to select two revisions.
+ */
+function node_revisions_overview_validate($form, &$form_state) {
+ $old_vid = $form_state['values']['old'];
+ $new_vid = $form_state['values']['new'];
+ if ($old_vid==$new_vid || !$old_vid || !$new_vid) {
+ form_set_error('diff', t('Select different revisions to compare.'));
+ }
+}
+
+/**
+ * Submit handler which redirects to the selected diff page.
+ */
+function node_revisions_overview_submit($form, &$form_state) {
+ // The ids are ordered so the old revision is always on the left.
+ $old_vid = min($form_state['values']['old'], $form_state['values']['new']);
+ $new_vid = max($form_state['values']['old'], $form_state['values']['new']);
+ $form_state['redirect'] = 'node/'. $form_state['values']['nid'] .'/revisions/view/'. $old_vid .'/'. $new_vid;
+}
+
+/**
+ * Creates an array of rows which represent a diff between $old_node and $new_node.
+ *
+ * @param $old_node
+ * Node for comparison which will be displayed on the left side.
+ * @param $new_node
+ * Node for comparison which will be displayed on the right side.
+ */
+function _diff_body_rows(&$old_node, &$new_node) {
+ drupal_add_css(drupal_get_path('module', 'node') .'/node.css');
+ module_load_include('inc', 'node', 'node.diff');
+
+ $rows = array();
+ $any_visible_change = FALSE;
+ $node_diffs = module_invoke_all('diff', $old_node, $new_node);
+
+ // We start off assuming all form elements are in the correct order.
+ $node_diffs['#sorted'] = TRUE;
+
+ // Recurse through all child elements.
+ $count = 0;
+ foreach (element_children($node_diffs) as $key) {
+ // Assign a decimal placeholder weight to preserve original array order.
+ if (!isset($node_diffs[$key]['#weight'])) {
+ $node_diffs[$key]['#weight'] = $count/1000;
+ }
+ else {
+ // If one of the child elements has a weight then we will need to sort
+ // later.
+ unset($node_diffs['#sorted']);
+ }
+ $count++;
+ }
+
+ // One of the children has a #weight.
+ if (!isset($node_diffs['#sorted'])) {
+ uasort($node_diffs, "element_sort");
+ }
+
+ foreach ($node_diffs as $node_diff) {
+ $diff = new Diff($node_diff['#old'], $node_diff['#new']);
+ $formatter = new DrupalDiffFormatter();
+ if (isset($node_diff['#format'])) {
+ $formatter->show_header = $node_diff['#format']['show_header'];
+ }
+ $diff_rows = $formatter->format($diff);
+ if (count($diff_rows)) {
+ $rows[] = array(
+ array(
+ 'data' => t('Changes to %name', array('%name' => $node_diff['#name'])),
+ 'class' => 'diff-section-title',
+ 'colspan' => 4
+ )
+ );
+ $rows = array_merge($rows, $diff_rows);
+ $any_visible_change = TRUE;
+ }
+ }
+ if (!$any_visible_change) {
+ $rows[] = array(
+ array(
+ 'data' => t('No visible changes'),
+ 'class' => 'diff-section-title',
+ 'colspan' => 4
+ ),
+ );
+ // Needed to keep Safari happy.
+ $rows[] = array(
+ array('data' => ''),
+ array('data' => ''),
+ array('data' => ''),
+ array('data' => ''),
+ );
+ }
+ return $rows;
+}
+
+/**
+ * Get the entry in the revisions list after $vid.
+ * Returns FALSE if $vid is the last entry.
+ *
+ * @param $node_revisions
+ * Array of node revision IDs in descending order.
+ * @param $vid
+ * Version ID to look for.
+ */
+function _diff_get_next_vid(&$node_revisions, $vid) {
+ $previous = NULL;
+ foreach ($node_revisions as $revision) {
+ if ($revision->vid == $vid) {
+ return ($previous ? $previous->vid : FALSE);
+ }
+ $previous = $revision;
+ }
+ return FALSE;
+}
+
+/**
+ * Get the entry in the revision list before $vid.
+ * Returns FALSE if $vid is the first entry.
+ *
+ * @param $node_revisions
+ * Array of node revision IDs in descending order.
+ * @param $vid
+ * Version ID to look for.
+ */
+function _diff_get_previous_vid(&$node_revisions, $vid) {
+ $previous = NULL;
+ foreach ($node_revisions as $revision) {
+ if ($previous && $previous->vid == $vid) {
+ return $revision->vid;
+ }
+ $previous = $revision;
+ }
+ return FALSE;
+}
+
+/**
+ * Submit handler for 'View changes' button.
+ */
+function node_form_view_changes_submit($form, &$form_state) {
+ $node = node_form_submit_build_node($form, $form_state);
+
+ // Create diff of old node and edited node
+ $rows = _diff_body_rows(node_load($form_state['values']['nid']), $node);
+ $cols = _diff_default_cols();
+ $header = _diff_default_header();
+ $changes = theme('table', $header, $rows, array('class' => 'diff'), NULL, $cols);
+ // Prepend diff to edit form
+ $form_state['node_preview'] = isset($form_state['node_preview']) ? $changes . $form_state['node_preview'] : $changes;
+}
+
+/**
+ * Theme function for a header line in the diff.
+ */
+function theme_diff_header_line($lineno) {
+ return ''. t('Line %lineno', array('%lineno' => $lineno)) .'';
+}
+
+/**
+ * Theme function for a content line in the diff.
+ */
+function theme_diff_content_line($line) {
+ return ''. $line .'
';
+}
+
+/**
+ * Theme function for an empty line in the diff.
+ */
+function theme_diff_empty_line($line) {
+ return $line;
+}
+
+/**
+ * Helper function to create default 'cols' array for diff table.
+ */
+function _diff_default_cols() {
+ return array(
+ array(
+ array(
+ 'class' => 'diff-marker',
+ ),
+ array(
+ 'class' => 'diff-content',
+ ),
+ array(
+ 'class' => 'diff-marker',
+ ),
+ array(
+ 'class' => 'diff-content',
+ ),
+ ),
+ );
+}
+
+/**
+ * Helper function to create default 'header' array for diff table.
+ */
+function _diff_default_header($old_header = '', $new_header = '') {
+ return array(
+ array(
+ 'data' => $old_header,
+ 'colspan' => 2
+ ),
+ array(
+ 'data' => $new_header,
+ 'colspan' => 2
+ )
+ );
+}
Index: modules/node/node.pages.inc
===================================================================
RCS file: /cvs/drupal/drupal/modules/node/node.pages.inc,v
retrieving revision 1.39
diff -u -F^f -p -r1.39 node.pages.inc
--- modules/node/node.pages.inc 27 Sep 2008 20:37:00 -0000 1.39
+++ modules/node/node.pages.inc 5 Oct 2008 01:04:32 -0000
@@ -248,6 +248,15 @@ function node_form(&$form_state, $node)
'#weight' => 10,
'#submit' => array('node_form_build_preview'),
);
+ // Add a 'View changes' button on the node edit form.
+ if (variable_get('node_show_view_changes_'. $node->type, FALSE) && !empty($node->nid)) {
+ $form['buttons']['view_changes'] = array(
+ '#type' => 'submit',
+ '#value' => t('View changes'),
+ '#weight' => 13,
+ '#submit' => array('node_form_view_changes_submit')
+ );
+ }
if (!empty($node->nid) && node_access('delete', $node)) {
$form['buttons']['delete'] = array(
'#type' => 'submit',
@@ -501,51 +510,6 @@ function node_delete_confirm_submit($for
}
/**
- * Generate an overview table of older revisions of a node.
- */
-function node_revision_overview($node) {
- drupal_set_title(t('Revisions for %title', array('%title' => $node->title)));
-
- $header = array(t('Revision'), array('data' => t('Operations'), 'colspan' => 2));
-
- $revisions = node_revision_list($node);
-
- $rows = array();
- $revert_permission = FALSE;
- if ((user_access('revert revisions') || user_access('administer nodes')) && node_access('update', $node)) {
- $revert_permission = TRUE;
- }
- $delete_permission = FALSE;
- if ((user_access('delete revisions') || user_access('administer nodes')) && node_access('delete', $node)) {
- $delete_permission = TRUE;
- }
- foreach ($revisions as $revision) {
- $row = array();
- $operations = array();
-
- if ($revision->current_vid > 0) {
- $row[] = array('data' => t('!date by !username', array('!date' => l(format_date($revision->timestamp, 'small'), "node/$node->nid"), '!username' => theme('username', $revision)))
- . (($revision->log != '') ? '' . filter_xss($revision->log) . '
' : ''),
- 'class' => 'revision-current');
- $operations[] = array('data' => theme('placeholder', t('current revision')), 'class' => 'revision-current', 'colspan' => 2);
- }
- else {
- $row[] = t('!date by !username', array('!date' => l(format_date($revision->timestamp, 'small'), "node/$node->nid/revisions/$revision->vid/view"), '!username' => theme('username', $revision)))
- . (($revision->log != '') ? '' . filter_xss($revision->log) . '
' : '');
- if ($revert_permission) {
- $operations[] = l(t('revert'), "node/$node->nid/revisions/$revision->vid/revert");
- }
- if ($delete_permission) {
- $operations[] = l(t('delete'), "node/$node->nid/revisions/$revision->vid/delete");
- }
- }
- $rows[] = array_merge($row, $operations);
- }
-
- return theme('table', $header, $rows);
-}
-
-/**
* Ask for confirmation of the reversion to prevent against CSRF attacks.
*/
function node_revision_revert_confirm($form_state, $node_revision) {
Index: modules/taxonomy/taxonomy.module
===================================================================
RCS file: /cvs/drupal/drupal/modules/taxonomy/taxonomy.module,v
retrieving revision 1.430
diff -u -F^f -p -r1.430 taxonomy.module
--- modules/taxonomy/taxonomy.module 27 Sep 2008 20:37:01 -0000 1.430
+++ modules/taxonomy/taxonomy.module 5 Oct 2008 01:04:33 -0000
@@ -1351,3 +1351,56 @@ function taxonomy_hook_info() {
),
);
}
+
+/**
+ * Implementation of hook_diff().
+ */
+function taxonomy_diff(&$old_node, &$new_node) {
+ $result = array();
+ //dsm($old_node);dsm($new_node);
+ // TODO: make taxonomy by category not only by whole taxonomy?
+ $old_taxonomy = array();
+ $new_taxonomy = array();
+ if (isset($old_node->taxonomy) && $old_node->taxonomy) {
+ foreach ($old_node->taxonomy as $term) {
+ $old_taxonomy[] = $term->name;
+ }
+ }
+ if (isset($new_node->taxonomy) && $new_node->taxonomy) {
+ foreach ($new_node->taxonomy as $id => $entry) {
+ if (is_array($entry)) {
+ // During editing the taxonomy is built up as a list of vocabulary ids as keys
+ // and a list of term ids per array entry.
+ if (is_numeric($id)) {
+ foreach ($entry as $tid) {
+ $term = taxonomy_get_term($tid);
+ $new_taxonomy[] = $term->name;
+ }
+ }
+ else {
+ // If the id is not numeric than it has to be 'tags' which denotes freetagging
+ // vocabularies. These are stored as an array which map the vocabulary id to
+ // a string of terms.
+ foreach ($entry as $taglist) {
+ $new_taxonomy = array_merge($new_taxonomy, drupal_explode_tags($taglist));
+ }
+ }
+ }
+ else {
+ // Not during editing the taxonomy list is a list of terms.
+ $term = taxonomy_term_load($id);
+ $new_taxonomy[] = $term->name;
+ }
+ }
+ }
+ $result['taxonomy'] = array(
+ '#name' => t('Taxonomy'),
+ '#old' => $old_taxonomy,
+ '#new' => $new_taxonomy,
+ '#weight' => -3,
+ '#format' => array(
+ 'show_header' => FALSE,
+ )
+ );
+ return $result;
+}
Index: modules/upload/upload.module
===================================================================
RCS file: /cvs/drupal/drupal/modules/upload/upload.module,v
retrieving revision 1.207
diff -u -F^f -p -r1.207 upload.module
--- modules/upload/upload.module 27 Sep 2008 20:37:01 -0000 1.207
+++ modules/upload/upload.module 5 Oct 2008 01:04:33 -0000
@@ -634,3 +634,44 @@ function upload_js() {
print drupal_to_js(array('status' => TRUE, 'data' => $output));
exit;
}
+
+/**
+ * Implementation of hook_diff() for file attachments.
+ */
+function upload_diff(&$old_node, &$new_node) {
+ $result = array();
+ $old_files = array();
+ if (isset($old_node->files)) {
+ foreach ($old_node->files as $file) {
+ $old_files[] = $file->filename;
+ }
+ }
+ $new_files = array();
+ if (isset($new_node->files)) {
+ foreach ($new_node->files as $key => $file) {
+ if (is_array($file)) {
+ // During editing the files are stored as arrays, not objects.
+ if ($file['remove']) {
+ // It looks better if a blank line is inserted for removed files.
+ $new_files[] = '';
+ }
+ else {
+ $new_files[] = $file['filename'];
+ }
+ }
+ else {
+ $new_files[] = $file->filename;
+ }
+ }
+ }
+ $result['attachments'] = array(
+ '#name' => t('Attachments'),
+ '#old' => $old_files,
+ '#new' => $new_files,
+ '#weight' => 30,
+ '#format' => array(
+ 'show_header' => FALSE,
+ )
+ );
+ return $result;
+}
\ No newline at end of file