OpenConext\Value\Saml\Metadata\ShibbolethMetadataScope

Complexity

Total Complexity

12

Size/Duplication

Total Lines	101
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	2

Importance

Changes	3
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	literal()	0	6	1
A	regexp()	0	6	1
A	__construct()	0	12	2
A	allows()	0	11	2
A	equals()	0	4	2
A	deserialize()	0	7	1
A	serialize()	0	7	1
A	__toString()	0	8	2

<?php

namespace OpenConext\Value\Saml\Metadata;

use OpenConext\Value\Assert\Assertion;
use OpenConext\Value\RegularExpression;
use OpenConext\Value\Serializable;

final class ShibbolethMetadataScope implements Serializable
{
    /**
     * @var string
     */
    private $scope;

    /**
     * @var bool
     */
    private $isRegexp;

    /**
     * @param string $literal
     * @return ShibbolethMetadataScope
     */
    public static function literal($literal)
    {
        Assertion::nonEmptyString($literal, 'literal');

        return new self($literal);
    }

    /**
     * @param string $regexp
     * @return ShibbolethMetadataScope
     */
    public static function regexp($regexp)
    {
        Assertion::nonEmptyString($regexp, 'regexp');

        return new self($regexp, true);
    }

    /**
     * @param string $scope    the scope as defined
     * @param bool   $isRegexp whether or not the scope is a regular expression as identified by the regexp attribute
     */
    public function __construct($scope, $isRegexp = false)
    {
        Assertion::nonEmptyString($scope, 'scope');
        Assertion::boolean($isRegexp);

        if ($isRegexp) {
            Assertion::validRegularExpression('#' . $scope . '#i', 'scope');
        }

        $this->scope    = $scope;
        $this->isRegexp = $isRegexp;
    }

    /**
     * @param string $string
     * @return bool
     */
    public function allows($string)
    {
        Assertion::string($string, 'Scope to check should be a string, "%s" given');

        if (!$this->isRegexp) {
            return strcasecmp($this->scope, $string) === 0;
        }

        $regexp = new RegularExpression('#' . $this->scope . '#i');
        return $regexp->matches($string);
    }

    /**
     * @param ShibbolethMetadataScope $other
     * @return bool
     */
    public function equals(ShibbolethMetadataScope $other)
    {
        return (strcasecmp($this->scope, $other->scope) === 0 && $this->isRegexp === $other->isRegexp);
    }

    public static function deserialize($data)
    {
        Assertion::isArray($data);
        Assertion::keysExist($data, array('is_regexp', 'scope'));

        return new self($data['scope'], $data['is_regexp']);
    }

    public function serialize()
    {
        return array(
            'scope'     => $this->scope,
            'is_regexp' => $this->isRegexp
        );
    }

    public function __toString()
    {
        return sprintf(
            'ShibbolethMetadataScope(scope=%s, regexp=%s)',
            $this->scope,
            $this->isRegexp ? 'true' : 'false'
        );
    }
}