Driver::find() - Code Metrics - Inspection of "Aws DynamoDb Driver" - Respect/Structural - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#7)

by Fábio da Silva

created 2016-03-01 00:52 UTC

Driver::find() A

↳ Parent: Driver

Complexity

Conditions	2
Paths	2

Size

Total Lines	14
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	8
CRAP Score	2

Importance

Changes	1
Bugs	0	Features	0

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

<?php

namespace Respect\Structural\Driver\DynamoDb;

use Aws\DynamoDb\DynamoDbClient;
use Aws\DynamoDb\Marshaler;
use Respect\Data\CollectionIterator;
use Respect\Data\Collections\Collection;
use Respect\Structural\Driver as BaseDriver;

class Driver implements BaseDriver
{
    /**
     * @var \Aws\DynamoDb\DynamoDbClient
     */
    private $connection;

    /**
     * @var \Aws\DynamoDb\Marshaler
     */
    private $marshaler;

    /**
     * Driver constructor.
     *
     * @param \Aws\DynamoDb\DynamoDbClient $connection
     */
    public function __construct(DynamoDbClient $connection)
    {
        $this->connection = $connection;
        $this->marshaler = new Marshaler();
    }

    /**
     * @return \Aws\DynamoDb\DynamoDbClient
     */
    public function getConnection()
    {
        return $this->connection;
    }

    /**
     * @param \Iterator $cursor
     *
     * @return array
     */
    public function fetch(\Iterator $cursor)
    {
        $data = [];

        if ($cursor->valid()) {
            $data = $cursor->current();
            $cursor->next();
        }

        return $data;
    }

    /**
     * @param array $collection
     * @param array $query
     *
     * @return \Iterator
     */
    public function find($collection, array $query = [])
    {
        $expression = [
            'TableName' => $collection,
        ];

        if (!empty($query)) {
            $expression['ScanFilter'] = $query;
        }

        $result = $this->getConnection()->scan($expression);

        return $this->formatResults($result);
    }

    /**
     * @param Collection $collection
     *
     * @return array
     */
    public function generateQuery(Collection $collection)
    {
        return $this->parseConditions($collection);
    }

    /**
     * @param Collection $collection
     *
     * @return array
     */
    protected function parseConditions(Collection $collection)
    {
        $collections = iterator_to_array(
            CollectionIterator::recursive($collection)
        );

        $collections = array_slice($collections, 1);
        $condition = $this->getConditionArray($collection);

        foreach ($collections as $name => $coll) {
            $condition += $this->getConditionArray($coll);
        }

        return $condition;
    }

    /**
     * @param Collection $collection
     *
     * @return array
     */
    protected function getConditionArray(Collection $collection)
    {
        $condition = $collection->getCondition();

        if (!is_array($condition)) {
            $condition = ['_id' => $condition];
        }

        $conditions = [];

        foreach ($condition as $key => $value) {
            $conditions = [
                $key => [
                    'AttributeValueList' => [
                        $this->marshaler->marshalValue($value),
                    ],
                    'ComparisonOperator' => 'EQ',
                ],
            ];
        }

        return $conditions;
    }

    /**
     * @param Collection $collection
     * @param $document
     */
    public function insert($collection, $document)
    {
        $args = [
            'TableName' => $collection,
            'Item' => $this->marshaler->marshalItem($document),
        ];

        $this->getConnection()->putItem($args);
    }

    /**
     * @param Collection $collection
     * @param $criteria
     * @param $document
     */
    public function update($collection, $criteria, $document)
    {
        $args = [
            'TableName' => $collection,
            'Key' => $this->marshaler->marshalItem($criteria),
            'AttributeUpdates' => $this->formatAttributes($document),
        ];

        $this->getConnection()->updateItem($args);
    }

    /**
     * @param Collection $collection
     * @param $criteria
     */
    public function remove($collection, $criteria)
    {
        $args = [
            'TableName' => $collection,
            'Key' => $this->marshaler->marshalItem($criteria),
        ];

        $this->getConnection()->deleteItem($args);
    }

    /**
     * @param $values
     *
     * @return array
     */
    protected function formatAttributes($values)
    {
        $attributes = [];

        foreach ($values as $key => $value) {
            $attributes[$key] = [
                'Value' => $this->marshaler->marshalValue($value),
            ];
        }

        return $attributes;
    }

    protected function formatResults(\Aws\Result $result)
    {
        $items = new \ArrayIterator();

        if ($result['Count'] === 0) {
            return $items;
        }

        foreach ($result['Items'] as $item) {
            $items[] = $this->marshaler->unmarshalItem($item);
        }

        return $items;
    }
}


