ConnectionBuilder::connectionFromArraySlice() - Code Metrics - Inspection of "Relay pagination customization" - overblog/GraphQLBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#413)

by Vincent

created 2018-12-20 10:25 UTC

ConnectionBuilder::connectionFromArraySlice() F

↳ Parent: ConnectionBuilder

Complexity

Conditions	17
Paths	151

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	56
CRAP Score	17.0015

Importance

Changes

Metric	Value
dl	0
loc	96
ccs	56
cts	57
cp	0.9825
rs	3.9206
c	0
b	0
f	0
cc	17
nc	151
nop	3
crap	17.0015

How to fix Long Method Complexity

<?php

declare(strict_types=1);

namespace Overblog\GraphQLBundle\Relay\Connection;

use Overblog\GraphQLBundle\Definition\Argument;
use Overblog\GraphQLBundle\Relay\Connection\Output\Connection;
use Overblog\GraphQLBundle\Relay\Connection\Output\Edge;
use Overblog\GraphQLBundle\Relay\Connection\Output\PageInfo;

/**
 * Class ConnectionBuilder.
 *
 * https://github.com/graphql/graphql-relay-js/blob/master/src/connection/arrayconnection.js
 */
class ConnectionBuilder
{
    public const PREFIX = 'arrayconnection:';

    /**
     * If set, used to generate the connection object.
     *
     * @var callable
     */
    protected $connectionCallback;

    /**
     * If set, used to generate the edge object.
     *
     * @var callable
     */
    protected $edgeCallback;

    public function __construct(callable $connectionCallback = null, callable $edgeCallback = null)
    {
        $this->connectionCallback = $connectionCallback;
        $this->edgeCallback = $edgeCallback;
    }

    /**
     * A simple function that accepts an array and connection arguments, and returns
     * a connection object for use in GraphQL. It uses array offsets as pagination,
     * so pagination will only work if the array is static.
     *
     * @param array          $data
     * @param array|Argument $args
     *
     * @return Connection
     */
    public function connectionFromArray(array $data, $args = []): Connection
    {
        return $this->connectionFromArraySlice(
            $data,
            $args,
            [
                'sliceStart' => 0,
                'arrayLength' => \count($data),
            ]
        );
    }

    /**
     * A version of `connectionFromArray` that takes a promised array, and returns a
     * promised connection.
     *
     * @param mixed          $dataPromise a promise
     * @param array|Argument $args
     *
     * @return mixed a promise
     */
    public function connectionFromPromisedArray($dataPromise, $args = [])
    {
        $this->checkPromise($dataPromise);

        return $dataPromise->then(function ($data) use ($args) {
            return $this->connectionFromArray($data, $args);
        });
    }

    /**
     * Given a slice (subset) of an array, returns a connection object for use in
     * GraphQL.
     *
     * This function is similar to `connectionFromArray`, but is intended for use
     * cases where you know the cardinality of the connection, consider it too large
     * to materialize the entire array, and instead wish pass in a slice of the
     * total result large enough to cover the range specified in `args`.
     *
     * @param array          $arraySlice
     * @param array|Argument $args
     * @param array          $meta
     *
     * @return Connection
     */
    public function connectionFromArraySlice(array $arraySlice, $args, array $meta): Connection
    {
        $connectionArguments = $this->getOptionsWithDefaults(
            $args instanceof Argument ? $args->getRawArguments() : $args,
            [
                'after' => '',
                'before' => '',
                'first' => null,
                'last' => null,
            ]
        );
        $arraySliceMetaInfo = $this->getOptionsWithDefaults(
            $meta,
            [
                'sliceStart' => 0,
                'arrayLength' => 0,
            ]
        );

        $arraySliceLength = \count($arraySlice);
        $after = $connectionArguments['after'];
        $before = $connectionArguments['before'];
        $first = $connectionArguments['first'];
        $last = $connectionArguments['last'];
        $sliceStart = $arraySliceMetaInfo['sliceStart'];
        $arrayLength = $arraySliceMetaInfo['arrayLength'];
        $sliceEnd = $sliceStart + $arraySliceLength;
        $beforeOffset = $this->getOffsetWithDefault($before, $arrayLength);
        $afterOffset = $this->getOffsetWithDefault($after, -1);

        $startOffset = \max($sliceStart - 1, $afterOffset, -1) + 1;
        $endOffset = \min($sliceEnd, $beforeOffset, $arrayLength);

        if (\is_numeric($first)) {
            if ($first < 0) {
                throw new \InvalidArgumentException('Argument "first" must be a non-negative integer');
            }
            $endOffset = \min($endOffset, $startOffset + $first);
        }

        if (\is_numeric($last)) {
            if ($last < 0) {
                throw new \InvalidArgumentException('Argument "last" must be a non-negative integer');
            }

            $startOffset = \max($startOffset, $endOffset - $last);
        }

        // If supplied slice is too large, trim it down before mapping over it.
        $offset = \max($startOffset - $sliceStart, 0);
        $length = ($arraySliceLength - ($sliceEnd - $endOffset)) - $offset;

        $slice = \array_slice(
            $arraySlice,
            $offset,
            $length
        );

        $edges = [];

        foreach ($slice as $index => $value) {
            $cursor = $this->offsetToCursor($startOffset + $index);
            if ($this->edgeCallback) {
                $edge = ($this->edgeCallback)($cursor, $value, $index);
                if (!($edge instanceof EdgeInterface)) {
                    throw new \InvalidArgumentException(\sprintf('The $edgeCallback of the ConnectionBuilder must return an instance of EdgeInterface'));
                }
            } else {
                $edge = new Edge($cursor, $value);
            }
            $edges[] = $edge;
        }

        $firstEdge = $edges[0] ?? null;
        $lastEdge = \end($edges);
        $lowerBound = $after ? ($afterOffset + 1) : 0;
        $upperBound = $before ? $beforeOffset : $arrayLength;

        $pageInfo = new PageInfo(
            $firstEdge instanceof EdgeInterface ? $firstEdge->getCursor() : null,
            $lastEdge instanceof EdgeInterface ? $lastEdge->getCursor() : null,
            null !== $last ? $startOffset > $lowerBound : false,
            null !== $first ? $endOffset < $upperBound : false
        );

        if ($this->connectionCallback) {
            $connection = ($this->connectionCallback)($edges, $pageInfo);
            if (!($connection instanceof ConnectionInterface)) {
                throw new \InvalidArgumentException(\sprintf('The $connectionCallback of the ConnectionBuilder must return an instance of ConnectionInterface'));
            }

            return $connection;
        }

        return new Connection($edges, $pageInfo);
    }

