Wikibase\DataModel\Services\Diff\EntityDiff

Complexity

Total Complexity

16

Size/Duplication

Total Lines	122
Duplicated Lines	0 %

Test Coverage

Coverage

65.79%

Importance

Changes	1
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	getType()	0	2	1
A	fixSubstructureDiff()	0	20	4
A	newForType()	0	5	2
A	getAliasesDiff()	0	2	1
A	__construct()	0	7	1
A	isEmpty()	0	5	4
A	getDescriptionsDiff()	0	2	1
A	getLabelsDiff()	0	2	1
A	getClaimsDiff()	0	2	1

<?php

namespace Wikibase\DataModel\Services\Diff;

use Diff\DiffOp\Diff\Diff;
use Diff\DiffOp\DiffOp;
use Wikibase\DataModel\Entity\Item;

/**
 * Represents a diff between two entities.
 *
 * @since 1.0
 *
 * @license GPL-2.0-or-later
 * @author Jeroen De Dauw < jeroendedauw@gmail.com >
 */
class EntityDiff extends Diff {

	/**
	 * @param string $entityType
	 * @param DiffOp[] $operations
	 *
	 * @return self
	 */
	public static function newForType( $entityType, array $operations = [] ) {
		if ( $entityType === Item::ENTITY_TYPE ) {
			return new ItemDiff( $operations );
		} else {
			return new self( $operations );
		}
	}

	/**
	 * @param DiffOp[] $operations
	 */
	public function __construct( array $operations = [] ) {
		$this->fixSubstructureDiff( $operations, 'aliases' );
		$this->fixSubstructureDiff( $operations, 'label' );
		$this->fixSubstructureDiff( $operations, 'description' );
		$this->fixSubstructureDiff( $operations, 'claim' );

		parent::__construct( $operations, true );
	}

	/**
	 * Checks the type of a substructure diff, and replaces it if needed.
	 * This is needed for backwards compatibility with old versions of
	 * MapDiffer: As of commit ff65735a125e, MapDiffer may generate atomic diffs for
	 * substructures even in recursive mode (bug 51363).
	 *
	 * @param array &$operations All change ops; This is a reference, so the
	 *        substructure diff can be replaced if need be.
	 * @param string $key The key of the substructure
	 */
	protected function fixSubstructureDiff( array &$operations, $key ) {
		if ( !isset( $operations[$key] ) ) {
			return;
		}

		if ( !( $operations[$key] instanceof Diff ) ) {
			$warning = "Invalid substructure diff for key $key: " . get_class( $operations[$key] );

			if ( function_exists( 'wfLogWarning' ) ) {
				wfLogWarning( $warning );
			} else {
				trigger_error( $warning, E_USER_WARNING );
			}

			// We could look into the atomic diff, see if it uses arrays as values,
			// and construct a new Diff according to these values. But since the
			// actual old behavior of MapDiffer didn't cause that to happen, let's
			// just use an empty diff, which is what MapDiffer should have returned
			// in the actual broken case mentioned in bug 51363.
			$operations[$key] = new Diff( [], true );
		}
	}

	/**
	 * FIXME: Not all entities do have aliases!
	 *
	 * Returns a Diff object with the aliases differences.
	 *
	 * @return Diff
	 */
	public function getAliasesDiff() {
		return $this['aliases'] ?? new Diff( [], true );
	}

	/**
	 * FIXME: Not all entities do have labels!
	 *
	 * Returns a Diff object with the labels differences.
	 *
	 * @return Diff
	 */
	public function getLabelsDiff() {
		return $this['label'] ?? new Diff( [], true );
	}

	/**
	 * FIXME: Not all entities do have descriptions!
	 *
	 * Returns a Diff object with the descriptions differences.
	 *
	 * @return Diff
	 */
	public function getDescriptionsDiff() {
		return $this['description'] ?? new Diff( [], true );
	}

	/**
	 * FIXME: Not all entities do have claims a.k.a. statements!
	 *
	 * Returns a Diff object with the claim differences.
	 *
	 * @return Diff
	 */
	public function getClaimsDiff() {
		return $this['claim'] ?? new Diff( [], true );
	}

	/**
	 * Returns if there are any changes (equivalent to: any differences between the entities).
	 */
	public function isEmpty(): bool {
		return $this->getLabelsDiff()->isEmpty()
			&& $this->getDescriptionsDiff()->isEmpty()
			&& $this->getAliasesDiff()->isEmpty()
			&& $this->getClaimsDiff()->isEmpty();
	}

	/**
	 * @see DiffOp::getType
	 *
	 * @return string
	 */
	public function getType(): string {
		return 'diff/entity';
	}

}