HeaderValue::__construct() - Code Metrics - Inspection of "add appveyor" - genkgo/mail - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#12)

by Frederik

created 2018-01-04 22:10 UTC

HeaderValue::__construct() A

↳ Parent: HeaderValue

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	6
rs	9.4285
c	0
b	0
f	0
ccs	2
cts	2
cp	1
cc	1
eloc	3
nc	1
nop	1
crap	1

<?php
declare(strict_types=1);

namespace Genkgo\Mail\Header;

/**
 * Class HeaderValue
 * @package Genkgo\Mail\Header
 */
final class HeaderValue
{
    /**
     *
     */
    private CONST PARSE_START = 1;
    /**
     *
     */
    private CONST PARSE_QUOTE = 2;
    /**
     * @var string
     */
    private $value;
    /**
     * @var array
     */
    private $parameters = [];
    /**
     * @var array
     */
    private $parametersForceNewLine = [];
    /**
     * @var bool
     */
    private $needsEncoding = true;

    /**
     * HeaderValue constructor.
     * @param string $value
     */
    public function __construct(string $value)
    {
        $this->assertValid($value);

        $this->value = $value;
    }

    /**
     * @param HeaderValueParameter $parameter
     * @param bool $forceNewLine
     * @return HeaderValue
     */
    public function withParameter(HeaderValueParameter $parameter, bool $forceNewLine = false): HeaderValue
    {
        $clone = clone $this;
        $clone->parameters[$parameter->getName()] = $parameter;
        $clone->parametersForceNewLine[$parameter->getName()] = $forceNewLine;
        return $clone;
    }

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

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

        if ($this->needsEncoding) {
            $value = (new OptimalEncodedHeaderValue($value));
        }

        $parameters = [];

        foreach ($this->parameters as $name => $parameter) {
            $parameters[] = sprintf(
                ';%s%s',
                empty($this->parametersForceNewLine[$name]) ? ' ' : "\r\n ",
                (string) $parameter
            );
        }

        return implode('', array_merge([$value], $parameters));
    }

    /**
     * @param string $value
     */
    private function assertValid(string $value): void
    {
        if ($this->validate($value) === false) {
            throw new \InvalidArgumentException('Invalid header value ' . $value);
        }
    }

    /**
     * @param $value
     * @return bool
     */
    private function validate(string $value): bool
    {
        $total = strlen($value);

        for ($i = 0; $i < $total; $i += 1) {
            $ord = ord($value[$i]);
            if ($ord === 10) {
                return false;
            }
            if ($ord === 13) {
                if ($i + 2 >= $total) {
                    return false;
                }
                $lf = ord($value[$i + 1]);
                $sp = ord($value[$i + 2]);
                if ($lf !== 10 || ! in_array($sp, [9, 32], true)) {
                    return false;
                }
                // skip over the LF following this
                $i += 2;
            }
        }

        return true;
    }

    /**
     * @param string $name
     * @return HeaderValueParameter
     */
    public function getParameter(string $name): HeaderValueParameter
    {
        if (isset($this->parameters[$name])) {
            return $this->parameters[$name];
        }

        throw new \UnexpectedValueException('No parameter with name ' . $name);
    }

    /**
     * @param string $value
     * @return HeaderValue
     */
    public static function fromEncodedString(string $value): HeaderValue
    {
        $headerValue = new self($value);
        $headerValue->needsEncoding = false;
        return $headerValue;
    }

    /**
     * @param string $headerValueAsString
     * @return HeaderValue
     */
    public static function fromString(string $headerValueAsString): HeaderValue
    {
        $values = [];

        $headerValueAsString = trim($headerValueAsString);

        $length = strlen($headerValueAsString) - 1;
        $n = -1;
        $state = self::PARSE_START;
        $escapeNext = false;
        $sequence = '';

        while ($n < $length) {
            $n++;

            $char = $headerValueAsString[$n];

            $sequence .= $char;

            if ($char === '\\') {
                $escapeNext = true;
                continue;
            }

            if ($escapeNext) {
                $escapeNext = false;
                continue;
            }

            switch ($state) {
                case self::PARSE_QUOTE:
                    if ($char === '"') {
                        $state = self::PARSE_START;
                    }

                    break;
                default:
                    if ($char === '"') {
                        $state = self::PARSE_QUOTE;
                    }

                    if ($char === ';') {
                        $values[] = trim(substr($sequence, 0, -1));
                        $sequence = '';
                        $state = self::PARSE_START;
                    }
                    break;
            }
        }

        $values[] = trim($sequence);

        $headerValue = new self($values[0]);

        $parameters = [];
        foreach (array_slice($values, 1) as $parameterString) {
            $parameter = HeaderValueParameter::fromString($parameterString);
            $parameters[$parameter->getName()] = $parameter;
        }

        $headerValue->parameters = $parameters;
        return $headerValue;
    }
}

