PEMBundle::__construct() - Code Metrics - Inspection of "Fix Key-classes" - simplesamlphp/xml-security - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#43)

by Tim

created 2022-12-02 21:04 UTC

PEMBundle::__construct() A

↳ Parent: PEMBundle

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	1
nc	1
nop	1
dl	0
loc	3
rs	10
c	1
b	0
f	0

<?php

declare(strict_types=1);

namespace SimpleSAML\XMLSecurity\CryptoEncoding;

use ArrayIterator;
use Countable;
use IteratorAggregate;
use LogicException;
use RuntimeException;
use SimpleSAML\XMLSecurity\Exception\IOException;
use UnexpectedValueException;

use function array_map;
use function array_merge;
use function base64_decode;
use function count;
use function implode;
use function is_readable;
use function file_get_contents;
use function preg_match_all;
use function preg_replace;

/**
 * Container for multiple PEM objects.
 *
 * The order of PEMs shall be retained, eg. when read from a file.
 */
class PEMBundle implements Countable, IteratorAggregate
{
    /**
     * Array of PEM objects.
     *
     * @var array \SimpleSAML\XMLSecurity\CryptoEncoding\PEM[]
     */
    protected array $pems;


    /**
     * Constructor.
     *
     * @param PEM ...$pems
     */
    public function __construct(PEM ...$pems)
    {
        $this->pems = $pems;
    }


    /**
     * @return string
     */
    public function __toString(): string
    {
        return $this->string();
    }


    /**
     * Initialize from a string.
     *
     * @param string $str
     *
     * @throws \UnexpectedValueException
     *
     * @return self
     */
    public static function fromString(string $str): self
    {
        if (!preg_match_all(PEM::PEM_REGEX, $str, $matches, PREG_SET_ORDER)) {
            throw new UnexpectedValueException('No PEM blocks.');
        }

        $pems = array_map(
            function ($match) {
                $payload = preg_replace('/\s+/', '', $match[2]);
                $data = base64_decode($payload, true);
                if (false === $data) {
                    throw new UnexpectedValueException(
                        'Failed to decode PEM data.'
                    );
                }
                return new PEM($match[1], $data);
            },
            $matches
        );

        return new self(...$pems);
    }


    /**
     * Initialize from a file.
     *
     * @param string $filename
     *
     * @throws \RuntimeException If file reading fails
     *
     * @return self
     */
    public static function fromFile(string $filename): self
    {
        error_clear_last();
        $str = @file_get_contents($filename);

        if (!is_readable($filename) || ($str === false)) {
            $e = error_get_last();
            $error = $e['message'] ?: "Check that the file exists and can be read.";
            throw new IOException(sprintf("File '%s' was not loaded;  %s", $filename, $error));
        }

        return self::fromString($str);
    }


    /**
     * Get self with PEM objects appended.
     *
     * @param \SimpleSAML\XMLSecurity\CryptoEncoding\PEM ...$pems
     *
     * @return self
     */
    public function withPEMs(PEM ...$pems): self
    {
        $obj = clone $this;
        $obj->pems = array_merge($obj->pems, $pems);

        return $obj;
    }


    /**
     * Get all PEMs in a bundle.
     *
     * @return \SimpleSAML\XMLSecurity\CryptoEncoding\PEM[]
     */
    public function all(): array
    {
        return $this->pems;
    }


    /**
     * Get the first PEM in a bundle.
     *
     * @throws \LogicException If bundle contains no PEM objects
     *
     * @return \SimpleSAML\XMLSecurity\CryptoEncoding\PEM
     */
    public function first(): PEM
    {
        if (!count($this->pems)) {
            throw new LogicException('No PEMs.');
        }

        return $this->pems[0];
    }


    /**
     * Get the last PEM in a bundle.
     *
     * @throws \LogicException If bundle contains no PEM objects
     *
     * @return \SimpleSAML\XMLSecurity\CryptoEncoding\PEM
     */
    public function last(): PEM
    {
        if (!count($this->pems)) {
            throw new LogicException('No PEMs.');
        }

        return $this->pems[count($this->pems) - 1];
    }


    /**
     * @see \Countable::count()
     *
     * @return int
     */
    public function count(): int
    {
        return count($this->pems);
    }


    /**
     * Get iterator for PEMs.
     *
     * @see \IteratorAggregate::getIterator()
     *
     * @return \ArrayIterator
     */
    public function getIterator(): ArrayIterator
    {
        return new ArrayIterator($this->pems);
    }


