Yiisoft\Http\Header\DirectiveHeader

Complexity

Total Complexity

7

Size/Duplication

Total Lines	44
Duplicated Lines	0 %

Test Coverage

Coverage

33.33%

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	2
A	withDirective()	0	7	1
A	getDirectives()	0	11	4

<?php

declare(strict_types=1);

namespace Yiisoft\Http\Header;

use InvalidArgumentException;
use Yiisoft\Http\Header\Internal\DirectivesHeaderValue;
use Yiisoft\Http\Header\Value\Unnamed\DirectiveValue;

final class DirectiveHeader extends Header
{
    protected const DEFAULT_VALUE_CLASS = DirectiveValue::class;

    public function __construct(string $nameOrClass)
    {
        parent::__construct($nameOrClass);
        if (!is_a($this->headerClass, DirectivesHeaderValue::class, true)) {
            throw new InvalidArgumentException(
                sprintf("%s class is not an instance of %s", $this->headerClass, DirectivesHeaderValue::class)
            );
        }
    }

    /**
     * @param string $directive
     * @param string|null $argument
     *
     * @throws InvalidArgumentException
     */
    public function withDirective(string $directive, string $argument = null): self
    {
        $clone = clone $this;
        /** @var DirectivesHeaderValue $headerValue */
        $headerValue = new $this->headerClass();
        $clone->addValue($headerValue->withDirective($directive, $argument));
        return $clone;
    }

    /**
     * @param bool $ignoreIncorrect
     * @return string[]|null[] Returns array where keys are directives and values are arguments
     */
    public function getDirectives(bool $ignoreIncorrect = true): array
    {
        $result = [];
        /** @var DirectivesHeaderValue $header */
        foreach ($this->collection as $header) {
            if ($ignoreIncorrect && $header->hasError()) {
                continue;
            }
            $result[] = [$header->getDirective() => $header->getArgument()];
        }
        return $result;

The expression return $result returns an array which contains values of type array which are incompatible with the documented value type null|string.

    }
}