Jose\Easy\AbstractLoader

Complexity

Total Complexity

36

Size/Duplication

Total Lines	255
Duplicated Lines	0 %

Coupling/Cohesion

Components	3
Dependencies	8

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	mandatory()	0	7	1
A	aud()	0	4	1
A	iss()	0	4	1
A	jti()	0	4	1
A	sub()	0	4	1
B	claim()	0	31	6
A	exp()	0	14	4
A	nbf()	0	14	4
A	iat()	0	14	4
A	alg()	0	17	3
A	algs()	0	9	2
A	header()	0	28	5
A	key()	0	8	1
A	keyset()	0	7	1

<?php

declare(strict_types=1);

/*
 * The MIT License (MIT)
 *
 * Copyright (c) 2014-2019 Spomky-Labs
 *
 * This software may be modified and distributed under the terms
 * of the MIT license.  See the LICENSE file for details.
 */

namespace Jose\Easy;

use InvalidArgumentException;
use Jose\Component\Checker;
use Jose\Component\Core\Algorithm;
use Jose\Component\Core\JWK;
use Jose\Component\Core\JWKSet;

abstract class AbstractLoader
{
    /**
     * @var string
     */
    protected $token;

    /**
     * @var JWKSet
     */
    protected $jwkset;

    /**
     * @var Checker\HeaderChecker[]
     */
    protected $headerCheckers = [];

    /**
     * @var Checker\ClaimChecker[]
     */
    protected $claimCheckers = [];

    /**
     * @var string[]
     */
    protected $allowedAlgorithms = [];

    /**
     * @var Algorithm[]
     */
    protected $algorithms = [];

    /**
     * @var string[]
     */
    protected $mandatoryClaims = [];

    protected function __construct(string $token)
    {
        $this->token = $token;
        $this->jwkset = new JWKSet([]);
        $this->claimCheckers = [];
    }

    /**
     * @param string[] $mandatoryClaims
     */
    public function mandatory(array $mandatoryClaims): self
    {
        $clone = clone $this;
        $clone->mandatoryClaims = $mandatoryClaims;

        return $clone;
    }

    public function aud(string $aud, bool $inHeader = false): self
    {
        return $this->claim('aud', new Checker\AudienceChecker($aud, true), $inHeader);
    }

    public function iss(string $iss, bool $inHeader = false): self
    {
        return $this->claim('iss', new Checker\IssuerChecker([$iss], true), $inHeader);
    }

    public function jti(string $jti, bool $inHeader = false): self
    {
        return $this->claim('jti', $jti, $inHeader);
    }

    public function sub(string $sub, bool $inHeader = false): self
    {
        return $this->claim('sub', $sub, $inHeader);
    }

    /**
     * @param null|array|callable|Checker\ClaimChecker $checker
     */
    public function claim(string $key, $checker, bool $inHeader = false): self
    {
        $clone = clone $this;
        if (false === $checker) {
            unset($clone->claimCheckers[$key]);

            return $clone;
        }

        switch (true) {
            case $checker instanceof Checker\ClaimChecker:
                break;
            case \is_callable($checker):
                $checker = new CallableChecker($key, $checker);

                break;
            case \is_array($checker):
                $checker = new CallableChecker($key, static function ($value) use ($checker) {return \in_array($value, $checker, true); });

                break;
            default:
                $checker = new CallableChecker($key, static function ($value) use ($checker) {return $value === $checker; });
        }

        $clone->claimCheckers[$key] = $checker;
        if ($inHeader) {
            return $clone->header($key, $checker);
        }

        return $clone;
    }

    /**
     * @param false|int $leeway
     *
     * @throws InvalidArgumentException if the leeway is negative, not an integer or not false
     */
    public function exp($leeway = 0, bool $inHeader = false): self
    {
        if (false === $leeway) {
            $clone = clone $this;
            unset($clone->claimCheckers['exp']);

            return $clone;
        }
        if (!\is_int($leeway) or $leeway < 0) {
            throw new InvalidArgumentException('First parameter for "exp" claim is invalid. Set false to disable or a positive integer.');
        }

        return $this->claim('exp', new Checker\ExpirationTimeChecker($leeway), $inHeader);
    }

    /**
     * @param false|int $leeway
     *
     * @throws InvalidArgumentException if the leeway is negative, not an integer or not false
     */
    public function nbf($leeway = 0, bool $inHeader = false): self
    {
        if (false === $leeway) {
            $clone = clone $this;
            unset($clone->claimCheckers['nbf']);

            return $clone;
        }
        if (!\is_int($leeway) or $leeway < 0) {
            throw new InvalidArgumentException('First parameter for "nbf" claim is invalid. Set false to disable or a positive integer.');
        }

        return $this->claim('nbf', new Checker\NotBeforeChecker($leeway, true), $inHeader);
    }

    /**
     * @param false|int $leeway
     *
     * @throws InvalidArgumentException if the leeway is negative, not an integer or not false
     */
    public function iat($leeway = 0, bool $inHeader = false): self
    {
        if (false === $leeway) {
            $clone = clone $this;
            unset($clone->claimCheckers['iat']);

            return $clone;
        }
        if (!\is_int($leeway) or $leeway < 0) {
            throw new InvalidArgumentException('First parameter for "iat" claim is invalid. Set false to disable or a positive integer.');
        }

        return $this->claim('iat', new Checker\IssuedAtChecker($leeway, true), $inHeader);
    }

    /**
     * @param Algorithm|string $alg
     *
     * @throws InvalidArgumentException if the algorithm is not a string or an instance of Jose\Component\Core\Algorithm
     */
    public function alg($alg): self
    {
        $clone = clone $this;
        switch (true) {
            case \is_string($alg):
                $clone->allowedAlgorithms[] = $alg;

                return $clone;
            case $alg instanceof Algorithm:
                $clone->algorithms[$alg->name()] = $alg;
                $clone->allowedAlgorithms[] = $alg->name();

                return $clone;
            default:
                throw new InvalidArgumentException('Invalid parameter "alg". Shall be a string or an algorithm instance.');
        }
    }

    /**
     * @param Algorithm[]|string[] $algs
     */
    public function algs($algs): self
    {
        $clone = clone $this;
        foreach ($algs as $alg) {
            $clone = $clone->alg($alg);
        }

        return $clone;
    }

    /**
     * @param array|callable|Checker\HeaderChecker|false|mixed $checker
     */
    public function header(string $key, $checker): self
    {
        $clone = clone $this;
        if (false === $checker) {
            unset($clone->headerCheckers[$key]);

            return $clone;
        }

        switch (true) {
            case $checker instanceof Checker\HeaderChecker:
                break;
            case \is_callable($checker):
                $checker = new CallableChecker($key, $checker);

                break;
            case \is_array($checker):
                $checker = new CallableChecker($key, static function ($value) use ($checker) {return \in_array($value, $checker, true); });

                break;
            default:
                $checker = new CallableChecker($key, static function ($value) use ($checker) {return $value === $checker; });
        }

        $clone->headerCheckers[$key] = $checker;

        return $clone;
    }

    public function key(JWK $jwk): self
    {
        $clone = clone $this;
        $jwkset = $this->jwkset->with($jwk);
        $clone->jwkset = $jwkset;

        return $clone;
    }

    public function keyset(JWKSet $jwkset): self
    {
        $clone = clone $this;
        $clone->jwkset = $jwkset;

        return $clone;
    }
}