Surfnet\Stepup\Configuration\Value\InstitutionSet

Complexity

Total Complexity

14

Size/Duplication

Total Lines	118
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	2
A	create()	0	18	2
A	createFromStringArray()	0	23	4
A	equals()	0	4	1
A	isOption()	0	4	1
A	getInstitutions()	0	4	1
A	toScalarArray()	0	4	1
A	jsonSerialize()	0	4	1
A	sort()	0	9	1

<?php

/**
 * 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.
 */

namespace Surfnet\Stepup\Configuration\Value;

use JsonSerializable;
use Surfnet\Stepup\Exception\InvalidArgumentException;

final class InstitutionSet implements JsonSerializable
{
    /**
     * @var Institution[]
     */
    private $institutions;

    /**
     * @param Institution[]
     */
    private function __construct(array $institutions)
    {
        // Normalize (lowercase) the institutions for the test on unique entries below.
        $institutionsLowerCased = array_map('strtolower', $institutions);
        if ($institutionsLowerCased !== array_unique($institutionsLowerCased)) {
            throw new InvalidArgumentException('Duplicate entries are not allowed in the InstitutionSet');
        }

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

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

        return new self($institutions);
    }

    /**
     * @param array $institutions
     * @return InstitutionSet
     */
    public static function createFromStringArray(array $institutions)
    {
        // Verify only strings are collected in the set
        array_walk(
            $institutions,
            function ($institution, $key) use ($institutions) {
                if (!is_string($institution)  || strlen(trim($institution)) === 0) {
                    throw InvalidArgumentException::invalidType(
                        'string',
                        'institutions',
                        $institutions[$key]
                    );
                }
            }
        );

        $set = [];
        foreach ($institutions as $institutionTitle) {
            $set[] = new Institution($institutionTitle);
        }

        return self::create($set);
    }

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

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

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

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

    public function jsonSerialize()
    {
        return $this->institutions;
    }

    /**
     * @param Institution[] $institutions
     * @return Institution[]
     */
    private function sort(array $institutions)
    {
        usort($institutions, function(Institution $a, Institution $b)
        {
            return strcmp($a->getInstitution(), $b->getInstitution());
        });

        return $institutions;
    }
}