php-kafka · nick-zh · Dec 15, 2021 · Dec 8, 2021 · Dec 13, 2021 · Dec 13, 2021
diff --git a/phpstan.neon b/phpstan.neon
@@ -5,5 +5,4 @@ parameters:
     ignoreErrors:
         - "#Call to function token_get_all\\(\\) on a separate line has no effect.#"
         - "#Strict comparison using === between non-empty-array<int, mixed> and ',' will always evaluate to false.#"
-        - "#Strict comparison using === between non-empty-array<int, mixed> and ';' will always evaluate to false.#"
-        - "#Method PhpKafka\\\\\\PhpAvroSchemaGenerator\\\\\\Optimizer\\\\\\OptimizerInterface::optimize\\(\\) invoked with 2 parameters, 1 required.#"
+        - "#Strict comparison using === between non-empty-array<int, mixed> and ';' will always evaluate to false.#"
diff --git a/src/Merger/SchemaMerger.php b/src/Merger/SchemaMerger.php
@@ -126,16 +126,12 @@ public function merge(
                 $resolvedTemplate = $this->getResolvedSchemaTemplate($rootSchemaTemplate);
 
                 foreach ($this->optimizers as $optimizer) {
-                    $resolvedTemplate = $resolvedTemplate->withSchemaDefinition(
-                        $optimizer->optimize(
-                            $resolvedTemplate->getSchemaDefinition(),
-                            $resolvedTemplate->isPrimitive()
-                        )
-                    );
+                    $resolvedTemplate = $optimizer->optimize($resolvedTemplate);
                 }
             } catch (SchemaMergerException $e) {
                 throw $e;
             }
+
             $this->exportSchema($resolvedTemplate, $prefixWithNamespace, $useTemplateName);
 
             ++$mergedFiles;

diff --git a/src/Optimizer/FieldOrderOptimizer.php b/src/Optimizer/FieldOrderOptimizer.php
@@ -4,20 +4,22 @@
 
 namespace PhpKafka\PhpAvroSchemaGenerator\Optimizer;
 
+use PhpKafka\PhpAvroSchemaGenerator\Schema\SchemaTemplateInterface;
+
 class FieldOrderOptimizer extends AbstractOptimizer implements OptimizerInterface
 {
     /**
-     * @param string $definition
-     * @return string
+     * @param SchemaTemplateInterface $schemaTemplate
+     * @return SchemaTemplateInterface
      * @throws \JsonException
      */
-    public function optimize(string $definition): string
+    public function optimize(SchemaTemplateInterface $schemaTemplate): SchemaTemplateInterface
     {
-        $data = json_decode($definition, true, JSON_THROW_ON_ERROR);
+        $data = json_decode($schemaTemplate->getSchemaDefinition(), true, JSON_THROW_ON_ERROR);
 
         $data = $this->processSchema($data);
 
-        return json_encode($data, JSON_THROW_ON_ERROR);
+        return $schemaTemplate->withSchemaDefinition(json_encode($data, JSON_THROW_ON_ERROR));
     }
 
     /**

diff --git a/src/Optimizer/FullNameOptimizer.php b/src/Optimizer/FullNameOptimizer.php
@@ -4,21 +4,23 @@
 
 namespace PhpKafka\PhpAvroSchemaGenerator\Optimizer;
 
+use PhpKafka\PhpAvroSchemaGenerator\Schema\SchemaTemplateInterface;
+
 class FullNameOptimizer extends AbstractOptimizer implements OptimizerInterface
 {
     /**
-     * @param string $definition
-     * @return string
+     * @param SchemaTemplateInterface $schemaTemplate
+     * @return SchemaTemplateInterface
      * @throws \JsonException
      */
-    public function optimize(string $definition): string
+    public function optimize(SchemaTemplateInterface $schemaTemplate): SchemaTemplateInterface
     {
-        $data = json_decode($definition, true, JSON_THROW_ON_ERROR);
+        $data = json_decode($schemaTemplate->getSchemaDefinition(), true, JSON_THROW_ON_ERROR);
 
         $currentNamespace = $data['namespace'] ?? '';
         $data = $this->processSchema($currentNamespace, $data, true);
 
-        return json_encode($data, JSON_THROW_ON_ERROR);
+        return $schemaTemplate->withSchemaDefinition(json_encode($data, JSON_THROW_ON_ERROR));
     }
 
     /**

diff --git a/src/Optimizer/OptimizerInterface.php b/src/Optimizer/OptimizerInterface.php
@@ -4,11 +4,13 @@
 
 namespace PhpKafka\PhpAvroSchemaGenerator\Optimizer;
 
+use PhpKafka\PhpAvroSchemaGenerator\Schema\SchemaTemplateInterface;
+
 interface OptimizerInterface
 {
     /**
-     * @param string $definition
-     * @return string
+     * @param SchemaTemplateInterface $schemaTemplate
+     * @return SchemaTemplateInterface
      */
-    public function optimize(string $definition): string;
+    public function optimize(SchemaTemplateInterface $schemaTemplate): SchemaTemplateInterface;
 }
