stdClass instead of AssocArray #4

jkowalleck · jkowalleck · commit 5a292eacf020 · 2022-09-27T20:11:07.000+02:00
Signed-off-by: Jan Kowalleck &lt;jan.kowalleck@gmail.com&gt;
diff --git a/src/Core/Serialization/JSON/Normalizers/BomNormalizer.php b/src/Core/Serialization/JSON/Normalizers/BomNormalizer.php
@@ -27,6 +27,7 @@
 use CycloneDX\Core\Models\Bom;
 use CycloneDX\Core\Models\Metadata;
 use CycloneDX\Core\Serialization\JSON\_BaseNormalizer;
+use stdClass;
 
 /**
  * @author jkowalleck
@@ -37,11 +38,11 @@ class BomNormalizer extends _BaseNormalizer
 
     private const BOM_FORMAT = 'CycloneDX';
 
-    public function normalize(Bom $bom): array
+    public function normalize(Bom $bom): object
     {
         $factory = $this->getNormalizerFactory();
 
-        return array_filter(
+        return (object) array_filter(
             [
                 'bomFormat' => self::BOM_FORMAT,
                 'specVersion' => $factory->getSpec()->getVersion(),
@@ -55,19 +56,15 @@ public function normalize(Bom $bom): array
         );
     }
 
-    private function normalizeMetaData(Metadata $metaData): ?array
+    private function normalizeMetaData(Metadata $metaData): ?object
     {
         $factory = $this->getNormalizerFactory();
 
         if (false === $factory->getSpec()->supportsMetaData()) {
             return null;
         }
 
-        $data = $factory->makeForMetaData()->normalize($metaData);
-
-        return empty($data)
-            ? null
-            : $data;
+        return $factory->makeForMetaData()->normalize($metaData);
     }
 
     private function normalizeExternalReferences(Bom $bom): ?array
diff --git a/src/Core/Serialization/JSON/Normalizers/ComponentNormalizer.php b/src/Core/Serialization/JSON/Normalizers/ComponentNormalizer.php
@@ -42,7 +42,7 @@ class ComponentNormalizer extends _BaseNormalizer
     /**
      * @throws DomainException if component has unsupported type
      */
