DifferentialHunk.php
db61eb20f0f0master

DifferentialHunk.php
View Options

			<?php

			final class DifferentialHunk
			extends DifferentialDAO
			implements
			PhabricatorPolicyInterface,
			PhabricatorDestructibleInterface {

			protected $changesetID;
			protected $oldOffset;
			protected $oldLen;
			protected $newOffset;
			protected $newLen;
			protected $dataType;
			protected $dataEncoding;
			protected $dataFormat;
			protected $data;

			private $changeset;
			private $splitLines;
			private $structuredLines;
			private $structuredFiles = array();

			private $rawData;
			private $forcedEncoding;
			private $fileData;

			const FLAG_LINES_ADDED = 1;
			const FLAG_LINES_REMOVED = 2;
			const FLAG_LINES_STABLE = 4;

			const DATATYPE_TEXT = 'text';
			const DATATYPE_FILE = 'file';

			const DATAFORMAT_RAW = 'byte';
			const DATAFORMAT_DEFLATED = 'gzde';

			protected function getConfiguration() {
			return array(
			self::CONFIG_BINARY => array(
			'data' => true,
			),
			self::CONFIG_COLUMN_SCHEMA => array(
			'dataType' => 'bytes4',
			'dataEncoding' => 'text16?',
			'dataFormat' => 'bytes4',
			'oldOffset' => 'uint32',
			'oldLen' => 'uint32',
			'newOffset' => 'uint32',
			'newLen' => 'uint32',
			),
			self::CONFIG_KEY_SCHEMA => array(
			'key_changeset' => array(
			'columns' => array('changesetID'),
			),
			'key_created' => array(
			'columns' => array('dateCreated'),
			),
			),
			) + parent::getConfiguration();
			}

			public function getAddedLines() {
			return $this->makeContent($include = '+');
			}

			public function getRemovedLines() {
			return $this->makeContent($include = '-');
			}

			public function makeNewFile() {
			return implode('', $this->makeContent($include = ' +'));
			}

			public function makeOldFile() {
			return implode('', $this->makeContent($include = ' -'));
			}

			public function makeChanges() {
			return implode('', $this->makeContent($include = '-+'));
			}

			public function getStructuredOldFile() {
			return $this->getStructuredFile('-');
			}

			public function getStructuredNewFile() {
			return $this->getStructuredFile('+');
			}

			private function getStructuredFile($kind) {
			if ($kind !== '+' && $kind !== '-') {
			throw new Exception(
			pht(
			'Structured file kind should be "+" or "-", got "%s".',
			$kind));
			}

			if (!isset($this->structuredFiles[$kind])) {
			if ($kind == '+') {
			$number = $this->newOffset;
			} else {
			$number = $this->oldOffset;
			}

			$lines = $this->getStructuredLines();

			// NOTE: We keep the "\ No newline at end of file" line if it appears
			// after a line which is not excluded. For example, if we're constructing
			// the "+" side of the diff, we want to ignore this one since it's
			// relevant only to the "-" side of the diff:
			//
			// - x
			// \ No newline at end of file
			// + x
			//
			// ...but we want to keep this one:
			//
			// - x
			// + x
			// \ No newline at end of file

			$file = array();
			$keep = true;
			foreach ($lines as $line) {
			switch ($line['type']) {
			case ' ':
			case $kind:
			$file[$number++] = $line;
			$keep = true;
			break;
			case '\\':
			if ($keep) {
			// Strip the actual newline off the line's text.
			$text = $file[$number - 1]['text'];
			$text = rtrim($text, "\r\n");
			$file[$number - 1]['text'] = $text;

			$file[$number++] = $line;
			$keep = false;
			}
			break;
			default:
			$keep = false;
			break;
			}
			}

			$this->structuredFiles[$kind] = $file;
			}

			return $this->structuredFiles[$kind];
			}

			public function getSplitLines() {
			if ($this->splitLines === null) {
			$this->splitLines = phutil_split_lines($this->getChanges());
			}
			return $this->splitLines;
			}

			public function getStructuredLines() {
			if ($this->structuredLines === null) {
			$lines = $this->getSplitLines();

			$structured = array();
			foreach ($lines as $line) {
			if (empty($line[0])) {
			// TODO: Can we just get rid of this?
			continue;
			}

			$structured[] = array(
			'type' => $line[0],
			'text' => substr($line, 1),
			);
			}

			$this->structuredLines = $structured;
			}

			return $this->structuredLines;
			}


			public function getContentWithMask($mask) {
			$include = array();

			if (($mask & self::FLAG_LINES_ADDED)) {
			$include[] = '+';
			}

			if (($mask & self::FLAG_LINES_REMOVED)) {
			$include[] = '-';
			}

			if (($mask & self::FLAG_LINES_STABLE)) {
			$include[] = ' ';
			}

			$include = implode('', $include);

			return implode('', $this->makeContent($include));
			}

			private function makeContent($include) {
			$lines = $this->getSplitLines();
			$results = array();

			$include_map = array();
			for ($ii = 0; $ii < strlen($include); $ii++) {
			$include_map[$include[$ii]] = true;
			}

			if (isset($include_map['+'])) {
			$n = $this->newOffset;
			} else {
			$n = $this->oldOffset;
			}

			$use_next_newline = false;
			foreach ($lines as $line) {
			if (!isset($line[0])) {
			continue;
			}

			if ($line[0] == '\\') {
			if ($use_next_newline) {
			$results[last_key($results)] = rtrim(end($results), "\n");
			}
			} else if (empty($include_map[$line[0]])) {
			$use_next_newline = false;
			} else {
			$use_next_newline = true;
			$results[$n] = substr($line, 1);
			}

			if ($line[0] == ' ' \|\| isset($include_map[$line[0]])) {
			$n++;
			}
			}

			return $results;
			}

			public function getChangeset() {
			return $this->assertAttached($this->changeset);
			}

			public function attachChangeset(DifferentialChangeset $changeset) {
			$this->changeset = $changeset;
			return $this;
			}


			/* -( Storage )------------------------------------------------------------ */


			public function setChanges($text) {
			$this->rawData = $text;

			$this->dataEncoding = $this->detectEncodingForStorage($text);
			$this->dataType = self::DATATYPE_TEXT;

			list($format, $data) = $this->formatDataForStorage($text);

			$this->dataFormat = $format;
			$this->data = $data;

			return $this;
			}

			public function getChanges() {
			return $this->getUTF8StringFromStorage(
			$this->getRawData(),
			nonempty($this->forcedEncoding, $this->getDataEncoding()));
			}

			public function forceEncoding($encoding) {
			$this->forcedEncoding = $encoding;
			return $this;
			}

			private function formatDataForStorage($data) {
			$deflated = PhabricatorCaches::maybeDeflateData($data);
			if ($deflated !== null) {
			return array(self::DATAFORMAT_DEFLATED, $deflated);
			}

			return array(self::DATAFORMAT_RAW, $data);
			}

			public function getAutomaticDataFormat() {
			// If the hunk is already stored deflated, just keep it deflated. This is
			// mostly a performance improvement for "bin/differential migrate-hunk" so
			// that we don't have to recompress all the stored hunks when looking for
			// stray uncompressed hunks.
			if ($this->dataFormat === self::DATAFORMAT_DEFLATED) {
			return self::DATAFORMAT_DEFLATED;
			}

			list($format) = $this->formatDataForStorage($this->getRawData());

			return $format;
			}

			public function saveAsText() {
			$old_type = $this->getDataType();
			$old_data = $this->getData();

			$raw_data = $this->getRawData();

			$this->setDataType(self::DATATYPE_TEXT);

			list($format, $data) = $this->formatDataForStorage($raw_data);
			$this->setDataFormat($format);
			$this->setData($data);

			$result = $this->save();

			$this->destroyData($old_type, $old_data);

			return $result;
			}

			public function saveAsFile() {
			$old_type = $this->getDataType();
			$old_data = $this->getData();

			$raw_data = $this->getRawData();

			list($format, $data) = $this->formatDataForStorage($raw_data);
			$this->setDataFormat($format);

			$file = PhabricatorFile::newFromFileData(
			$data,
			array(
			'name' => 'differential-hunk',
			'mime-type' => 'application/octet-stream',
			'viewPolicy' => PhabricatorPolicies::POLICY_NOONE,
			));

			$this->setDataType(self::DATATYPE_FILE);
			$this->setData($file->getPHID());

			// NOTE: Because hunks don't have a PHID and we just load hunk data with
			// the omnipotent viewer, we do not need to attach the file to anything.

			$result = $this->save();

			$this->destroyData($old_type, $old_data);

			return $result;
			}

			private function getRawData() {
			if ($this->rawData === null) {
			$type = $this->getDataType();
			$data = $this->getData();

			switch ($type) {
			case self::DATATYPE_TEXT:
			// In this storage type, the changes are stored on the object.
			$data = $data;
			break;
			case self::DATATYPE_FILE:
			$data = $this->loadFileData();
			break;
			default:
			throw new Exception(
			pht('Hunk has unsupported data type "%s"!', $type));
			}

			$format = $this->getDataFormat();
			switch ($format) {
			case self::DATAFORMAT_RAW:
			// In this format, the changes are stored as-is.
			$data = $data;
			break;
			case self::DATAFORMAT_DEFLATED:
			$data = PhabricatorCaches::inflateData($data);
			break;
			default:
			throw new Exception(
			pht('Hunk has unsupported data encoding "%s"!', $type));
			}

			$this->rawData = $data;
			}

			return $this->rawData;
			}

			private function loadFileData() {
			if ($this->fileData === null) {
			$type = $this->getDataType();
			if ($type !== self::DATATYPE_FILE) {
			throw new Exception(
			pht(
			'Unable to load file data for hunk with wrong data type ("%s").',
			$type));
			}

			$file_phid = $this->getData();

			$file = $this->loadRawFile($file_phid);
			$data = $file->loadFileData();

			$this->fileData = $data;
			}

			return $this->fileData;
			}

			private function loadRawFile($file_phid) {
			$viewer = PhabricatorUser::getOmnipotentUser();


			$files = id(new PhabricatorFileQuery())
			->setViewer($viewer)
			->withPHIDs(array($file_phid))
			->execute();
			if (!$files) {
			throw new Exception(
			pht(
			'Failed to load file ("%s") with hunk data.',
			$file_phid));
			}

			$file = head($files);

			return $file;
			}

			private function destroyData(
			$type,
			$data,
			?PhabricatorDestructionEngine $engine = null) {

			if (!$engine) {
			$engine = new PhabricatorDestructionEngine();
			}

			switch ($type) {
			case self::DATATYPE_FILE:
			$file = $this->loadRawFile($data);
			$engine->destroyObject($file);
			break;
			}
			}


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


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

			public function getPolicy($capability) {
			return $this->getChangeset()->getPolicy($capability);
			}

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


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


			public function destroyObjectPermanently(
			PhabricatorDestructionEngine $engine) {

			$type = $this->getDataType();
			$data = $this->getData();

			$this->destroyData($type, $data, $engine);

			$this->delete();
			}

			}

Owner Packages

No Owners

phorge/src/applications/differential/storage/DifferentialHunk.phpdb61eb20f0f0master

DifferentialHunk.phpView Options

Owner Packages

phorge/src/applications/differential/storage/DifferentialHunk.php
db61eb20f0f0master

DifferentialHunk.php
View Options