TransactionalClient::addList() - Code Metrics - Inspection of "Use HTTP factory and introduce stream handler" - sandrokeil/arangodb-php-client - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#7)

by Sandro

created 2019-06-13 20:37 UTC

TransactionalClient::addList() A

↳ Parent: TransactionalClient

Complexity

Conditions	3
Paths	3

Size

Total Lines	8
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	12

Importance

Changes

Metric	Value
eloc	5
dl	0
loc	8
ccs	0
cts	8
cp	0
rs	10
c	0
b	0
f	0
cc	3
nc	3
nop	1
crap	12

<?php
/**
 * Sandro Keil (https://sandro-keil.de)
 *
 * @link      http://github.com/sandrokeil/arangodb-php-client for the canonical source repository
 * @copyright Copyright (c) 2018-2019 Sandro Keil
 * @license   http://github.com/sandrokeil/arangodb-php-client/blob/master/LICENSE.md New BSD License
 */

declare(strict_types=1);

namespace ArangoDb;

use ArangoDb\Type\Batch;
use ArangoDb\Type\GuardSupport;
use ArangoDb\Type\Transaction as TransactionType;
use ArangoDb\Type\Transactional;
use ArangoDb\Type\Type;
use Fig\Http\Message\StatusCodeInterface;
use function MongoDB\BSON\toPHP;
use Psr\Http\Client\ClientInterface;
use Psr\Http\Message\RequestFactoryInterface;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseFactoryInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\StreamFactoryInterface;

final class TransactionalClient implements ClientInterface
{
    /**
     * @var ClientInterface
     */
    private $client;

    /**
     * @var RequestFactoryInterface
     */
    private $requestFactory;

    /**
     * @var ResponseFactoryInterface
     */
    private $responseFactory;

    /**
     * Types
     *
     * @var Type[]
     */
    private $types = [];

    /**
     * Types
     *
     * @var Transactional[]
     */
    private $transactionalTypes = [];

    /**
     * @var StreamFactoryInterface
     */
    private $streamFactory;

    public function __construct(
        ClientInterface $client,
        RequestFactoryInterface $requestFactory,
        ResponseFactoryInterface $responseFactory,
        StreamFactoryInterface $streamFactory
    ) {
        $this->client = $client;
        $this->requestFactory = $requestFactory;
        $this->responseFactory = $responseFactory;
        $this->streamFactory = $streamFactory;
    }

    public function sendRequest(RequestInterface $request): ResponseInterface
    {
        return $this->client->sendRequest($request);
    }

    /**
     * Sends types and transactional types. Type responses and transaction response are validated via guards if provided
     * to a type. You can also manually validate the transaction response but not the non transaction response.
     *
     * @param array $params
     * @param bool $waitForSync
     * @return ResponseInterface
     * @throws \Psr\Http\Client\ClientExceptionInterface
     */
    public function send(array $params = [], bool $waitForSync = false): ResponseInterface
    {
        if (0 !== count($this->types)) {
            $batch = Batch::fromTypes(...$this->types);
            $responseBatch = $this->client->sendRequest($batch->toRequest($this->requestFactory, $this->streamFactory));

            if (null !== ($guards = $batch->guards())) {

                BatchResult::fromResponse(
                    $responseBatch,
                    $this->responseFactory,
                    $this->streamFactory
                )->validate(...$guards);
            }
        }

        $actions = '';
        $collectionsWrite = [[]];
        $collectionsRead = [[]];
        $return = [];
        $guards = [];

        if (0 === count($this->transactionalTypes)) {
            return $this->responseFactory->createResponse(StatusCodeInterface::STATUS_OK);
        }

        foreach ($this->transactionalTypes as $key => $type) {
            $collectionsWrite[] = $type->collectionsWrite();
            $collectionsRead[] = $type->collectionsRead();

            if ($type instanceof GuardSupport
                && ($guard = $type->guard()) !== null
            ) {
                $guards[] = $guard;
                $key = $guard->contentId();
            }
            $actions .= str_replace('var rId', 'var rId' . $key, $type->toJs());
            $return[] = 'rId' . $key;
        }
        $collectionsWrite = array_merge(...$collectionsWrite);
        $collectionsRead = array_merge(...$collectionsRead);

        $response = $this->client->sendRequest(
            TransactionType::with(
                sprintf(
                    'function () {var db = require("@arangodb").db;%s return {%s}}',
                    $actions,
                    implode(',', $return)
                ),
                array_unique($collectionsWrite),
                $params,
                array_unique($collectionsRead),
                $waitForSync
            )->toRequest($this->requestFactory, $this->streamFactory)
        );

        if (0 !== count($guards)) {
            \array_walk($guards, static function ($guard) use ($response) {
                $guard($response);
            });
        }

        $this->types = [];
        $this->transactionalTypes = [];

        return $response;
    }

