CheckResultDeserializer::deserialize() - Code Metrics - Inspection of "Localisation updates from https://translatewiki.ne..." - wikimedia/mediawiki-extensions-WikibaseQualityConstraints - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( f2f357...ccb861 )

unknown

created 2018-06-24 20:31 UTC

CheckResultDeserializer::deserialize() A

↳ Parent: CheckResultDeserializer

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	41
rs	9.264
c	0
b	0
f	0
cc	2
nc	2
nop	1

<?php

namespace WikibaseQuality\ConstraintReport\ConstraintCheck\Result;

use DataValues\TimeValue;
use Wikibase\DataModel\Entity\EntityIdParser;
use WikibaseQuality\ConstraintReport\ConstraintCheck\Cache\CachingMetadata;
use WikibaseQuality\ConstraintReport\ConstraintCheck\Cache\DependencyMetadata;
use WikibaseQuality\ConstraintReport\ConstraintCheck\Cache\Metadata;
use WikibaseQuality\ConstraintReport\ConstraintCheck\Context\ContextCursorDeserializer;
use WikibaseQuality\ConstraintReport\ConstraintCheck\Message\ViolationMessage;
use WikibaseQuality\ConstraintReport\ConstraintCheck\Message\ViolationMessageDeserializer;
use WikibaseQuality\ConstraintReport\ConstraintDeserializer;

/**
 * A deserializer for {@link CheckResult}s.
 *
 * @author Lucas Werkmeister
 * @license GPL-2.0-or-later
 */
class CheckResultDeserializer {

	/**
	 * @var ConstraintDeserializer
	 */
	private $constraintDeserializer;

	/**
	 * @var ContextCursorDeserializer
	 */
	private $contextCursorDeserializer;

	/**
	 * @var ViolationMessageDeserializer
	 */
	private $violationMessageDeserializer;

	/**
	 * @var EntityIdParser
	 */
	private $entityIdParser;

	public function __construct(
		ConstraintDeserializer $constraintDeserializer,
		ContextCursorDeserializer $contextCursorDeserializer,
		ViolationMessageDeserializer $violationMessageDeserializer,
		EntityIdParser $entityIdParser
	) {
		$this->constraintDeserializer = $constraintDeserializer;
		$this->contextCursorDeserializer = $contextCursorDeserializer;
		$this->violationMessageDeserializer = $violationMessageDeserializer;
		$this->entityIdParser = $entityIdParser;
	}

	/**
	 * @param array $serialization
	 * @return CheckResult
	 */
	public function deserialize( array $serialization ) {
		$contextCursor = $this->contextCursorDeserializer->deserialize(
			$serialization[CheckResultSerializer::KEY_CONTEXT_CURSOR]
		);

		if ( array_key_exists( CheckResultSerializer::KEY_NULL_RESULT, $serialization ) ) {
			$result = new NullResult( $contextCursor );
			$cachingMetadata = CachingMetadata::fresh();
		} else {
			$constraint = $this->constraintDeserializer->deserialize(
				$serialization[CheckResultSerializer::KEY_CONSTRAINT]
			);

			$parameters = []; // serialization of parameters not supported yet

			$status = $serialization[CheckResultSerializer::KEY_CHECK_RESULT_STATUS];

			$violationMessage = $this->getViolationMessageFromSerialization( $serialization );

			$result = new CheckResult(
				$contextCursor,
				$constraint,
				$parameters,
				$status,
				$violationMessage
			);

			$cachingMetadata = $this->deserializeCachingMetadata(
				$serialization[CheckResultSerializer::KEY_CACHING_METADATA]
			);
		}

		$dependencyMetadata = $this->getDependencyMetadataFromSerialization( $serialization );

		return $result->withMetadata(
			Metadata::merge( [
				Metadata::ofCachingMetadata( $cachingMetadata ),
				Metadata::ofDependencyMetadata( $dependencyMetadata ),
			] )
		);
	}

	/**
	 * @param array $serialization
	 * @return null|ViolationMessage
	 */
	private function getViolationMessageFromSerialization( array $serialization ) {
		if ( array_key_exists( CheckResultSerializer::KEY_VIOLATION_MESSAGE, $serialization ) ) {
			return $this->violationMessageDeserializer->deserialize(
				$serialization[CheckResultSerializer::KEY_VIOLATION_MESSAGE]
			);
		} else {
			return null;
		}
	}

