<?php
/**
* Diffs two arbitrary files in the depot.
*
* @copyright 2011 Perforce Software. All rights reserved.
* @license Please see LICENSE.txt in top-level folder of this distribution.
* @version <release>/<patch>
*/
namespace P4\File;
use P4\File\File;
use P4\Filter\Utf8 as Utf8Filter;
use P4\Model\Connected\ConnectedAbstract;
class Diff extends ConnectedAbstract
{
const MAX_FILESIZE = 1048576; // 1 MB
const IGNORE_WS = 'ignoreWs';
const UTF8_CONVERT = 'convert';
const UTF8_SANITIZE = 'sanitize';
/**
* Compare left/right files.
*
* @param File $right optional - right-hand file
* @param File $left optional - left-hand file
* @param array $options optional - influence diff behavior
* IGNORE_WS - ignore whitespace and line-ending
* changes (defaults to false)
* UTF8_CONVERT - attempt to covert non UTF-8 to UTF-8
* UTF8_SANITIZE - replace invalid UTF-8 sequences with �
* @return array array with three elements:
* lines - added/deleted and contextual (common) lines
* isCut - true if lines exceed max filesize (>1MB)
* isSame - true if left and right file contents are equal
* @throws \InvalidArgumentException if no right-hand file is given
*/
public function diff(File $right = null, File $left = null, array $options = array())
{
$options = $options + array(
static::IGNORE_WS => false, static::UTF8_CONVERT => false, static::UTF8_SANITIZE => false
);
if (!$right && !$left) {
throw new \InvalidArgumentException(
"Cannot diff. Must specify at least one file to diff."
);
}
$diff = array(
'lines' => array(),
'isCut' => false,
'isSame' => false
);
// only examine contents if both sides are non-binary and at least one has content
$leftIsBinary = $left && $left->isBinary();
$leftHasContent = $left && !$left->isDeletedOrPurged();
$rightIsBinary = $right && $right->isBinary();
$rightHasContent = $right && !$right->isDeletedOrPurged();
if (!$leftIsBinary && !$rightIsBinary && ($leftHasContent || $rightHasContent)) {
// if only one file given or either file was deleted/purged,
// can't use diff2, must print the file contents instead.
if (!$left || !$right || $left->isDeletedOrPurged() || $right->isDeletedOrPurged()) {
$diff = $this->diffAddDelete($diff, $right, $left, $options);
} else {
$diff = $this->diffEdit($diff, $right, $left, $options);
}
}
// compare digests if we have no diff lines (need both sides)
if (!$diff['lines'] && $left && $right) {
$leftDigest = $left->hasStatusField('digest') ? $left->getStatus('digest') : null;
$rightDigest = $right->hasStatusField('digest') ? $right->getStatus('digest') : null;
$diff['isSame'] = $leftDigest === $rightDigest;
}
return $diff;
}
/**
* Run p4 diff2 against left/right files and parse output into array.
*
* @param array $diff diff result array we are building.
* @param File $right right-hand file.
* @param File $left left-hand file.
* @param array $options influences diff behavior.
* @return array diff result with lines added.
*/
protected function diffEdit(array $diff, File $right, File $left, array $options)
{
$mode = $options[static::IGNORE_WS] ? '-dwu5' : '-du5';
$flags = array($mode, $left->getFilespec(), $right->getFilespec());
$data = $this->getConnection()->run('diff2', $flags, null, false)->getData();
// diff output puts a file header in the first data block
// (which we skip) and the diffs in one or more following blocks.
$diffs = "";
for ($i = 1; $i < count($data); $i++) {
$diffs .= $data[$i];
}
// if we are requested to convert or replace; do so prior to split
if ($options[static::UTF8_CONVERT] || $options[static::UTF8_SANITIZE]) {
$filter = new Utf8Filter;
$diffs = $filter->setConvertEncoding($options[static::UTF8_CONVERT])
->setReplaceInvalid($options[static::UTF8_SANITIZE])
->filter($diffs);
}
// parse diff block into lines
// capture line-ending so we can detect line-end changes.
$types = array('@' => 'meta', ' ' => 'same', '-' => 'delete', '+' => 'add');
$lines = preg_split("/(\r\n|\n|\r)/", $diffs, null, PREG_SPLIT_DELIM_CAPTURE);
for ($i = 0; $i < count($lines); $i = $i+2) {
$line = $lines[$i];
$end = isset($lines[$i+1]) ? $lines[$i+1] : '';
// skip empty or unexpected output
if (!strlen($line) || !isset($types[$line[0]])) {
continue;
}
$type = $types[$line[0]];
// extract starting left/right line numbers from meta block
// meta block has the format of "@@ -133,29 +133,27 @@"
if ($type === 'meta') {
preg_match('/@@ \-([0-9]+),[0-9]+ \+([0-9]+),[0-9]+ @@/', $line, $matches);
$leftLine = $matches[1];
$rightLine = $matches[2];
}
$diff['lines'][] = array(
'value' => $line,
'type' => $type,
'lineEnd' => $end,
'leftLine' => ($type === 'same' || $type === 'delete') ? $leftLine++ : null,
'rightLine' => ($type === 'same' || $type === 'add') ? $rightLine++ : null
);
}
return $diff;
}
/**
* Get file contents of added/deleted files.
*
* @param array $diff diff result array we are building.
* @param File $right optional - right-hand file.
* @param File $left optional - left-hand file.
* @param array|null $options influences diff behavior.
* @return array diff result with lines added.
*/
protected function diffAddDelete(array $diff, File $right = null, File $left = null, $options = null)
{
// contents must come from the side we have, or the side that is not deleted/purged
// contents from right imply add, contents from left imply delete
$file = $right && !$right->isDeletedOrPurged() ? $right : $left;
$isAdd = $file == $right;
// get file contents truncated to max filesize to avoid consuming too much memory.
$options += array(File::MAX_FILESIZE => static::MAX_FILESIZE);
$content = $file->getDepotContents($options, $cropped);
$lines = preg_split("/\r\n|\n|\r/", $content);
$count = count($lines);
$meta = '@@ ' . ($isAdd ? '-1,0 +1,' . $count : '-1,' . $count . '+1,0') . ' @@';
$diff['isCut'] = $cropped ? static::MAX_FILESIZE : false;
$diff['lines'][] = array(
'value' => $meta,
'type' => 'meta',
'leftLine' => null,
'rightLine' => null
);
foreach ($lines as $i => $line) {
$diff['lines'][] = array(
'value' => $isAdd ? '+' . $line : '-' . $line,
'type' => $isAdd ? 'add' : 'delete',
'leftLine' => $isAdd ? null : $i+1,
'rightLine' => $isAdd ? $i+1 : null
);
}
return $diff;
}
}