    /**
     * Add type
     *
     * @param Type $type
     */
    public function add(Type $type): void
    {
        if ($type instanceof Transactional) {
            $this->transactionalTypes[] = $type;
            return;
        }
        $this->types[] = $type;
    }

    /**
     * Adds multiple types
     *
     * @param Type ...$types
     */
    public function addList(Type ...$types): void
    {
        foreach ($types as $type) {
            if ($type instanceof Transactional) {
                $this->transactionalTypes[] = $type;
                continue;
            }
            $this->types[] = $type;
        }
    }

    /**
     * Counts non transactional types
     *
     * @return int
     */
    public function countTypes(): int
    {
        return count($this->types);
    }

    /**
     * Counts transactional types
     *
     * @return int
     */
    public function countTransactionalTypes(): int
    {
        return count($this->transactionalTypes);
    }

    /**
     * Resets all types and transactional types
     */
    public function reset(): void
    {
        $this->types = [];
        $this->transactionalTypes = [];
    }
}


1			<?php
2			/**
3			* Sandro Keil (https://sandro-keil.de)
4			*
5			* @link http://github.com/sandrokeil/arangodb-php-client for the canonical source repository
6			* @copyright Copyright (c) 2018-2019 Sandro Keil
7			* @license http://github.com/sandrokeil/arangodb-php-client/blob/master/LICENSE.md New BSD License
8			*/
9
10			declare(strict_types=1);
11
12			namespace ArangoDb;
13
14			use ArangoDb\Type\Batch;
15			use ArangoDb\Type\GuardSupport;
16			use ArangoDb\Type\Transaction as TransactionType;
17			use ArangoDb\Type\Transactional;
18			use ArangoDb\Type\Type;
19			use Fig\Http\Message\StatusCodeInterface;
20			use function MongoDB\BSON\toPHP;
21			use Psr\Http\Client\ClientInterface;
22			use Psr\Http\Message\RequestFactoryInterface;
23			use Psr\Http\Message\RequestInterface;
24			use Psr\Http\Message\ResponseFactoryInterface;
25			use Psr\Http\Message\ResponseInterface;
26			use Psr\Http\Message\StreamFactoryInterface;
27
28			final class TransactionalClient implements ClientInterface
29			{
30			/**
31			* @var ClientInterface
32			*/
33			private $client;
34
35			/**
36			* @var RequestFactoryInterface
37			*/
38			private $requestFactory;
39
40			/**
41			* @var ResponseFactoryInterface
42			*/
43			private $responseFactory;
44
45			/**
46			* Types
47			*
48			* @var Type[]
49			*/
50			private $types = [];
51
52			/**
53			* Types
54			*
55			* @var Transactional[]
56			*/
57			private $transactionalTypes = [];
58
59			/**
60			* @var StreamFactoryInterface
61			*/
62			private $streamFactory;
63
64			public function __construct(
65			ClientInterface $client,
66			RequestFactoryInterface $requestFactory,
67			ResponseFactoryInterface $responseFactory,
68			StreamFactoryInterface $streamFactory
69			) {
70			$this->client = $client;
71			$this->requestFactory = $requestFactory;
72			$this->responseFactory = $responseFactory;
73			$this->streamFactory = $streamFactory;
74			}
75
76			public function sendRequest(RequestInterface $request): ResponseInterface
77			{
78			return $this->client->sendRequest($request);
79			}
80
81			/**
82			* Sends types and transactional types. Type responses and transaction response are validated via guards if provided
83			* to a type. You can also manually validate the transaction response but not the non transaction response.
84			*
85			* @param array $params
86			* @param bool $waitForSync
87			* @return ResponseInterface
88			* @throws \Psr\Http\Client\ClientExceptionInterface
89			*/
90			public function send(array $params = [], bool $waitForSync = false): ResponseInterface
91			{
92			if (0 !== count($this->types)) {
93			$batch = Batch::fromTypes(...$this->types);
94			$responseBatch = $this->client->sendRequest($batch->toRequest($this->requestFactory, $this->streamFactory));
95
96			if (null !== ($guards = $batch->guards())) {
			0 ignored issues – show introduced 2019-05-31 14:04 UTC by Report Bug Copy Issue Report The condition `null !== $guards = $batch->guards()` is always `true`. Loading history...
97			BatchResult::fromResponse(
98			$responseBatch,
99			$this->responseFactory,
100			$this->streamFactory
101			)->validate(...$guards);
102			}
103			}
104
105			$actions = '';
106			$collectionsWrite = [[]];
107			$collectionsRead = [[]];
108			$return = [];
109			$guards = [];
110
111			if (0 === count($this->transactionalTypes)) {
112			return $this->responseFactory->createResponse(StatusCodeInterface::STATUS_OK);
113			}
114
115			foreach ($this->transactionalTypes as $key => $type) {
116			$collectionsWrite[] = $type->collectionsWrite();
117			$collectionsRead[] = $type->collectionsRead();
118
119			if ($type instanceof GuardSupport
120			&& ($guard = $type->guard()) !== null
121			) {
122			$guards[] = $guard;
123			$key = $guard->contentId();
124			}
125			$actions .= str_replace('var rId', 'var rId' . $key, $type->toJs());
126			$return[] = 'rId' . $key;
127			}
128			$collectionsWrite = array_merge(...$collectionsWrite);
129			$collectionsRead = array_merge(...$collectionsRead);
130
131			$response = $this->client->sendRequest(
132			TransactionType::with(
133			sprintf(
134			'function () {var db = require("@arangodb").db;%s return {%s}}',
135			$actions,
136			implode(',', $return)
137			),
138			array_unique($collectionsWrite),
139			$params,
140			array_unique($collectionsRead),
141			$waitForSync
142			)->toRequest($this->requestFactory, $this->streamFactory)
143			);
144
145			if (0 !== count($guards)) {
146			\array_walk($guards, static function ($guard) use ($response) {
147			$guard($response);
148			});
149			}
150
151			$this->types = [];
152			$this->transactionalTypes = [];
153
154			return $response;
155			}
156
157			/**
158			* Add type
159			*
160			* @param Type $type
161			*/
162			public function add(Type $type): void
163			{
164			if ($type instanceof Transactional) {
165			$this->transactionalTypes[] = $type;
166			return;
167			}
168			$this->types[] = $type;
169			}
170
171			/**
172			* Adds multiple types
173			*
174			* @param Type ...$types
175			*/
176			public function addList(Type ...$types): void
177			{
178			foreach ($types as $type) {
179			if ($type instanceof Transactional) {
180			$this->transactionalTypes[] = $type;
181			continue;
182			}
183			$this->types[] = $type;
184			}
185			}
186
187			/**
188			* Counts non transactional types
189			*
190			* @return int
191			*/
192			public function countTypes(): int
193			{
194			return count($this->types);
195			}
196
197			/**
198			* Counts transactional types
199			*
200			* @return int
201			*/
202			public function countTransactionalTypes(): int
203			{
204			return count($this->transactionalTypes);
205			}
206
207			/**
208			* Resets all types and transactional types
209			*/
210			public function reset(): void
211			{
212			$this->types = [];
213			$this->transactionalTypes = [];
214			}
215			}
216

sandrokeil / arangodb-php-client

Pull Request — master (#7)

TransactionalClient::addList() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like