RangeParser::parseBigIntRange() - Code Metrics - Inspection of "Range and MultiRange parser" - yiisoft/db-pgsql - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Pull Request — master (#307)

unknown

created 2023-08-03 18:37 UTC

RangeParser::parseBigIntRange() A

↳ Parent: RangeParser

Complexity

Conditions	6
Paths	5

Size

Total Lines	19
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	6
eloc	8
c	1
b	0
f	0
nc	5
nop	4
dl	0
loc	19
rs	9.2222

<?php

declare(strict_types=1);

namespace Yiisoft\Db\Pgsql;

use DateInterval;
use DateTime;
use DateTimeInterface;
use InvalidArgumentException;
use function preg_match;

final class RangeParser
{
    private const RANGES = [
        Schema::TYPE_INT_RANGE,
        Schema::TYPE_BIGINT_RANGE,
        Schema::TYPE_NUM_RANGE,
        Schema::TYPE_TS_RANGE,
        Schema::TYPE_TS_TZ_RANGE,
        Schema::TYPE_DATE_RANGE,
    ];

    private ?string $type;

    public function __construct(?string $type = null)
    {
        $this->type = $type;
    }

    public function withType(?string $type): self
    {
        $new = clone $this;
        $new->type = $type;

        return $new;
    }

    public function asInt(): self
    {
        return $this->withType(Schema::TYPE_INT_RANGE);
    }

    public function asBigInt(): self
    {
        return $this->withType(Schema::TYPE_BIGINT_RANGE);
    }

    public function asNumeric(): self
    {
        return $this->withType(Schema::TYPE_NUM_RANGE);
    }

    public function asDate(): self
    {
        return $this->withType(Schema::TYPE_DATE_RANGE);
    }

    public function asTimestamp(): self
    {
        return $this->withType(Schema::TYPE_TS_RANGE);
    }

    public function asTimestampTz(): self
    {
        return $this->withType(Schema::TYPE_TS_TZ_RANGE);
    }

    public function asCustom(): self
    {
        return $this->withType(null);
    }

    /**
     * @param string|null $value
     * @return float[]|int[]|null[]|DateTimeInterface[]|null
     */
    public function parse(?string $value): ?array
    {
        if ($value === null || $value === 'empty') {
            return null;
        }

        if (!preg_match('/^(?P<open>\[|\()(?P<lower>[^,]*),(?P<upper>[^\)\]]*)(?P<close>\)|\])$/', $value, $matches)) {
            throw new InvalidArgumentException('Unsupported range format');
        }

        $lower = $matches['lower'] ? trim($matches['lower'], '"') : null;
        $upper = $matches['upper'] ? trim($matches['upper'], '"') : null;
        $includeLower = $matches['open'] === '[';
        $includeUpper = $matches['close'] === ']';

        if ($lower === null && $upper === null) {
            return [null, null];
        }

        return match($this->type) {
            Schema::TYPE_INT_RANGE => self::parseIntRange($lower, $upper, $includeLower, $includeUpper),
            Schema::TYPE_BIGINT_RANGE => self::parseBigIntRange($lower, $upper, $includeLower, $includeUpper),
            Schema::TYPE_NUM_RANGE => self::parseNumRange($lower, $upper),
            Schema::TYPE_DATE_RANGE => self::parseDateRange($lower, $upper, $includeLower, $includeUpper),
            Schema::TYPE_TS_RANGE => self::parseTsRange($lower, $upper),
            Schema::TYPE_TS_TZ_RANGE => self::parseTsTzRange($lower, $upper),
            default => [$lower, $upper]
        };
    }

    /**
     * @param string|null $lower
     * @param string|null $upper
     * @param bool $includeLower
     * @param bool $includeUpper
     * @return int[]|null[]
     */
    private static function parseIntRange(?string $lower, ?string $upper, bool $includeLower, bool $includeUpper): array
    {
        $min = $lower === null ? null : (int) $lower;
        $max = $upper === null ? null : (int) $upper;

        if ($min !== null && $includeLower === false) {
            $min += 1;
        }

        if ($max !== null && $includeUpper === false) {
            $max -= 1;
        }

        return [$min, $max];
    }

    /**
     * @param string|null $lower
     * @param string|null $upper
     * @param bool $includeLower
     * @param bool $includeUpper
     * @return float[]|int[]|null[]
     */
    private static function parseBigIntRange(?string $lower, ?string $upper, bool $includeLower, bool $includeUpper): array
    {
        if (PHP_INT_SIZE === 8) {
            return self::parseIntRange($lower, $upper, $includeLower, $includeUpper);
        }

        [$min, $max] = self::parseNumRange($lower, $upper);

        if ($min !== null && $includeLower === false) {
            /** @var float $min */
            $min += 1;
        }

        if ($max !== null && $includeUpper === false) {
            /** @var float $max */
            $max -= 1;
        }

        return [$min, $max];
    }

    /**
     * @param string|null $lower
     * @param string|null $upper
     * @return float[]|null[]
     */
    private static function parseNumRange(?string $lower, ?string $upper): array
    {
        $min = $lower === null ? null : (float) $lower;
        $max = $upper === null ? null : (float) $upper;

        return [$min, $max];
    }

    /**
     * @param string|null $lower
     * @param string|null $upper
     * @param bool $includeLower
     * @param bool $includeUpper
     * @return DateTimeInterface[]|null[]
     */
    private static function parseDateRange(?string $lower, ?string $upper, bool $includeLower, bool $includeUpper): array
    {
        $interval = new DateInterval('P1D');
        $min = $lower ? DateTime::createFromFormat('Y-m-d', $lower) : null;
        $max = $upper ? DateTime::createFromFormat('Y-m-d', $upper) : null;

        if ($min && $includeLower === false) {
            $min->add($interval);
        }

        if ($max && $includeUpper === false) {
            $max->sub($interval);
        }

        return [$min, $max];
    }

    /**
     * @param string|null $lower
     * @param string|null $upper
     * @return DateTimeInterface[]|null[]
     */
    private static function parseTsRange(?string $lower, ?string $upper): array
    {
        $min = $lower ? DateTime::createFromFormat('Y-m-d H:i:s', $lower) : null;
        $max = $upper ? DateTime::createFromFormat('Y-m-d H:i:s', $upper) : null;

        return [$min, $max];
    }

    /**
     * @param string|null $lower
     * @param string|null $upper
     * @return DateTimeInterface[]|null[]
     */
    private static function parseTsTzRange(?string $lower, ?string $upper): array
    {
        $min = $lower ? DateTime::createFromFormat('Y-m-d H:i:sP', $lower) : null;
        $max = $upper ? DateTime::createFromFormat('Y-m-d H:i:sP', $upper) : null;

        return [$min, $max];
    }

    public static function isAllowedType(string $type): bool
    {
        return in_array($type, self::RANGES, true);
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Yiisoft\Db\Pgsql;
6
7			use DateInterval;
8			use DateTime;
9			use DateTimeInterface;
10			use InvalidArgumentException;
11			use function preg_match;
12
13			final class RangeParser
14			{
15			private const RANGES = [
16			Schema::TYPE_INT_RANGE,
17			Schema::TYPE_BIGINT_RANGE,
18			Schema::TYPE_NUM_RANGE,
19			Schema::TYPE_TS_RANGE,
20			Schema::TYPE_TS_TZ_RANGE,
21			Schema::TYPE_DATE_RANGE,
22			];
23
24			private ?string $type;
25
26			public function __construct(?string $type = null)
27			{
28			$this->type = $type;
29			}
30
31			public function withType(?string $type): self
32			{
33			$new = clone $this;
34			$new->type = $type;
35
36			return $new;
37			}
38
39			public function asInt(): self
40			{
41			return $this->withType(Schema::TYPE_INT_RANGE);
42			}
43
44			public function asBigInt(): self
45			{
46			return $this->withType(Schema::TYPE_BIGINT_RANGE);
47			}
48
49			public function asNumeric(): self
50			{
51			return $this->withType(Schema::TYPE_NUM_RANGE);
52			}
53
54			public function asDate(): self
55			{
56			return $this->withType(Schema::TYPE_DATE_RANGE);
57			}
58
59			public function asTimestamp(): self
60			{
61			return $this->withType(Schema::TYPE_TS_RANGE);
62			}
63
64			public function asTimestampTz(): self
65			{
66			return $this->withType(Schema::TYPE_TS_TZ_RANGE);
67			}
68
69			public function asCustom(): self
70			{
71			return $this->withType(null);
72			}
73
74			/**
75			* @param string\|null $value
76			* @return float[]\|int[]\|null[]\|DateTimeInterface[]\|null
77			*/
78			public function parse(?string $value): ?array
79			{
80			if ($value === null \|\| $value === 'empty') {
81			return null;
82			}
83
84			if (!preg_match('/^(?P<open>\[\|\()(?P<lower>[^,]),(?P<upper>[^\)\]])(?P<close>\)\|\])$/', $value, $matches)) {
85			throw new InvalidArgumentException('Unsupported range format');
86			}
87
88			$lower = $matches['lower'] ? trim($matches['lower'], '"') : null;
89			$upper = $matches['upper'] ? trim($matches['upper'], '"') : null;
90			$includeLower = $matches['open'] === '[';
91			$includeUpper = $matches['close'] === ']';
92
93			if ($lower === null && $upper === null) {
94			return [null, null];
95			}
96
97			return match($this->type) {
98			Schema::TYPE_INT_RANGE => self::parseIntRange($lower, $upper, $includeLower, $includeUpper),
99			Schema::TYPE_BIGINT_RANGE => self::parseBigIntRange($lower, $upper, $includeLower, $includeUpper),
100			Schema::TYPE_NUM_RANGE => self::parseNumRange($lower, $upper),
101			Schema::TYPE_DATE_RANGE => self::parseDateRange($lower, $upper, $includeLower, $includeUpper),
102			Schema::TYPE_TS_RANGE => self::parseTsRange($lower, $upper),
103			Schema::TYPE_TS_TZ_RANGE => self::parseTsTzRange($lower, $upper),
104			default => [$lower, $upper]
105			};
106			}
107
108			/**
109			* @param string\|null $lower
110			* @param string\|null $upper
111			* @param bool $includeLower
112			* @param bool $includeUpper
113			* @return int[]\|null[]
114			*/
115			private static function parseIntRange(?string $lower, ?string $upper, bool $includeLower, bool $includeUpper): array
116			{
117			$min = $lower === null ? null : (int) $lower;
118			$max = $upper === null ? null : (int) $upper;
119
120			if ($min !== null && $includeLower === false) {
121			$min += 1;
122			}
123
124			if ($max !== null && $includeUpper === false) {
125			$max -= 1;
126			}
127
128			return [$min, $max];
129			}
130
131			/**
132			* @param string\|null $lower
133			* @param string\|null $upper
134			* @param bool $includeLower
135			* @param bool $includeUpper
136			* @return float[]\|int[]\|null[]
137			*/
138			private static function parseBigIntRange(?string $lower, ?string $upper, bool $includeLower, bool $includeUpper): array
139			{
140			if (PHP_INT_SIZE === 8) {
141			return self::parseIntRange($lower, $upper, $includeLower, $includeUpper);
142			}
143
144			[$min, $max] = self::parseNumRange($lower, $upper);
145
146			if ($min !== null && $includeLower === false) {
147			/** @var float $min */
148			$min += 1;
149			}
150
151			if ($max !== null && $includeUpper === false) {
152			/** @var float $max */
153			$max -= 1;
154			}
155
156			return [$min, $max];
157			}
158
159			/**
160			* @param string\|null $lower
161			* @param string\|null $upper
162			* @return float[]\|null[]
163			*/
164			private static function parseNumRange(?string $lower, ?string $upper): array
165			{
166			$min = $lower === null ? null : (float) $lower;
167			$max = $upper === null ? null : (float) $upper;
168
169			return [$min, $max];
170			}
171
172			/**
173			* @param string\|null $lower
174			* @param string\|null $upper
175			* @param bool $includeLower
176			* @param bool $includeUpper
177			* @return DateTimeInterface[]\|null[]
178			*/
179			private static function parseDateRange(?string $lower, ?string $upper, bool $includeLower, bool $includeUpper): array
180			{
181			$interval = new DateInterval('P1D');
182			$min = $lower ? DateTime::createFromFormat('Y-m-d', $lower) : null;
183			$max = $upper ? DateTime::createFromFormat('Y-m-d', $upper) : null;
184
185			if ($min && $includeLower === false) {
186			$min->add($interval);
187			}
188
189			if ($max && $includeUpper === false) {
190			$max->sub($interval);
191			}
192
193			return [$min, $max];
194			}
195
196			/**
197			* @param string\|null $lower
198			* @param string\|null $upper
199			* @return DateTimeInterface[]\|null[]
200			*/
201			private static function parseTsRange(?string $lower, ?string $upper): array
202			{
203			$min = $lower ? DateTime::createFromFormat('Y-m-d H:i:s', $lower) : null;
204			$max = $upper ? DateTime::createFromFormat('Y-m-d H:i:s', $upper) : null;
205
206			return [$min, $max];
207			}
208
209			/**
210			* @param string\|null $lower
211			* @param string\|null $upper
212			* @return DateTimeInterface[]\|null[]
213			*/
214			private static function parseTsTzRange(?string $lower, ?string $upper): array
215			{
216			$min = $lower ? DateTime::createFromFormat('Y-m-d H:i:sP', $lower) : null;
217			$max = $upper ? DateTime::createFromFormat('Y-m-d H:i:sP', $upper) : null;
218
219			return [$min, $max];
220			}
221
222			public static function isAllowedType(string $type): bool
223			{
224			return in_array($type, self::RANGES, true);
225			}
226			}
227

yiisoft / db-pgsql

Pull Request — master (#307)

RangeParser::parseBigIntRange() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like