1		<?php
2		declare(strict_types=1);
3
4		namespace Genkgo\Mail\Header;
5
6		/**
7		* Class HeaderValue
8		* @package Genkgo\Mail\Header
9		*/
10		final class HeaderValue
11		{
12		/**
13		*
14		*/
15		private CONST PARSE_START = 1;
16		/**
17		*
18		*/
19		private CONST PARSE_QUOTE = 2;
20		/**
21		* @var string
22		*/
23		private $value;
24		/**
25		* @var array
26		*/
27		private $parameters = [];
28		/**
29		* @var array
30		*/
31		private $parametersForceNewLine = [];
32		/**
33		* @var bool
34		*/
35		private $needsEncoding = true;
36
37	89	/**
38		* HeaderValue constructor.
39	89	* @param string $value
40		*/
41	86	public function __construct(string $value)
42	86	{
43		$this->assertValid($value);
44
45		$this->value = $value;
46		}
47
48	24	/**
49		* @param HeaderValueParameter $parameter
50	24	* @param bool $forceNewLine
51	24	* @return HeaderValue
52	24	*/
53		public function withParameter(HeaderValueParameter $parameter, bool $forceNewLine = false): HeaderValue
54		{
55		$clone = clone $this;
56		$clone->parameters[$parameter->getName()] = $parameter;
57		$clone->parametersForceNewLine[$parameter->getName()] = $forceNewLine;
58	13	return $clone;
59		}
60	13
61		/**
62		* @return string
63		*/
64		public function getRaw(): string
65		{
66	69	return $this->value;
67		}
68	69
69		/**
70	69	* @return string
71	62	*/
72		public function __toString(): string
73		{
74	16	$value = $this->value;
75
76		if ($this->needsEncoding) {
77		$value = (new OptimalEncodedHeaderValue($value));
78		}
79
80	89	$parameters = [];
81
82	89	foreach ($this->parameters as $name => $parameter) {
83	3	$parameters[] = sprintf(
84		';%s%s',
85	86	empty($this->parametersForceNewLine[$name]) ? ' ' : "\r\n ",
86		(string) $parameter
87		);
88		}
89
90		return implode('', array_merge([$value], $parameters));
91	89	}
92
93	89	/**
94		* @param string $value
95	89	*/
96	89	private function assertValid(string $value): void
97	89	{
98	1	if ($this->validate($value) === false) {
99		throw new \InvalidArgumentException('Invalid header value ' . $value);
100	89	}
101	5	}
102
103		/**
104	5	* @param $value
105	5	* @return bool
106	5	*/
107	2	private function validate(string $value): bool
108		{
109		$total = strlen($value);
110	3
111		for ($i = 0; $i < $total; $i += 1) {
112		$ord = ord($value[$i]);
113		if ($ord === 10) {
114	86	return false;
115		}
116		if ($ord === 13) {
117		if ($i + 2 >= $total) {
118		return false;
119		}
120		$lf = ord($value[$i + 1]);
121	7	$sp = ord($value[$i + 2]);
122		if ($lf !== 10 \|\| ! in_array($sp, [9, 32], true)) {
123	7	return false;
124	7	}
125		// skip over the LF following this
126		$i += 2;
127	2	}
128		}
129
130		return true;
131		}
132
133		/**
134	16	* @param string $name
135		* @return HeaderValueParameter
136	16	*/
137	16	public function getParameter(string $name): HeaderValueParameter
138	16	{
139		if (isset($this->parameters[$name])) {
140		return $this->parameters[$name];
141		}
142
143		throw new \UnexpectedValueException('No parameter with name ' . $name);
144		}
145	3
146		/**
147	3	* @param string $value
148		* @return HeaderValue
149	3	*/
150		public static function fromEncodedString(string $value): HeaderValue
151	3	{
152	3	$headerValue = new self($value);
153	3	$headerValue->needsEncoding = false;
154	3	return $headerValue;
155	3	}
156
157	3	/**
158	3	* @param string $headerValueAsString
159		* @return HeaderValue
160	3	*/
161		public static function fromString(string $headerValueAsString): HeaderValue
162	3	{
163		$values = [];
164	3
165		$headerValueAsString = trim($headerValueAsString);
166
167		$length = strlen($headerValueAsString) - 1;
168		$n = -1;
169	3	$state = self::PARSE_START;
170		$escapeNext = false;
171		$sequence = '';
172
173		while ($n < $length) {
174		$n++;
175	3
176	2	$char = $headerValueAsString[$n];
177	2
178		$sequence .= $char;
179
180	2	if ($char === '\\') {
181		$escapeNext = true;
182	3	continue;
183	2	}
184
185		if ($escapeNext) {
186	3	$escapeNext = false;
187	3	continue;
188	3	}
189	3
190		switch ($state) {
191	3	case self::PARSE_QUOTE:
192		if ($char === '"') {
193		$state = self::PARSE_START;
194		}
195	3
196		break;
197	3	default:
198		if ($char === '"') {
199	3	$state = self::PARSE_QUOTE;
200	3	}
201	3
202	3	if ($char === ';') {
203		$values[] = trim(substr($sequence, 0, -1));
204		$sequence = '';
205	3	$state = self::PARSE_START;
206	3	}
207		break;
208		}
209		}
210
211		$values[] = trim($sequence);
212
213		$headerValue = new self($values[0]);
214
215		$parameters = [];
216		foreach (array_slice($values, 1) as $parameterString) {
217		$parameter = HeaderValueParameter::fromString($parameterString);
218		$parameters[$parameter->getName()] = $parameter;
219		}
220
221		$headerValue->parameters = $parameters;
222		return $headerValue;
223		}
224		}

genkgo / mail

Pull Request — master (#12)

HeaderValue::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like