QueryRepository::inserted() - Code Metrics - Inspection of "Add QueryRepository::inserted" - rougin/windstorm - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( d81d6b...0a2e96 )

by Rougin

created 2019-03-05 23:46 UTC

QueryRepository::inserted() A

↳ Parent: QueryRepository

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

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

<?php

namespace Rougin\Windstorm;

use Rougin\Windstorm\MixedInterface;
use Rougin\Windstorm\QueryInterface;
use Rougin\Windstorm\ResultInterface;

/**
 * Query Repository
 *
 * @package Windstorm
 * @author  Rougin Gutib <[email protected]>
 */
class QueryRepository
{
    /**
     * @var \Rougin\Windstorm\ResultInterface
     */
    protected $result;

    /**
     * @var \Rougin\Windstorm\MappingInterface
     */
    protected $mapping;

    /**
     * @var \Rougin\Windstorm\MixedInterface
     */
    protected $mixed = null;

    /**
     * @var \Rougin\Windstorm\QueryInterface
     */
    protected $query;

    /**
     * Initializes the repository instance.
     *
     * @param \Rougin\Windstorm\QueryInterface  $query
     * @param \Rougin\Windstorm\ResultInterface $result
     */
    public function __construct(QueryInterface $query, ResultInterface $result)
    {
        $this->result = $result;

        $this->query = $query;
    }

    /**
     * Returns a number of affected rows.
     *
     * @return integer
     */
    public function affected()
    {
        return $this->execute($this->query)->affected();
    }

    /**
     * Executes the result against query instance.
     *
     * @param  \Rougin\Windstorm\QueryInterface $query
     * @return \Rougin\Windstorm\ResultInterface
     */
    public function execute(QueryInterface $query)
    {
        return $this->result->execute($query);
    }

    /**
     * Returns the first row from result.
     *
     * @return mixed
     */
    public function first()
    {
        if ($this->mixed !== null)
        {
            return current($this->items());
        }

        $item = $this->execute($this->query)->first();

        if ($this->mapping)
        {
            return $this->mapping->map($item);
        }

        return $item;
    }

    /**
     * Returns the last inserted ID.
     *
     * @return integer
     */
    public function inserted()
    {
        return $this->execute($this->query)->inserted();
    }

    /**
     * Returns all items from the result.
     *
     * @return mixed
     */
    public function items()
    {
        if ($this->mixed !== null)
        {
            $result = $this->combine();
        }
        else
        {
            $result = $this->execute($this->query)->items();
        }

        if ($this->mapping === null)
        {
            return $result;
        }

        foreach ($result as $key => $item)
        {
            $result[$key] = $this->mapping->map($item);
        }

        return $result;
    }

    /**
     * Sets the mapping instance.
     *
     * @param  \Rougin\Windstorm\MappingInterface $mapping
     * @return self
     */
    public function map(MappingInterface $mapping)
    {
        $this->mapping = $mapping;

        return $this;
    }

    /**
     * Returns the query instance.
     *
     * @return \Rougin\Windstorm\QueryRepository
     */
    public function query()
    {
        return clone $this->query;
    }

    /**
     * Mutates the specified query instance.
     *
     * @param  \Rougin\Windstorm\MutatorInterface $mutator
     * @return self
     */
    public function set(MutatorInterface $mutator)
    {
        $query = $mutator->set($this->query);

        if ($query instanceof MixedInterface)
        {
            $this->mixed = $query;

            return $this;
        }

        $this->query = $query;

        return $this;
    }

    public function combine()
    {
        $parent = $this->execute($this->mixed)->items();

        $ids = array();

        foreach ($parent as $item)
        {
            $ids[] = (integer) $item[$this->mixed->primary()];
        }

        foreach ($this->mixed->all() as $field => $child)
        {
            $children = $child->where($child->column())->in($ids);

            $children = $this->execute($children)->items();

            foreach ($parent as $index => $item)
            {
                $parent[$index][$field] = array();

                foreach ($children as $key => $value)
                {
                    if ($item[$this->mixed->primary()] === $value[$child->foreign()])
                    {
                        $parent[$index][$field][] = $value;

                        unset($children[$key]);
                    }
                }
            }
        }

        return $parent;
    }
}


