Unbuilder the builders

src/Console/Service/YieldsClassDefinitions.php

@@ -4,24 +4,19 @@
 
 namespace Membrane\Console\Service;
 
-use Membrane\Filter;
 use Membrane\Console\Template;
-use Membrane\OpenAPI\Builder\OpenAPIRequestBuilder;
-use Membrane\OpenAPI\Builder\OpenAPIResponseBuilder;
+use Membrane\Filter;
+use Membrane\OpenAPI\Builder\Internal\Request;
+use Membrane\OpenAPI\Builder\Internal\Response;
 use Membrane\OpenAPI\ExtractPathParameters\PathParameterExtractor;
-use Membrane\OpenAPI\Specification\OpenAPIRequest;
-use Membrane\OpenAPI\Specification\OpenAPIResponse;
-use Membrane\OpenAPIReader\Exception\CannotRead;
-use Membrane\OpenAPIReader\Exception\CannotSupport;
-use Membrane\OpenAPIReader\Exception\InvalidOpenAPI;
 use Membrane\OpenAPIReader\MembraneReader;
 use Membrane\OpenAPIReader\OpenAPIVersion;
 use Membrane\OpenAPIReader\ValueObject\Valid\{Enum\Method, V30, V31};
 
 final class YieldsClassDefinitions
 {
-    private OpenAPIRequestBuilder $requestBuilder;
-    private OpenAPIResponseBuilder $responseBuilder;
+    private Request $requestBuilder;
+    private Response $responseBuilder;
 
     public function __construct(
         private readonly \Psr\Log\LoggerInterface $logger,
@@ -61,11 +56,9 @@ public function __invoke(
                         namespace: "$cacheNamespace\\Request",
                         name: $className,
                         processor: $this->getRequestBuilder()->build(
-                            new OpenAPIRequest(
-                                new PathParameterExtractor($pathUrl),
-                                $path,
-                                $methodObject,
-                            )
+                            new PathParameterExtractor($pathUrl),
+                            $path,
+                            $methodObject,
                         )
                     );
                 }
@@ -80,13 +73,7 @@ public function __invoke(
                         yield new Template\Processor(
                             namespace: "$cacheNamespace\\Response\\$prefixedCode",
                             name: $className,
-                            processor: $this->getResponseBuilder()->build(
-                                new OpenAPIResponse(
-                                    $operation->operationId,
-                                    (string)$code,
-                                    $response,
-                                )
-                            )
+                            processor: $this->getResponseBuilder()->build($response),
                         );
                     }
                 }