-    public function normalize(Component $component): array
+    public function normalize(Component $component): object
     {
         $spec = $this->getNormalizerFactory()->getSpec();
 
@@ -63,7 +63,7 @@ public function normalize(Component $component): array
             ? $component->getBomRef()->getValue()
             : null;
 
-        return array_filter(
+        return (object) array_filter(
             [
                 'bom-ref' => $bomRef,
                 'type' => $type,
diff --git a/src/Core/Serialization/JSON/Normalizers/ComponentRepositoryNormalizer.php b/src/Core/Serialization/JSON/Normalizers/ComponentRepositoryNormalizer.php
@@ -32,7 +32,9 @@
 class ComponentRepositoryNormalizer extends _BaseNormalizer
 {
     /**
-     * @psalm-return list<mixed>
+     * @return object[]
+     *
+     * @psalm-return list<object>
      */
     public function normalize(ComponentRepository $repo): array
     {
diff --git a/src/Core/Serialization/JSON/Normalizers/DependenciesNormalizer.php b/src/Core/Serialization/JSON/Normalizers/DependenciesNormalizer.php
@@ -28,9 +28,10 @@
 use CycloneDX\Core\Models\BomRef;
 use CycloneDX\Core\Models\Component;
 use CycloneDX\Core\Serialization\JSON\_BaseNormalizer;
+use stdClass;
 
 /**
- * @psalm-type Dependency = array{ref: string, dependsOn?: non-empty-list<string>}
+ * @psalm-type Dependency = object{ref: string, dependsOn?: non-empty-list<string>}
  */
 class DependenciesNormalizer extends _BaseNormalizer
 {
@@ -40,7 +41,7 @@ class DependenciesNormalizer extends _BaseNormalizer
      * Only named {@see \CycloneDX\Core\Models\BomRef BomRefs} will be taken into account.
      * Make sure to use the {@see \CycloneDX\Core\Serialization\BomRefDiscriminator} before calling.
      *
-     * @return array[]
+     * @return object[]
      *
      * @psalm-return list<Dependency>
      */
@@ -76,14 +77,15 @@ public function normalize(Bom $bom): array
     /**
      * @psalm-return Dependency|null
      */
-    private function normalizeDependency(BomRef $componentRef, BomRef ...$dependencyRefs): ?array
+    private function normalizeDependency(BomRef $componentRef, BomRef ...$dependencyRefs): ?object
     {
         $componentRefValue = $componentRef->getValue();
         if (null === $componentRefValue) {
             return null;
         }
 
-        $dep = ['ref' => $componentRefValue];
+        $dep = new stdClass();
+        $dep->ref = $componentRefValue;
 
         $deps = [];
         foreach ($dependencyRefs as $dependencyRef) {
@@ -93,7 +95,7 @@ private function normalizeDependency(BomRef $componentRef, BomRef ...$dependency
             }
         }
         if (!empty($deps)) {
-            $dep['dependsOn'] = $deps;
+            $dep->dependsOn = $deps;
         }
 
         return $dep;
diff --git a/src/Core/Serialization/JSON/Normalizers/ExternalReferenceNormalizer.php b/src/Core/Serialization/JSON/Normalizers/ExternalReferenceNormalizer.php
@@ -40,7 +40,7 @@ class ExternalReferenceNormalizer extends _BaseNormalizer
     /**
      * @throws DomainException when the type was not supported by the spec
      */
-    public function normalize(ExternalReference $externalReference): array
+    public function normalize(ExternalReference $externalReference): object
     {
         $spec = $this->getNormalizerFactory()->getSpec();
         $type = $externalReference->getType();
@@ -52,7 +52,7 @@ public function normalize(ExternalReference $externalReference): array
             }
         }
 
-        return array_filter(
+        return (object) array_filter(
             [
                 'type' => $type,
                 'url' => $externalReference->getUrl(),
diff --git a/src/Core/Serialization/JSON/Normalizers/ExternalReferenceRepositoryNormalizer.php b/src/Core/Serialization/JSON/Normalizers/ExternalReferenceRepositoryNormalizer.php
@@ -32,9 +32,9 @@
 class ExternalReferenceRepositoryNormalizer extends _BaseNormalizer
 {
     /**
-     * @return array[]
+     * @return object[]
      *
-     * @psalm-return list<array>
+     * @psalm-return list<object>
      */
     public function normalize(ExternalReferenceRepository $repo): array
     {
diff --git a/src/Core/Serialization/JSON/Normalizers/HashDictionaryNormalizer.php b/src/Core/Serialization/JSON/Normalizers/HashDictionaryNormalizer.php
@@ -31,6 +31,11 @@
  */
 class HashDictionaryNormalizer extends _BaseNormalizer
 {
+    /**
+     * @return object[]
+     *
+     * @psalm-return list<object>
+     */
     public function normalize(HashDictionary $repo): array
     {
         $hashes = [];
diff --git a/src/Core/Serialization/JSON/Normalizers/HashNormalizer.php b/src/Core/Serialization/JSON/Normalizers/HashNormalizer.php
@@ -34,7 +34,7 @@ class HashNormalizer extends _BaseNormalizer
     /**
      * @throws DomainException
      */
-    public function normalize(string $algorithm, string $content): array
+    public function normalize(string $algorithm, string $content): object
     {
         $spec = $this->getNormalizerFactory()->getSpec();
         if (false === $spec->isSupportedHashAlgorithm($algorithm)) {
@@ -44,7 +44,7 @@ public function normalize(string $algorithm, string $content): array
             throw new DomainException("Invalid hash content: $content", 2);
         }
 
-        return [
+        return (object) [
             'alg' => $algorithm,
             'content' => $content,
         ];
diff --git a/src/Core/Serialization/JSON/Normalizers/LicenseNormalizer.php b/src/Core/Serialization/JSON/Normalizers/LicenseNormalizer.php
@@ -36,31 +36,31 @@ class LicenseNormalizer extends _BaseNormalizer
 {
     use NullAssertionTrait;
 
-    public function normalize(LicenseExpression|DisjunctiveLicenseWithId|DisjunctiveLicenseWithName $license): array
+    public function normalize(LicenseExpression|DisjunctiveLicenseWithId|DisjunctiveLicenseWithName $license): object
     {
         return $license instanceof LicenseExpression
             ? $this->normalizeExpression($license)
             : $this->normalizeDisjunctive($license);
     }
 
-    private function normalizeExpression(LicenseExpression $license): array
+    private function normalizeExpression(LicenseExpression $license): object
     {
         // TODO: IMPLEMENTED IF NEEDED: may throw, if not supported by the spec
         // $this->getNormalizerFactory()->getSpec()->supportsLicenseExpression()
 
-        return ['expression' => $license->getExpression()];
+        return (object) ['expression' => $license->getExpression()];
     }
 
     /**
      * @SuppressWarnings(PHPMD.ShortVariable)
      */
-    private function normalizeDisjunctive(DisjunctiveLicenseWithId|DisjunctiveLicenseWithName $license): array
+    private function normalizeDisjunctive(DisjunctiveLicenseWithId|DisjunctiveLicenseWithName $license): object
     {
         [$id, $name] = $license instanceof DisjunctiveLicenseWithId
             ? [$license->getId(), null]
             : [null, $license->getName()];
 
-        return ['license' => array_filter(
+        return (object) ['license' => (object) array_filter(
             [
                 'id' => $id,
                 'name' => $name,
diff --git a/src/Core/Serialization/JSON/Normalizers/LicenseRepositoryNormalizer.php b/src/Core/Serialization/JSON/Normalizers/LicenseRepositoryNormalizer.php
@@ -31,6 +31,11 @@
  */
 class LicenseRepositoryNormalizer extends _BaseNormalizer
 {
+    /**
+     * @return object[]
+     *
+     * @psalm-return list<object>
+     */
     public function normalize(LicenseRepository $repo): array
     {
         return array_map(
diff --git a/src/Core/Serialization/JSON/Normalizers/MetaDataNormalizer.php b/src/Core/Serialization/JSON/Normalizers/MetaDataNormalizer.php
@@ -36,9 +36,9 @@ class MetaDataNormalizer extends _BaseNormalizer
 {
     use NullAssertionTrait;
 
-    public function normalize(Metadata $metaData): array
+    public function normalize(Metadata $metaData): object
     {
-        return array_filter(
+        return (object) array_filter(
             [
                 // timestamp
                 'tools' => $this->normalizeTools($metaData->getTools()),
@@ -58,7 +58,7 @@ private function normalizeTools(ToolRepository $tools): ?array
             : $this->getNormalizerFactory()->makeForToolRepository()->normalize($tools);
     }
 
-    private function normalizeComponent(?Component $component): ?array
+    private function normalizeComponent(?Component $component): ?object
     {
         if (null === $component) {
             return null;
diff --git a/src/Core/Serialization/JSON/Normalizers/ToolNormalizer.php b/src/Core/Serialization/JSON/Normalizers/ToolNormalizer.php
@@ -36,9 +36,9 @@ class ToolNormalizer extends _BaseNormalizer
 {
     use NullAssertionTrait;
 
-    public function normalize(Tool $tool): array
+    public function normalize(Tool $tool): object
     {
-        return array_filter(
+        return (object) array_filter(
             [
                 'vendor' => $tool->getVendor(),
                 'name' => $tool->getName(),
diff --git a/src/Core/Serialization/JSON/Normalizers/ToolRepositoryNormalizer.php b/src/Core/Serialization/JSON/Normalizers/ToolRepositoryNormalizer.php
@@ -32,9 +32,9 @@
 class ToolRepositoryNormalizer extends _BaseNormalizer
 {
     /**
-     * @return array[]
+     * @return object[]
      *
-     * @psalm-return list<array>
+     * @psalm-return list<object>
      */
     public function normalize(ToolRepository $repo): array
     {
diff --git a/src/Core/Serialization/JsonSerializer.php b/src/Core/Serialization/JsonSerializer.php
@@ -54,26 +54,26 @@ class JsonSerializer extends BaseSerializer
         Version::v1dot4 => 'http://cyclonedx.org/schema/bom-1.4.schema.json',
     ];
 
-    private function getSchemaBase(): array
+    private function setSchemaBase(object $struct): void
     {
         $schema = self::SCHEMA[$this->getSpec()->getVersion()] ?? null;
-
-        return null === $schema
-            ? [] // @codeCoverageIgnore
-            : ['$schema' => $schema];
+        if (null !== $schema) {
+            $struct->{'$schema'} = $schema;
+        }
     }
 
     /**
      * @throws DomainException if something was not supported
      */
     protected function normalize(Bom $bom): string
     {
-        $schemaBase = $this->getSchemaBase();
         $data = (new JSON\NormalizerFactory($this->getSpec()))
             ->makeForBom()
             ->normalize($bom);
 
-        $json = json_encode(array_merge($schemaBase, $data), self::NORMALIZE_OPTIONS);
+        $this->setSchemaBase($data);
+
+        $json = json_encode($data, self::NORMALIZE_OPTIONS);
         \assert(false !== $json); // as option JSON_THROW_ON_ERROR is expected to be set
         \assert('' !== $json);
 

Original file line number	Diff line number	Diff line change
`@@ -27,6 +27,7 @@`
`27`	`27`	`use CycloneDX\Core\Models\Bom;`
`28`	`28`	`use CycloneDX\Core\Models\Metadata;`
`29`	`29`	`use CycloneDX\Core\Serialization\JSON\_BaseNormalizer;`
	`30`	`+use stdClass;`
`30`	`31`
`31`	`32`	`/**`
`32`	`33`	`* @author jkowalleck`
`@@ -37,11 +38,11 @@ class BomNormalizer extends _BaseNormalizer`
`37`	`38`
`38`	`39`	`private const BOM_FORMAT = 'CycloneDX';`
`39`	`40`
`40`		`- public function normalize(Bom $bom): array`
	`41`	`+ public function normalize(Bom $bom): object`
`41`	`42`	`{`
`42`	`43`	`$factory = $this->getNormalizerFactory();`
`43`	`44`
`44`		`- return array_filter(`
	`45`	`+ return (object) array_filter(`
`45`	`46`	`[`
`46`	`47`	`'bomFormat' => self::BOM_FORMAT,`
`47`	`48`	`'specVersion' => $factory->getSpec()->getVersion(),`
`@@ -55,19 +56,15 @@ public function normalize(Bom $bom): array`
`55`	`56`	`);`
`56`	`57`	`}`
`57`	`58`
`58`		`- private function normalizeMetaData(Metadata $metaData): ?array`
	`59`	`+ private function normalizeMetaData(Metadata $metaData): ?object`
`59`	`60`	`{`
`60`	`61`	`$factory = $this->getNormalizerFactory();`
`61`	`62`
`62`	`63`	`if (false === $factory->getSpec()->supportsMetaData()) {`
`63`	`64`	`return null;`
`64`	`65`	`}`
`65`	`66`
`66`		`- $data = $factory->makeForMetaData()->normalize($metaData);`
`67`		`-`
`68`		`- return empty($data)`
`69`		`- ? null`
`70`		`- : $data;`
	`67`	`+ return $factory->makeForMetaData()->normalize($metaData);`
`71`	`68`	`}`
`72`	`69`
`73`	`70`	`private function normalizeExternalReferences(Bom $bom): ?array`
Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,9 @@`
`32`	`32`	`class ComponentRepositoryNormalizer extends _BaseNormalizer`
`33`	`33`	`{`
`34`	`34`	`/**`
`35`		`- * @psalm-return list<mixed>`
	`35`	`+ * @return object[]`
	`36`	`+ *`
	`37`	`+ * @psalm-return list<object>`
`36`	`38`	`*/`
`37`	`39`	`public function normalize(ComponentRepository $repo): array`
`38`	`40`	`{`
Original file line number	Diff line number	Diff line change
`@@ -28,9 +28,10 @@`
`28`	`28`	`use CycloneDX\Core\Models\BomRef;`
`29`	`29`	`use CycloneDX\Core\Models\Component;`
`30`	`30`	`use CycloneDX\Core\Serialization\JSON\_BaseNormalizer;`
	`31`	`+use stdClass;`
`31`	`32`
`32`	`33`	`/**`
`33`		`- * @psalm-type Dependency = array{ref: string, dependsOn?: non-empty-list<string>}`
	`34`	`+ * @psalm-type Dependency = object{ref: string, dependsOn?: non-empty-list<string>}`
`34`	`35`	`*/`
`35`	`36`	`class DependenciesNormalizer extends _BaseNormalizer`
`36`	`37`	`{`
`@@ -40,7 +41,7 @@ class DependenciesNormalizer extends _BaseNormalizer`
`40`	`41`	`* Only named {@see \CycloneDX\Core\Models\BomRef BomRefs} will be taken into account.`
`41`	`42`	`* Make sure to use the {@see \CycloneDX\Core\Serialization\BomRefDiscriminator} before calling.`
`42`	`43`	`*`
`43`		`- * @return array[]`
	`44`	`+ * @return object[]`
`44`	`45`	`*`
`45`	`46`	`* @psalm-return list<Dependency>`
`46`	`47`	`*/`
`@@ -76,14 +77,15 @@ public function normalize(Bom $bom): array`
`76`	`77`	`/**`
`77`	`78`	`* @psalm-return Dependency\|null`
`78`	`79`	`*/`
`79`		`- private function normalizeDependency(BomRef $componentRef, BomRef ...$dependencyRefs): ?array`
	`80`	`+ private function normalizeDependency(BomRef $componentRef, BomRef ...$dependencyRefs): ?object`
`80`	`81`	`{`
`81`	`82`	`$componentRefValue = $componentRef->getValue();`
`82`	`83`	`if (null === $componentRefValue) {`
`83`	`84`	`return null;`
`84`	`85`	`}`
`85`	`86`
`86`		`- $dep = ['ref' => $componentRefValue];`
	`87`	`+ $dep = new stdClass();`
	`88`	`+ $dep->ref = $componentRefValue;`
`87`	`89`
`88`	`90`	`$deps = [];`
`89`	`91`	`foreach ($dependencyRefs as $dependencyRef) {`
`@@ -93,7 +95,7 @@ private function normalizeDependency(BomRef $componentRef, BomRef ...$dependency`
`93`	`95`	`}`
`94`	`96`	`}`
`95`	`97`	`if (!empty($deps)) {`
`96`		`- $dep['dependsOn'] = $deps;`
	`98`	`+ $dep->dependsOn = $deps;`
`97`	`99`	`}`
`98`	`100`
`99`	`101`	`return $dep;`
Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ class ExternalReferenceNormalizer extends _BaseNormalizer`
`40`	`40`	`/**`
`41`	`41`	`* @throws DomainException when the type was not supported by the spec`
`42`	`42`	`*/`
`43`		`- public function normalize(ExternalReference $externalReference): array`
	`43`	`+ public function normalize(ExternalReference $externalReference): object`
`44`	`44`	`{`
`45`	`45`	`$spec = $this->getNormalizerFactory()->getSpec();`
`46`	`46`	`$type = $externalReference->getType();`
`@@ -52,7 +52,7 @@ public function normalize(ExternalReference $externalReference): array`
`52`	`52`	`}`
`53`	`53`	`}`
`54`	`54`
`55`		`- return array_filter(`
	`55`	`+ return (object) array_filter(`
`56`	`56`	`[`
`57`	`57`	`'type' => $type,`
`58`	`58`	`'url' => $externalReference->getUrl(),`
Original file line number	Diff line number	Diff line change
`@@ -32,9 +32,9 @@`
`32`	`32`	`class ExternalReferenceRepositoryNormalizer extends _BaseNormalizer`
`33`	`33`	`{`
`34`	`34`	`/**`
`35`		`- * @return array[]`
	`35`	`+ * @return object[]`
`36`	`36`	`*`
`37`		`- * @psalm-return list<array>`
	`37`	`+ * @psalm-return list<object>`
`38`	`38`	`*/`
`39`	`39`	`public function normalize(ExternalReferenceRepository $repo): array`
`40`	`40`	`{`
Original file line number	Diff line number	Diff line change
`@@ -31,6 +31,11 @@`
`31`	`31`	`*/`
`32`	`32`	`class HashDictionaryNormalizer extends _BaseNormalizer`
`33`	`33`	`{`
	`34`	`+ /**`
	`35`	`+ * @return object[]`
	`36`	`+ *`
	`37`	`+ * @psalm-return list<object>`
	`38`	`+ */`
`34`	`39`	`public function normalize(HashDictionary $repo): array`
`35`	`40`	`{`
`36`	`41`	`$hashes = [];`
Original file line number	Diff line number	Diff line change
`@@ -36,31 +36,31 @@ class LicenseNormalizer extends _BaseNormalizer`
`36`	`36`	`{`
`37`	`37`	`use NullAssertionTrait;`
`38`	`38`
`39`		`- public function normalize(LicenseExpression\|DisjunctiveLicenseWithId\|DisjunctiveLicenseWithName $license): array`
	`39`	`+ public function normalize(LicenseExpression\|DisjunctiveLicenseWithId\|DisjunctiveLicenseWithName $license): object`
`40`	`40`	`{`
`41`	`41`	`return $license instanceof LicenseExpression`
`42`	`42`	`? $this->normalizeExpression($license)`
`43`	`43`	`: $this->normalizeDisjunctive($license);`
`44`	`44`	`}`
`45`	`45`
`46`		`- private function normalizeExpression(LicenseExpression $license): array`
	`46`	`+ private function normalizeExpression(LicenseExpression $license): object`
`47`	`47`	`{`
`48`	`48`	`// TODO: IMPLEMENTED IF NEEDED: may throw, if not supported by the spec`
`49`	`49`	`// $this->getNormalizerFactory()->getSpec()->supportsLicenseExpression()`
`50`	`50`
`51`		`- return ['expression' => $license->getExpression()];`
	`51`	`+ return (object) ['expression' => $license->getExpression()];`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`/**`
`55`	`55`	`* @SuppressWarnings(PHPMD.ShortVariable)`
`56`	`56`	`*/`
`57`		`- private function normalizeDisjunctive(DisjunctiveLicenseWithId\|DisjunctiveLicenseWithName $license): array`
	`57`	`+ private function normalizeDisjunctive(DisjunctiveLicenseWithId\|DisjunctiveLicenseWithName $license): object`
`58`	`58`	`{`
`59`	`59`	`[$id, $name] = $license instanceof DisjunctiveLicenseWithId`
`60`	`60`	`? [$license->getId(), null]`
`61`	`61`	`: [null, $license->getName()];`
`62`	`62`
`63`		`- return ['license' => array_filter(`
	`63`	`+ return (object) ['license' => (object) array_filter(`
`64`	`64`	`[`
`65`	`65`	`'id' => $id,`
`66`	`66`	`'name' => $name,`