rewrite errors and renames variable

matheo · matheo · commit feb1f440f91d · 2023-09-14T12:11:40.000+02:00
diff --git a/src/LiveComponent/src/LiveComponentHydrator.php b/src/LiveComponent/src/LiveComponentHydrator.php
@@ -325,14 +325,14 @@ private function setWritablePaths(array $writablePaths, string $frontendPropName
         return $propertyValue;
     }
 
-    private function dehydrateValue(mixed $value, LivePropMetadata $propMetadata, object $component): mixed
+    private function dehydrateValue(mixed $value, LivePropMetadata $propMetadata, object $parentObject): mixed
     {
         if ($method = $propMetadata->dehydrateMethod()) {
-            if (!method_exists($component, $method)) {
-                throw new \LogicException(sprintf('The "%s" component has a dehydrateMethod of "%s" but the method does not exist.', $component::class, $method));
+            if (!method_exists($parentObject, $method)) {
+                throw new \LogicException(sprintf('The dehydration failed for class "%s" because the "%s" method does not exist.', $parentObject::class, $method));
             }
 
-            return $component->$method($value);
+            return $parentObject->$method($value);
         }
 
         if ($propMetadata->useSerializerForHydration()) {
@@ -348,37 +348,37 @@ private function dehydrateValue(mixed $value, LivePropMetadata $propMetadata, ob
                 $collectionClass = $propMetadata->collectionValueType()->getClassName();
                 foreach ($value as $key => $objectItem) {
                     if (!$objectItem instanceof $collectionClass) {
-                        throw new \LogicException(sprintf('The LiveProp "%s" on component "%s" is an array. We determined the array is full of %s objects, but at least on key had a different value of %s', $propMetadata->getName(), $component::class, $collectionClass, get_debug_type($objectItem)));
+                        throw new \LogicException(sprintf('The LiveProp "%s" on component "%s" is an array. We determined the array is full of %s objects, but at least on key had a different value of %s', $propMetadata->getName(), $parentObject::class, $collectionClass, get_debug_type($objectItem)));
                     }
 
-                    $value[$key] = $this->dehydrateObjectValue($objectItem, $collectionClass, $propMetadata->getFormat(), $component);
+                    $value[$key] = $this->dehydrateObjectValue($objectItem, $collectionClass, $propMetadata->getFormat(), $parentObject);
                 }
             }
 
             if (!$this->isValueValidDehydratedValue($value)) {
                 $badKeys = $this->getNonScalarKeys($value, $propMetadata->getName());
                 $badKeysText = implode(', ', array_map(fn ($key) => sprintf('%s: %s', $key, $badKeys[$key]), array_keys($badKeys)));
-                throw new \LogicException(sprintf('The LiveProp "%s" on component "%s" is an array, but it contains one or more keys that are not scalars: %s', $propMetadata->getName(), $component::class, $badKeysText));
+                throw new \LogicException(sprintf('The LiveProp "%s" on component "%s" is an array, but it contains one or more keys that are not scalars: %s', $propMetadata->getName(), $parentObject::class, $badKeysText));
             }
 
             return $value;
         }
 
         if (!\is_object($value)) {
-            throw new \LogicException(sprintf('Unable to dehydrate value of type "%s" for property "%s" on component "%s". Change this to a simpler type of an object that can be dehydrated. Or set the hydrateWith/dehydrateWith options in LiveProp or set "useSerializerForHydration: true" on the LiveProp to use the serializer.', get_debug_type($value), $propMetadata->getName(), $component::class));
+            throw new \LogicException(sprintf('The "%s" object has a hydrateMethod of "%s" but the method does not exist.', $parentObject::class, $propMetadata->hydrateMethod()));
         }
 
         if (!$propMetadata->getType() || $propMetadata->isBuiltIn()) {
-            throw new \LogicException(sprintf('The "%s" property on component "%s" is missing its property-type. Add the "%s" type so the object can be hydrated later.', $propMetadata->getName(), $component::class, $value::class));
+            throw new \LogicException(sprintf('The "%s" property on component "%s" is missing its property-type. Add the "%s" type so the object can be hydrated later.', $propMetadata->getName(), $parentObject::class, $value::class));
         }
 
         // at this point, we have an object and can assume $propMetadata->getType()
         // is set correctly (needed for hydration later)
 
-        return $this->dehydrateObjectValue($value, $propMetadata->getType(), $propMetadata->getFormat(), $component);
+        return $this->dehydrateObjectValue($value, $propMetadata->getType(), $propMetadata->getFormat(), $parentObject);
     }
 
-    private function dehydrateObjectValue(object $value, string $classType, ?string $dateFormat, object $component): mixed
+    private function dehydrateObjectValue(object $value, string $classType, ?string $dateFormat, object $parentObject): mixed
     {
         if ($value instanceof \DateTimeInterface) {
             return $value->format($dateFormat ?: \DateTimeInterface::RFC3339);
@@ -398,20 +398,20 @@ private function dehydrateObjectValue(object $value, string $classType, ?string
         foreach ((new \ReflectionClass($classType))->getProperties() as $property) {
             $propertyValue = $this->propertyAccessor->getValue($value, $property->getName());
             $propMetadata = $this->liveComponentMetadataFactory->createLivePropMetadata($classType, $property->getName(), $property, new LiveProp());
-            $dehydratedObjectValues[$property->getName()] = $this->dehydrateValue($propertyValue, $propMetadata, $component);
+            $dehydratedObjectValues[$property->getName()] = $this->dehydrateValue($propertyValue, $propMetadata, $parentObject);
         }
 
         return $dehydratedObjectValues;
     }
 
-    private function hydrateValue(mixed $value, LivePropMetadata $propMetadata, object $component): mixed
+    private function hydrateValue(mixed $value, LivePropMetadata $propMetadata, object $parentObject): mixed
     {
         if ($propMetadata->hydrateMethod()) {
-            if (!method_exists($component, $propMetadata->hydrateMethod())) {
-                throw new \LogicException(sprintf('The "%s" component has a hydrateMethod of "%s" but the method does not exist.', $component::class, $propMetadata->hydrateMethod()));
+            if (!method_exists($parentObject, $propMetadata->hydrateMethod())) {
+                throw new \LogicException(sprintf('The "%s" object has a hydrateMethod of "%s" but the method does not exist.', $parentObject::class, $propMetadata->hydrateMethod()));
             }
 
-            return $component->{$propMetadata->hydrateMethod()}($value);
+            return $parentObject->{$propMetadata->hydrateMethod()}($value);
         }
 
         if ($propMetadata->useSerializerForHydration()) {
@@ -421,7 +421,7 @@ private function hydrateValue(mixed $value, LivePropMetadata $propMetadata, obje
         if ($propMetadata->collectionValueType() && Type::BUILTIN_TYPE_OBJECT === $propMetadata->collectionValueType()->getBuiltinType()) {
             $collectionClass = $propMetadata->collectionValueType()->getClassName();
             foreach ($value as $key => $objectItem) {
-                $value[$key] = $this->hydrateObjectValue($objectItem, $collectionClass, true, $component::class, sprintf('%s.%s', $propMetadata->getName(), $key), $component);
+                $value[$key] = $this->hydrateObjectValue($objectItem, $collectionClass, true, $parentObject::class, sprintf('%s.%s', $propMetadata->getName(), $key), $parentObject);
             }
         }
 
@@ -443,7 +443,7 @@ private function hydrateValue(mixed $value, LivePropMetadata $propMetadata, obje
             return $value;
         }
 
-        return $this->hydrateObjectValue($value, $propMetadata->getType(), $propMetadata->allowsNull(), $component::class, $propMetadata->getName(), $component);
+        return $this->hydrateObjectValue($value, $propMetadata->getType(), $propMetadata->allowsNull(), $parentObject::class, $propMetadata->getName(), $parentObject);
     }
 
     private function hydrateObjectValue(mixed $value, string $className, bool $allowsNull, string $componentClassForError, string $propertyPathForError, object $component): ?object
diff --git a/src/LiveComponent/tests/Integration/LiveComponentHydratorTest.php b/src/LiveComponent/tests/Integration/LiveComponentHydratorTest.php
@@ -836,7 +836,7 @@ public function mount()
                             'address' => '1 rue du Bac',
                             'city' => 'Paris',
                         ],
-                    ]
+                    ],
                 ])
                 ->userUpdatesProps(['customerDetails' => ['lastName' => 'Matheo', 'firstName' => 'Daninos', 'address' => ['address' => '3 rue du Bac', 'city' => 'Paris']]])
                 ->assertObjectAfterHydration(function (object $object) {

Original file line number	Diff line number	Diff line change
`@@ -325,14 +325,14 @@ private function setWritablePaths(array $writablePaths, string $frontendPropName`
`325`	`325`	`return $propertyValue;`
`326`	`326`	`}`
`327`	`327`
`328`		`- private function dehydrateValue(mixed $value, LivePropMetadata $propMetadata, object $component): mixed`
	`328`	`+ private function dehydrateValue(mixed $value, LivePropMetadata $propMetadata, object $parentObject): mixed`
`329`	`329`	`{`
`330`	`330`	`if ($method = $propMetadata->dehydrateMethod()) {`
`331`		`- if (!method_exists($component, $method)) {`
`332`		`- throw new \LogicException(sprintf('The "%s" component has a dehydrateMethod of "%s" but the method does not exist.', $component::class, $method));`
	`331`	`+ if (!method_exists($parentObject, $method)) {`
	`332`	`+ throw new \LogicException(sprintf('The dehydration failed for class "%s" because the "%s" method does not exist.', $parentObject::class, $method));`
`333`	`333`	`}`
`334`	`334`
`335`		`- return $component->$method($value);`
	`335`	`+ return $parentObject->$method($value);`
`336`	`336`	`}`
`337`	`337`
`338`	`338`	`if ($propMetadata->useSerializerForHydration()) {`
`@@ -348,37 +348,37 @@ private function dehydrateValue(mixed $value, LivePropMetadata $propMetadata, ob`
`348`	`348`	`$collectionClass = $propMetadata->collectionValueType()->getClassName();`
`349`	`349`	`foreach ($value as $key => $objectItem) {`
`350`	`350`	`if (!$objectItem instanceof $collectionClass) {`
`351`		`- throw new \LogicException(sprintf('The LiveProp "%s" on component "%s" is an array. We determined the array is full of %s objects, but at least on key had a different value of %s', $propMetadata->getName(), $component::class, $collectionClass, get_debug_type($objectItem)));`
	`351`	`+ throw new \LogicException(sprintf('The LiveProp "%s" on component "%s" is an array. We determined the array is full of %s objects, but at least on key had a different value of %s', $propMetadata->getName(), $parentObject::class, $collectionClass, get_debug_type($objectItem)));`
`352`	`352`	`}`
`353`	`353`
`354`		`- $value[$key] = $this->dehydrateObjectValue($objectItem, $collectionClass, $propMetadata->getFormat(), $component);`
	`354`	`+ $value[$key] = $this->dehydrateObjectValue($objectItem, $collectionClass, $propMetadata->getFormat(), $parentObject);`
`355`	`355`	`}`
`356`	`356`	`}`
`357`	`357`
`358`	`358`	`if (!$this->isValueValidDehydratedValue($value)) {`
`359`	`359`	`$badKeys = $this->getNonScalarKeys($value, $propMetadata->getName());`
`360`	`360`	`$badKeysText = implode(', ', array_map(fn ($key) => sprintf('%s: %s', $key, $badKeys[$key]), array_keys($badKeys)));`
`361`		`- throw new \LogicException(sprintf('The LiveProp "%s" on component "%s" is an array, but it contains one or more keys that are not scalars: %s', $propMetadata->getName(), $component::class, $badKeysText));`
	`361`	`+ throw new \LogicException(sprintf('The LiveProp "%s" on component "%s" is an array, but it contains one or more keys that are not scalars: %s', $propMetadata->getName(), $parentObject::class, $badKeysText));`
`362`	`362`	`}`
`363`	`363`
`364`	`364`	`return $value;`
`365`	`365`	`}`
`366`	`366`
`367`	`367`	`if (!\is_object($value)) {`
`368`		`- throw new \LogicException(sprintf('Unable to dehydrate value of type "%s" for property "%s" on component "%s". Change this to a simpler type of an object that can be dehydrated. Or set the hydrateWith/dehydrateWith options in LiveProp or set "useSerializerForHydration: true" on the LiveProp to use the serializer.', get_debug_type($value), $propMetadata->getName(), $component::class));`
	`368`	`+ throw new \LogicException(sprintf('The "%s" object has a hydrateMethod of "%s" but the method does not exist.', $parentObject::class, $propMetadata->hydrateMethod()));`
`369`	`369`	`}`
`370`	`370`
`371`	`371`	`if (!$propMetadata->getType() \|\| $propMetadata->isBuiltIn()) {`
`372`		`- throw new \LogicException(sprintf('The "%s" property on component "%s" is missing its property-type. Add the "%s" type so the object can be hydrated later.', $propMetadata->getName(), $component::class, $value::class));`
	`372`	`+ throw new \LogicException(sprintf('The "%s" property on component "%s" is missing its property-type. Add the "%s" type so the object can be hydrated later.', $propMetadata->getName(), $parentObject::class, $value::class));`
`373`	`373`	`}`
`374`	`374`
`375`	`375`	`// at this point, we have an object and can assume $propMetadata->getType()`
`376`	`376`	`// is set correctly (needed for hydration later)`
`377`	`377`
`378`		`- return $this->dehydrateObjectValue($value, $propMetadata->getType(), $propMetadata->getFormat(), $component);`
	`378`	`+ return $this->dehydrateObjectValue($value, $propMetadata->getType(), $propMetadata->getFormat(), $parentObject);`
`379`	`379`	`}`
`380`	`380`
`381`		`- private function dehydrateObjectValue(object $value, string $classType, ?string $dateFormat, object $component): mixed`
	`381`	`+ private function dehydrateObjectValue(object $value, string $classType, ?string $dateFormat, object $parentObject): mixed`
`382`	`382`	`{`
`383`	`383`	`if ($value instanceof \DateTimeInterface) {`
`384`	`384`	`return $value->format($dateFormat ?: \DateTimeInterface::RFC3339);`
`@@ -398,20 +398,20 @@ private function dehydrateObjectValue(object $value, string $classType, ?string`
`398`	`398`	`foreach ((new \ReflectionClass($classType))->getProperties() as $property) {`
`399`	`399`	`$propertyValue = $this->propertyAccessor->getValue($value, $property->getName());`
`400`	`400`	`$propMetadata = $this->liveComponentMetadataFactory->createLivePropMetadata($classType, $property->getName(), $property, new LiveProp());`
`401`		`- $dehydratedObjectValues[$property->getName()] = $this->dehydrateValue($propertyValue, $propMetadata, $component);`
	`401`	`+ $dehydratedObjectValues[$property->getName()] = $this->dehydrateValue($propertyValue, $propMetadata, $parentObject);`
`402`	`402`	`}`
`403`	`403`
`404`	`404`	`return $dehydratedObjectValues;`
`405`	`405`	`}`
`406`	`406`
`407`		`- private function hydrateValue(mixed $value, LivePropMetadata $propMetadata, object $component): mixed`
	`407`	`+ private function hydrateValue(mixed $value, LivePropMetadata $propMetadata, object $parentObject): mixed`
`408`	`408`	`{`
`409`	`409`	`if ($propMetadata->hydrateMethod()) {`
`410`		`- if (!method_exists($component, $propMetadata->hydrateMethod())) {`
`411`		`- throw new \LogicException(sprintf('The "%s" component has a hydrateMethod of "%s" but the method does not exist.', $component::class, $propMetadata->hydrateMethod()));`
	`410`	`+ if (!method_exists($parentObject, $propMetadata->hydrateMethod())) {`
	`411`	`+ throw new \LogicException(sprintf('The "%s" object has a hydrateMethod of "%s" but the method does not exist.', $parentObject::class, $propMetadata->hydrateMethod()));`
`412`	`412`	`}`
`413`	`413`
`414`		`- return $component->{$propMetadata->hydrateMethod()}($value);`
	`414`	`+ return $parentObject->{$propMetadata->hydrateMethod()}($value);`
`415`	`415`	`}`
`416`	`416`
`417`	`417`	`if ($propMetadata->useSerializerForHydration()) {`
`@@ -421,7 +421,7 @@ private function hydrateValue(mixed $value, LivePropMetadata $propMetadata, obje`
`421`	`421`	`if ($propMetadata->collectionValueType() && Type::BUILTIN_TYPE_OBJECT === $propMetadata->collectionValueType()->getBuiltinType()) {`
`422`	`422`	`$collectionClass = $propMetadata->collectionValueType()->getClassName();`
`423`	`423`	`foreach ($value as $key => $objectItem) {`
`424`		`- $value[$key] = $this->hydrateObjectValue($objectItem, $collectionClass, true, $component::class, sprintf('%s.%s', $propMetadata->getName(), $key), $component);`
	`424`	`+ $value[$key] = $this->hydrateObjectValue($objectItem, $collectionClass, true, $parentObject::class, sprintf('%s.%s', $propMetadata->getName(), $key), $parentObject);`
`425`	`425`	`}`
`426`	`426`	`}`
`427`	`427`
`@@ -443,7 +443,7 @@ private function hydrateValue(mixed $value, LivePropMetadata $propMetadata, obje`
`443`	`443`	`return $value;`
`444`	`444`	`}`
`445`	`445`
`446`		`- return $this->hydrateObjectValue($value, $propMetadata->getType(), $propMetadata->allowsNull(), $component::class, $propMetadata->getName(), $component);`
	`446`	`+ return $this->hydrateObjectValue($value, $propMetadata->getType(), $propMetadata->allowsNull(), $parentObject::class, $propMetadata->getName(), $parentObject);`
`447`	`447`	`}`
`448`	`448`
`449`	`449`	`private function hydrateObjectValue(mixed $value, string $className, bool $allowsNull, string $componentClassForError, string $propertyPathForError, object $component): ?object`