diff --git a/src/Optimizer/PrimitiveSchemaOptimizer.php b/src/Optimizer/PrimitiveSchemaOptimizer.php
@@ -4,25 +4,26 @@
 
 namespace PhpKafka\PhpAvroSchemaGenerator\Optimizer;
 
+use PhpKafka\PhpAvroSchemaGenerator\Schema\SchemaTemplateInterface;
+
 class PrimitiveSchemaOptimizer extends AbstractOptimizer implements OptimizerInterface
 {
     /**
-     * @param string $definition
-     * @param bool $isPrimitive
-     * @return string
+     * @param SchemaTemplateInterface $schemaTemplate
+     * @return SchemaTemplateInterface
      * @throws \JsonException
      */
-    public function optimize(string $definition, bool $isPrimitive = false): string
+    public function optimize(SchemaTemplateInterface $schemaTemplate): SchemaTemplateInterface
     {
-        if (false === $isPrimitive) {
-            return $definition;
+        if (false === $schemaTemplate->isPrimitive()) {
+            return $schemaTemplate;
         }
 
-        $data = json_decode($definition, true, JSON_THROW_ON_ERROR);
+        $data = json_decode($schemaTemplate->getSchemaDefinition(), true, JSON_THROW_ON_ERROR);
 
         $data = $this->processSchema($data);
 
-        return json_encode($data, JSON_THROW_ON_ERROR);
+        return $schemaTemplate->withSchemaDefinition(json_encode($data, JSON_THROW_ON_ERROR));
     }
 
     /**

diff --git a/tests/Unit/Merger/SchemaMergerTest.php b/tests/Unit/Merger/SchemaMergerTest.php
@@ -385,11 +385,11 @@ public function testMerge()
 
         $schemaTemplate = $this->getMockForAbstractClass(SchemaTemplateInterface::class);
         $schemaTemplate
-            ->expects(self::exactly(3))
+            ->expects(self::exactly(2))
             ->method('getSchemaDefinition')
             ->willReturn($definition);
         $schemaTemplate
-            ->expects(self::exactly(2))
+            ->expects(self::exactly(1))
             ->method('withSchemaDefinition')
             ->with($definition)
             ->willReturn($schemaTemplate);
@@ -400,7 +400,7 @@ public function testMerge()
             ->method('getRootSchemas')
             ->willReturn([$schemaTemplate]);
         $optimizer = $this->getMockForAbstractClass(OptimizerInterface::class);
-        $optimizer->expects(self::once())->method('optimize')->with($definition)->willReturn($definition);
+        $optimizer->expects(self::once())->method('optimize')->with($schemaTemplate)->willReturn($schemaTemplate);
         $merger = new SchemaMerger($schemaRegistry, '/tmp/foobar');
         $merger->addOptimizer($optimizer);
         $mergedFiles = $merger->merge(true);
@@ -453,11 +453,11 @@ public function testMergePrimitiveWithOptimizerEnabled()
 
         $schemaTemplate = $this->getMockForAbstractClass(SchemaTemplateInterface::class);
         $schemaTemplate
-            ->expects(self::exactly(3))
+            ->expects(self::exactly(2))
             ->method('getSchemaDefinition')
             ->willReturn($definition);
         $schemaTemplate
-            ->expects(self::exactly(2))
+            ->expects(self::exactly(1))
             ->method('withSchemaDefinition')
             ->with($definition)
             ->willReturn($schemaTemplate);
@@ -466,7 +466,7 @@ public function testMergePrimitiveWithOptimizerEnabled()
             ->method('getFilename')
             ->willReturn('primitive-type.avsc');
         $schemaTemplate
-            ->expects(self::exactly(3))
+            ->expects(self::exactly(2))
             ->method('isPrimitive')
             ->willReturn(true);
 
@@ -476,7 +476,7 @@ public function testMergePrimitiveWithOptimizerEnabled()
             ->method('getRootSchemas')
             ->willReturn([$schemaTemplate]);
         $optimizer = $this->getMockBuilder(PrimitiveSchemaOptimizer::class)->getMock();
-        $optimizer->expects(self::once())->method('optimize')->with($definition, true)->willReturn($definition);
+        $optimizer->expects(self::once())->method('optimize')->with($schemaTemplate)->willReturn($schemaTemplate);
         $merger = new SchemaMerger($schemaRegistry, '/tmp/foobar');
         $merger->addOptimizer($optimizer);
         $merger->merge(true);

diff --git a/tests/Unit/Optimizer/FieldOrderOptimizerTest.php b/tests/Unit/Optimizer/FieldOrderOptimizerTest.php
@@ -5,6 +5,7 @@
 namespace PhpKafka\PhpAvroSchemaGenerator\Tests\Unit\Optimizer;
 
 use PhpKafka\PhpAvroSchemaGenerator\Optimizer\FieldOrderOptimizer;
+use PhpKafka\PhpAvroSchemaGenerator\Schema\SchemaTemplateInterface;
 use PHPUnit\Framework\TestCase;
 
 class FieldOrderOptimizerTest extends TestCase
@@ -203,8 +204,20 @@ public function testOptimize(): void
             ]
         }'));
 
+        $schemaTemplate = $this->getMockForAbstractClass(SchemaTemplateInterface::class);
+        $schemaTemplate
+            ->expects(self::once())
+            ->method('getSchemaDefinition')
+            ->willReturn($schema);
+
+        $schemaTemplate
+            ->expects(self::once())
+            ->method('withSchemaDefinition')
+            ->with($expectedResult)
+            ->willReturn($schemaTemplate);
+
         $optimizer = new FieldOrderOptimizer();
 
-        self::assertEquals($expectedResult, $optimizer->optimize($schema));
+        self::assertInstanceOf(SchemaTemplateInterface::class, $optimizer->optimize($schemaTemplate));
     }
 }
diff --git a/tests/Unit/Optimizer/FullNameOptimizerTest.php b/tests/Unit/Optimizer/FullNameOptimizerTest.php
@@ -5,6 +5,7 @@
 namespace PhpKafka\PhpAvroSchemaGenerator\Tests\Unit\Optimizer;
 
 use PhpKafka\PhpAvroSchemaGenerator\Optimizer\FullNameOptimizer;
+use PhpKafka\PhpAvroSchemaGenerator\Schema\SchemaTemplateInterface;
 use PHPUnit\Framework\TestCase;
 
 class FullNameOptimizerTest extends TestCase
@@ -160,8 +161,21 @@ public function testOptimize(): void
             ]
         }'));
 
+
+        $schemaTemplate = $this->getMockForAbstractClass(SchemaTemplateInterface::class);
+        $schemaTemplate
+            ->expects(self::once())
+            ->method('getSchemaDefinition')
+            ->willReturn($schema);
+
+        $schemaTemplate
+            ->expects(self::once())
+            ->method('withSchemaDefinition')
+            ->with($expectedResult)
+            ->willReturn($schemaTemplate);
+
         $optimizer = new FullNameOptimizer();
 
-        self::assertEquals($expectedResult, $optimizer->optimize($schema));
+        self::assertInstanceOf(SchemaTemplateInterface::class, $optimizer->optimize($schemaTemplate));
     }
 }
diff --git a/tests/Unit/Optimizer/PrimitiveSchemaOptimizerTest.php b/tests/Unit/Optimizer/PrimitiveSchemaOptimizerTest.php
@@ -5,6 +5,7 @@
 namespace PhpKafka\PhpAvroSchemaGenerator\Tests\Unit\Optimizer;
 
 use PhpKafka\PhpAvroSchemaGenerator\Optimizer\PrimitiveSchemaOptimizer;
+use PhpKafka\PhpAvroSchemaGenerator\Schema\SchemaTemplateInterface;
 use PHPUnit\Framework\TestCase;
 
 class PrimitiveSchemaOptimizerTest extends TestCase
@@ -15,9 +16,27 @@ public function testOptimize(): void
 
         $expectedResult = json_encode(json_decode('"string"'));
 
+
+        $schemaTemplate = $this->getMockForAbstractClass(SchemaTemplateInterface::class);
+        $schemaTemplate
+            ->expects(self::once())
+            ->method('getSchemaDefinition')
+            ->willReturn($schema);
+
+        $schemaTemplate
+            ->expects(self::once())
+            ->method('withSchemaDefinition')
+            ->with($expectedResult)
+            ->willReturn($schemaTemplate);
+
+        $schemaTemplate
+            ->expects(self::once())
+            ->method('isPrimitive')
+            ->willReturn(true);
+
         $optimizer = new PrimitiveSchemaOptimizer();
 
-        self::assertEquals($expectedResult, $optimizer->optimize($schema, true));
+        self::assertInstanceOf(SchemaTemplateInterface::class, $optimizer->optimize($schemaTemplate));
     }
 
     public function testOptimizeForStringSchema(): void
@@ -26,19 +45,42 @@ public function testOptimizeForStringSchema(): void
 
         $expectedResult = json_encode(json_decode('"string"'));
 
+
+        $schemaTemplate = $this->getMockForAbstractClass(SchemaTemplateInterface::class);
+        $schemaTemplate
+            ->expects(self::once())
+            ->method('getSchemaDefinition')
+            ->willReturn($schema);
+
+        $schemaTemplate
+            ->expects(self::once())
+            ->method('withSchemaDefinition')
+            ->with($expectedResult)
+            ->willReturn($schemaTemplate);
+
+        $schemaTemplate
+            ->expects(self::once())
+            ->method('isPrimitive')
+            ->willReturn(true);
+
         $optimizer = new PrimitiveSchemaOptimizer();
 
-        self::assertEquals($expectedResult, $optimizer->optimize($schema, true));
+        self::assertInstanceOf(SchemaTemplateInterface::class, $optimizer->optimize($schemaTemplate));
     }
 
     public function testOptimizeForRecordSchema(): void
     {
-        $schema = '{"type":"record","namespace":"com.example","name":"Book","fields":[{"name":"isbn","type":"string"}]}';
+        $schemaTemplate = $this->getMockForAbstractClass(SchemaTemplateInterface::class);
+        $schemaTemplate->expects(self::never())->method('getSchemaDefinition');
+        $schemaTemplate->expects(self::never())->method('withSchemaDefinition');
 
-        $expectedResult = json_encode(json_decode($schema));
+        $schemaTemplate
+            ->expects(self::once())
+            ->method('isPrimitive')
+            ->willReturn(false);
 
         $optimizer = new PrimitiveSchemaOptimizer();
 
-        self::assertEquals($expectedResult, $optimizer->optimize($schema, false));
+        self::assertInstanceOf(SchemaTemplateInterface::class, $optimizer->optimize($schemaTemplate));
     }
 }