	/**
	 * @param array $serialization
	 * @return DependencyMetadata
	 */
	private function getDependencyMetadataFromSerialization( array $serialization ) {
		if ( array_key_exists( CheckResultSerializer::KEY_DEPENDENCY_METADATA, $serialization ) ) {
			return $this->deserializeDependencyMetadata(
				$serialization[CheckResultSerializer::KEY_DEPENDENCY_METADATA]
			);
		} else {
			return DependencyMetadata::blank();
		}
	}

	/**
	 * @param array $serialization
	 * @return CachingMetadata
	 */
	private function deserializeCachingMetadata( array $serialization ) {
		if (
			array_key_exists(
				CheckResultSerializer::KEY_CACHING_METADATA_MAX_AGE,
				$serialization
			)
		) {
			return CachingMetadata::ofMaximumAgeInSeconds(
				$serialization[CheckResultSerializer::KEY_CACHING_METADATA_MAX_AGE]
			);
		} else {
			return CachingMetadata::fresh();
		}
	}

	/**
	 * @param array $serialization
	 * @return DependencyMetadata
	 */
	private function deserializeDependencyMetadata( array $serialization ) {
		if (
			array_key_exists(
				CheckResultSerializer::KEY_DEPENDENCY_METADATA_FUTURE_TIME,
				$serialization
			)
		) {
			$futureTime = TimeValue::newFromArray(
				$serialization[CheckResultSerializer::KEY_DEPENDENCY_METADATA_FUTURE_TIME]
			);
			$futureTimeDependencyMetadata = DependencyMetadata::ofFutureTime( $futureTime );
		} else {
			$futureTimeDependencyMetadata = DependencyMetadata::blank();
		}

		$dependencyMetadata = array_reduce(
			$serialization[CheckResultSerializer::KEY_DEPENDENCY_METADATA_ENTITY_IDS],
			function ( DependencyMetadata $metadata, $entityIdSerialization ) {
				$entityId = $this->entityIdParser->parse( $entityIdSerialization );

				return DependencyMetadata::merge( [
					$metadata,
					DependencyMetadata::ofEntityId( $entityId )
				] );
			},
			$futureTimeDependencyMetadata
		);

		return $dependencyMetadata;
	}

}


