Merge branch 'main' of github.com:php-kafka/php-avro-schema-generator into issue-38-fix-search-class-in-the-same-namespace

Pavel Alexeev · Pavel Alexeev · commit f770360d1148 · 2022-01-08T03:13:34.000+03:00
diff --git a/example/classes/SomeTestClass.php b/example/classes/SomeTestClass.php
@@ -79,4 +79,6 @@ class SomeTestClass extends SomeBaseClass
      * @var array|SomeOtherTestClass[]
      */
     public $someOtherTestClasses;
+
+    public int|string $blaaaaaaaa;
 }
diff --git a/src/Converter/PhpClassConverter.php b/src/Converter/PhpClassConverter.php
@@ -11,21 +11,31 @@
 use PhpKafka\PhpAvroSchemaGenerator\PhpClass\PhpClassProperty;
 use PhpKafka\PhpAvroSchemaGenerator\PhpClass\PhpClassPropertyInterface;
 
-class PhpClassConverter implements PhpClassConverterInterface
+final class PhpClassConverter implements PhpClassConverterInterface
 {
     private ClassParserInterface $parser;
 
     /**
      * @var array<string,int>
      */
-    private array $typesToSkip = [
+    private array $singleTypesToSkip = [
         'null' => 1,
         'object' => 1,
         'callable' => 1,
         'resource' => 1,
         'mixed' => 1
     ];
 
+    /**
+     * @var array<string,int>
+     */
+    private array $unionTypesToSkip = [
+        'object' => 1,
+        'callable' => 1,
+        'resource' => 1,
+        'mixed' => 1
+    ];
+
     /**
      * @param ClassParserInterface $parser
      */
@@ -98,13 +108,17 @@ private function getConvertedType(string $type)
         return $this->getConvertedUnionType($types);
     }
 
-    private function getFullTypeName(string $type): ?string
+    private function getFullTypeName(string $type, bool $isUnionType = false): ?string
     {
+
         if (true === isset(Avro::MAPPED_TYPES[$type])) {
             $type = Avro::MAPPED_TYPES[$type];
         }
 
-        if (true === isset($this->typesToSkip[$type])) {
+        if (
+            (false === $isUnionType && true === isset($this->singleTypesToSkip[$type]))
+            || (true === $isUnionType && true === isset($this->unionTypesToSkip[$type]))
+        ) {
             return null;
         }
 
@@ -134,20 +148,16 @@ private function getConvertedUnionType(array $types): array
         $convertedUnionType = [];
 
         foreach ($types as $type) {
-            if (true === isset($this->typesToSkip[$type])) {
-                continue;
-            }
-
-            if (false === $this->isArrayType($type)) {
-                $convertedUnionType[] = $this->getFullTypeName($type);
+            if (false === $this->isArrayType($type) && null !== $formattedType = $this->getFullTypeName($type, true)) {
+                $convertedUnionType[] = $formattedType;
             }
         }
 
         $arrayType = $this->getArrayType($types);
 
         if (0 !== count($convertedUnionType) && [] !== $arrayType) {
             $convertedUnionType[] = $arrayType;
-        } else {
+        } elseif (0 === count($convertedUnionType) && [] !== $arrayType) {
             return $arrayType;
         }
 
diff --git a/src/Parser/ClassParser.php b/src/Parser/ClassParser.php
@@ -17,7 +17,7 @@
 use ReflectionClass;
 use ReflectionException;
 
-class ClassParser implements ClassParserInterface
+final class ClassParser implements ClassParserInterface
 {
     private ClassPropertyParserInterface $propertyParser;
     private Parser $parser;
@@ -163,13 +163,27 @@ private function getClassProperties(array $statements): array
             if ($statement instanceof Namespace_) {
                 foreach ($statement->stmts as $nsStatement) {
                     if ($nsStatement instanceof Class_) {
-                        foreach ($nsStatement->stmts as $pStatement) {
-                            if ($pStatement instanceof Property) {
-                                $properties[] = $this->propertyParser->parseProperty($pStatement);
-                            }
-                        }
+                        $properties = $this->getAllClassProperties($nsStatement, $properties);
                     }
                 }
+            } elseif ($statement instanceof Class_) {
+                $properties = $this->getAllClassProperties($statement, $properties);
+            }
+        }
+
+        return $properties;
+    }
+
+    /**
+     * @param Class_ $class
+     * @param PhpClassPropertyInterface[] $properties
+     * @return PhpClassPropertyInterface[]
+     */
+    private function getAllClassProperties(Class_ $class, array $properties): array
+    {
+        foreach ($class->stmts as $pStatement) {
+            if ($pStatement instanceof Property) {
+                $properties[] = $this->propertyParser->parseProperty($pStatement);
             }
         }
 
diff --git a/src/Parser/ClassPropertyParser.php b/src/Parser/ClassPropertyParser.php
@@ -9,11 +9,12 @@
 use PhpKafka\PhpAvroSchemaGenerator\PhpClass\PhpClassPropertyInterface;
 use PhpParser\Comment\Doc;
 use PhpParser\Node\Identifier;
+use PhpParser\Node\NullableType;
 use PhpParser\Node\Stmt\Property;
 use PhpParser\Node\UnionType;
 use RuntimeException;
 
-class ClassPropertyParser implements ClassPropertyParserInterface
+final class ClassPropertyParser implements ClassPropertyParserInterface
 {
     private DocCommentParserInterface $docParser;
 
@@ -80,7 +81,12 @@ private function getPropertyName(Property $property): string
      */
     private function getPropertyType(Property $property, array $docComments): string
     {
-        if ($property->type instanceof Identifier) {
+        if ($property->type instanceof NullableType) {
+            if ($property->type->type instanceof Identifier) {
+                $type = Avro::MAPPED_TYPES[$property->type->type->name] ?? $property->type->type->name;
+                return 'null|' . $type;
+            }
+        } elseif ($property->type instanceof Identifier) {
             return Avro::MAPPED_TYPES[$property->type->name] ?? $property->type->name;
         } elseif ($property->type instanceof UnionType) {
             $types = '';
@@ -89,7 +95,7 @@ private function getPropertyType(Property $property, array $docComments): string
             foreach ($property->type->types as $type) {
                 $type = Avro::MAPPED_TYPES[$type->name] ?? $type->name;
                 $types .= $separator . $type;
-                $separator = ',';
+                $separator = '|';
             }
 
             return $types;
@@ -118,11 +124,42 @@ private function getTypeFromDocComment(array $docComments): ?string
 
     /**
      * @param array<string, mixed> $docComments
-     * @return string
+     * @return string|int|float|null
+     */
+    private function getDefaultFromDocComment(array $docComments)
+    {
+        if (false === isset($docComments['avro-default'])) {
+            return PhpClassPropertyInterface::NO_DEFAULT;
+        }
+
+        if (PhpClassPropertyInterface::EMPTY_STRING_DEFAULT === $docComments['avro-default']) {
+            return '';
+        }
+
+        if (true === is_string($docComments['avro-default']) && true === is_numeric($docComments['avro-default'])) {
+            $docComments['avro-default'] = $this->convertStringToNumber($docComments['avro-default']);
+        }
+
+        if ('null' === $docComments['avro-default']) {
+            return null;
+        }
+
+        return $docComments['avro-default'];
+    }
+
+    /**
+     * @param string $number
+     * @return float|int
      */
-    private function getDefaultFromDocComment(array $docComments): string
+    private function convertStringToNumber(string $number)
     {
-        return $docComments['avro-default'] ?? PhpClassPropertyInterface::NO_DEFAULT;
+        $int = (int) $number;
+
+        if (strval($int) == $number) {
+            return $int;
+        }
+
+        return (float) $number;
     }
 
     /**
diff --git a/src/Parser/DocCommentParser.php b/src/Parser/DocCommentParser.php
@@ -4,7 +4,7 @@
 
 namespace PhpKafka\PhpAvroSchemaGenerator\Parser;
 
-class DocCommentParser implements DocCommentParserInterface
+final class DocCommentParser implements DocCommentParserInterface
 {
     /**
      * @param string $docComment
diff --git a/src/PhpClass/PhpClass.php b/src/PhpClass/PhpClass.php
@@ -4,7 +4,7 @@
 
 namespace PhpKafka\PhpAvroSchemaGenerator\PhpClass;
 
-class PhpClass implements PhpClassInterface
+final class PhpClass implements PhpClassInterface
 {
     private string $classBody;
     private string $className;
diff --git a/src/PhpClass/PhpClassProperty.php b/src/PhpClass/PhpClassProperty.php
@@ -6,7 +6,7 @@
 
 use PhpKafka\PhpAvroSchemaGenerator\Parser\PropertyAttributesInterface;
 
-class PhpClassProperty implements PhpClassPropertyInterface
+final class PhpClassProperty implements PhpClassPropertyInterface
 {
     /** @var mixed */
     private $propertyDefault;
diff --git a/src/PhpClass/PhpClassPropertyInterface.php b/src/PhpClass/PhpClassPropertyInterface.php
@@ -7,6 +7,8 @@
 interface PhpClassPropertyInterface
 {
     public const NO_DEFAULT = 'there-was-no-default-set';
+    public const EMPTY_STRING_DEFAULT = 'empty-string-default';
+
 
     /**
      * @return mixed
diff --git a/src/Registry/ClassRegistry.php b/src/Registry/ClassRegistry.php
@@ -8,7 +8,6 @@
 use PhpKafka\PhpAvroSchemaGenerator\Converter\PhpClassConverterInterface;
 use PhpKafka\PhpAvroSchemaGenerator\Exception\ClassRegistryException;
 use PhpKafka\PhpAvroSchemaGenerator\Parser\TokenParser;
-use PhpKafka\PhpAvroSchemaGenerator\PhpClass\PhpClass;
 use PhpKafka\PhpAvroSchemaGenerator\PhpClass\PhpClassInterface;
 use RecursiveDirectoryIterator;
 use RecursiveIteratorIterator;
diff --git a/tests/Integration/Parser/ClassParserTest.php b/tests/Integration/Parser/ClassParserTest.php
@@ -52,7 +52,7 @@ public function testGetProperties()
         $parser = new ClassParser((new ParserFactory())->create(ParserFactory::PREFER_PHP7), $propertyParser);
         $parser->setCode(file_get_contents($filePath));
         $properties = $parser->getProperties();
-        self::assertCount(15, $properties);
+        self::assertCount(16, $properties);
 
         foreach($properties as $property) {
             self::assertInstanceOf(PhpClassPropertyInterface::class, $property);
@@ -84,12 +84,85 @@ public function testClassWithNoParent(): void
 
     }
 
+    public function testClassWithNullableType(): void
+    {
+        $propertyParser = new ClassPropertyParser(new DocCommentParser());
+        $parser = new ClassParser((new ParserFactory())->create(ParserFactory::PREFER_PHP7), $propertyParser);
+        $parser->setCode('
+            <?php
+                class foo {
+                    public ?string $bla;
+                }
+        ');
+        $properties = $parser->getProperties();
+        self::assertEquals(1, count($properties));
+        self::assertEquals('null|string', $properties[0]->getPropertyType());
+    }
+
+    public function testClassWithUnionType(): void
+    {
+        $propertyParser = new ClassPropertyParser(new DocCommentParser());
+        $parser = new ClassParser((new ParserFactory())->create(ParserFactory::PREFER_PHP7), $propertyParser);
+        $parser->setCode('
+            <?php
+                class foo {
+                    public int|string $bla;
+                }
+        ');
+        $properties = $parser->getProperties();
+        self::assertEquals(1, count($properties));
+        self::assertEquals('int|string', $properties[0]->getPropertyType());
+    }
+
+    public function testClassWithDocUnionType(): void
+    {
+        $propertyParser = new ClassPropertyParser(new DocCommentParser());
+        $parser = new ClassParser((new ParserFactory())->create(ParserFactory::PREFER_PHP7), $propertyParser);
+        $parser->setCode('
+            <?php
+                class foo {
+                    /**
+                     * @var int|string
+                     */
+                    public $bla;
+                }
+        ');
+        $properties = $parser->getProperties();
+        self::assertEquals(1, count($properties));
+        self::assertEquals('int|string', $properties[0]->getPropertyType());
+    }
+
+    public function testClassWithAnnotations(): void
+    {
+        $propertyParser = new ClassPropertyParser(new DocCommentParser());
+        $parser = new ClassParser((new ParserFactory())->create(ParserFactory::PREFER_PHP7), $propertyParser);
+        $parser->setCode('
+            <?php
+                class foo {
+                    /**
+                     * @avro-type string
+                     * @avro-default abc def
+                     * @avro-doc some doc bla bla
+                     * @var int|string
+                     */
+                    public $bla;
+                }
+        ');
+        $properties = $parser->getProperties();
+        self::assertEquals(1, count($properties));
+        self::assertEquals('string', $properties[0]->getPropertyType());
+        self::assertEquals('abc def', $properties[0]->getPropertyDefault());
+        self::assertEquals('some doc bla bla', $properties[0]->getPropertyDoc());
+
+    }
+
     public function testClassWithNoParentFile(): void
     {
         $propertyParser = new ClassPropertyParser(new DocCommentParser());
         $parser = new ClassParser((new ParserFactory())->create(ParserFactory::PREFER_PHP7), $propertyParser);
         $parser->setCode('<?php class foo extends \RuntimeException {private $x;}');
-        self::assertEquals([], $parser->getProperties());
-
+        $properties = $parser->getProperties();
+        self::assertEquals(1, count($properties));
+        self::assertEquals('string', $properties[0]->getPropertyType());
     }
 }
diff --git a/tests/Integration/Parser/ClassPropertyParserTest.php b/tests/Integration/Parser/ClassPropertyParserTest.php
diff --git a/tests/Unit/Parser/ClassPropertyParserTest.php b/tests/Unit/Parser/ClassPropertyParserTest.php

Original file line number	Diff line number	Diff line change
`@@ -79,4 +79,6 @@ class SomeTestClass extends SomeBaseClass`
`79`	`79`	`* @var array\|SomeOtherTestClass[]`
`80`	`80`	`*/`
`81`	`81`	`public $someOtherTestClasses;`
	`82`	`+`
	`83`	`+ public int\|string $blaaaaaaaa;`
`82`	`84`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@`
`4`	`4`
`5`	`5`	`namespace PhpKafka\PhpAvroSchemaGenerator\Parser;`
`6`	`6`
`7`		`-class DocCommentParser implements DocCommentParserInterface`
	`7`	`+final class DocCommentParser implements DocCommentParserInterface`
`8`	`8`	`{`
`9`	`9`	`/**`
`10`	`10`	`* @param string $docComment`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@`
`4`	`4`
`5`	`5`	`namespace PhpKafka\PhpAvroSchemaGenerator\PhpClass;`
`6`	`6`
`7`		`-class PhpClass implements PhpClassInterface`
	`7`	`+final class PhpClass implements PhpClassInterface`
`8`	`8`	`{`
`9`	`9`	`private string $classBody;`
`10`	`10`	`private string $className;`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@`
`6`	`6`
`7`	`7`	`use PhpKafka\PhpAvroSchemaGenerator\Parser\PropertyAttributesInterface;`
`8`	`8`
`9`		`-class PhpClassProperty implements PhpClassPropertyInterface`
	`9`	`+final class PhpClassProperty implements PhpClassPropertyInterface`
`10`	`10`	`{`
`11`	`11`	`/** @var mixed */`
`12`	`12`	`private $propertyDefault;`
Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,8 @@`
`7`	`7`	`interface PhpClassPropertyInterface`
`8`	`8`	`{`
`9`	`9`	`public const NO_DEFAULT = 'there-was-no-default-set';`
	`10`	`+ public const EMPTY_STRING_DEFAULT = 'empty-string-default';`
	`11`	`+`
`10`	`12`
`11`	`13`	`/**`
`12`	`14`	`* @return mixed`