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-10-30 15:26 UTC

ConnectionBuilder::connectionFromArraySlice() F

↳ Parent: ConnectionBuilder

Complexity

Conditions	17
Paths	151

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	96
rs	3.9206
c	0
b	0
f	0
cc	17
nc	151
nop	3

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			public function __construct(callable $connectionCallback = null, callable $edgeCallback = null)
36			{
37			$this->connectionCallback = $connectionCallback;
38			$this->edgeCallback = $edgeCallback;
39			}
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			public function connectionFromArray(array $data, $args = []): Connection
52			{
53			return $this->connectionFromArraySlice(
54			$data,
55			$args,
56			[
57			'sliceStart' => 0,
58			'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			public function connectionFromPromisedArray($dataPromise, $args = [])
73			{
74			$this->checkPromise($dataPromise);
75
76			return $dataPromise->then(function ($data) use ($args) {
77			return $this->connectionFromArray($data, $args);
78			});
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			public function connectionFromArraySlice(array $arraySlice, $args, array $meta): Connection
97			{
98			$connectionArguments = $this->getOptionsWithDefaults(
99			$args instanceof Argument ? $args->getRawArguments() : $args,
100			[
101			'after' => '',
102			'before' => '',
103			'first' => null,
104			'last' => null,
105			]
106			);
107			$arraySliceMetaInfo = $this->getOptionsWithDefaults(
108			$meta,
109			[
110			'sliceStart' => 0,
111			'arrayLength' => 0,
112			]
113			);
114
115			$arraySliceLength = \count($arraySlice);
116			$after = $connectionArguments['after'];
117			$before = $connectionArguments['before'];
118			$first = $connectionArguments['first'];
119			$last = $connectionArguments['last'];
120			$sliceStart = $arraySliceMetaInfo['sliceStart'];
121			$arrayLength = $arraySliceMetaInfo['arrayLength'];
122			$sliceEnd = $sliceStart + $arraySliceLength;
123			$beforeOffset = $this->getOffsetWithDefault($before, $arrayLength);
124			$afterOffset = $this->getOffsetWithDefault($after, -1);
125
126			$startOffset = \max($sliceStart - 1, $afterOffset, -1) + 1;
127			$endOffset = \min($sliceEnd, $beforeOffset, $arrayLength);
128
129			if (\is_numeric($first)) {
130			if ($first < 0) {
131			throw new \InvalidArgumentException('Argument "first" must be a non-negative integer');
132			}
133			$endOffset = \min($endOffset, $startOffset + $first);
134			}
135
136			if (\is_numeric($last)) {
137			if ($last < 0) {
138			throw new \InvalidArgumentException('Argument "last" must be a non-negative integer');
139			}
140
141			$startOffset = \max($startOffset, $endOffset - $last);
142			}
143
144			// If supplied slice is too large, trim it down before mapping over it.
145			$offset = \max($startOffset - $sliceStart, 0);
146			$length = ($arraySliceLength - ($sliceEnd - $endOffset)) - $offset;
147
148			$slice = \array_slice(
149			$arraySlice,
150			$offset,
151			$length
152			);
153
154			$edges = [];
155
156			foreach ($slice as $index => $value) {
157			$cursor = $this->offsetToCursor($startOffset + $index);
158			if ($this->edgeCallback) {
159			$edge = ($this->edgeCallback)($cursor, $value, $index);
160			if (!($edge instanceof EdgeInterface)) {
161			throw new \InvalidArgumentException(\sprintf('The $edgeCallback of the ConnectionBuilder must return an instance of EdgeInterface'));
162			}
163			} else {
164			$edge = new Edge($cursor, $value);
165			}
166			$edges[] = $edge;
167			}
168
169			$firstEdge = $edges[0] ?? null;
170			$lastEdge = \end($edges);
171			$lowerBound = $after ? ($afterOffset + 1) : 0;
172			$upperBound = $before ? $beforeOffset : $arrayLength;
173
174			$pageInfo = new PageInfo(
175			$firstEdge instanceof EdgeInterface ? $firstEdge->getCursor() : null,
176			$lastEdge instanceof EdgeInterface ? $lastEdge->getCursor() : null,
177			null !== $last ? $startOffset > $lowerBound : false,
178			null !== $first ? $endOffset < $upperBound : false
179			);
180
181			if ($this->connectionCallback) {
182			$connection = ($this->connectionCallback)($edges, $pageInfo);
183			if (!($connection instanceof ConnectionInterface)) {
184			throw new \InvalidArgumentException(\sprintf('The $connectionCallback of the ConnectionBuilder must return an instance of ConnectionInterface'));
185			}
186
187			return $connection;
188			}
189
190			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			public function connectionFromPromisedArraySlice($dataPromise, $args, array $meta)
204			{
205			$this->checkPromise($dataPromise);
206
207			return $dataPromise->then(function ($arraySlice) use ($args, $meta) {
208			return $this->connectionFromArraySlice($arraySlice, $args, $meta);
209			});
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			public function cursorForObjectInConnection(array $data, $object): ? string
221			{
222			$offset = null;
223
224			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			if ($entry == $object) {
229			$offset = $i;
230			break;
231			}
232			}
233
234			if (null === $offset) {
235			return null;
236			}
237
238			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			public function getOffsetWithDefault(? string $cursor, int $defaultOffset): int
252			{
253			if (empty($cursor)) {
254			return $defaultOffset;
255			}
256			$offset = $this->cursorToOffset($cursor);
257
258			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			public function offsetToCursor($offset): string
269			{
270			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			public function cursorToOffset($cursor): string
281			{
282			if (null === $cursor) {
283			return '';
284			}
285
286			return \str_replace(static::PREFIX, '', \base64_decode($cursor, true));
287			}
288
289			private function getOptionsWithDefaults(array $options, array $defaults)
290			{
291			return $options + $defaults;
292			}
293
294			private function checkPromise($value): void
295			{
296			if (!\is_callable([$value, 'then'])) {
297			throw new \InvalidArgumentException('This is not a valid promise.');
298			}
299			}
300			}
301

overblog / GraphQLBundle

Scrutinizer GitHub App not installed

Pull Request — master (#413)

ConnectionBuilder::connectionFromArraySlice() F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like