Completed
Push — master ( 1e5bde...d42fc6 )
by
unknown
05:28
created
src/ConstraintCheck/Message/ViolationMessageDeserializer.php 1 patch
Spacing   +23 added lines, -23 removed lines patch added patch discarded remove patch
@@ -36,23 +36,23 @@  discard block
 block discarded – undo
36 36
 		$this->dataValueFactory = $dataValueFactory;
37 37
 	}
38 38
 
39
-	public function unabbreviateViolationMessageKey( $messageKeySuffix ) {
40
-		return ViolationMessage::MESSAGE_KEY_PREFIX . $messageKeySuffix;
39
+	public function unabbreviateViolationMessageKey($messageKeySuffix) {
40
+		return ViolationMessage::MESSAGE_KEY_PREFIX.$messageKeySuffix;
41 41
 	}
42 42
 
43 43
 	/**
44 44
 	 * @param array $serialization
45 45
 	 * @return ViolationMessage
46 46
 	 */
47
-	public function deserialize( $serialization ) {
48
-		Assert::parameterType( 'array', $serialization, '$serialization' );
47
+	public function deserialize($serialization) {
48
+		Assert::parameterType('array', $serialization, '$serialization');
49 49
 
50 50
 		$message = new ViolationMessage(
51
-			$this->unabbreviateViolationMessageKey( $serialization['k'] )
51
+			$this->unabbreviateViolationMessageKey($serialization['k'])
52 52
 		);
53 53
 
54
-		foreach ( $serialization['a'] as $serializedArgument ) {
55
-			$message = $this->deserializeArgument( $message, $serializedArgument );
54
+		foreach ($serialization['a'] as $serializedArgument) {
55
+			$message = $this->deserializeArgument($message, $serializedArgument);
56 56
 		}
57 57
 
58 58
 		return $message;
@@ -63,7 +63,7 @@  discard block
 block discarded – undo
63 63
 	 * @param array $serializedArgument [ 't' => ViolationMessage::TYPE_*, 'v' => serialized value, 'r' => $role ]
64 64
 	 * @return ViolationMessage $message with the deserialized argument appended
65 65
 	 */
66
-	private function deserializeArgument( ViolationMessage $message, array $serializedArgument ) {
66
+	private function deserializeArgument(ViolationMessage $message, array $serializedArgument) {
67 67
 		$methods = [
68 68
 			ViolationMessage::TYPE_ENTITY_ID => 'deserializeEntityId',
69 69
 			ViolationMessage::TYPE_ENTITY_ID_LIST => 'deserializeEntityIdList',
@@ -76,46 +76,46 @@  discard block
 block discarded – undo
76 76
 		$serializedValue = $serializedArgument['v'];
77 77
 		$role = $serializedArgument['r'];
78 78
 
79
-		if ( array_key_exists( $type, $methods ) ) {
79
+		if (array_key_exists($type, $methods)) {
80 80
 			$method = $methods[$type];
81
-			$value = $this->$method( $serializedValue );
81
+			$value = $this->$method($serializedValue);
82 82
 		} else {
83 83
 			throw new InvalidArgumentException(
84
-				'Unknown ViolationMessage argument type ' . $type . '!'
84
+				'Unknown ViolationMessage argument type '.$type.'!'
85 85
 			);
86 86
 		}
87 87
 
88
-		return $message->withArgument( $type, $role, $value );
88
+		return $message->withArgument($type, $role, $value);
89 89
 	}
90 90
 
91 91
 	/**
92 92
 	 * @param string $entityIdSerialization entity ID serialization
93 93
 	 * @return EntityId
94 94
 	 */
95
-	private function deserializeEntityId( $entityIdSerialization ) {
96
-		return $this->entityIdParser->parse( $entityIdSerialization );
95
+	private function deserializeEntityId($entityIdSerialization) {
96
+		return $this->entityIdParser->parse($entityIdSerialization);
97 97
 	}
98 98
 
99 99
 	/**
100 100
 	 * @param string[] $entityIdSerializations entity ID serializations
101 101
 	 * @return EntityId[]
102 102
 	 */
103
-	private function deserializeEntityIdList( array $entityIdSerializations ) {
104
-		return array_map( [ $this, 'deserializeEntityId' ], $entityIdSerializations );
103
+	private function deserializeEntityIdList(array $entityIdSerializations) {
104
+		return array_map([$this, 'deserializeEntityId'], $entityIdSerializations);
105 105
 	}
106 106
 
107 107
 	/**
108 108
 	 * @param string $valueSerialization entity ID serialization, '::somevalue' or '::novalue'
109 109
 	 * @return ItemIdSnakValue
110 110
 	 */
111
-	private function deserializeItemIdSnakValue( $valueSerialization ) {
112
-		switch ( $valueSerialization ) {
111
+	private function deserializeItemIdSnakValue($valueSerialization) {
112
+		switch ($valueSerialization) {
113 113
 			case '::somevalue':
114 114
 				return ItemIdSnakValue::someValue();
115 115
 			case '::novalue':
116 116
 				return ItemIdSnakValue::noValue();
117 117
 			default:
118
-				return ItemIdSnakValue::fromItemId( $this->deserializeEntityId( $valueSerialization ) );
118
+				return ItemIdSnakValue::fromItemId($this->deserializeEntityId($valueSerialization));
119 119
 		}
120 120
 	}
121 121
 
@@ -123,16 +123,16 @@  discard block
 block discarded – undo
123 123
 	 * @param string[] $valueSerializations entity ID serializations, '::somevalue's or '::novalue's
124 124
 	 * @return ItemIdSnakValue[]
125 125
 	 */
126
-	private function deserializeItemIdSnakValueList( $valueSerializations ) {
127
-		return array_map( [ $this, 'deserializeItemIdSnakValue' ], $valueSerializations );
126
+	private function deserializeItemIdSnakValueList($valueSerializations) {
127
+		return array_map([$this, 'deserializeItemIdSnakValue'], $valueSerializations);
128 128
 	}
129 129
 
130 130
 	/**
131 131
 	 * @param array $dataValueSerialization the data value in array form
132 132
 	 * @return DataValue
133 133
 	 */
134
-	private function deserializeDataValue( array $dataValueSerialization ) {
135
-		return $this->dataValueFactory->newFromArray( $dataValueSerialization );
134
+	private function deserializeDataValue(array $dataValueSerialization) {
135
+		return $this->dataValueFactory->newFromArray($dataValueSerialization);
136 136
 	}
137 137
 
138 138
 }
Please login to merge, or discard this patch.
src/ConstraintCheck/Message/ViolationMessageSerializer.php 1 patch
Spacing   +20 added lines, -20 removed lines patch added patch discarded remove patch
@@ -17,26 +17,26 @@  discard block
 block discarded – undo
17 17
  */
18 18
 class ViolationMessageSerializer implements Serializer {
19 19
 
20
-	private function abbreviateViolationMessageKey( $fullMessageKey ) {
21
-		return substr( $fullMessageKey, strlen( ViolationMessage::MESSAGE_KEY_PREFIX ) );
20
+	private function abbreviateViolationMessageKey($fullMessageKey) {
21
+		return substr($fullMessageKey, strlen(ViolationMessage::MESSAGE_KEY_PREFIX));
22 22
 	}
23 23
 
24 24
 	/**
25 25
 	 * @param ViolationMessage $object
26 26
 	 * @return array
27 27
 	 */
28
-	public function serialize( $object ) {
28
+	public function serialize($object) {
29 29
 		/** @var ViolationMessage $object */
30
-		Assert::parameterType( ViolationMessage::class, $object, '$object' );
30
+		Assert::parameterType(ViolationMessage::class, $object, '$object');
31 31
 
32 32
 		$arguments = $object->getArguments();
33 33
 		$serializedArguments = [];
34
-		foreach ( $arguments as $argument ) {
35
-			$serializedArguments[] = $this->serializeArgument( $argument );
34
+		foreach ($arguments as $argument) {
35
+			$serializedArguments[] = $this->serializeArgument($argument);
36 36
 		}
37 37
 
38 38
 		return [
39
-			'k' => $this->abbreviateViolationMessageKey( $object->getMessageKey() ),
39
+			'k' => $this->abbreviateViolationMessageKey($object->getMessageKey()),
40 40
 			'a' => $serializedArguments,
41 41
 		];
42 42
 	}
@@ -45,7 +45,7 @@  discard block
 block discarded – undo
45 45
 	 * @param array $argument element of ViolationMessage::getArguments()
46 46
 	 * @return array [ 't' => ViolationMessage::TYPE_*, 'v' => serialized value, 'r' => $role ]
47 47
 	 */
48
-	private function serializeArgument( array $argument ) {
48
+	private function serializeArgument(array $argument) {
49 49
 		$methods = [
50 50
 			ViolationMessage::TYPE_ENTITY_ID => 'serializeEntityId',
51 51
 			ViolationMessage::TYPE_ENTITY_ID_LIST => 'serializeEntityIdList',
@@ -58,12 +58,12 @@  discard block
 block discarded – undo
58 58
 		$value = $argument['value'];
59 59
 		$role = $argument['role'];
60 60
 
61
-		if ( array_key_exists( $type, $methods ) ) {
61
+		if (array_key_exists($type, $methods)) {
62 62
 			$method = $methods[$type];
63
-			$serializedValue = $this->$method( $value );
63
+			$serializedValue = $this->$method($value);
64 64
 		} else {
65 65
 			throw new InvalidArgumentException(
66
-				'Unknown ViolationMessage argument type ' . $type . '!'
66
+				'Unknown ViolationMessage argument type '.$type.'!'
67 67
 			);
68 68
 		}
69 69
 
@@ -80,7 +80,7 @@  discard block
 block discarded – undo
80 80
 	 * @param EntityId $entityId
81 81
 	 * @return string entity ID serialization
82 82
 	 */
83
-	private function serializeEntityId( EntityId $entityId ) {
83
+	private function serializeEntityId(EntityId $entityId) {
84 84
 		return $entityId->getSerialization();
85 85
 	}
86 86
 
@@ -88,8 +88,8 @@  discard block
 block discarded – undo
88 88
 	 * @param EntityId[] $entityIdList
89 89
 	 * @return string[] entity ID serializations
90 90
 	 */
91
-	private function serializeEntityIdList( array $entityIdList ) {
92
-		return array_map( [ $this, 'serializeEntityId' ], $entityIdList );
91
+	private function serializeEntityIdList(array $entityIdList) {
92
+		return array_map([$this, 'serializeEntityId'], $entityIdList);
93 93
 	}
94 94
 
95 95
 	/**
@@ -97,10 +97,10 @@  discard block
 block discarded – undo
97 97
 	 * @return string entity ID serialization, '::somevalue', or '::novalue'
98 98
 	 * (according to EntityId::PATTERN, entity ID serializations can never begin with two colons)
99 99
 	 */
100
-	private function serializeItemIdSnakValue( ItemIdSnakValue $value ) {
101
-		switch ( true ) {
100
+	private function serializeItemIdSnakValue(ItemIdSnakValue $value) {
101
+		switch (true) {
102 102
 			case $value->isValue():
103
-				return $this->serializeEntityId( $value->getItemId() );
103
+				return $this->serializeEntityId($value->getItemId());
104 104
 			case $value->isSomeValue():
105 105
 				return '::somevalue';
106 106
 			case $value->isNoValue():
@@ -118,15 +118,15 @@  discard block
 block discarded – undo
118 118
 	 * @param ItemIdSnakValue[] $valueList
119 119
 	 * @return string[] array of entity ID serializations, '::somevalue's or '::novalue's
120 120
 	 */
121
-	private function serializeItemIdSnakValueList( array $valueList ) {
122
-		return array_map( [ $this, 'serializeItemIdSnakValue' ], $valueList );
121
+	private function serializeItemIdSnakValueList(array $valueList) {
122
+		return array_map([$this, 'serializeItemIdSnakValue'], $valueList);
123 123
 	}
124 124
 
125 125
 	/**
126 126
 	 * @param DataValue $dataValue
127 127
 	 * @return array the data value in array form
128 128
 	 */
129
-	private function serializeDataValue( DataValue $dataValue ) {
129
+	private function serializeDataValue(DataValue $dataValue) {
130 130
 		return $dataValue->toArray();
131 131
 	}
132 132
 
Please login to merge, or discard this patch.