No OneTemporary
Actions

Size

31 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/applications/differential/controller/DifferentialChangesetViewController.php b/src/applications/differential/controller/DifferentialChangesetViewController.php
	index 28a6e26b2c..5efb8561af 100644
	--- a/src/applications/differential/controller/DifferentialChangesetViewController.php
	+++ b/src/applications/differential/controller/DifferentialChangesetViewController.php
	@@ -1,428 +1,420 @@
	<?php

	final class DifferentialChangesetViewController extends DifferentialController {

	public function shouldAllowPublic() {
	return true;
	}

	public function handleRequest(AphrontRequest $request) {
	$viewer = $this->getViewer();

	$rendering_reference = $request->getStr('ref');
	$parts = explode('/', $rendering_reference);
	if (count($parts) == 2) {
	list($id, $vs) = $parts;
	} else {
	$id = $parts[0];
	$vs = 0;
	}

	$id = (int)$id;
	$vs = (int)$vs;

	$load_ids = array($id);
	if ($vs && ($vs != -1)) {
	$load_ids[] = $vs;
	}

	$changesets = id(new DifferentialChangesetQuery())
	->setViewer($viewer)
	->withIDs($load_ids)
	->needHunks(true)
	->execute();
	$changesets = mpull($changesets, null, 'getID');

	$changeset = idx($changesets, $id);
	if (!$changeset) {
	return new Aphront404Response();
	}

	$vs_changeset = null;
	if ($vs && ($vs != -1)) {
	$vs_changeset = idx($changesets, $vs);
	if (!$vs_changeset) {
	return new Aphront404Response();
	}
	}

	$view = $request->getStr('view');
	if ($view) {
	$phid = idx($changeset->getMetadata(), "$view:binary-phid");
	if ($phid) {
	return id(new AphrontRedirectResponse())->setURI("/file/info/$phid/");
	}
	switch ($view) {
	case 'new':
	return $this->buildRawFileResponse($changeset, $is_new = true);
	case 'old':
	if ($vs_changeset) {
	return $this->buildRawFileResponse($vs_changeset, $is_new = true);
	}
	return $this->buildRawFileResponse($changeset, $is_new = false);
	default:
	return new Aphront400Response();
	}
	}

	$old = array();
	$new = array();
	if (!$vs) {
	$right = $changeset;
	$left = null;

	$right_source = $right->getID();
	$right_new = true;
	$left_source = $right->getID();
	$left_new = false;

	$render_cache_key = $right->getID();

	$old[] = $changeset;
	$new[] = $changeset;
	} else if ($vs == -1) {
	$right = null;
	$left = $changeset;

	$right_source = $left->getID();
	$right_new = false;
	$left_source = $left->getID();
	$left_new = true;

	$render_cache_key = null;

	$old[] = $changeset;
	$new[] = $changeset;
	} else {
	$right = $changeset;
	$left = $vs_changeset;

	$right_source = $right->getID();
	$right_new = true;
	$left_source = $left->getID();
	$left_new = true;

	$render_cache_key = null;

	$new[] = $left;
	$new[] = $right;
	}

	if ($left) {
	$left_data = $left->makeNewFile();
	if ($right) {
	$right_data = $right->makeNewFile();
	} else {
	$right_data = $left->makeOldFile();
	}

	$engine = new PhabricatorDifferenceEngine();
	$synthetic = $engine->generateChangesetFromFileContent(
	$left_data,
	$right_data);

	$choice = clone nonempty($left, $right);
	$choice->attachHunks($synthetic->getHunks());

	$changeset = $choice;
	}

	- $coverage = null;
	- if ($right && $right->getDiffID()) {
	- $unit = id(new DifferentialDiffProperty())->loadOneWhere(
	- 'diffID = %d AND name = %s',
	- $right->getDiffID(),
	- 'arc:unit');
	-
	- if ($unit) {
	- $coverage = array();
	- foreach ($unit->getData() as $result) {
	- $result_coverage = idx($result, 'coverage');
	- if (!$result_coverage) {
	- continue;
	- }
	- $file_coverage = idx($result_coverage, $right->getFileName());
	- if (!$file_coverage) {
	- continue;
	- }
	- $coverage[] = $file_coverage;
	- }
	+ if ($left_new \|\| $right_new) {
	+ $diff_map = array();
	+ if ($left) {
	+ $diff_map[] = $left->getDiff();
	+ }
	+ if ($right) {
	+ $diff_map[] = $right->getDiff();
	+ }
	+ $diff_map = mpull($diff_map, null, 'getPHID');

	- $coverage = ArcanistUnitTestResult::mergeCoverage($coverage);
	+ $buildables = id(new HarbormasterBuildableQuery())
	+ ->setViewer($viewer)
	+ ->withBuildablePHIDs(array_keys($diff_map))
	+ ->withManualBuildables(false)
	+ ->needBuilds(true)
	+ ->needTargets(true)
	+ ->execute();
	+ $buildables = mpull($buildables, null, 'getBuildablePHID');
	+ foreach ($diff_map as $diff_phid => $changeset_diff) {
	+ $changeset_diff->attachBuildable(idx($buildables, $diff_phid));
	}
	}

	+ $coverage = null;
	+ if ($right_new) {
	+ $coverage = $this->loadCoverage($right);
	+ }
	+
	$spec = $request->getStr('range');
	list($range_s, $range_e, $mask) =
	DifferentialChangesetParser::parseRangeSpecification($spec);

	$parser = id(new DifferentialChangesetParser())
	->setCoverage($coverage)
	->setChangeset($changeset)
	->setRenderingReference($rendering_reference)
	->setRenderCacheKey($render_cache_key)
	->setRightSideCommentMapping($right_source, $right_new)
	->setLeftSideCommentMapping($left_source, $left_new);

	$parser->readParametersFromRequest($request);

	if ($left && $right) {
	$parser->setOriginals($left, $right);
	}

	$diff = $changeset->getDiff();
	$revision_id = $diff->getRevisionID();

	$can_mark = false;
	$object_owner_phid = null;
	$revision = null;
	if ($revision_id) {
	$revision = id(new DifferentialRevisionQuery())
	->setViewer($viewer)
	->withIDs(array($revision_id))
	->executeOne();
	if ($revision) {
	$can_mark = ($revision->getAuthorPHID() == $viewer->getPHID());
	$object_owner_phid = $revision->getAuthorPHID();
	}
	}

	// Load both left-side and right-side inline comments.
	if ($revision) {
	$query = id(new DifferentialInlineCommentQuery())
	->setViewer($viewer)
	->needHidden(true)
	->withRevisionPHIDs(array($revision->getPHID()));
	$inlines = $query->execute();
	$inlines = $query->adjustInlinesForChangesets(
	$inlines,
	$old,
	$new,
	$revision);
	} else {
	$inlines = array();
	}

	- if ($left_new \|\| $right_new) {
	- $diff_map = array();
	- if ($left) {
	- $diff_map[] = $left->getDiff();
	- }
	- if ($right) {
	- $diff_map[] = $right->getDiff();
	- }
	- $diff_map = mpull($diff_map, null, 'getPHID');
	-
	- $buildables = id(new HarbormasterBuildableQuery())
	- ->setViewer($viewer)
	- ->withBuildablePHIDs(array_keys($diff_map))
	- ->withManualBuildables(false)
	- ->needBuilds(true)
	- ->needTargets(true)
	- ->execute();
	- $buildables = mpull($buildables, null, 'getBuildablePHID');
	- foreach ($diff_map as $diff_phid => $changeset_diff) {
	- $changeset_diff->attachBuildable(idx($buildables, $diff_phid));
	- }
	- }
	-
	if ($left_new) {
	$inlines = array_merge(
	$inlines,
	$this->buildLintInlineComments($left));
	}

	if ($right_new) {
	$inlines = array_merge(
	$inlines,
	$this->buildLintInlineComments($right));
	}

	$phids = array();
	foreach ($inlines as $inline) {
	$parser->parseInlineComment($inline);
	if ($inline->getAuthorPHID()) {
	$phids[$inline->getAuthorPHID()] = true;
	}
	}
	$phids = array_keys($phids);

	$handles = $this->loadViewerHandles($phids);
	$parser->setHandles($handles);

	$engine = new PhabricatorMarkupEngine();
	$engine->setViewer($viewer);

	foreach ($inlines as $inline) {
	$engine->addObject(
	$inline,
	PhabricatorInlineCommentInterface::MARKUP_FIELD_BODY);
	}

	$engine->process();

	$parser
	->setUser($viewer)
	->setMarkupEngine($engine)
	->setShowEditAndReplyLinks(true)
	->setCanMarkDone($can_mark)
	->setObjectOwnerPHID($object_owner_phid)
	->setRange($range_s, $range_e)
	->setMask($mask);

	if ($request->isAjax()) {
	$mcov = $parser->renderModifiedCoverage();

	$coverage = array(
	'differential-mcoverage-'.md5($changeset->getFilename()) => $mcov,
	);

	return id(new PhabricatorChangesetResponse())
	->setRenderedChangeset($parser->renderChangeset())
	->setCoverage($coverage)
	->setUndoTemplates($parser->getRenderer()->renderUndoTemplates());
	}

	$detail = id(new DifferentialChangesetListView())
	->setUser($this->getViewer())
	->setChangesets(array($changeset))
	->setVisibleChangesets(array($changeset))
	->setRenderingReferences(array($rendering_reference))
	->setRenderURI('/differential/changeset/')
	->setDiff($diff)
	->setTitle(pht('Standalone View'))
	->setParser($parser);

	if ($revision_id) {
	$detail->setInlineCommentControllerURI(
	'/differential/comment/inline/edit/'.$revision_id.'/');
	}

	$crumbs = $this->buildApplicationCrumbs();

	if ($revision_id) {
	$crumbs->addTextCrumb('D'.$revision_id, '/D'.$revision_id);
	}

	$diff_id = $diff->getID();
	if ($diff_id) {
	$crumbs->addTextCrumb(
	pht('Diff %d', $diff_id),
	$this->getApplicationURI('diff/'.$diff_id));
	}

	$crumbs->addTextCrumb($changeset->getDisplayFilename());

	return $this->buildApplicationPage(
	array(
	$crumbs,
	$detail,
	),
	array(
	'title' => pht('Changeset View'),
	'device' => false,
	));
	}

	private function buildRawFileResponse(
	DifferentialChangeset $changeset,
	$is_new) {

	$viewer = $this->getViewer();

	if ($is_new) {
	$key = 'raw:new:phid';
	} else {
	$key = 'raw:old:phid';
	}

	$metadata = $changeset->getMetadata();

	$file = null;
	$phid = idx($metadata, $key);
	if ($phid) {
	$file = id(new PhabricatorFileQuery())
	->setViewer($viewer)
	->withPHIDs(array($phid))
	->execute();
	if ($file) {
	$file = head($file);
	}
	}

	if (!$file) {
	// This is just building a cache of the changeset content in the file
	// tool, and is safe to run on a read pathway.
	$unguard = AphrontWriteGuard::beginScopedUnguardedWrites();

	if ($is_new) {
	$data = $changeset->makeNewFile();
	} else {
	$data = $changeset->makeOldFile();
	}

	$file = PhabricatorFile::newFromFileData(
	$data,
	array(
	'name' => $changeset->getFilename(),
	'mime-type' => 'text/plain',
	));

	$metadata[$key] = $file->getPHID();
	$changeset->setMetadata($metadata);
	$changeset->save();

	unset($unguard);
	}

	return $file->getRedirectResponse();
	}

	private function buildLintInlineComments($changeset) {
	$diff = $changeset->getDiff();

	- $buildable = $diff->getBuildable();
	- if (!$buildable) {
	- return array();
	- }
	-
	- $target_phids = array();
	- foreach ($buildable->getBuilds() as $build) {
	- foreach ($build->getBuildTargets() as $target) {
	- $target_phids[] = $target->getPHID();
	- }
	- }
	-
	+ $target_phids = $diff->getBuildTargetPHIDs();
	if (!$target_phids) {
	return array();
	}

	$messages = id(new HarbormasterBuildLintMessage())->loadAllWhere(
	'buildTargetPHID IN (%Ls) AND path = %s',
	$target_phids,
	$changeset->getFilename());

	if (!$messages) {
	return array();
	}

	$template = id(new DifferentialInlineComment())
	->setChangesetID($changeset->getID())
	->setIsNewFile(1)
	->setLineLength(0);

	$inlines = array();
	foreach ($messages as $message) {
	$description = $message->getProperty('description');
	$description = '%%%'.$description.'%%%';

	$inlines[] = id(clone $template)
	->setSyntheticAuthor(pht('Lint: %s', $message->getName()))
	->setLineNumber($message->getLine())
	->setContent($description);
	}

	return $inlines;
	}

	+ private function loadCoverage(DifferentialChangeset $changeset) {
	+ $target_phids = $changeset->getDiff()->getBuildTargetPHIDs();
	+ if (!$target_phids) {
	+ return array();
	+ }
	+
	+ $unit = id(new HarbormasterBuildUnitMessage())->loadAllWhere(
	+ 'buildTargetPHID IN (%Ls)',
	+ $target_phids);
	+
	+ $coverage = array();
	+ foreach ($unit as $message) {
	+ $test_coverage = $message->getProperty('coverage', array());
	+ $coverage_data = idx($test_coverage, $changeset->getFileName());
	+ if (!strlen($coverage_data)) {
	+ continue;
	+ }
	+ $coverage[] = $coverage_data;
	+ }
	+
	+ return ArcanistUnitTestResult::mergeCoverage($coverage);
	+ }
	+
	}
	diff --git a/src/applications/differential/customfield/DifferentialHarbormasterField.php b/src/applications/differential/customfield/DifferentialHarbormasterField.php
	index f84bb74f29..c9b573bda2 100644
	--- a/src/applications/differential/customfield/DifferentialHarbormasterField.php
	+++ b/src/applications/differential/customfield/DifferentialHarbormasterField.php
	@@ -1,107 +1,98 @@
	<?php

	abstract class DifferentialHarbormasterField
	extends DifferentialCustomField {

	abstract protected function getDiffPropertyKeys();
	abstract protected function loadHarbormasterTargetMessages(
	array $target_phids);
	abstract protected function getLegacyProperty();
	abstract protected function newModernMessage(array $message);
	abstract protected function renderHarbormasterStatus(
	DifferentialDiff $diff,
	array $messages);
	abstract protected function newHarbormasterMessageView(array $messages);

	public function renderDiffPropertyViewValue(DifferentialDiff $diff) {
	// TODO: This load is slightly inefficient, but most of this is moving
	// to Harbormaster and this simplifies the transition. Eat 1-2 extra
	// queries for now.
	$keys = $this->getDiffPropertyKeys();

	$properties = id(new DifferentialDiffProperty())->loadAllWhere(
	'diffID = %d AND name IN (%Ls)',
	$diff->getID(),
	$keys);
	$properties = mpull($properties, 'getData', 'getName');

	foreach ($keys as $key) {
	$diff->attachProperty($key, idx($properties, $key));
	}

	- $messages = array();
	-
	- $buildable = $diff->getBuildable();
	- if ($buildable) {
	- $target_phids = array();
	- foreach ($buildable->getBuilds() as $build) {
	- foreach ($build->getBuildTargets() as $target) {
	- $target_phids[] = $target->getPHID();
	- }
	- }
	-
	- if ($target_phids) {
	- $messages = $this->loadHarbormasterTargetMessages($target_phids);
	- }
	+ $target_phids = $diff->getBuildTargetPHIDs();
	+ if ($target_phids) {
	+ $messages = $this->loadHarbormasterTargetMessages($target_phids);
	+ } else {
	+ $messages = array();
	}

	if (!$messages) {
	// No Harbormaster messages, so look for legacy messages and make them
	// look like modern messages.
	$legacy_messages = $diff->getProperty($this->getLegacyProperty());
	if ($legacy_messages) {
	// Show the top 100 legacy lint messages. Previously, we showed some
	// by default and let the user toggle the rest. With modern messages,
	// we can send the user to the Harbormaster detail page. Just show
	// "a lot" of messages in legacy cases to try to strike a balance
	// between implementation simplicitly and compatibility.
	$legacy_messages = array_slice($legacy_messages, 0, 100);

	foreach ($legacy_messages as $message) {
	try {
	$modern = $this->newModernMessage($message);
	$messages[] = $modern;
	} catch (Exception $ex) {
	// Ignore any poorly formatted messages.
	}
	}
	}
	}

	$status = $this->renderHarbormasterStatus($diff, $messages);

	if ($messages) {
	$path_map = mpull($diff->loadChangesets(), 'getID', 'getFilename');
	foreach ($path_map as $path => $id) {
	$href = '#C'.$id.'NL';

	// TODO: When the diff is not the right-hand-size diff, we should
	// ideally adjust this URI to be absolute.

	$path_map[$path] = $href;
	}

	$view = $this->newHarbormasterMessageView($messages);
	if ($view) {
	$view->setPathURIMap($path_map);
	}
	} else {
	$view = null;
	}

	if ($view) {
	$view = phutil_tag(
	'div',
	array(
	'class' => 'differential-harbormaster-table-view',
	),
	$view);
	}

	return array(
	$status,
	$view,
	);
	}

	}
	diff --git a/src/applications/differential/storage/DifferentialDiff.php b/src/applications/differential/storage/DifferentialDiff.php
	index 4a0e63d5a7..e30a401306 100644
	--- a/src/applications/differential/storage/DifferentialDiff.php
	+++ b/src/applications/differential/storage/DifferentialDiff.php
	@@ -1,469 +1,485 @@
	<?php

	final class DifferentialDiff
	extends DifferentialDAO
	implements
	PhabricatorPolicyInterface,
	HarbormasterBuildableInterface,
	PhabricatorApplicationTransactionInterface,
	PhabricatorDestructibleInterface {

	protected $revisionID;
	protected $authorPHID;
	protected $repositoryPHID;

	protected $sourceMachine;
	protected $sourcePath;

	protected $sourceControlSystem;
	protected $sourceControlBaseRevision;
	protected $sourceControlPath;

	protected $lintStatus;
	protected $unitStatus;

	protected $lineCount;

	protected $branch;
	protected $bookmark;

	protected $creationMethod;
	protected $repositoryUUID;

	protected $description;

	protected $viewPolicy;

	private $unsavedChangesets = array();
	private $changesets = self::ATTACHABLE;
	private $revision = self::ATTACHABLE;
	private $properties = array();
	private $buildable = self::ATTACHABLE;

	protected function getConfiguration() {
	return array(
	self::CONFIG_AUX_PHID => true,
	self::CONFIG_COLUMN_SCHEMA => array(
	'revisionID' => 'id?',
	'authorPHID' => 'phid?',
	'repositoryPHID' => 'phid?',
	'sourceMachine' => 'text255?',
	'sourcePath' => 'text255?',
	'sourceControlSystem' => 'text64?',
	'sourceControlBaseRevision' => 'text255?',
	'sourceControlPath' => 'text255?',
	'lintStatus' => 'uint32',
	'unitStatus' => 'uint32',
	'lineCount' => 'uint32',
	'branch' => 'text255?',
	'bookmark' => 'text255?',
	'repositoryUUID' => 'text64?',

	// T6203/NULLABILITY
	// These should be non-null; all diffs should have a creation method
	// and the description should just be empty.
	'creationMethod' => 'text255?',
	'description' => 'text255?',
	),
	self::CONFIG_KEY_SCHEMA => array(
	'revisionID' => array(
	'columns' => array('revisionID'),
	),
	),
	) + parent::getConfiguration();
	}

	public function generatePHID() {
	return PhabricatorPHID::generateNewPHID(
	DifferentialDiffPHIDType::TYPECONST);
	}

	public function addUnsavedChangeset(DifferentialChangeset $changeset) {
	if ($this->changesets === null) {
	$this->changesets = array();
	}
	$this->unsavedChangesets[] = $changeset;
	$this->changesets[] = $changeset;
	return $this;
	}

	public function attachChangesets(array $changesets) {
	assert_instances_of($changesets, 'DifferentialChangeset');
	$this->changesets = $changesets;
	return $this;
	}

	public function getChangesets() {
	return $this->assertAttached($this->changesets);
	}

	public function loadChangesets() {
	if (!$this->getID()) {
	return array();
	}
	return id(new DifferentialChangeset())->loadAllWhere(
	'diffID = %d',
	$this->getID());
	}

	public function save() {
	$this->openTransaction();
	$ret = parent::save();
	foreach ($this->unsavedChangesets as $changeset) {
	$changeset->setDiffID($this->getID());
	$changeset->save();
	}
	$this->saveTransaction();
	return $ret;
	}

	public static function initializeNewDiff(PhabricatorUser $actor) {
	$app = id(new PhabricatorApplicationQuery())
	->setViewer($actor)
	->withClasses(array('PhabricatorDifferentialApplication'))
	->executeOne();
	$view_policy = $app->getPolicy(
	DifferentialDefaultViewCapability::CAPABILITY);

	$diff = id(new DifferentialDiff())
	->setViewPolicy($view_policy);

	return $diff;
	}

	public static function newFromRawChanges(
	PhabricatorUser $actor,
	array $changes) {

	assert_instances_of($changes, 'ArcanistDiffChange');

	$diff = self::initializeNewDiff($actor);
	return self::buildChangesetsFromRawChanges($diff, $changes);
	}

	public static function newEphemeralFromRawChanges(array $changes) {
	assert_instances_of($changes, 'ArcanistDiffChange');

	$diff = id(new DifferentialDiff())->makeEphemeral();
	return self::buildChangesetsFromRawChanges($diff, $changes);
	}

	private static function buildChangesetsFromRawChanges(
	DifferentialDiff $diff,
	array $changes) {

	// There may not be any changes; initialize the changesets list so that
	// we don't throw later when accessing it.
	$diff->attachChangesets(array());

	$lines = 0;
	foreach ($changes as $change) {
	if ($change->getType() == ArcanistDiffChangeType::TYPE_MESSAGE) {
	// If a user pastes a diff into Differential which includes a commit
	// message (e.g., they ran `git show` to generate it), discard that
	// change when constructing a DifferentialDiff.
	continue;
	}

	$changeset = new DifferentialChangeset();
	$add_lines = 0;
	$del_lines = 0;
	$first_line = PHP_INT_MAX;
	$hunks = $change->getHunks();
	if ($hunks) {
	foreach ($hunks as $hunk) {
	$dhunk = new DifferentialModernHunk();
	$dhunk->setOldOffset($hunk->getOldOffset());
	$dhunk->setOldLen($hunk->getOldLength());
	$dhunk->setNewOffset($hunk->getNewOffset());
	$dhunk->setNewLen($hunk->getNewLength());
	$dhunk->setChanges($hunk->getCorpus());
	$changeset->addUnsavedHunk($dhunk);
	$add_lines += $hunk->getAddLines();
	$del_lines += $hunk->getDelLines();
	$added_lines = $hunk->getChangedLines('new');
	if ($added_lines) {
	$first_line = min($first_line, head_key($added_lines));
	}
	}
	$lines += $add_lines + $del_lines;
	} else {
	// This happens when you add empty files.
	$changeset->attachHunks(array());
	}

	$metadata = $change->getAllMetadata();
	if ($first_line != PHP_INT_MAX) {
	$metadata['line:first'] = $first_line;
	}

	$changeset->setOldFile($change->getOldPath());
	$changeset->setFilename($change->getCurrentPath());
	$changeset->setChangeType($change->getType());

	$changeset->setFileType($change->getFileType());
	$changeset->setMetadata($metadata);
	$changeset->setOldProperties($change->getOldProperties());
	$changeset->setNewProperties($change->getNewProperties());
	$changeset->setAwayPaths($change->getAwayPaths());
	$changeset->setAddLines($add_lines);
	$changeset->setDelLines($del_lines);

	$diff->addUnsavedChangeset($changeset);
	}
	$diff->setLineCount($lines);

	$parser = new DifferentialChangesetParser();
	$changesets = $parser->detectCopiedCode(
	$diff->getChangesets(),
	$min_width = 30,
	$min_lines = 3);
	$diff->attachChangesets($changesets);

	return $diff;
	}


	public function getDiffDict() {
	$dict = array(
	'id' => $this->getID(),
	'revisionID' => $this->getRevisionID(),
	'dateCreated' => $this->getDateCreated(),
	'dateModified' => $this->getDateModified(),
	'sourceControlBaseRevision' => $this->getSourceControlBaseRevision(),
	'sourceControlPath' => $this->getSourceControlPath(),
	'sourceControlSystem' => $this->getSourceControlSystem(),
	'branch' => $this->getBranch(),
	'bookmark' => $this->getBookmark(),
	'creationMethod' => $this->getCreationMethod(),
	'description' => $this->getDescription(),
	'unitStatus' => $this->getUnitStatus(),
	'lintStatus' => $this->getLintStatus(),
	'changes' => array(),
	'properties' => array(),
	);

	$dict['changes'] = $this->buildChangesList();

	$properties = id(new DifferentialDiffProperty())->loadAllWhere(
	'diffID = %d',
	$this->getID());
	foreach ($properties as $property) {
	$dict['properties'][$property->getName()] = $property->getData();

	if ($property->getName() == 'local:commits') {
	foreach ($property->getData() as $commit) {
	$dict['authorName'] = $commit['author'];
	$dict['authorEmail'] = idx($commit, 'authorEmail');
	break;
	}
	}
	}

	return $dict;
	}

	public function buildChangesList() {
	$changes = array();
	foreach ($this->getChangesets() as $changeset) {
	$hunks = array();
	foreach ($changeset->getHunks() as $hunk) {
	$hunks[] = array(
	'oldOffset' => $hunk->getOldOffset(),
	'newOffset' => $hunk->getNewOffset(),
	'oldLength' => $hunk->getOldLen(),
	'newLength' => $hunk->getNewLen(),
	'addLines' => null,
	'delLines' => null,
	'isMissingOldNewline' => null,
	'isMissingNewNewline' => null,
	'corpus' => $hunk->getChanges(),
	);
	}
	$change = array(
	'id' => $changeset->getID(),
	'metadata' => $changeset->getMetadata(),
	'oldPath' => $changeset->getOldFile(),
	'currentPath' => $changeset->getFilename(),
	'awayPaths' => $changeset->getAwayPaths(),
	'oldProperties' => $changeset->getOldProperties(),
	'newProperties' => $changeset->getNewProperties(),
	'type' => $changeset->getChangeType(),
	'fileType' => $changeset->getFileType(),
	'commitHash' => null,
	'addLines' => $changeset->getAddLines(),
	'delLines' => $changeset->getDelLines(),
	'hunks' => $hunks,
	);
	$changes[] = $change;
	}
	return $changes;
	}

	public function hasRevision() {
	return $this->revision !== self::ATTACHABLE;
	}

	public function getRevision() {
	return $this->assertAttached($this->revision);
	}

	public function attachRevision(DifferentialRevision $revision = null) {
	$this->revision = $revision;
	return $this;
	}

	public function attachProperty($key, $value) {
	$this->properties[$key] = $value;
	return $this;
	}

	public function getProperty($key) {
	return $this->assertAttachedKey($this->properties, $key);
	}

	public function attachBuildable(HarbormasterBuildable $buildable = null) {
	$this->buildable = $buildable;
	return $this;
	}

	public function getBuildable() {
	return $this->assertAttached($this->buildable);
	}

	+ public function getBuildTargetPHIDs() {
	+ $buildable = $this->getBuildable();
	+
	+ if (!$buildable) {
	+ return array();
	+ }
	+
	+ $target_phids = array();
	+ foreach ($buildable->getBuilds() as $build) {
	+ foreach ($build->getBuildTargets() as $target) {
	+ $target_phids[] = $target->getPHID();
	+ }
	+ }
	+
	+ return $target_phids;
	+ }

	/* -( PhabricatorPolicyInterface )----------------------------------------- */


	public function getCapabilities() {
	return array(
	PhabricatorPolicyCapability::CAN_VIEW,
	);
	}

	public function getPolicy($capability) {
	if ($this->hasRevision()) {
	return $this->getRevision()->getPolicy($capability);
	}

	return $this->viewPolicy;
	}

	public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
	if ($this->hasRevision()) {
	return $this->getRevision()->hasAutomaticCapability($capability, $viewer);
	}

	return ($this->getAuthorPHID() == $viewer->getPhid());
	}

	public function describeAutomaticCapability($capability) {
	if ($this->hasRevision()) {
	return pht(
	'This diff is attached to a revision, and inherits its policies.');
	}
	return pht('The author of a diff can see it.');
	}



	/* -( HarbormasterBuildableInterface )------------------------------------- */


	public function getHarbormasterBuildablePHID() {
	return $this->getPHID();
	}

	public function getHarbormasterContainerPHID() {
	if ($this->getRevisionID()) {
	$revision = id(new DifferentialRevision())->load($this->getRevisionID());
	if ($revision) {
	return $revision->getPHID();
	}
	}

	return null;
	}

	public function getBuildVariables() {
	$results = array();

	$results['buildable.diff'] = $this->getID();
	if ($this->revisionID) {
	$revision = $this->getRevision();
	$results['buildable.revision'] = $revision->getID();
	$repo = $revision->getRepository();

	if ($repo) {
	$results['repository.callsign'] = $repo->getCallsign();
	$results['repository.vcs'] = $repo->getVersionControlSystem();
	$results['repository.uri'] = $repo->getPublicCloneURI();
	}
	}

	return $results;
	}

	public function getAvailableBuildVariables() {
	return array(
	'buildable.diff' =>
	pht('The differential diff ID, if applicable.'),
	'buildable.revision' =>
	pht('The differential revision ID, if applicable.'),
	'repository.callsign' =>
	pht('The callsign of the repository in Phabricator.'),
	'repository.vcs' =>
	pht('The version control system, either "svn", "hg" or "git".'),
	'repository.uri' =>
	pht('The URI to clone or checkout the repository from.'),
	);
	}


	/* -( PhabricatorApplicationTransactionInterface )------------------------- */


	public function getApplicationTransactionEditor() {
	return new DifferentialDiffEditor();
	}

	public function getApplicationTransactionObject() {
	return $this;
	}

	public function getApplicationTransactionTemplate() {
	return new DifferentialDiffTransaction();
	}

	public function willRenderTimeline(
	PhabricatorApplicationTransactionView $timeline,
	AphrontRequest $request) {

	return $timeline;
	}


	/* -( PhabricatorDestructibleInterface )----------------------------------- */


	public function destroyObjectPermanently(
	PhabricatorDestructionEngine $engine) {

	$this->openTransaction();
	$this->delete();

	foreach ($this->loadChangesets() as $changeset) {
	$changeset->delete();
	}

	$properties = id(new DifferentialDiffProperty())->loadAllWhere(
	'diffID = %d',
	$this->getID());
	foreach ($properties as $prop) {
	$prop->delete();
	}

	$this->saveTransaction();
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Wed, Feb 4, 5:41 AM (1 d, 22 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 738906
Default Alt Text: (31 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions