Merge pull request #21 from clementtalleu/feat/class_metadata

add metadata + tests on prefix

src/Command/GenerateSchema.php

@@ -7,7 +7,7 @@
 use Talleu\RedisOm\Om\Mapping\Entity;
 use Talleu\RedisOm\Om\RedisFormat;
 
-class GenerateSchema
+final class GenerateSchema
 {
     public static function generateSchema(string $dir): void
     {

src/Om/Metadata/ClassMetadata.php

@@ -0,0 +1,137 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Talleu\RedisOm\Om\Metadata;
+
+class ClassMetadata implements MetadataInterface
+{
+    public function __construct(
+        public string $className,
+        public ?array $identifier = [],
+        public ?array $fieldsMapping = [],
+        public ?array $associations = [],
+        public ?array $typesFields = [],
+    ) {
+    }
+
+    public function getName()
+    {
+        return $this->className;
+    }
+
+    public function getIdentifier()
+    {
+        return $this->identifier;
+    }
+
+    public function getReflectionClass()
+    {
+        return new \ReflectionClass($this->className);
+    }
+
+    public function isIdentifier(string $fieldName)
+    {
+        foreach ($this->identifier as $identifier) {
+            if ($identifier === $fieldName) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public function hasField(string $fieldName)
+    {
+        foreach ($this->fieldsMapping as $field) {
+            if ($field === $fieldName) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public function hasAssociation(string $fieldName)
+    {
+        foreach ($this->associations as $association) {
+            if ($association === $fieldName) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public function isSingleValuedAssociation(string $fieldName)
+    {
+        foreach ($this->associations as $association) {
+            if ($association === $fieldName) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    public function isCollectionValuedAssociation(string $fieldName)
+    {
+        return false;
+    }
+
+    public function getFieldNames()
+    {
+        return array_values($this->fieldsMapping);
+    }
+
+    public function getIdentifierFieldNames()
+    {
+        return array_values($this->identifier);
+    }
+
+    public function getAssociationNames()
+    {
+        return array_values($this->associations);
+    }
+
+    public function getTypeOfField(string $fieldName): ?string
+    {
+        foreach ($this->typesFields as $field => $type) {
+            if ($field === $fieldName) {
+                return $type;
+            }
+        }
+
+        return null;
+    }
+
+    public function isAssociationInverseSide(string $assocName)
+    {
+        return false;
+    }
+
+    public function getIdentifierValues(object $object)
+    {
+        return array_values($this->identifier);
+    }
+
+    public function setIdentifier(array $identifier)
+    {
+        $this->identifier = $identifier;
+    }
+
+    public function setFieldsMapping(array $fields)
+    {
+        $this->fieldsMapping = $fields;
+    }
+
+    public function setAssociations(array $associations)
+    {
+        $this->associations = $associations;
+    }
+
+    public function setTypesFields(array $fields)
+    {
+        $this->typesFields = $fields;
+    }
+}

src/Om/Metadata/MetadataFactory.php

@@ -0,0 +1,88 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Talleu\RedisOm\Om\Metadata;
+
+use Talleu\RedisOm\Om\Mapping\Entity;
+use Talleu\RedisOm\Om\Mapping\Id;
+use Talleu\RedisOm\Om\Mapping\Property;
+
+class MetadataFactory
+{
+    private ?\ReflectionClass $reflectionClass = null;
+
+    public function createClassMetadata(string $className): ClassMetadata
+    {
+        $classMetadata = new ClassMetadata($className);
+        $classMetadata->setIdentifier($this->buildIdentifier($className));
+        $classMetadata->setFieldsMapping($this->buildFieldsMapping());
+        $classMetadata->setAssociations($this->buildAssociations());
+        $classMetadata->setTypesFields($this->buildTypesFields());
+
+        return $classMetadata;
+    }
+
+    private function buildIdentifier(string $className): array
+    {
+        $this->reflectionClass = new \ReflectionClass($className);
+        $properties = $this->reflectionClass->getProperties();
+        $identifier = [];
+        foreach ($properties as $property) {
+            $attributeId = $property->getAttributes(Id::class);
+            if ($attributeId !== []) {
+                $identifier[] = $property->getName();
+            }
+        }
+
+        return $identifier;
+    }
+
+    private function buildFieldsMapping(): array
+    {
+        $reflectionProperties = $this->reflectionClass->getProperties();
+        $properties = [];
+        foreach ($reflectionProperties as $property) {
+            $attributeProperty = $property->getAttributes(Property::class);
+            if ($attributeProperty !== []) {
+                $properties[] = $property->getName();
+            }
+        }
+
+        return $properties;
+    }
+
+    private function buildAssociations(): array
+    {
+        $associations = [];
+        $properties = $this->reflectionClass->getProperties();
+        foreach ($properties as $property) {
+            $attributes = $property->getAttributes(Property::class);
+            if ($attributes === []) {
+                continue;
+            }
+
+            $associationClassName = $attributes[0]->getName();
+            $reflectionAssociation = new \ReflectionClass($associationClassName);
+            $attributesMapping = $reflectionAssociation->getAttributes(Entity::class);
+            if ($attributesMapping !== []) {
+                $associations[] = $property->getName();
+            }
+        }
+
+        return $associations;
+    }
+
+    private function buildTypesFields(): array
+    {
+        $fields = [];
+        $properties = $this->reflectionClass->getProperties();
+        foreach ($properties as $property) {
+            /** @var \ReflectionNamedType|null $propertyType */
+            $propertyType = $property->getType();
+            $fields[$property->getName()] = $propertyType?->getName();
+        }
+
+        return $fields;
+    }
+}

src/Om/Metadata/MetadataInterface.php

@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Talleu\RedisOm\Om\Metadata;
+
+interface MetadataInterface
+{
+    public function getName();
+
+    public function getIdentifier();
+
+    public function getReflectionClass();
+
+    public function isIdentifier(string $fieldName);
+
+    public function hasField(string $fieldName);
+
+    public function hasAssociation(string $fieldName);
+
+    public function isSingleValuedAssociation(string $fieldName);
+
+    public function isCollectionValuedAssociation(string $fieldName);
+
+    public function getFieldNames();
+
+    public function getIdentifierFieldNames();
+
+    public function getAssociationNames();
+
+    public function getTypeOfField(string $fieldName);
+
+    public function isAssociationInverseSide(string $assocName);
+
+    public function getIdentifierValues(object $object);
+}

src/Om/RedisObjectManager.php

@@ -10,6 +10,8 @@
 use Talleu\RedisOm\Om\Converters\JsonModel\JsonObjectConverter;
 use Talleu\RedisOm\Om\Key\KeyGenerator;
 use Talleu\RedisOm\Om\Mapping\Entity;
+use Talleu\RedisOm\Om\Metadata\ClassMetadata;
+use Talleu\RedisOm\Om\Metadata\MetadataFactory;
 use Talleu\RedisOm\Om\Persister\ObjectToPersist;
 use Talleu\RedisOm\Om\Persister\PersisterInterface;
 use Talleu\RedisOm\Om\Repository\RepositoryInterface;
@@ -93,19 +95,19 @@ public function getRepository(string $className): RepositoryInterface
         return $objectMapper->repository;
     }
 
-    public function getClassMetadata(string $className)
+    public function getClassMetadata(string $className): ClassMetadata
     {
-        // TODO: Implement getClassMetadata() method.
+        return (new MetadataFactory())->createClassMetadata($className);
     }
 
     public function getMetadataFactory()
     {
-        // TODO: Implement getMetadataFactory() method.
+        return new MetadataFactory();
     }
 
     public function initializeObject(object $obj)
     {
-        // TODO: Implement initializeObject() method.
+        return new $obj();
     }
 
     public function contains(object $object): bool

tests/Fixtures/FixturesGenerator.php

@@ -4,15 +4,10 @@
 
 namespace Talleu\RedisOm\Tests\Fixtures;
 
-use Talleu\RedisOm\Tests\Fixtures\Hash\DummyHash;
-use Talleu\RedisOm\Tests\Fixtures\Json\DummyJson;
-
 class FixturesGenerator
 {
-    public static function generateDummies(string $format): array
+    public static function generateDummies($dummyClass): array
     {
-        $dummyClass = $format === 'JSON' ? DummyJson::class : DummyHash::class;
-
         $dummy =  $dummyClass::create(
             id: 1,
             age: 20,

tests/Fixtures/Hash/PrefixDummyHash.php

@@ -0,0 +1,13 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Talleu\RedisOm\Tests\Fixtures\Hash;
+
+use Talleu\RedisOm\Om\Mapping as RedisOm;
+use Talleu\RedisOm\Tests\Fixtures\AbstractDummy;
+
+#[RedisOm\Entity(prefix: 'dummy')]
+class PrefixDummyHash extends AbstractDummy
+{
+}

tests/Fixtures/Json/PrefixDummyJson.php

@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Talleu\RedisOm\Tests\Fixtures\Json;
+
+use Talleu\RedisOm\Om\Mapping as RedisOm;
+use Talleu\RedisOm\Om\RedisFormat;
+use Talleu\RedisOm\Tests\Fixtures\AbstractDummy;
+
+#[RedisOm\Entity(prefix: 'dummy', format: RedisFormat::JSON->value)]
+class PrefixDummyJson extends AbstractDummy
+{
+}