apie-lib / openapi-schema

src/Spec/Responses.php

<?php


namespace Apie\OpenapiSchema\Spec;

use Apie\OpenapiSchema\ValueObjects\SpecificationExtension;
use Apie\TypeJuggling\PrimitiveArray;
use Apie\ValueObjects\ValueObjectInterface;
use ArrayIterator;
use Exception;
use IteratorAggregate;
use Traversable;

class Responses implements ValueObjectInterface, IteratorAggregate
{
    /**
     * @var Response|null
     */
    private $default;

    /**
     * @var Response[]
     */
    private $statusCodeResponses = [];

    /**
     * @var SpecificationExtension
     */
    private $specificationExtension;

    public function __construct()
    {
        $this->specificationExtension = new SpecificationExtension([]);
    }

    public static function fromNative($value)
    {
        $result = new Responses();
        $extension = [];
        foreach ($value as $key => $itemValue) {
            if ($key === 'default') {
                $result->default = self::responseFromNative($itemValue);

It seems like self::responseFromNative($itemValue) can also be of type Apie\OpenapiSchema\Spec\Reference. However, the property $default is declared as type Apie\OpenapiSchema\Spec\Response|null. Maybe add an additional type check?

            } elseif (preg_match('/^\d+$/', $key)) {
                $result->statusCodeResponses[$key] = self::responseFromNative($itemValue, $key);
            } else {
                $extension[$key] = $itemValue;
            }
        }
        $result->specificationExtension = new SpecificationExtension($extension);
        return $result;
    }

    private static function responseFromNative($itemValue, string $key = 'default')
    {
        $itemValue = (new PrimitiveArray($key))->toNative($itemValue);
        if (isset($itemValue['$ref'])) {
            return Reference::fromNative($itemValue);
        }
        return Response::fromNative($itemValue);
    }

    public function toNative()
    {
        $result = $this->specificationExtension->toNative();
        if ($this->default) {
            $result['default'] = $this->default->toNative();
        }
        foreach ($this->statusCodeResponses as $statusCode => $response) {
            $result[$statusCode] = $response->toNative();
        }
        return $result;
    }

    public function getIterator()
    {
        $list = $this->default ? ['default' => $this->default] : [];
        if ($this->statusCodeResponses) {

The expression $this->statusCodeResponses of type Apie\OpenapiSchema\Spec\Response[] is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            $list = array_merge($list, $this->statusCodeResponses);
        }
        return new ArrayIterator($list);
    }
}