schmittjoh / serializer

src/Metadata/Driver/XmlDriver.php

Spacing +71 added lines, -71 removed lines

@@ -62,97 +62,97 @@ 
         }
 
         $metadata = new ClassMetadata($name = $class->name);
-        if (!$elems = $elem->xpath("./class[@name = '" . $name . "']")) {
+        if ( ! $elems = $elem->xpath("./class[@name = '".$name."']")) {
             throw new RuntimeException(sprintf('Could not find class %s inside XML element.', $name));
         }
         $elem = reset($elems);
 
         $metadata->fileResources[] = $path;
         $metadata->fileResources[] = $class->getFileName();
-        $exclusionPolicy = strtoupper((string)$elem->attributes()->{'exclusion-policy'}) ?: 'NONE';
-        $excludeAll = null !== ($exclude = $elem->attributes()->exclude) ? 'true' === strtolower((string)$exclude) : false;
-        $classAccessType = (string)($elem->attributes()->{'access-type'} ?: PropertyMetadata::ACCESS_TYPE_PROPERTY);
+        $exclusionPolicy = strtoupper((string) $elem->attributes()->{'exclusion-policy'}) ?: 'NONE';
+        $excludeAll = null !== ($exclude = $elem->attributes()->exclude) ? 'true' === strtolower((string) $exclude) : false;
+        $classAccessType = (string) ($elem->attributes()->{'access-type'} ?: PropertyMetadata::ACCESS_TYPE_PROPERTY);
 
         $propertiesMetadata = [];
         $propertiesNodes = [];
 
         if (null !== $accessorOrder = $elem->attributes()->{'accessor-order'}) {
-            $metadata->setAccessorOrder((string)$accessorOrder, preg_split('/\s*,\s*/', (string)$elem->attributes()->{'custom-accessor-order'}));
+            $metadata->setAccessorOrder((string) $accessorOrder, preg_split('/\s*,\s*/', (string) $elem->attributes()->{'custom-accessor-order'}));
         }
 
         if (null !== $xmlRootName = $elem->attributes()->{'xml-root-name'}) {
-            $metadata->xmlRootName = (string)$xmlRootName;
+            $metadata->xmlRootName = (string) $xmlRootName;
         }
 
         if (null !== $xmlRootNamespace = $elem->attributes()->{'xml-root-namespace'}) {
-            $metadata->xmlRootNamespace = (string)$xmlRootNamespace;
+            $metadata->xmlRootNamespace = (string) $xmlRootNamespace;
         }
 
-        $readOnlyClass = 'true' === strtolower((string)$elem->attributes()->{'read-only'});
+        $readOnlyClass = 'true' === strtolower((string) $elem->attributes()->{'read-only'});
 
-        $discriminatorFieldName = (string)$elem->attributes()->{'discriminator-field-name'};
+        $discriminatorFieldName = (string) $elem->attributes()->{'discriminator-field-name'};
         $discriminatorMap = [];
         foreach ($elem->xpath('./discriminator-class') as $entry) {
-            if (!isset($entry->attributes()->value)) {
+            if ( ! isset($entry->attributes()->value)) {
                 throw new RuntimeException('Each discriminator-class element must have a "value" attribute.');
             }
 
-            $discriminatorMap[(string)$entry->attributes()->value] = (string)$entry;
+            $discriminatorMap[(string) $entry->attributes()->value] = (string) $entry;
         }
 
-        if ('true' === (string)$elem->attributes()->{'discriminator-disabled'}) {
+        if ('true' === (string) $elem->attributes()->{'discriminator-disabled'}) {
             $metadata->discriminatorDisabled = true;
-        } elseif (!empty($discriminatorFieldName) || !empty($discriminatorMap)) {
+        } elseif ( ! empty($discriminatorFieldName) || ! empty($discriminatorMap)) {
 
             $discriminatorGroups = [];
             foreach ($elem->xpath('./discriminator-groups/group') as $entry) {
-                $discriminatorGroups[] = (string)$entry;
+                $discriminatorGroups[] = (string) $entry;
             }
             $metadata->setDiscriminator($discriminatorFieldName, $discriminatorMap, $discriminatorGroups);
         }
 
         foreach ($elem->xpath('./xml-namespace') as $xmlNamespace) {
-            if (!isset($xmlNamespace->attributes()->uri)) {
+            if ( ! isset($xmlNamespace->attributes()->uri)) {
                 throw new RuntimeException('The prefix attribute must be set for all xml-namespace elements.');
             }
 
             if (isset($xmlNamespace->attributes()->prefix)) {
-                $prefix = (string)$xmlNamespace->attributes()->prefix;
+                $prefix = (string) $xmlNamespace->attributes()->prefix;
             } else {
                 $prefix = null;
             }
 
-            $metadata->registerNamespace((string)$xmlNamespace->attributes()->uri, $prefix);
+            $metadata->registerNamespace((string) $xmlNamespace->attributes()->uri, $prefix);
         }
 
         foreach ($elem->xpath('./xml-discriminator') as $xmlDiscriminator) {
             if (isset($xmlDiscriminator->attributes()->attribute)) {
-                $metadata->xmlDiscriminatorAttribute = (string)$xmlDiscriminator->attributes()->attribute === 'true';
+                $metadata->xmlDiscriminatorAttribute = (string) $xmlDiscriminator->attributes()->attribute === 'true';
             }
             if (isset($xmlDiscriminator->attributes()->cdata)) {
-                $metadata->xmlDiscriminatorCData = (string)$xmlDiscriminator->attributes()->cdata === 'true';
+                $metadata->xmlDiscriminatorCData = (string) $xmlDiscriminator->attributes()->cdata === 'true';
             }
             if (isset($xmlDiscriminator->attributes()->namespace)) {
-                $metadata->xmlDiscriminatorNamespace = (string)$xmlDiscriminator->attributes()->namespace;
+                $metadata->xmlDiscriminatorNamespace = (string) $xmlDiscriminator->attributes()->namespace;
             }
         }
 
         foreach ($elem->xpath('./virtual-property') as $method) {
 
             if (isset($method->attributes()->expression)) {
-                $virtualPropertyMetadata = new ExpressionPropertyMetadata($name, (string)$method->attributes()->name, (string)$method->attributes()->expression);
+                $virtualPropertyMetadata = new ExpressionPropertyMetadata($name, (string) $method->attributes()->name, (string) $method->attributes()->expression);
             } else {
-                if (!isset($method->attributes()->method)) {
+                if ( ! isset($method->attributes()->method)) {
                     throw new RuntimeException('The method attribute must be set for all virtual-property elements.');
                 }
-                $virtualPropertyMetadata = new VirtualPropertyMetadata($name, (string)$method->attributes()->method);
+                $virtualPropertyMetadata = new VirtualPropertyMetadata($name, (string) $method->attributes()->method);
             }
 
             $propertiesMetadata[] = $virtualPropertyMetadata;
             $propertiesNodes[] = $method;
         }
 
-        if (!$excludeAll) {
+        if ( ! $excludeAll) {
 
             foreach ($class->getProperties() as $property) {
                 if ($property->class !== $name || (isset($property->info) && $property->info['class'] !== $name)) {
@@ -160,7 +160,7 @@ 
                 }
 
                 $propertiesMetadata[] = new PropertyMetadata($name, $pName = $property->getName());
-                $pElems = $elem->xpath("./property[@name = '" . $pName . "']");
+                $pElems = $elem->xpath("./property[@name = '".$pName."']");
 
                 $propertiesNodes[] = $pElems ? reset($pElems) : null;
             }
@@ -172,10 +172,10 @@ 
                     || $pMetadata instanceof ExpressionPropertyMetadata;
 
                 $pElem = $propertiesNodes[$propertyKey];
-                if (!empty($pElem)) {
+                if ( ! empty($pElem)) {
 
                     if (null !== $exclude = $pElem->attributes()->exclude) {
-                        $isExclude = 'true' === strtolower((string)$exclude);
+                        $isExclude = 'true' === strtolower((string) $exclude);
                     }
 
                     if ($isExclude) {
@@ -183,44 +183,44 @@ 
                     }
 
                     if (null !== $expose = $pElem->attributes()->expose) {
-                        $isExpose = 'true' === strtolower((string)$expose);
+                        $isExpose = 'true' === strtolower((string) $expose);
                     }
 
                     if (null !== $excludeIf = $pElem->attributes()->{'exclude-if'}) {
-                        $pMetadata->excludeIf = (string)$excludeIf;
+                        $pMetadata->excludeIf = (string) $excludeIf;
                     }
 
                     if (null !== $skip = $pElem->attributes()->{'skip-when-empty'}) {
-                        $pMetadata->skipWhenEmpty = 'true' === strtolower((string)$skip);
+                        $pMetadata->skipWhenEmpty = 'true' === strtolower((string) $skip);
                     }
 
                     if (null !== $excludeIf = $pElem->attributes()->{'expose-if'}) {
-                        $pMetadata->excludeIf = "!(" . (string)$excludeIf . ")";
+                        $pMetadata->excludeIf = "!(".(string) $excludeIf.")";
                         $isExpose = true;
                     }
 
                     if (null !== $version = $pElem->attributes()->{'since-version'}) {
-                        $pMetadata->sinceVersion = (string)$version;
+                        $pMetadata->sinceVersion = (string) $version;
                     }
 
                     if (null !== $version = $pElem->attributes()->{'until-version'}) {
-                        $pMetadata->untilVersion = (string)$version;
+                        $pMetadata->untilVersion = (string) $version;
                     }
 
                     if (null !== $serializedName = $pElem->attributes()->{'serialized-name'}) {
-                        $pMetadata->serializedName = (string)$serializedName;
+                        $pMetadata->serializedName = (string) $serializedName;
                     }
 
                     if (null !== $type = $pElem->attributes()->type) {
-                        $pMetadata->setType($this->typeParser->parse((string)$type));
+                        $pMetadata->setType($this->typeParser->parse((string) $type));
                     } elseif (isset($pElem->type)) {
-                        $pMetadata->setType($this->typeParser->parse((string)$pElem->type));
+                        $pMetadata->setType($this->typeParser->parse((string) $pElem->type));
                     }
 
                     if (null !== $groups = $pElem->attributes()->groups) {
-                        $pMetadata->groups = preg_split('/\s*,\s*/', trim((string)$groups));
+                        $pMetadata->groups = preg_split('/\s*,\s*/', trim((string) $groups));
                     } elseif (isset($pElem->groups)) {
-                        $pMetadata->groups = (array)$pElem->groups->value;
+                        $pMetadata->groups = (array) $pElem->groups->value;
                     }
 
                     if (isset($pElem->{'xml-list'})) {
@@ -229,21 +229,21 @@ 
 
                         $colConfig = $pElem->{'xml-list'};
                         if (isset($colConfig->attributes()->inline)) {
-                            $pMetadata->xmlCollectionInline = 'true' === (string)$colConfig->attributes()->inline;
+                            $pMetadata->xmlCollectionInline = 'true' === (string) $colConfig->attributes()->inline;
                         }
 
                         if (isset($colConfig->attributes()->{'entry-name'})) {
-                            $pMetadata->xmlEntryName = (string)$colConfig->attributes()->{'entry-name'};
+                            $pMetadata->xmlEntryName = (string) $colConfig->attributes()->{'entry-name'};
                         }
 
                         if (isset($colConfig->attributes()->{'skip-when-empty'})) {
-                            $pMetadata->xmlCollectionSkipWhenEmpty = 'true' === (string)$colConfig->attributes()->{'skip-when-empty'};
+                            $pMetadata->xmlCollectionSkipWhenEmpty = 'true' === (string) $colConfig->attributes()->{'skip-when-empty'};
                         } else {
                             $pMetadata->xmlCollectionSkipWhenEmpty = true;
                         }
 
                         if (isset($colConfig->attributes()->namespace)) {
-                            $pMetadata->xmlEntryNamespace = (string)$colConfig->attributes()->namespace;
+                            $pMetadata->xmlEntryNamespace = (string) $colConfig->attributes()->namespace;
                         }
                     }
 
@@ -252,56 +252,56 @@ 
 
                         $colConfig = $pElem->{'xml-map'};
                         if (isset($colConfig->attributes()->inline)) {
-                            $pMetadata->xmlCollectionInline = 'true' === (string)$colConfig->attributes()->inline;
+                            $pMetadata->xmlCollectionInline = 'true' === (string) $colConfig->attributes()->inline;
                         }
 
                         if (isset($colConfig->attributes()->{'entry-name'})) {
-                            $pMetadata->xmlEntryName = (string)$colConfig->attributes()->{'entry-name'};
+                            $pMetadata->xmlEntryName = (string) $colConfig->attributes()->{'entry-name'};
                         }
 
                         if (isset($colConfig->attributes()->namespace)) {
-                            $pMetadata->xmlEntryNamespace = (string)$colConfig->attributes()->namespace;
+                            $pMetadata->xmlEntryNamespace = (string) $colConfig->attributes()->namespace;
                         }
 
                         if (isset($colConfig->attributes()->{'key-attribute-name'})) {
-                            $pMetadata->xmlKeyAttribute = (string)$colConfig->attributes()->{'key-attribute-name'};
+                            $pMetadata->xmlKeyAttribute = (string) $colConfig->attributes()->{'key-attribute-name'};
                         }
                     }
 
                     if (isset($pElem->{'xml-element'})) {
                         $colConfig = $pElem->{'xml-element'};
                         if (isset($colConfig->attributes()->cdata)) {
-                            $pMetadata->xmlElementCData = 'true' === (string)$colConfig->attributes()->cdata;
+                            $pMetadata->xmlElementCData = 'true' === (string) $colConfig->attributes()->cdata;
                         }
 
                         if (isset($colConfig->attributes()->namespace)) {
-                            $pMetadata->xmlNamespace = (string)$colConfig->attributes()->namespace;
+                            $pMetadata->xmlNamespace = (string) $colConfig->attributes()->namespace;
                         }
                     }
 
                     if (isset($pElem->attributes()->{'xml-attribute'})) {
-                        $pMetadata->xmlAttribute = 'true' === (string)$pElem->attributes()->{'xml-attribute'};
+                        $pMetadata->xmlAttribute = 'true' === (string) $pElem->attributes()->{'xml-attribute'};
                     }
 
                     if (isset($pElem->attributes()->{'xml-attribute-map'})) {
-                        $pMetadata->xmlAttributeMap = 'true' === (string)$pElem->attributes()->{'xml-attribute-map'};
+                        $pMetadata->xmlAttributeMap = 'true' === (string) $pElem->attributes()->{'xml-attribute-map'};
                     }
 
                     if (isset($pElem->attributes()->{'xml-value'})) {
-                        $pMetadata->xmlValue = 'true' === (string)$pElem->attributes()->{'xml-value'};
+                        $pMetadata->xmlValue = 'true' === (string) $pElem->attributes()->{'xml-value'};
                     }
 
                     if (isset($pElem->attributes()->{'xml-key-value-pairs'})) {
-                        $pMetadata->xmlKeyValuePairs = 'true' === (string)$pElem->attributes()->{'xml-key-value-pairs'};
+                        $pMetadata->xmlKeyValuePairs = 'true' === (string) $pElem->attributes()->{'xml-key-value-pairs'};
                     }
 
                     if (isset($pElem->attributes()->{'max-depth'})) {
-                        $pMetadata->maxDepth = (int)$pElem->attributes()->{'max-depth'};
+                        $pMetadata->maxDepth = (int) $pElem->attributes()->{'max-depth'};
                     }
 
                     //we need read-only before setter and getter set, because that method depends on flag being set
                     if (null !== $readOnly = $pElem->attributes()->{'read-only'}) {
-                        $pMetadata->readOnly = 'true' === strtolower((string)$readOnly);
+                        $pMetadata->readOnly = 'true' === strtolower((string) $readOnly);
                     } else {
                         $pMetadata->readOnly = $pMetadata->readOnly || $readOnlyClass;
                     }
@@ -309,26 +309,26 @@ 
                     $getter = $pElem->attributes()->{'accessor-getter'};
                     $setter = $pElem->attributes()->{'accessor-setter'};
                     $pMetadata->setAccessor(
-                        (string)($pElem->attributes()->{'access-type'} ?: $classAccessType),
-                        $getter ? (string)$getter : null,
-                        $setter ? (string)$setter : null
+                        (string) ($pElem->attributes()->{'access-type'} ?: $classAccessType),
+                        $getter ? (string) $getter : null,
+                        $setter ? (string) $setter : null
                     );
 
                     if (null !== $inline = $pElem->attributes()->inline) {
-                        $pMetadata->inline = 'true' === strtolower((string)$inline);
+                        $pMetadata->inline = 'true' === strtolower((string) $inline);
                     }
                 }
 
-                if (!$pMetadata->serializedName) {
+                if ( ! $pMetadata->serializedName) {
                     $pMetadata->serializedName = $this->namingStrategy->translateName($pMetadata);
                 }
 
-                if (!empty($pElem) && null !== $name = $pElem->attributes()->name) {
-                    $pMetadata->name = (string)$name;
+                if ( ! empty($pElem) && null !== $name = $pElem->attributes()->name) {
+                    $pMetadata->name = (string) $name;
                 }
 
-                if ((ExclusionPolicy::NONE === (string)$exclusionPolicy && !$isExclude)
-                    || (ExclusionPolicy::ALL === (string)$exclusionPolicy && $isExpose)
+                if ((ExclusionPolicy::NONE === (string) $exclusionPolicy && ! $isExclude)
+                    || (ExclusionPolicy::ALL === (string) $exclusionPolicy && $isExpose)
                 ) {
 
 
@@ -338,31 +338,31 @@ 
         }
 
         foreach ($elem->xpath('./callback-method') as $method) {
-            if (!isset($method->attributes()->type)) {
+            if ( ! isset($method->attributes()->type)) {
                 throw new RuntimeException('The type attribute must be set for all callback-method elements.');
             }
-            if (!isset($method->attributes()->name)) {
+            if ( ! isset($method->attributes()->name)) {
                 throw new RuntimeException('The name attribute must be set for all callback-method elements.');
             }
 
-            switch ((string)$method->attributes()->type) {
+            switch ((string) $method->attributes()->type) {
                 case 'pre-serialize':
-                    $metadata->addPreSerializeMethod(new MethodMetadata($name, (string)$method->attributes()->name));
+                    $metadata->addPreSerializeMethod(new MethodMetadata($name, (string) $method->attributes()->name));
                     break;
 
                 case 'post-serialize':
-                    $metadata->addPostSerializeMethod(new MethodMetadata($name, (string)$method->attributes()->name));
+                    $metadata->addPostSerializeMethod(new MethodMetadata($name, (string) $method->attributes()->name));
                     break;
 
                 case 'post-deserialize':
-                    $metadata->addPostDeserializeMethod(new MethodMetadata($name, (string)$method->attributes()->name));
+                    $metadata->addPostDeserializeMethod(new MethodMetadata($name, (string) $method->attributes()->name));
                     break;
 
                 case 'handler':
-                    if (!isset($method->attributes()->format)) {
+                    if ( ! isset($method->attributes()->format)) {
                         throw new RuntimeException('The format attribute must be set for "handler" callback methods.');
                     }
-                    if (!isset($method->attributes()->direction)) {
+                    if ( ! isset($method->attributes()->direction)) {
                         throw new RuntimeException('The direction attribute must be set for "handler" callback methods.');
                     }
 

src/Naming/CamelCaseNamingStrategy.php

Spacing +1 added lines, -1 removed lines

@@ -43,7 +43,7 @@
      */
     public function translateName(PropertyMetadata $property): string
     {
-        $name = preg_replace('/[A-Z]+/', $this->separator . '\\0', $property->name);
+        $name = preg_replace('/[A-Z]+/', $this->separator.'\\0', $property->name);
 
         if ($this->lowerCase) {
             return strtolower($name);

src/GraphNavigator/DeserializationGraphNavigator.php

Spacing +3 added lines, -3 removed lines

@@ -163,11 +163,11 @@ 
                 /** @var $metadata ClassMetadata */
                 $metadata = $this->metadataFactory->getMetadataForClass($type['name']);
 
-                if ($metadata->usingExpression && !$this->expressionExclusionStrategy) {
+                if ($metadata->usingExpression && ! $this->expressionExclusionStrategy) {
                     throw new ExpressionLanguageRequiredException("To use conditional exclude/expose in {$metadata->name} you must configure the expression language.");
                 }
 
-                if (!empty($metadata->discriminatorMap) && $type['name'] === $metadata->discriminatorBaseClass) {
+                if ( ! empty($metadata->discriminatorMap) && $type['name'] === $metadata->discriminatorBaseClass) {
                     $metadata = $this->resolveMetadata($data, $metadata);
                 }
 
@@ -216,7 +216,7 @@ 
     {
         $typeValue = $this->visitor->visitDiscriminatorMapProperty($data, $metadata);
 
-        if (!isset($metadata->discriminatorMap[$typeValue])) {
+        if ( ! isset($metadata->discriminatorMap[$typeValue])) {
             throw new LogicException(sprintf(
                 'The type value "%s" does not exist in the discriminator map of class "%s". Available types: %s',
                 $typeValue,

src/Handler/HandlerRegistry.php

Spacing +4 added lines, -4 removed lines

@@ -37,10 +37,10 @@ 
 
         switch ($direction) {
             case GraphNavigatorInterface::DIRECTION_DESERIALIZATION:
-                return 'deserialize' . $type . 'From' . $format;
+                return 'deserialize'.$type.'From'.$format;
 
             case GraphNavigatorInterface::DIRECTION_SERIALIZATION:
-                return 'serialize' . $type . 'To' . $format;
+                return 'serialize'.$type.'To'.$format;
 
             default:
                 throw new LogicException(sprintf('The direction %s does not exist; see GraphNavigatorInterface::DIRECTION_??? constants.', json_encode($direction)));
@@ -55,7 +55,7 @@ 
     public function registerSubscribingHandler(SubscribingHandlerInterface $handler): void
     {
         foreach ($handler->getSubscribingMethods() as $methodData) {
-            if (!isset($methodData['type'], $methodData['format'])) {
+            if ( ! isset($methodData['type'], $methodData['format'])) {
                 throw new RuntimeException(sprintf('For each subscribing method a "type" and "format" attribute must be given, but only got "%s" for %s.', implode('" and "', array_keys($methodData)), \get_class($handler)));
             }
 
@@ -82,7 +82,7 @@ 
 
     public function getHandler(int $direction, string $typeName, string $format)
     {
-        if (!isset($this->handlers[$direction][$typeName][$format])) {
+        if ( ! isset($this->handlers[$direction][$typeName][$format])) {
             return null;
         }
 

src/Handler/DateHandler.php

Spacing +13 added lines, -13 removed lines

@@ -55,7 +55,7 @@ 
                     'type' => $type,
                     'format' => $format,
                     'direction' => GraphNavigatorInterface::DIRECTION_SERIALIZATION,
-                    'method' => 'serialize' . $type,
+                    'method' => 'serialize'.$type,
                 ];
             }
         }
@@ -82,7 +82,7 @@ 
 
         $format = $this->getFormat($type);
         if ('U' === $format) {
-            return $visitor->visitInteger((int)$date->format($format), $type);
+            return $visitor->visitInteger((int) $date->format($format), $type);
         }
 
         return $visitor->visitString($date->format($this->getFormat($type)), $type);
@@ -116,7 +116,7 @@ 
     private function isDataXmlNull($data)
     {
         $attributes = $data->attributes('xsi', true);
-        return isset($attributes['nil'][0]) && (string)$attributes['nil'][0] === 'true';
+        return isset($attributes['nil'][0]) && (string) $attributes['nil'][0] === 'true';
     }
 
     public function deserializeDateTimeFromXml(XmlDeserializationVisitor $visitor, $data, array $type)
@@ -143,7 +143,7 @@ 
             return null;
         }
 
-        return $this->parseDateInterval((string)$data);
+        return $this->parseDateInterval((string) $data);
     }
 
     public function deserializeDateTimeFromJson(JsonDeserializationVisitor $visitor, $data, array $type)
@@ -175,13 +175,13 @@ 
 
     private function parseDateTime($data, array $type, $immutable = false)
     {
-        $timezone = !empty($type['params'][1]) ? new \DateTimeZone($type['params'][1]) : $this->defaultTimezone;
+        $timezone = ! empty($type['params'][1]) ? new \DateTimeZone($type['params'][1]) : $this->defaultTimezone;
         $format = $this->getDeserializationFormat($type);
 
         if ($immutable) {
-            $datetime = \DateTimeImmutable::createFromFormat($format, (string)$data, $timezone);
+            $datetime = \DateTimeImmutable::createFromFormat($format, (string) $data, $timezone);
         } else {
-            $datetime = \DateTime::createFromFormat($format, (string)$data, $timezone);
+            $datetime = \DateTime::createFromFormat($format, (string) $data, $timezone);
         }
 
         if (false === $datetime) {
@@ -240,15 +240,15 @@ 
         $format = 'P';
 
         if (0 < $dateInterval->y) {
-            $format .= $dateInterval->y . 'Y';
+            $format .= $dateInterval->y.'Y';
         }
 
         if (0 < $dateInterval->m) {
-            $format .= $dateInterval->m . 'M';
+            $format .= $dateInterval->m.'M';
         }
 
         if (0 < $dateInterval->d) {
-            $format .= $dateInterval->d . 'D';
+            $format .= $dateInterval->d.'D';
         }
 
         if (0 < $dateInterval->h || 0 < $dateInterval->i || 0 < $dateInterval->s) {
@@ -256,15 +256,15 @@ 
         }
 
         if (0 < $dateInterval->h) {
-            $format .= $dateInterval->h . 'H';
+            $format .= $dateInterval->h.'H';
         }
 
         if (0 < $dateInterval->i) {
-            $format .= $dateInterval->i . 'M';
+            $format .= $dateInterval->i.'M';
         }
 
         if (0 < $dateInterval->s) {
-            $format .= $dateInterval->s . 'S';
+            $format .= $dateInterval->s.'S';
         }
 
         if ($format === 'P') {

src/XmlSerializationVisitor.php

Spacing +23 added lines, -23 removed lines

@@ -79,7 +79,7 @@ 
 
     public function createRoot(ClassMetadata $metadata = null, $rootName = null, $rootNamespace = null)
     {
-        if ($metadata !== null && !empty($metadata->xmlRootName)) {
+        if ($metadata !== null && ! empty($metadata->xmlRootName)) {
             $rootName = $metadata->xmlRootName;
             $rootNamespace = $metadata->xmlRootNamespace ?: $this->getClassDefaultNamespace($metadata);
         } else {
@@ -112,12 +112,12 @@ 
     {
         $doCData = null !== $this->currentMetadata ? $this->currentMetadata->xmlElementCData : true;
 
-        return $doCData ? $this->document->createCDATASection($data) : $this->document->createTextNode((string)$data);
+        return $doCData ? $this->document->createCDATASection($data) : $this->document->createTextNode((string) $data);
     }
 
     public function visitSimpleString($data, array $type)
     {
-        return $this->document->createTextNode((string)$data);
+        return $this->document->createTextNode((string) $data);
     }
 
     public function visitBoolean(bool $data, array $type)
@@ -127,15 +127,15 @@ 
 
     public function visitInteger(int $data, array $type)
     {
-        return $this->document->createTextNode((string)$data);
+        return $this->document->createTextNode((string) $data);
     }
 
     public function visitDouble(float $data, array $type)
     {
         if (floor($data) === $data) {
-            return $this->document->createTextNode($data . ".0");
+            return $this->document->createTextNode($data.".0");
         } else {
-            return $this->document->createTextNode((string)$data);
+            return $this->document->createTextNode((string) $data);
         }
     }
 
@@ -152,14 +152,14 @@ 
         $elType = $this->getElementType($type);
         foreach ($data as $k => $v) {
 
-            $tagName = (null !== $this->currentMetadata && $this->currentMetadata->xmlKeyValuePairs && $this->isElementNameValid((string)$k)) ? $k : $entryName;
+            $tagName = (null !== $this->currentMetadata && $this->currentMetadata->xmlKeyValuePairs && $this->isElementNameValid((string) $k)) ? $k : $entryName;
 
             $entryNode = $this->createElement($tagName, $namespace);
             $this->currentNode->appendChild($entryNode);
             $this->setCurrentNode($entryNode);
 
             if (null !== $keyAttributeName) {
-                $entryNode->setAttribute($keyAttributeName, (string)$k);
+                $entryNode->setAttribute($keyAttributeName, (string) $k);
             }
 
             try {
@@ -194,7 +194,7 @@ 
             $node = $this->navigator->accept($v, $metadata->type);
             $this->revertCurrentMetadata();
 
-            if (!$node instanceof \DOMCharacterData) {
+            if ( ! $node instanceof \DOMCharacterData) {
                 throw new RuntimeException(sprintf('Unsupported value for XML attribute for %s. Expected character data, but got %s.', $metadata->name, json_encode($v)));
             }
 
@@ -204,7 +204,7 @@ 
         }
 
         if (($metadata->xmlValue && $this->currentNode->childNodes->length > 0)
-            || (!$metadata->xmlValue && $this->hasValue)
+            || ( ! $metadata->xmlValue && $this->hasValue)
         ) {
             throw new RuntimeException(sprintf('If you make use of @XmlValue, all other properties in the class must have the @XmlAttribute annotation. Invalid usage detected in class %s.', $metadata->class));
         }
@@ -216,7 +216,7 @@ 
             $node = $this->navigator->accept($v, $metadata->type);
             $this->revertCurrentMetadata();
 
-            if (!$node instanceof \DOMCharacterData) {
+            if ( ! $node instanceof \DOMCharacterData) {
                 throw new RuntimeException(sprintf('Unsupported value for property %s::$%s. Expected character data, but got %s.', $metadata->reflection->class, $metadata->reflection->name, \is_object($node) ? \get_class($node) : \gettype($node)));
             }
 
@@ -226,7 +226,7 @@ 
         }
 
         if ($metadata->xmlAttributeMap) {
-            if (!\is_array($v)) {
+            if ( ! \is_array($v)) {
                 throw new RuntimeException(sprintf('Unsupported value type for XML attribute map. Expected array but got %s.', \gettype($v)));
             }
 
@@ -235,7 +235,7 @@ 
                 $node = $this->navigator->accept($value, null);
                 $this->revertCurrentMetadata();
 
-                if (!$node instanceof \DOMCharacterData) {
+                if ( ! $node instanceof \DOMCharacterData) {
                     throw new RuntimeException(sprintf('Unsupported value for a XML attribute map value. Expected character data, but got %s.', json_encode($v)));
                 }
 
@@ -245,7 +245,7 @@ 
             return;
         }
 
-        if ($addEnclosingElement = !$this->isInLineCollection($metadata) && !$metadata->inline) {
+        if ($addEnclosingElement = ! $this->isInLineCollection($metadata) && ! $metadata->inline) {
 
             $namespace = null !== $metadata->xmlNamespace
                 ? $metadata->xmlNamespace
@@ -290,7 +290,7 @@ 
 
     private function isSkippableEmptyObject($node, PropertyMetadata $metadata)
     {
-        return $node === null && !$metadata->xmlCollection && $metadata->skipWhenEmpty;
+        return $node === null && ! $metadata->xmlCollection && $metadata->skipWhenEmpty;
     }
 
     private function isSkippableCollection(PropertyMetadata $metadata)
@@ -300,7 +300,7 @@ 
 
     private function isElementEmpty(\DOMElement $element)
     {
-        return !$element->hasChildNodes() && !$element->hasAttributes();
+        return ! $element->hasChildNodes() && ! $element->hasAttributes();
     }
 
     public function endVisitingObject(ClassMetadata $metadata, object $data, array $type)
@@ -407,7 +407,7 @@ 
         foreach ($metadata->xmlNamespaces as $prefix => $uri) {
             $attribute = 'xmlns';
             if ($prefix !== '') {
-                $attribute .= ':' . $prefix;
+                $attribute .= ':'.$prefix;
             } elseif ($element->namespaceURI === $uri) {
                 continue;
             }
@@ -423,19 +423,19 @@ 
         if ($this->currentNode->isDefaultNamespace($namespace)) {
             return $this->document->createElementNS($namespace, $tagName);
         }
-        if (!($prefix = $this->currentNode->lookupPrefix($namespace)) && !($prefix = $this->document->lookupPrefix($namespace))) {
-            $prefix = 'ns-' . substr(sha1($namespace), 0, 8);
+        if ( ! ($prefix = $this->currentNode->lookupPrefix($namespace)) && ! ($prefix = $this->document->lookupPrefix($namespace))) {
+            $prefix = 'ns-'.substr(sha1($namespace), 0, 8);
         }
-        return $this->document->createElementNS($namespace, $prefix . ':' . $tagName);
+        return $this->document->createElementNS($namespace, $prefix.':'.$tagName);
     }
 
     private function setAttributeOnNode(\DOMElement $node, $name, $value, $namespace = null)
     {
         if (null !== $namespace) {
-            if (!$prefix = $node->lookupPrefix($namespace)) {
-                $prefix = 'ns-' . substr(sha1($namespace), 0, 8);
+            if ( ! $prefix = $node->lookupPrefix($namespace)) {
+                $prefix = 'ns-'.substr(sha1($namespace), 0, 8);
             }
-            $node->setAttributeNS($namespace, $prefix . ':' . $name, $value);
+            $node->setAttributeNS($namespace, $prefix.':'.$name, $value);
         } else {
             $node->setAttribute($name, $value);
         }

src/XmlDeserializationVisitor.php

Spacing +19 added lines, -19 removed lines

@@ -60,7 +60,7 @@ 
 
         if (false !== stripos($data, '<!doctype')) {
             $internalSubset = $this->getDomDocumentTypeEntitySubset($data);
-            if (!in_array($internalSubset, $this->doctypeWhitelist, true)) {
+            if ( ! in_array($internalSubset, $this->doctypeWhitelist, true)) {
                 throw new InvalidArgumentException(sprintf(
                     'The document type "%s" is not allowed. If it is safe, you may add it to the whitelist configuration.',
                     $internalSubset
@@ -82,7 +82,7 @@ 
 
     private function emptyStringToSpaceCharacter($data)
     {
-        return $data === '' ? ' ' : (string)$data;
+        return $data === '' ? ' ' : (string) $data;
     }
 
     public function visitNull($data, array $type): void
@@ -92,12 +92,12 @@ 
 
     public function visitString($data, array $type): string
     {
-        return (string)$data;
+        return (string) $data;
     }
 
     public function visitBoolean($data, array $type): bool
     {
-        $data = (string)$data;
+        $data = (string) $data;
 
         if ('true' === $data || '1' === $data) {
             return true;
@@ -110,12 +110,12 @@ 
 
     public function visitInteger($data, array $type): int
     {
-        return (integer)$data;
+        return (integer) $data;
     }
 
     public function visitDouble($data, array $type): float
     {
-        return (double)$data;
+        return (double) $data;
     }
 
     public function visitArray($data, array $type): array
@@ -160,7 +160,7 @@ 
             $nodes = $data->xpath($entryName);
         }
 
-        if (!\count($nodes)) {
+        if ( ! \count($nodes)) {
             return [];
         }
 
@@ -188,7 +188,7 @@ 
                 $nodes = $data->children($namespace)->$entryName;
                 foreach ($nodes as $v) {
                     $attrs = $v->attributes();
-                    if (!isset($attrs[$this->currentMetadata->xmlKeyAttribute])) {
+                    if ( ! isset($attrs[$this->currentMetadata->xmlKeyAttribute])) {
                         throw new RuntimeException(sprintf('The key attribute "%s" must be set for each entry of the map.', $this->currentMetadata->xmlKeyAttribute));
                     }
 
@@ -208,18 +208,18 @@ 
         switch (true) {
             // Check XML attribute without namespace for discriminatorFieldName
             case $metadata->xmlDiscriminatorAttribute && null === $metadata->xmlDiscriminatorNamespace && isset($data->attributes()->{$metadata->discriminatorFieldName}):
-                return (string)$data->attributes()->{$metadata->discriminatorFieldName};
+                return (string) $data->attributes()->{$metadata->discriminatorFieldName};
 
             // Check XML attribute with namespace for discriminatorFieldName
             case $metadata->xmlDiscriminatorAttribute && null !== $metadata->xmlDiscriminatorNamespace && isset($data->attributes($metadata->xmlDiscriminatorNamespace)->{$metadata->discriminatorFieldName}):
-                return (string)$data->attributes($metadata->xmlDiscriminatorNamespace)->{$metadata->discriminatorFieldName};
+                return (string) $data->attributes($metadata->xmlDiscriminatorNamespace)->{$metadata->discriminatorFieldName};
 
             // Check XML element with namespace for discriminatorFieldName
-            case !$metadata->xmlDiscriminatorAttribute && null !== $metadata->xmlDiscriminatorNamespace && isset($data->children($metadata->xmlDiscriminatorNamespace)->{$metadata->discriminatorFieldName}):
-                return (string)$data->children($metadata->xmlDiscriminatorNamespace)->{$metadata->discriminatorFieldName};
+            case ! $metadata->xmlDiscriminatorAttribute && null !== $metadata->xmlDiscriminatorNamespace && isset($data->children($metadata->xmlDiscriminatorNamespace)->{$metadata->discriminatorFieldName}):
+                return (string) $data->children($metadata->xmlDiscriminatorNamespace)->{$metadata->discriminatorFieldName};
             // Check XML element for discriminatorFieldName
             case isset($data->{$metadata->discriminatorFieldName}):
-                return (string)$data->{$metadata->discriminatorFieldName};
+                return (string) $data->{$metadata->discriminatorFieldName};
 
             default:
                 throw new LogicException(sprintf(
@@ -240,7 +240,7 @@ 
     {
         $name = $metadata->serializedName;
 
-        if (!$metadata->type) {
+        if ( ! $metadata->type) {
             throw new RuntimeException(sprintf('You must define a type for %s::$%s.', $metadata->reflection->class, $metadata->name));
         }
 
@@ -260,7 +260,7 @@ 
 
         if ($metadata->xmlCollection) {
             $enclosingElem = $data;
-            if (!$metadata->xmlCollectionInline) {
+            if ( ! $metadata->xmlCollectionInline) {
                 $enclosingElem = $data->children($metadata->xmlNamespace)->$name;
             }
 
@@ -272,7 +272,7 @@ 
 
         if ($metadata->xmlNamespace) {
             $node = $data->children($metadata->xmlNamespace)->$name;
-            if (!$node->count()) {
+            if ( ! $node->count()) {
                 throw new NotAcceptableException();
             }
         } else {
@@ -282,9 +282,9 @@ 
             if (isset($namespaces[''])) {
                 $prefix = uniqid('ns-');
                 $data->registerXPathNamespace($prefix, $namespaces['']);
-                $nodes = $data->xpath('./' . $prefix . ':' . $name);
+                $nodes = $data->xpath('./'.$prefix.':'.$name);
             } else {
-                $nodes = $data->xpath('./' . $name);
+                $nodes = $data->xpath('./'.$name);
             }
             if (empty($nodes)) {
                 throw new NotAcceptableException();
@@ -397,7 +397,7 @@ 
 
             $xsiAttributes = $value->attributes('http://www.w3.org/2001/XMLSchema-instance');
             if (isset($xsiAttributes['nil'])
-                && ((string)$xsiAttributes['nil'] === 'true' || (string)$xsiAttributes['nil'] === '1')
+                && ((string) $xsiAttributes['nil'] === 'true' || (string) $xsiAttributes['nil'] === '1')
             ) {
                 return true;
             }

src/SerializationContext.php

Spacing +5 added lines, -5 removed lines

@@ -54,7 +54,7 @@ 
 
     public function startVisiting($object): void
     {
-        if (!\is_object($object)) {
+        if ( ! \is_object($object)) {
             return;
         }
         $this->visitingSet->attach($object);
@@ -63,7 +63,7 @@ 
 
     public function stopVisiting($object): void
     {
-        if (!\is_object($object)) {
+        if ( ! \is_object($object)) {
             return;
         }
         $this->visitingSet->detach($object);
@@ -76,7 +76,7 @@ 
 
     public function isVisiting($object): bool
     {
-        if (!\is_object($object)) {
+        if ( ! \is_object($object)) {
             return false;
         }
 
@@ -90,7 +90,7 @@ 
             $path[] = \get_class($obj);
         }
 
-        if (!$path) {
+        if ( ! $path) {
             return null;
         }
 
@@ -109,7 +109,7 @@ 
 
     public function getObject(): ?object
     {
-        return !$this->visitingStack->isEmpty() ? $this->visitingStack->top() : null;
+        return ! $this->visitingStack->isEmpty() ? $this->visitingStack->top() : null;
     }
 
     public function getVisitingStack()

src/EventDispatcher/EventDispatcher.php

Spacing +9 added lines, -9 removed lines

@@ -37,7 +37,7 @@ 
 
     public static function getDefaultMethodName($eventName)
     {
-        return 'on' . str_replace(['_', '.'], '', $eventName);
+        return 'on'.str_replace(['_', '.'], '', $eventName);
     }
 
     /**
@@ -60,7 +60,7 @@ 
     public function addSubscriber(EventSubscriberInterface $subscriber): void
     {
         foreach ($subscriber->getSubscribedEvents() as $eventData) {
-            if (!isset($eventData['event'])) {
+            if ( ! isset($eventData['event'])) {
                 throw new InvalidArgumentException(sprintf('Each event must have a "event" key.'));
             }
 
@@ -75,34 +75,34 @@ 
 
     public function hasListeners(string $eventName, string $class, string $format): bool
     {
-        if (!isset($this->listeners[$eventName])) {
+        if ( ! isset($this->listeners[$eventName])) {
             return false;
         }
 
-        if (!isset($this->classListeners[$eventName][$class][$format])) {
+        if ( ! isset($this->classListeners[$eventName][$class][$format])) {
             $this->classListeners[$eventName][$class][$format] = $this->initializeListeners($eventName, $class, $format);
         }
 
-        return !!$this->classListeners[$eventName][$class][$format];
+        return ! ! $this->classListeners[$eventName][$class][$format];
     }
 
     public function dispatch($eventName, string $class, string $format, Event $event): void
     {
-        if (!isset($this->listeners[$eventName])) {
+        if ( ! isset($this->listeners[$eventName])) {
             return;
         }
 
         $object = $event instanceof ObjectEvent ? $event->getObject() : null;
         $realClass = is_object($object) ? get_class($object) : '';
-        $objectClass = $realClass !== $class ? ($realClass . $class) : $class;
+        $objectClass = $realClass !== $class ? ($realClass.$class) : $class;
 
-        if (!isset($this->classListeners[$eventName][$objectClass][$format])) {
+        if ( ! isset($this->classListeners[$eventName][$objectClass][$format])) {
             $this->classListeners[$eventName][$objectClass][$format] = $this->initializeListeners($eventName, $class, $format);
         }
 
         foreach ($this->classListeners[$eventName][$objectClass][$format] as $listener) {
 
-            if ($listener[3] !== null && !($object instanceof $listener[3])) {
+            if ($listener[3] !== null && ! ($object instanceof $listener[3])) {
                 continue;
             }