    /**
     * A version of `connectionFromArraySlice` that takes a promised array slice,
     * and returns a promised connection.
     *
     * @param mixed          $dataPromise a promise
     * @param array|Argument $args
     * @param array          $meta
     *
     * @return mixed a promise
     */
    public function connectionFromPromisedArraySlice($dataPromise, $args, array $meta)
    {
        $this->checkPromise($dataPromise);

        return $dataPromise->then(function ($arraySlice) use ($args, $meta) {
            return $this->connectionFromArraySlice($arraySlice, $args, $meta);
        });
    }

    /**
     * Return the cursor associated with an object in an array.
     *
     * @param array $data
     * @param mixed $object
     *
     * @return null|string
     */
    public function cursorForObjectInConnection(array $data, $object): ? string
    {
        $offset = null;

        foreach ($data as $i => $entry) {
            // When using the comparison operator (==), object variables are compared in a simple manner,
            // namely: Two object instances are equal if they have the same attributes and values,
            // and are instances of the same class.
            if ($entry == $object) {
                $offset = $i;
                break;
            }
        }

        if (null === $offset) {
            return null;
        }

        return $this->offsetToCursor($offset);
    }

    /**
     * Given an optional cursor and a default offset, returns the offset
     * to use; if the cursor contains a valid offset, that will be used,
     * otherwise it will be the default.
     *
     * @param string|null $cursor
     * @param int         $defaultOffset
     *
     * @return int
     */
    public function getOffsetWithDefault(? string $cursor, int $defaultOffset): int
    {
        if (empty($cursor)) {
            return $defaultOffset;
        }
        $offset = $this->cursorToOffset($cursor);

        return !\is_numeric($offset) ? $defaultOffset : (int) $offset;
    }

    /**
     * Creates the cursor string from an offset.
     *
     * @param $offset
     *
     * @return string
     */
    public function offsetToCursor($offset): string
    {
        return \base64_encode(static::PREFIX.$offset);
    }

    /**
     * Redefines the offset from the cursor string.
     *
     * @param $cursor
     *
     * @return string
     */
    public function cursorToOffset($cursor): string
    {
        if (null === $cursor) {
            return '';
        }

        return \str_replace(static::PREFIX, '', \base64_decode($cursor, true));
    }

    private function getOptionsWithDefaults(array $options, array $defaults)
    {
        return $options + $defaults;
    }

