Surfnet\Stepup\Configuration\Value\InstitutionSet

Complexity

Total Complexity

9

Size/Duplication

Total Lines	76
Duplicated Lines	0 %

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	toScalarArray()	0	3	1
A	getInstitutions()	0	3	1
A	equals()	0	3	1
A	create()	0	17	2
A	isOption()	0	3	1
A	__construct()	0	7	2
A	sort()	0	8	1

<?php

declare(strict_types=1);

/**
 * Copyright 2018 SURFnet B.V.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

Missing @link tag in file comment

namespace Surfnet\Stepup\Configuration\Value;

use Surfnet\Stepup\Exception\InvalidArgumentException;

final class InstitutionSet

Missing doc comment for class InstitutionSet

{
    /**
     * @var Institution[]
     */
    private readonly array $institutions;

    /**
     * @param Institution[] $institutions
     */
    private function __construct(array $institutions)
    {
        if ($institutions !== array_unique($institutions)) {
            throw new InvalidArgumentException('Duplicate entries are not allowed in the InstitutionSet');
        }

        $this->institutions = $this->sort($institutions);

The property institutions is declared read-only in Surfnet\Stepup\Configuration\Value\InstitutionSet.

    }

    /**
     * @param Institution[] $institutions
     */

Missing @return tag in function comment

    public static function create(array $institutions): self
    {
        // Verify only institutions are collected in the set
        array_walk(
            $institutions,
            function ($institution, $key) use ($institutions): void {
                if (!$institution instanceof Institution) {
                    throw InvalidArgumentException::invalidType(
                        Institution::class,
                        'institutions',
                        $institutions[$key],
                    );
                }
            },
        );

        return new self($institutions);
    }

    public function equals(InstitutionSet $other): bool
    {
        return $this->toScalarArray() === $other->toScalarArray();
    }

    public function isOption(Institution $institution): bool
    {
        return in_array($institution->getInstitution(), $this->institutions);
    }

    /**
     * @return Institution[]
     */
    public function getInstitutions(): array
    {
        return $this->institutions;
    }

    public function toScalarArray(): array
    {
        return array_map('strval', $this->institutions);
    }

    /**
     * @param Institution[] $institutions

Tag value for @param tag indented incorrectly; expected 2 spaces but found 1

     * @return Institution[]

Tag @return cannot be grouped with parameter tags in a doc comment

     */
    private function sort(array $institutions): array

Private method name "InstitutionSet::sort" must be prefixed with an underscore

    {
        usort(
            $institutions,
            fn(Institution $a, Institution $b): int => strcmp($a->getInstitution(), $b->getInstitution()),
        );

        return $institutions;
    }
}