    /**
     * Encode bundle to a string of contiguous PEM blocks.
     *
     * @return string
     */
    public function string(): string
    {
        return implode(
            "\n",
            array_map(
                function (PEM $pem) {
                    return $pem->string();
                },
                $this->pems
            )
        );
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace SimpleSAML\XMLSecurity\CryptoEncoding;
6
7			use ArrayIterator;
8			use Countable;
9			use IteratorAggregate;
10			use LogicException;
11			use RuntimeException;
12			use SimpleSAML\XMLSecurity\Exception\IOException;
13			use UnexpectedValueException;
14
15			use function array_map;
16			use function array_merge;
17			use function base64_decode;
18			use function count;
19			use function implode;
20			use function is_readable;
21			use function file_get_contents;
22			use function preg_match_all;
23			use function preg_replace;
24
25			/**
26			* Container for multiple PEM objects.
27			*
28			* The order of PEMs shall be retained, eg. when read from a file.
29			*/
30			class PEMBundle implements Countable, IteratorAggregate
31			{
32			/**
33			* Array of PEM objects.
34			*
35			* @var array \SimpleSAML\XMLSecurity\CryptoEncoding\PEM[]
36			*/
37			protected array $pems;
38
39
40			/**
41			* Constructor.
42			*
43			* @param PEM ...$pems
44			*/
45			public function __construct(PEM ...$pems)
46			{
47			$this->pems = $pems;
48			}
49
50
51			/**
52			* @return string
53			*/
54			public function __toString(): string
55			{
56			return $this->string();
57			}
58
59
60			/**
61			* Initialize from a string.
62			*
63			* @param string $str
64			*
65			* @throws \UnexpectedValueException
66			*
67			* @return self
68			*/
69			public static function fromString(string $str): self
70			{
71			if (!preg_match_all(PEM::PEM_REGEX, $str, $matches, PREG_SET_ORDER)) {
72			throw new UnexpectedValueException('No PEM blocks.');
73			}
74
75			$pems = array_map(
76			function ($match) {
77			$payload = preg_replace('/\s+/', '', $match[2]);
78			$data = base64_decode($payload, true);
79			if (false === $data) {
80			throw new UnexpectedValueException(
81			'Failed to decode PEM data.'
82			);
83			}
84			return new PEM($match[1], $data);
85			},
86			$matches
87			);
88
89			return new self(...$pems);
90			}
91
92
93			/**
94			* Initialize from a file.
95			*
96			* @param string $filename
97			*
98			* @throws \RuntimeException If file reading fails
99			*
100			* @return self
101			*/
102			public static function fromFile(string $filename): self
103			{
104			error_clear_last();
105			$str = @file_get_contents($filename);
106
107			if (!is_readable($filename) \|\| ($str === false)) {
108			$e = error_get_last();
109			$error = $e['message'] ?: "Check that the file exists and can be read.";
110			throw new IOException(sprintf("File '%s' was not loaded; %s", $filename, $error));
111			}
112
113			return self::fromString($str);
114			}
115
116
117			/**
118			* Get self with PEM objects appended.
119			*
120			* @param \SimpleSAML\XMLSecurity\CryptoEncoding\PEM ...$pems
121			*
122			* @return self
123			*/
124			public function withPEMs(PEM ...$pems): self
125			{
126			$obj = clone $this;
127			$obj->pems = array_merge($obj->pems, $pems);
128
129			return $obj;
130			}
131
132
133			/**
134			* Get all PEMs in a bundle.
135			*
136			* @return \SimpleSAML\XMLSecurity\CryptoEncoding\PEM[]
137			*/
138			public function all(): array
139			{
140			return $this->pems;
141			}
142
143
144			/**
145			* Get the first PEM in a bundle.
146			*
147			* @throws \LogicException If bundle contains no PEM objects
148			*
149			* @return \SimpleSAML\XMLSecurity\CryptoEncoding\PEM
150			*/
151			public function first(): PEM
152			{
153			if (!count($this->pems)) {
154			throw new LogicException('No PEMs.');
155			}
156
157			return $this->pems[0];
158			}
159
160
161			/**
162			* Get the last PEM in a bundle.
163			*
164			* @throws \LogicException If bundle contains no PEM objects
165			*
166			* @return \SimpleSAML\XMLSecurity\CryptoEncoding\PEM
167			*/
168			public function last(): PEM
169			{
170			if (!count($this->pems)) {
171			throw new LogicException('No PEMs.');
172			}
173
174			return $this->pems[count($this->pems) - 1];
175			}
176
177
178			/**
179			* @see \Countable::count()
180			*
181			* @return int
182			*/
183			public function count(): int
184			{
185			return count($this->pems);
186			}
187
188
189			/**
190			* Get iterator for PEMs.
191			*
192			* @see \IteratorAggregate::getIterator()
193			*
194			* @return \ArrayIterator
195			*/
196			public function getIterator(): ArrayIterator
197			{
198			return new ArrayIterator($this->pems);
199			}
200
201
202			/**
203			* Encode bundle to a string of contiguous PEM blocks.
204			*
205			* @return string
206			*/
207			public function string(): string
208			{
209			return implode(
210			"\n",
211			array_map(
212			function (PEM $pem) {
213			return $pem->string();
214			},
215			$this->pems
216			)
217			);
218			}
219			}
220

simplesamlphp / xml-security

Pull Request — master (#43)

PEMBundle::__construct() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like