@@ -113,10 +100,10 @@ public function __invoke(
     private function readOpenAPIFile(string $filepath): V30\OpenAPI | V31\OpenAPI
     {
         $this->logger->info("Reading OpenAPI from $filepath");
-        return (new MembraneReader([
+        return new MembraneReader([
             OpenAPIVersion::Version_3_0,
             OpenAPIVersion::Version_3_1
-        ]))->readFromAbsoluteFilePath($filepath);
+        ])->readFromAbsoluteFilePath($filepath);
     }
 
     /** @param array<string,string> $existingClassNames */
@@ -143,20 +130,20 @@ private function createSuitableClassName(string $nameToConvert, array $existingC
     }
 
 
-    private function getRequestBuilder(): OpenAPIRequestBuilder
+    private function getRequestBuilder(): Request
     {
         if (!isset($this->requestBuilder)) {
-            $this->requestBuilder = new OpenAPIRequestBuilder();
+            $this->requestBuilder = new Request();
             return $this->requestBuilder;
         }
 
         return $this->requestBuilder;
     }
 
-    private function getResponseBuilder(): OpenAPIResponseBuilder
+    private function getResponseBuilder(): Response
     {
         if (!isset($this->responseBuilder)) {
-            $this->responseBuilder = new OpenAPIResponseBuilder();
+            $this->responseBuilder = new Response();
             return $this->responseBuilder;
         }
         return $this->responseBuilder;

src/OpenAPI/Builder/Arrays.php → src/OpenAPI/Builder/Internal/Arrays.php

@@ -2,15 +2,18 @@
 
 declare(strict_types=1);
 
-namespace Membrane\OpenAPI\Builder;
+namespace Membrane\OpenAPI\Builder\Internal;
 
-use Membrane\Builder\Specification;
 use Membrane\Filter;
+use Membrane\OpenAPI\Exception\CannotProcessSpecification;
 use Membrane\OpenAPI\Filter\FormatStyle\Form;
 use Membrane\OpenAPI\Filter\FormatStyle\Matrix;
 use Membrane\OpenAPI\Filter\FormatStyle\PipeDelimited;
 use Membrane\OpenAPI\Filter\FormatStyle\SpaceDelimited;
+use Membrane\OpenAPIReader\ValueObject\Valid\{V30, V31};
 use Membrane\OpenAPIReader\ValueObject\Valid\Enum\Style;
+use Membrane\OpenAPIReader\ValueObject\Valid\Enum\Type;
+use Membrane\OpenAPIReader\ValueObject\Value;
 use Membrane\Processor;
 use Membrane\Processor\BeforeSet;
 use Membrane\Processor\Collection;
@@ -19,38 +22,47 @@
 use Membrane\Validator\Collection\Unique;
 use Membrane\Validator\Type\IsList;
 
-class Arrays extends APIBuilder
+/**
+ * @internal see README.md
+ */
+class Arrays extends Schema
 {
-    public function supports(Specification $specification): bool
-    {
-        return $specification instanceof \Membrane\OpenAPI\Specification\Arrays;
-    }
-
-    public function build(Specification $specification): Processor
-    {
-        assert($specification instanceof \Membrane\OpenAPI\Specification\Arrays);
+    public function build(
+        string $fieldName,
+        V30\Keywords | V31\Keywords $keywords,
+        bool $convertFromString,
+        bool $convertFromArray,
+        ?string $style,
+        ?bool $explode,
+    ): Processor {
+        if (!in_array(Type::Array, $keywords->types)) {
+            throw CannotProcessSpecification::mismatchedType(
+                ['array'],
+                array_map(fn($t) => $t->value, $keywords->types),
+            );
+        }
 
-        $beforeChain = $specification->convertFromArray ?
+        $beforeChain = $convertFromArray ?
             [new Filter\String\Implode(',')] :
             [];
 
-        if (isset($specification->style)) {
+        if (isset($style)) {
             $beforeChain = array_merge(
                 $beforeChain,
-                match (Style::from($specification->style)) {
+                match (Style::from($style)) {
                     Style::Matrix => [
-                        new Matrix('array', $specification->explode ?? false),
+                        new Matrix('array', $explode ?? false),
                     ],
                     Style::Label => [
                         new Filter\String\LeftTrim('.'),
                         new Filter\String\Explode(
-                            $specification->explode ?? false ?
+                            $explode ?? false ?
                                 '.' :
                                 ','
                         ),
                     ],
                     Style::Form => [
-                        new Form('array', $specification->explode ?? true),
+                        new Form('array', $explode ?? true),
                     ],
                     Style::Simple => [
                         new Filter\String\Explode(',')
@@ -64,30 +76,39 @@ public function build(Specification $specification): Processor
 
         $beforeChain[] = new IsList();
 
-        if ($specification->enum !== null) {
-            $beforeChain[] = new Contained($specification->enum);
+        if (
+            $keywords->enum !== null
+        ) {
+            $beforeChain[] = new Contained(array_map(
+                fn(Value $v) => $v->value,
+                $keywords->enum,
+            ));
         }
 
-        if ($specification->minItems > 0 || $specification->maxItems !== null) {
-            $beforeChain[] = new Count($specification->minItems, $specification->maxItems);
+        if (
+            $keywords->minItems > 0
+            || $keywords->maxItems !== null
+        ) {
+            $beforeChain[] = new Count(
+                $keywords->minItems,
+                $keywords->maxItems,
+            );
         }
 
-        if ($specification->uniqueItems === true) {
+        if ($keywords->uniqueItems === true) {
             $beforeChain[] = new Unique();
         }
 
         $beforeSet = new BeforeSet(...$beforeChain);
 
-        $collection = new Collection(
-            $specification->fieldName,
+        return new Collection(
+            $fieldName,
             $beforeSet,
             $this->fromSchema(
-                $specification->items,
+                $keywords->items,
                 '',
-                $specification->convertFromString,
+                $convertFromString,
             )
         );
-
-        return $collection;
     }
 }

src/OpenAPI/Builder/Internal/Numeric.php

@@ -0,0 +1,144 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Membrane\OpenAPI\Builder\Internal;
+
+use Membrane\Filter;
+use Membrane\Filter\String\LeftTrim;
+use Membrane\Filter\Type\ToFloat;
+use Membrane\Filter\Type\ToInt;
+use Membrane\Filter\Type\ToNumber;
+use Membrane\OpenAPI\Exception\CannotProcessSpecification;
+use Membrane\OpenAPI\Filter\FormatStyle\Form;
+use Membrane\OpenAPI\Filter\FormatStyle\Matrix;
+use Membrane\OpenAPIReader\ValueObject\Valid\{V30, V31};
+use Membrane\OpenAPIReader\ValueObject\Valid\Enum\Style;
+use Membrane\OpenAPIReader\ValueObject\Valid\Enum\Type;
+use Membrane\OpenAPIReader\ValueObject\Value;
+use Membrane\Processor;
+use Membrane\Processor\Field;
+use Membrane\Validator;
+use Membrane\Validator\Collection\Contained;
+use Membrane\Validator\Numeric\Maximum;
+use Membrane\Validator\Numeric\Minimum;
+use Membrane\Validator\Numeric\MultipleOf;
+use Membrane\Validator\String\IntString;
+use Membrane\Validator\String\NumericString;
+use Membrane\Validator\Type\IsFloat;
+use Membrane\Validator\Type\IsInt;
+use Membrane\Validator\Type\IsNumber;
+
+/**
+ * @internal see README.md
+ */
+final readonly class Numeric
+{
+    public function build(
+        string $fieldName,
+        V30\Keywords | V31\Keywords $keywords,
+        bool $convertFromString = false,
+        bool $convertFromArray = false,
+        ?string $style = null,
+    ): Processor {
+        $types = $keywords->types;
+        if (in_array(Type::Integer, $types)) {
+            $type = Type::Integer->value;
+        } elseif (in_array(Type::Number, $types)) {
+            $type = Type::Number->value;
+        } else {
+            throw CannotProcessSpecification::mismatchedType(
+                ['number', 'integer'],
+                array_map(fn($t) => $t->value, $keywords->types),
+            );
+        }
+
+        $chain = $convertFromArray ?
+            [new Filter\String\Implode(',')] :
+            [];
+
+        if (isset($style)) {
+            switch (Style::tryFrom($style)) {
+                case Style::Matrix:
+                    $chain[] = new Matrix($type, false);
+                    break;
+                case Style::Label:
+                    $chain[] = new LeftTrim('.');
+                    break;
+                case Style::Form:
+                case Style::SpaceDelimited:
+                case Style::PipeDelimited:
+                    $chain[] = new Form($type, false);
+                    break;
+            }
+        }
+
+        $chain = array_merge($chain, $type === 'number'
+            ? $this->handleNumber($keywords, $convertFromString)
+            : $this->handleInteger($keywords, $convertFromString));
+
+        if (
+            $keywords->enum !== null
+        ) {
+            $chain[] = new Contained(array_map(
+                fn(Value $v) => $v->value,
+                $keywords->enum,
+            ));
+        }
+
+        $chain = array_merge(
+            $chain,
+            $this->handleNumericConstraints($keywords),
+        );
+
+        return new Field($fieldName, ...$chain);
+    }
+
+    /** @return Filter[]|Validator[] */
+    private function handleNumber(
+        V30\Keywords | V31\Keywords $keywords,
+        bool $convertFromString,
+    ): array {
+        if (in_array($keywords->format, ['float', 'double'], true)) {
+            return $convertFromString ? [new NumericString(), new ToFloat()] : [new IsFloat()];
+        } else {
+            return $convertFromString ? [new NumericString(), new ToNumber()] : [new IsNumber()];
+        }
+    }
+
+    /** @return Filter[]|Validator[] */
+    private function handleInteger(
+        V30\Keywords | V31\Keywords $keywords,
+        bool $convertFromString,
+    ): array {
+        return $convertFromString ? [new IntString(), new ToInt()] : [new IsInt()];
+    }
+
+    /** @return Validator[] */
+    private function handleNumericConstraints(
+        V30\Keywords | V31\Keywords $keywords,
+    ): array {
+        $chain = [];
+        // if keywords->maximum !== null
+        // keywords->maximum->limit
+        if ($keywords->maximum !== null) {
+            $chain[] = new Maximum(
+                $keywords->maximum->limit,
+                $keywords->maximum->exclusive,
+            );
+        }
+
+        if ($keywords->minimum !== null) {
+            $chain[] = new Minimum(
+                $keywords->minimum->limit,
+                $keywords->minimum->exclusive,
+            );
+        }
+
+        if ($keywords->multipleOf !== null) {
+            $chain[] = new MultipleOf($keywords->multipleOf);
+        }
+
+        return $chain;
+    }
+}