    private function checkPromise($value): void
    {
        if (!\is_callable([$value, 'then'])) {
            throw new \InvalidArgumentException('This is not a valid promise.');
        }
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Overblog\GraphQLBundle\Relay\Connection;
6
7		use Overblog\GraphQLBundle\Definition\Argument;
8		use Overblog\GraphQLBundle\Relay\Connection\Output\Connection;
9		use Overblog\GraphQLBundle\Relay\Connection\Output\Edge;
10		use Overblog\GraphQLBundle\Relay\Connection\Output\PageInfo;
11
12		/**
13		* Class ConnectionBuilder.
14		*
15		* https://github.com/graphql/graphql-relay-js/blob/master/src/connection/arrayconnection.js
16		*/
17		class ConnectionBuilder
18		{
19		public const PREFIX = 'arrayconnection:';
20
21		/**
22		* If set, used to generate the connection object.
23		*
24		* @var callable
25		*/
26		protected $connectionCallback;
27
28		/**
29		* If set, used to generate the edge object.
30		*
31		* @var callable
32		*/
33		protected $edgeCallback;
34
35	71	public function __construct(callable $connectionCallback = null, callable $edgeCallback = null)
36		{
37	71	$this->connectionCallback = $connectionCallback;
38	71	$this->edgeCallback = $edgeCallback;
39	71	}
40
41		/**
42		* A simple function that accepts an array and connection arguments, and returns
43		* a connection object for use in GraphQL. It uses array offsets as pagination,
44		* so pagination will only work if the array is static.
45		*
46		* @param array $data
47		* @param array\|Argument $args
48		*
49		* @return Connection
50		*/
51	41	public function connectionFromArray(array $data, $args = []): Connection
52		{
53	41	return $this->connectionFromArraySlice(
54	41	$data,
55	41	$args,
56		[
57	41	'sliceStart' => 0,
58	41	'arrayLength' => \count($data),
59		]
60		);
61		}
62
63		/**
64		* A version of `connectionFromArray` that takes a promised array, and returns a
65		* promised connection.
66		*
67		* @param mixed $dataPromise a promise
68		* @param array\|Argument $args
69		*
70		* @return mixed a promise
71		*/
72	7	public function connectionFromPromisedArray($dataPromise, $args = [])
73		{
74	7	$this->checkPromise($dataPromise);
75
76		return $dataPromise->then(function ($data) use ($args) {
77	2	return $this->connectionFromArray($data, $args);
78	2	});
79		}
80
81		/**
82		* Given a slice (subset) of an array, returns a connection object for use in
83		* GraphQL.
84		*
85		* This function is similar to `connectionFromArray`, but is intended for use
86		* cases where you know the cardinality of the connection, consider it too large
87		* to materialize the entire array, and instead wish pass in a slice of the
88		* total result large enough to cover the range specified in `args`.
89		*
90		* @param array $arraySlice
91		* @param array\|Argument $args
92		* @param array $meta
93		*
94		* @return Connection
95		*/
96	58	public function connectionFromArraySlice(array $arraySlice, $args, array $meta): Connection
97		{
98	58	$connectionArguments = $this->getOptionsWithDefaults(
99	58	$args instanceof Argument ? $args->getRawArguments() : $args,
100		[
101	58	'after' => '',
102		'before' => '',
103		'first' => null,
104		'last' => null,
105		]
106		);
107	58	$arraySliceMetaInfo = $this->getOptionsWithDefaults(
108	58	$meta,
109		[
110	58	'sliceStart' => 0,
111		'arrayLength' => 0,
112		]
113		);
114
115	58	$arraySliceLength = \count($arraySlice);
116	58	$after = $connectionArguments['after'];
117	58	$before = $connectionArguments['before'];
118	58	$first = $connectionArguments['first'];
119	58	$last = $connectionArguments['last'];
120	58	$sliceStart = $arraySliceMetaInfo['sliceStart'];
121	58	$arrayLength = $arraySliceMetaInfo['arrayLength'];
122	58	$sliceEnd = $sliceStart + $arraySliceLength;
123	58	$beforeOffset = $this->getOffsetWithDefault($before, $arrayLength);
124	58	$afterOffset = $this->getOffsetWithDefault($after, -1);
125
126	58	$startOffset = \max($sliceStart - 1, $afterOffset, -1) + 1;
127	58	$endOffset = \min($sliceEnd, $beforeOffset, $arrayLength);
128
129	58	if (\is_numeric($first)) {
130	36	if ($first < 0) {
131	1	throw new \InvalidArgumentException('Argument "first" must be a non-negative integer');
132		}
133	35	$endOffset = \min($endOffset, $startOffset + $first);
134		}
135
136	57	if (\is_numeric($last)) {
137	16	if ($last < 0) {
138	1	throw new \InvalidArgumentException('Argument "last" must be a non-negative integer');
139		}
140
141	15	$startOffset = \max($startOffset, $endOffset - $last);
142		}
143
144		// If supplied slice is too large, trim it down before mapping over it.
145	56	$offset = \max($startOffset - $sliceStart, 0);
146	56	$length = ($arraySliceLength - ($sliceEnd - $endOffset)) - $offset;
147
148	56	$slice = \array_slice(
149	56	$arraySlice,
150	56	$offset,
151	56	$length
152		);
153
154	56	$edges = [];
155
156	56	foreach ($slice as $index => $value) {
157	53	$cursor = $this->offsetToCursor($startOffset + $index);
158	53	if ($this->edgeCallback) {
159	1	$edge = ($this->edgeCallback)($cursor, $value, $index);
160	1	if (!($edge instanceof EdgeInterface)) {
161	1	throw new \InvalidArgumentException(\sprintf('The $edgeCallback of the ConnectionBuilder must return an instance of EdgeInterface'));
162		}
163		} else {
164	52	$edge = new Edge($cursor, $value);
165		}
166	53	$edges[] = $edge;
167		}
168
169	56	$firstEdge = $edges[0] ?? null;
170	56	$lastEdge = \end($edges);
171	56	$lowerBound = $after ? ($afterOffset + 1) : 0;
172	56	$upperBound = $before ? $beforeOffset : $arrayLength;
173
174	56	$pageInfo = new PageInfo(
175	56	$firstEdge instanceof EdgeInterface ? $firstEdge->getCursor() : null,
176	56	$lastEdge instanceof EdgeInterface ? $lastEdge->getCursor() : null,
177	56	null !== $last ? $startOffset > $lowerBound : false,
178	56	null !== $first ? $endOffset < $upperBound : false
179		);
180
181	56	if ($this->connectionCallback) {
182	1	$connection = ($this->connectionCallback)($edges, $pageInfo);
183	1	if (!($connection instanceof ConnectionInterface)) {
184		throw new \InvalidArgumentException(\sprintf('The $connectionCallback of the ConnectionBuilder must return an instance of ConnectionInterface'));
185		}
186
187	1	return $connection;
188		}
189
190	55	return new Connection($edges, $pageInfo);
191		}
192
193		/**
194		* A version of `connectionFromArraySlice` that takes a promised array slice,
195		* and returns a promised connection.
196		*
197		* @param mixed $dataPromise a promise
198		* @param array\|Argument $args
199		* @param array $meta
200		*
201		* @return mixed a promise
202		*/
203	6	public function connectionFromPromisedArraySlice($dataPromise, $args, array $meta)
204		{
205	6	$this->checkPromise($dataPromise);
206
207		return $dataPromise->then(function ($arraySlice) use ($args, $meta) {
208	1	return $this->connectionFromArraySlice($arraySlice, $args, $meta);
209	1	});
210		}
211
212		/**
213		* Return the cursor associated with an object in an array.
214		*
215		* @param array $data
216		* @param mixed $object
217		*
218		* @return null\|string
219		*/
220	2	public function cursorForObjectInConnection(array $data, $object): ? string
221		{
222	2	$offset = null;
223
224	2	foreach ($data as $i => $entry) {
225		// When using the comparison operator (==), object variables are compared in a simple manner,
226		// namely: Two object instances are equal if they have the same attributes and values,
227		// and are instances of the same class.
228	2	if ($entry == $object) {
229	1	$offset = $i;
230	2	break;
231		}
232		}
233
234	2	if (null === $offset) {
235	1	return null;
236		}
237
238	1	return $this->offsetToCursor($offset);
239		}
240
241		/**
242		* Given an optional cursor and a default offset, returns the offset
243		* to use; if the cursor contains a valid offset, that will be used,
244		* otherwise it will be the default.
245		*
246		* @param string\|null $cursor
247		* @param int $defaultOffset
248		*
249		* @return int
250		*/
251	59	public function getOffsetWithDefault(? string $cursor, int $defaultOffset): int
252		{
253	59	if (empty($cursor)) {
254	50	return $defaultOffset;
255		}
256	25	$offset = $this->cursorToOffset($cursor);
257
258	25	return !\is_numeric($offset) ? $defaultOffset : (int) $offset;
259		}
260
261		/**
262		* Creates the cursor string from an offset.
263		*
264		* @param $offset
265		*
266		* @return string
267		*/
268	54	public function offsetToCursor($offset): string
269		{
270	54	return \base64_encode(static::PREFIX.$offset);
271		}
272
273		/**
274		* Redefines the offset from the cursor string.
275		*
276		* @param $cursor
277		*
278		* @return string
279		*/
280	28	public function cursorToOffset($cursor): string
281		{
282	28	if (null === $cursor) {
283	3	return '';
284		}
285
286	25	return \str_replace(static::PREFIX, '', \base64_decode($cursor, true));
287		}
288
289	58	private function getOptionsWithDefaults(array $options, array $defaults)
290		{
291	58	return $options + $defaults;
292		}
293
294	13	private function checkPromise($value): void
295		{
296	13	if (!\is_callable([$value, 'then'])) {
297	10	throw new \InvalidArgumentException('This is not a valid promise.');
298		}
299	3	}
300		}
301

overblog / GraphQLBundle

Scrutinizer GitHub App not installed

Pull Request — master (#413)

ConnectionBuilder::connectionFromArraySlice() F

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like