1		<?php
2
3		namespace Respect\Structural\Driver\DynamoDb;
4
5		use Aws\DynamoDb\DynamoDbClient;
6		use Aws\DynamoDb\Marshaler;
7		use Respect\Data\CollectionIterator;
8		use Respect\Data\Collections\Collection;
9		use Respect\Structural\Driver as BaseDriver;
10
11		class Driver implements BaseDriver
12		{
13		/**
14		* @var \Aws\DynamoDb\DynamoDbClient
15		*/
16		private $connection;
17
18		/**
19		* @var \Aws\DynamoDb\Marshaler
20		*/
21		private $marshaler;
22
23		/**
24		* Driver constructor.
25		*
26		* @param \Aws\DynamoDb\DynamoDbClient $connection
27		*/
28	8	public function __construct(DynamoDbClient $connection)
29		{
30	8	$this->connection = $connection;
31	8	$this->marshaler = new Marshaler();
32	8	}
33
34		/**
35		* @return \Aws\DynamoDb\DynamoDbClient
36		*/
37	3	public function getConnection()
38		{
39	3	return $this->connection;
40		}
41
42		/**
43		* @param \Iterator $cursor
44		*
45		* @return array
46		*/
47	1	public function fetch(\Iterator $cursor)
48		{
49	1	$data = [];
50
51	1	if ($cursor->valid()) {
52	1	$data = $cursor->current();
53	1	$cursor->next();
54	1	}
55
56	1	return $data;
57		}
58
59		/**
60		* @param array $collection
61		* @param array $query
62		*
63		* @return \Iterator
64		*/
65	2	public function find($collection, array $query = [])
66		{
67		$expression = [
68	2	'TableName' => $collection,
69	2	];
70
71	2	if (!empty($query)) {
72	2	$expression['ScanFilter'] = $query;
73	2	}
74
75	2	$result = $this->getConnection()->scan($expression);
76
77	2	return $this->formatResults($result);
78		}
79
80		/**
81		* @param Collection $collection
82		*
83		* @return array
84		*/
85	3	public function generateQuery(Collection $collection)
86		{
87	3	return $this->parseConditions($collection);
88		}
89
90		/**
91		* @param Collection $collection
92		*
93		* @return array
94		*/
95	3	protected function parseConditions(Collection $collection)
96		{
97	3	$collections = iterator_to_array(
98	3	CollectionIterator::recursive($collection)
99	3	);
100
101	3	$collections = array_slice($collections, 1);
102	3	$condition = $this->getConditionArray($collection);
103
104	3	foreach ($collections as $name => $coll) {
105	1	$condition += $this->getConditionArray($coll);
106	3	}
107
108	3	return $condition;
109		}
110
111		/**
112		* @param Collection $collection
113		*
114		* @return array
115		*/
116	3	protected function getConditionArray(Collection $collection)
117		{
118	3	$condition = $collection->getCondition();
119
120	3	if (!is_array($condition)) {
121	2	$condition = ['_id' => $condition];
122	2	}
123
124	3	$conditions = [];
125
126	3	foreach ($condition as $key => $value) {
127		$conditions = [
128		$key => [
129		'AttributeValueList' => [
130	2	$this->marshaler->marshalValue($value),
131	2	],
132	2	'ComparisonOperator' => 'EQ',
133	2	],
134	2	];
135	3	}
136
137	3	return $conditions;
138		}
139
140		/**
141		* @param Collection $collection
142		* @param $document
143		*/
144		public function insert($collection, $document)
145		{
146		$args = [
147		'TableName' => $collection,
148		'Item' => $this->marshaler->marshalItem($document),
149		];
150
151		$this->getConnection()->putItem($args);
152		}
153
154		/**
155		* @param Collection $collection
156		* @param $criteria
157		* @param $document
158		*/
159		public function update($collection, $criteria, $document)
160		{
161		$args = [
162		'TableName' => $collection,
163		'Key' => $this->marshaler->marshalItem($criteria),
164		'AttributeUpdates' => $this->formatAttributes($document),
165		];
166
167		$this->getConnection()->updateItem($args);
168		}
169
170		/**
171		* @param Collection $collection
172		* @param $criteria
173		*/
174		public function remove($collection, $criteria)
175		{
176		$args = [
177		'TableName' => $collection,
178		'Key' => $this->marshaler->marshalItem($criteria),
179		];
180
181		$this->getConnection()->deleteItem($args);
182		}
183
184		/**
185		* @param $values
186		*
187		* @return array
188		*/
189		protected function formatAttributes($values)
190		{
191		$attributes = [];
192
193		foreach ($values as $key => $value) {
194		$attributes[$key] = [
195		'Value' => $this->marshaler->marshalValue($value),
196		];
197		}
198
199		return $attributes;
200		}
201
202	2	protected function formatResults(\Aws\Result $result)
203		{
204	2	$items = new \ArrayIterator();
205
206	2	if ($result['Count'] === 0) {
207	1	return $items;
208		}
209
210	1	foreach ($result['Items'] as $item) {
211	1	$items[] = $this->marshaler->unmarshalItem($item);
212	1	}
213
214	1	return $items;
215		}
216		}
217

Respect / Structural

Pull Request — master (#7)

Driver::find() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like