1			<?php
2
3			namespace WikibaseQuality\ConstraintReport\ConstraintCheck\Result;
4
5			use DataValues\TimeValue;
6			use Wikibase\DataModel\Entity\EntityIdParser;
7			use WikibaseQuality\ConstraintReport\ConstraintCheck\Cache\CachingMetadata;
8			use WikibaseQuality\ConstraintReport\ConstraintCheck\Cache\DependencyMetadata;
9			use WikibaseQuality\ConstraintReport\ConstraintCheck\Cache\Metadata;
10			use WikibaseQuality\ConstraintReport\ConstraintCheck\Context\ContextCursorDeserializer;
11			use WikibaseQuality\ConstraintReport\ConstraintCheck\Message\ViolationMessage;
12			use WikibaseQuality\ConstraintReport\ConstraintCheck\Message\ViolationMessageDeserializer;
13			use WikibaseQuality\ConstraintReport\ConstraintDeserializer;
14
15			/**
16			* A deserializer for {@link CheckResult}s.
17			*
18			* @author Lucas Werkmeister
19			* @license GPL-2.0-or-later
20			*/
21			class CheckResultDeserializer {
22
23			/**
24			* @var ConstraintDeserializer
25			*/
26			private $constraintDeserializer;
27
28			/**
29			* @var ContextCursorDeserializer
30			*/
31			private $contextCursorDeserializer;
32
33			/**
34			* @var ViolationMessageDeserializer
35			*/
36			private $violationMessageDeserializer;
37
38			/**
39			* @var EntityIdParser
40			*/
41			private $entityIdParser;
42
43			public function __construct(
44			ConstraintDeserializer $constraintDeserializer,
45			ContextCursorDeserializer $contextCursorDeserializer,
46			ViolationMessageDeserializer $violationMessageDeserializer,
47			EntityIdParser $entityIdParser
48			) {
49			$this->constraintDeserializer = $constraintDeserializer;
50			$this->contextCursorDeserializer = $contextCursorDeserializer;
51			$this->violationMessageDeserializer = $violationMessageDeserializer;
52			$this->entityIdParser = $entityIdParser;
53			}
54
55			/**
56			* @param array $serialization
57			* @return CheckResult
58			*/
59			public function deserialize( array $serialization ) {
60			$contextCursor = $this->contextCursorDeserializer->deserialize(
61			$serialization[CheckResultSerializer::KEY_CONTEXT_CURSOR]
62			);
63
64			if ( array_key_exists( CheckResultSerializer::KEY_NULL_RESULT, $serialization ) ) {
65			$result = new NullResult( $contextCursor );
66			$cachingMetadata = CachingMetadata::fresh();
67			} else {
68			$constraint = $this->constraintDeserializer->deserialize(
69			$serialization[CheckResultSerializer::KEY_CONSTRAINT]
70			);
71
72			$parameters = []; // serialization of parameters not supported yet
73
74			$status = $serialization[CheckResultSerializer::KEY_CHECK_RESULT_STATUS];
75
76			$violationMessage = $this->getViolationMessageFromSerialization( $serialization );
77
78			$result = new CheckResult(
79			$contextCursor,
80			$constraint,
81			$parameters,
82			$status,
83			$violationMessage
84			);
85
86			$cachingMetadata = $this->deserializeCachingMetadata(
87			$serialization[CheckResultSerializer::KEY_CACHING_METADATA]
88			);
89			}
90
91			$dependencyMetadata = $this->getDependencyMetadataFromSerialization( $serialization );
92
93			return $result->withMetadata(
94			Metadata::merge( [
95			Metadata::ofCachingMetadata( $cachingMetadata ),
96			Metadata::ofDependencyMetadata( $dependencyMetadata ),
97			] )
98			);
99			}
100
101			/**
102			* @param array $serialization
103			* @return null\|ViolationMessage
104			*/
105			private function getViolationMessageFromSerialization( array $serialization ) {
106			if ( array_key_exists( CheckResultSerializer::KEY_VIOLATION_MESSAGE, $serialization ) ) {
107			return $this->violationMessageDeserializer->deserialize(
108			$serialization[CheckResultSerializer::KEY_VIOLATION_MESSAGE]
109			);
110			} else {
111			return null;
112			}
113			}
114
115			/**
116			* @param array $serialization
117			* @return DependencyMetadata
118			*/
119			private function getDependencyMetadataFromSerialization( array $serialization ) {
120			if ( array_key_exists( CheckResultSerializer::KEY_DEPENDENCY_METADATA, $serialization ) ) {
121			return $this->deserializeDependencyMetadata(
122			$serialization[CheckResultSerializer::KEY_DEPENDENCY_METADATA]
123			);
124			} else {
125			return DependencyMetadata::blank();
126			}
127			}
128
129			/**
130			* @param array $serialization
131			* @return CachingMetadata
132			*/
133			private function deserializeCachingMetadata( array $serialization ) {
134			if (
135			array_key_exists(
136			CheckResultSerializer::KEY_CACHING_METADATA_MAX_AGE,
137			$serialization
138			)
139			) {
140			return CachingMetadata::ofMaximumAgeInSeconds(
141			$serialization[CheckResultSerializer::KEY_CACHING_METADATA_MAX_AGE]
142			);
143			} else {
144			return CachingMetadata::fresh();
145			}
146			}
147
148			/**
149			* @param array $serialization
150			* @return DependencyMetadata
151			*/
152			private function deserializeDependencyMetadata( array $serialization ) {
153			if (
154			array_key_exists(
155			CheckResultSerializer::KEY_DEPENDENCY_METADATA_FUTURE_TIME,
156			$serialization
157			)
158			) {
159			$futureTime = TimeValue::newFromArray(
160			$serialization[CheckResultSerializer::KEY_DEPENDENCY_METADATA_FUTURE_TIME]
161			);
162			$futureTimeDependencyMetadata = DependencyMetadata::ofFutureTime( $futureTime );
163			} else {
164			$futureTimeDependencyMetadata = DependencyMetadata::blank();
165			}
166
167			$dependencyMetadata = array_reduce(
168			$serialization[CheckResultSerializer::KEY_DEPENDENCY_METADATA_ENTITY_IDS],
169			function ( DependencyMetadata $metadata, $entityIdSerialization ) {
170			$entityId = $this->entityIdParser->parse( $entityIdSerialization );
171
172			return DependencyMetadata::merge( [
173			$metadata,
174			DependencyMetadata::ofEntityId( $entityId )
175			] );
176			},
177			$futureTimeDependencyMetadata
178			);
179
180			return $dependencyMetadata;
181			}
182
183			}
184

wikimedia / mediawiki-extensions-WikibaseQualityConstraints

Push — master ( f2f357...ccb861 )

CheckResultDeserializer::deserialize() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like