1		<?php
2
3		namespace Rougin\Windstorm;
4
5		use Rougin\Windstorm\MixedInterface;
6		use Rougin\Windstorm\QueryInterface;
7		use Rougin\Windstorm\ResultInterface;
8
9		/**
10		* Query Repository
11		*
12		* @package Windstorm
13		* @author Rougin Gutib <[email protected]>
14		*/
15		class QueryRepository
16		{
17		/**
18		* @var \Rougin\Windstorm\ResultInterface
19		*/
20		protected $result;
21
22		/**
23		* @var \Rougin\Windstorm\MappingInterface
24		*/
25		protected $mapping;
26
27		/**
28		* @var \Rougin\Windstorm\MixedInterface
29		*/
30		protected $mixed = null;
31
32		/**
33		* @var \Rougin\Windstorm\QueryInterface
34		*/
35		protected $query;
36
37		/**
38		* Initializes the repository instance.
39		*
40		* @param \Rougin\Windstorm\QueryInterface $query
41		* @param \Rougin\Windstorm\ResultInterface $result
42		*/
43	57	public function __construct(QueryInterface $query, ResultInterface $result)
44	2	{
45	57	$this->result = $result;
46
47	57	$this->query = $query;
48	57	}
49
50		/**
51		* Returns a number of affected rows.
52		*
53		* @return integer
54		*/
55	21	public function affected()
56		{
57	21	return $this->execute($this->query)->affected();
58		}
59
60		/**
61		* Executes the result against query instance.
62		*
63		* @param \Rougin\Windstorm\QueryInterface $query
64		* @return \Rougin\Windstorm\ResultInterface
65		*/
66	51	public function execute(QueryInterface $query)
67		{
68	51	return $this->result->execute($query);
69		}
70
71		/**
72		* Returns the first row from result.
73		*
74		* @return mixed
75		*/
76	9	public function first()
77		{
78	9	if ($this->mixed !== null)
79	6	{
80	3	return current($this->items());
81		}
82
83	6	$item = $this->execute($this->query)->first();
84
85	6	if ($this->mapping)
86	4	{
87	3	return $this->mapping->map($item);
88		}
89
90	3	return $item;
91		}
92
93		/**
94		* Returns the last inserted ID.
95		*
96		* @return integer
97		*/
98		public function inserted()
99		{
100		return $this->execute($this->query)->inserted();
101		}
102
103		/**
104		* Returns all items from the result.
105		*
106		* @return mixed
107		*/
108	24	public function items()
109		{
110	24	if ($this->mixed !== null)
111	16	{
112	3	$result = $this->combine();
113	2	}
114		else
115		{
116	21	$result = $this->execute($this->query)->items();
117		}
118
119	24	if ($this->mapping === null)
120	16	{
121	9	return $result;
122		}
123
124	15	foreach ($result as $key => $item)
125		{
126	15	$result[$key] = $this->mapping->map($item);
127	10	}
128
129	15	return $result;
130		}
131
132		/**
133		* Sets the mapping instance.
134		*
135		* @param \Rougin\Windstorm\MappingInterface $mapping
136		* @return self
137		*/
138	42	public function map(MappingInterface $mapping)
139		{
140	42	$this->mapping = $mapping;
141
142	42	return $this;
143		}
144
145		/**
146		* Returns the query instance.
147		*
148		* @return \Rougin\Windstorm\QueryRepository
149		*/
150	3	public function query()
151		{
152	3	return clone $this->query;
153		}
154
155		/**
156		* Mutates the specified query instance.
157		*
158		* @param \Rougin\Windstorm\MutatorInterface $mutator
159		* @return self
160		*/
161	51	public function set(MutatorInterface $mutator)
162		{
163	51	$query = $mutator->set($this->query);
164
165	51	if ($query instanceof MixedInterface)
166	34	{
167	3	$this->mixed = $query;
168
169	3	return $this;
170		}
171
172	48	$this->query = $query;
173
174	48	return $this;
175		}
176
177	3	public function combine()
178		{
179	3	$parent = $this->execute($this->mixed)->items();
180
181	3	$ids = array();
182
183	3	foreach ($parent as $item)
184		{
185	3	$ids[] = (integer) $item[$this->mixed->primary()];
186	2	}
187
188	3	foreach ($this->mixed->all() as $field => $child)
189		{
190	3	$children = $child->where($child->column())->in($ids);
191
192	3	$children = $this->execute($children)->items();
193
194	3	foreach ($parent as $index => $item)
195		{
196	3	$parent[$index][$field] = array();
197
198	3	foreach ($children as $key => $value)
199		{
200	3	if ($item[$this->mixed->primary()] === $value[$child->foreign()])
201	2	{
202	3	$parent[$index][$field][] = $value;
203
204	3	unset($children[$key]);
205	2	}
206	2	}
207	2	}
208	2	}
209
210	3	return $parent;
211		}
212		}
213

rougin / windstorm

Push — master ( d81d6b...0a2e96 )

QueryRepository::inserted() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like