QueryBuilderTrait - Code Metrics - Codexshaper/laravel-woocommerce - Measure and Improve Code Quality continuously with Scrutinizer

QueryBuilderTrait B
last analyzed 2020-11-12 11:36 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	395
Duplicated Lines	24.81 %

Coupling/Cohesion

Components	1
Dependencies	0

Test Coverage

Coverage

Importance

Changes

Metric	Value
wmc	50
lcom	1
cbo	0
dl	98
loc	395
ccs	0
cts	198
cp	0
rs	8.4
c	0
b	0
f	0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	withOriginal()	8	8	1
A	withLazyCollection()	8	8	1
A	all()	12	12	3
A	find()	0	12	3
A	create()	12	12	3
A	update()	12	12	3
A	delete()	0	12	3
A	batch()	12	12	3
A	get()	12	12	3
A	first()	0	12	3
A	withCollection()	8	8	1
A	options()	0	16	4
B	where()	0	19	7
A	orderBy()	0	7	1
B	paginate()	0	48	6
A	count()	0	11	2
A	save()	14	14	3

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like QueryBuilderTrait often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use QueryBuilderTrait, and based on these observations, apply Extract Interface, too.

<?php

namespace Codexshaper\WooCommerce\Traits;

use Codexshaper\WooCommerce\Facades\WooCommerce;
use Illuminate\Support\LazyCollection;

trait QueryBuilderTrait
{
    /**
     * @var
     */
    protected $options = [];

    /**
     * @var
     */
    protected $where = [];

    /**
     * @var
     */
    protected $properties = [];

    /**
     * @var
     */
    protected $isLazyCollection = false;

    /**
     * @var
     */
    protected $isCollection = true;

    /**
     * @var
     */
    protected $isOriginal = false;

    /**
     * Retrieve all Items.
     *
     * @param array $options
     *
     * @return array
     */
    protected function all($options = [])

    {
        if ($this->isLazyCollection) {
            return LazyCollection::make(WooCommerce::all($this->endpoint, $options));
class MyClass { }

$x = new MyClass();
$x->foo = true;
        }

        if ($this->isCollection) {
            return collect(WooCommerce::all($this->endpoint, $options));
        }

        return WooCommerce::all($this->endpoint, $options);
    }

    /**
     * Retrieve single Item.
     *
     * @param int   $id
     * @param array $options
     *
     * @return object
     */
    protected function find($id, $options = [])
    {
        if ($this->isLazyCollection) {
            return LazyCollection::make(WooCommerce::find("{$this->endpoint}/{$id}", $options));
        }

        if ($this->isCollection) {
            return collect(WooCommerce::find("{$this->endpoint}/{$id}", $options));
        }

        return WooCommerce::find("{$this->endpoint}/{$id}", $options);
    }

    /**
     * Create new Item.
     *
     * @param array $data
     *
     * @return object
     */
    protected function create($data)

    {
        if ($this->isLazyCollection) {
            return LazyCollection::make(WooCommerce::create($this->endpoint, $data));
        }

        if ($this->isCollection) {
            return collect(WooCommerce::create($this->endpoint, $data));
        }

        return WooCommerce::create($this->endpoint, $data);
    }

    /**
     * Update Existing Item.
     *
     * @param int   $id
     * @param array $data
     *
     * @return object
     */
    protected function update($id, $data)

    {
        if ($this->isLazyCollection) {
            return LazyCollection::make(WooCommerce::update("{$this->endpoint}/{$id}", $data));
        }

        if ($this->isCollection) {
            return collect(WooCommerce::update("{$this->endpoint}/{$id}", $data));
        }

        return WooCommerce::update("{$this->endpoint}/{$id}", $data);
    }

    /**
     * Destroy Item.
     *
     * @param int   $id
     * @param array $options
     *
     * @return object
     */
    protected function delete($id, $options = [])
    {
        if ($this->isLazyCollection) {
            return LazyCollection::make(WooCommerce::delete("{$this->endpoint}/{$id}", $options));
        }

        if ($this->isCollection) {
            return collect(WooCommerce::delete("{$this->endpoint}/{$id}", $options));
        }

        return WooCommerce::delete("{$this->endpoint}/{$id}", $options);
    }

    /**
     * Batch Update.
     *
     * @param array $data
     *
     * @return object
     */
    protected function batch($data)

    {
        if ($this->isLazyCollection) {
            return LazyCollection::make(WooCommerce::create("{$this->endpoint}/batch", $data));
        }

        if ($this->isCollection) {
            return collect(WooCommerce::create("{$this->endpoint}/batch", $data));
        }

        return WooCommerce::create("{$this->endpoint}/batch", $data);
    }

    /**
     * Retrieve data.
     *
     * @return array
     */
    protected function get()

    {
        if ($this->isLazyCollection) {
            return LazyCollection::make(WooCommerce::all($this->endpoint, $this->options));
        }

        if ($this->isCollection) {
            return collect(WooCommerce::all($this->endpoint, $this->options));
        }

        return WooCommerce::all($this->endpoint, $this->options);
    }

    /**
     * Retrieve data.
     *
     * @return object
     */
    protected function first()
    {
        if ($this->isLazyCollection) {
            return LazyCollection::make($this->get()[0] ?? new \stdClass());
        }

        if ($this->isCollection) {
            return collect($this->get()[0] ?? new \stdClass());
        }

        return collect($this->get()[0] ?? new \stdClass());
    }

    /**
     * Set original.
     *
     * @return object $this
     */
    protected function withOriginal()

    {
        $this->isOriginal = true;
        $this->isCollection = false;
        $this->isLazyCollection = false;

        return $this;
    }

    /**
     * Set collection.
     *
     * @return object $this
     */
    protected function withCollection()

    {
        $this->isOriginal = false;
        $this->isCollection = true;
        $this->isLazyCollection = false;

        return $this;
    }

    /**
     * Set lazy collection.
     *
     * @return object $this
     */
    protected function withLazyCollection()

    {
        $this->isOriginal = false;
        $this->isCollection = false;
        $this->isLazyCollection = true;

        return $this;
    }

    /**
     * Set options for woocommerce request.
     *
     * @param array $parameters
     *
     * @return object $this
     */
    protected function options($parameters)
    {
        if (!is_array($parameters)) {
            throw new \Exception('Options must be an array', 1);
        }

        if (empty($parameters)) {
            throw new \Exception('Options must be pass at least one element', 1);
        }

        foreach ($parameters as $key => $value) {
            $this->options[$key] = $value;
        }

        return $this;
    }

    /**
     * Join options for woocommerce request.
     *
     * @param array $parameters
     *
     * @return object $this
     */
    protected function where(...$parameters)
    {
        if (count($parameters) < 2 || count($parameters) > 3) {
            throw new \Exception('You can pass minimum 2 and maximum 3 paramneters');
        }
        $field = strtolower($parameters[0]);
        $value = count($parameters) == 3 ? $parameters[2] : $parameters[1];

        switch ($field) {
            case 'name': case 'title': case 'description':
                $this->options['search'] = $value;
                break;
            default:
                $this->options[$field] = $value;
                break;
        }

        return $this;
    }

    /**
     * Set order direction.
     *
     * @param string $name
     * @param string $direction
     *
     * @return object $this
     */
    protected function orderBy($name, $direction = 'desc')
    {
        $this->options['orderby'] = $name;
        $this->options['order'] = $direction;

        return $this;
    }

    /**
     * Paginate results.
     *
     * @param int   $per_page
     * @param int   $current_page
     * @param array $options
     *
     * @return array
     */
    protected function paginate($per_page = 10, $current_page = 1, $options = [])
    {
        try {
            $this->options['per_page'] = (int) $per_page;

            if ($current_page > 0) {
                $this->options['page'] = (int) $current_page;
            }

            foreach ($options as $option => $value) {
                $this->options[$option] = $value;
            }

            $data = $this->get();
            $totalResults = WooCommerce::countResults();
            $totalPages = WooCommerce::countPages();
            $currentPage = WooCommerce::current();
            $previousPage = WooCommerce::previous();
            $nextPage = WooCommerce::next();

            $pagination = [
                'total_results' => $totalResults,
                'total_pages'   => $totalPages,
                'current_page'  => $currentPage,
                'previous_page' => $previousPage,
                'next_page'     => $nextPage,
                'first_page'    => 1,
                'last_page'     => $totalResults,
            ];

            $results = [
                'meta'       => $pagination,
                'data'       => $data,
            ];

            if ($this->isLazyCollection) {
                return LazyCollection::make($results);
            }

            if ($this->isCollection) {
                return collect($results);
            }

            return $results;
        } catch (\Exception $ex) {
            throw new \Exception($ex->getMessage(), 1);
        }
    }

    /**
     * Count all results.
     *
     * @return int
     */
    protected function count()
    {
        try {
            $results = WooCommerce::all($this->endpoint, $this->options);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
            $totalResults = WooCommerce::countResults();

            return $totalResults;
        } catch (\Exception $ex) {
            throw new \Exception($ex->getMessage(), 1);
        }
    }

    /**
     * Store data.
     *
     * @return array
     */
    public function save()

    {
        $this->results = WooCommerce::create($this->endpoint, $this->properties);
class MyClass { }

$x = new MyClass();
$x->foo = true;

        if ($this->isLazyCollection) {
            return LazyCollection::make($this->results);
        }

        if ($this->isCollection) {
            return collect($this->results);
        }

        return $this->results;
    }
}


1		<?php
2
3		namespace Codexshaper\WooCommerce\Traits;
4
5		use Codexshaper\WooCommerce\Facades\WooCommerce;
6		use Illuminate\Support\LazyCollection;
7
8		trait QueryBuilderTrait
9		{
10		/**
11		* @var
12		*/
13		protected $options = [];
14
15		/**
16		* @var
17		*/
18		protected $where = [];
19
20		/**
21		* @var
22		*/
23		protected $properties = [];
24
25		/**
26		* @var
27		*/
28		protected $isLazyCollection = false;
29
30		/**
31		* @var
32		*/
33		protected $isCollection = true;
34
35		/**
36		* @var
37		*/
38		protected $isOriginal = false;
39
40		/**
41		* Retrieve all Items.
42		*
43		* @param array $options
44		*
45		* @return array
46		*/
47	View Code Duplication	protected function all($options = [])
		0 ignored issues – show Duplication introduced 2020-11-12 10:47 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
48		{
49		if ($this->isLazyCollection) {
50		return LazyCollection::make(WooCommerce::all($this->endpoint, $options));
		0 ignored issues – show Bug introduced 2020-10-28 12:48 UTC by Report Bug Copy Issue Report The property `endpoint` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
51		}
52
53		if ($this->isCollection) {
54		return collect(WooCommerce::all($this->endpoint, $options));
55		}
56
57		return WooCommerce::all($this->endpoint, $options);
58		}
59
60		/**
61		* Retrieve single Item.
62		*
63		* @param int $id
64		* @param array $options
65		*
66		* @return object
67		*/
68		protected function find($id, $options = [])
69		{
70		if ($this->isLazyCollection) {
71		return LazyCollection::make(WooCommerce::find("{$this->endpoint}/{$id}", $options));
72		}
73
74		if ($this->isCollection) {
75		return collect(WooCommerce::find("{$this->endpoint}/{$id}", $options));
76		}
77
78		return WooCommerce::find("{$this->endpoint}/{$id}", $options);
79		}
80
81		/**
82		* Create new Item.
83		*
84		* @param array $data
85		*
86		* @return object
87		*/
88	View Code Duplication	protected function create($data)
		0 ignored issues – show Duplication introduced 2020-11-12 10:47 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
89		{
90		if ($this->isLazyCollection) {
91		return LazyCollection::make(WooCommerce::create($this->endpoint, $data));
92		}
93
94		if ($this->isCollection) {
95		return collect(WooCommerce::create($this->endpoint, $data));
96		}
97
98		return WooCommerce::create($this->endpoint, $data);
99		}
100
101		/**
102		* Update Existing Item.
103		*
104		* @param int $id
105		* @param array $data
106		*
107		* @return object
108		*/
109	View Code Duplication	protected function update($id, $data)
		0 ignored issues – show Duplication introduced 2020-10-28 12:48 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
110		{
111		if ($this->isLazyCollection) {
112		return LazyCollection::make(WooCommerce::update("{$this->endpoint}/{$id}", $data));
113		}
114
115		if ($this->isCollection) {
116		return collect(WooCommerce::update("{$this->endpoint}/{$id}", $data));
117		}
118
119		return WooCommerce::update("{$this->endpoint}/{$id}", $data);
120		}
121
122		/**
123		* Destroy Item.
124		*
125		* @param int $id
126		* @param array $options
127		*
128		* @return object
129		*/
130		protected function delete($id, $options = [])
131		{
132		if ($this->isLazyCollection) {
133		return LazyCollection::make(WooCommerce::delete("{$this->endpoint}/{$id}", $options));
134		}
135
136		if ($this->isCollection) {
137		return collect(WooCommerce::delete("{$this->endpoint}/{$id}", $options));
138		}
139
140		return WooCommerce::delete("{$this->endpoint}/{$id}", $options);
141		}
142
143		/**
144		* Batch Update.
145		*
146		* @param array $data
147		*
148		* @return object
149		*/
150	View Code Duplication	protected function batch($data)
		0 ignored issues – show Duplication introduced 2020-10-28 12:48 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
151		{
152		if ($this->isLazyCollection) {
153		return LazyCollection::make(WooCommerce::create("{$this->endpoint}/batch", $data));
154		}
155
156		if ($this->isCollection) {
157		return collect(WooCommerce::create("{$this->endpoint}/batch", $data));
158		}
159
160		return WooCommerce::create("{$this->endpoint}/batch", $data);
161		}
162
163		/**
164		* Retrieve data.
165		*
166		* @return array
167		*/
168	View Code Duplication	protected function get()
		0 ignored issues – show Duplication introduced 2020-10-28 12:48 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
169		{
170		if ($this->isLazyCollection) {
171		return LazyCollection::make(WooCommerce::all($this->endpoint, $this->options));
172		}
173
174		if ($this->isCollection) {
175		return collect(WooCommerce::all($this->endpoint, $this->options));
176		}
177
178		return WooCommerce::all($this->endpoint, $this->options);
179		}
180
181		/**
182		* Retrieve data.
183		*
184		* @return object
185		*/
186		protected function first()
187		{
188		if ($this->isLazyCollection) {
189		return LazyCollection::make($this->get()[0] ?? new \stdClass());
190		}
191
192		if ($this->isCollection) {
193		return collect($this->get()[0] ?? new \stdClass());
194		}
195
196		return collect($this->get()[0] ?? new \stdClass());
197		}
198
199		/**
200		* Set original.
201		*
202		* @return object $this
203		*/
204	View Code Duplication	protected function withOriginal()
		0 ignored issues – show Duplication introduced 2020-10-28 12:48 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
205		{
206		$this->isOriginal = true;
207		$this->isCollection = false;
208		$this->isLazyCollection = false;
209
210		return $this;
211		}
212
213		/**
214		* Set collection.
215		*
216		* @return object $this
217		*/
218	View Code Duplication	protected function withCollection()
		0 ignored issues – show Duplication introduced 2020-10-28 12:48 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
219		{
220		$this->isOriginal = false;
221		$this->isCollection = true;
222		$this->isLazyCollection = false;
223
224		return $this;
225		}
226
227		/**
228		* Set lazy collection.
229		*
230		* @return object $this
231		*/
232	View Code Duplication	protected function withLazyCollection()
		0 ignored issues – show Duplication introduced 2020-10-28 12:48 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
233		{
234		$this->isOriginal = false;
235		$this->isCollection = false;
236		$this->isLazyCollection = true;
237
238		return $this;
239		}
240
241		/**
242		* Set options for woocommerce request.
243		*
244		* @param array $parameters
245		*
246		* @return object $this
247		*/
248		protected function options($parameters)
249		{
250		if (!is_array($parameters)) {
251		throw new \Exception('Options must be an array', 1);
252		}
253
254		if (empty($parameters)) {
255		throw new \Exception('Options must be pass at least one element', 1);
256		}
257
258		foreach ($parameters as $key => $value) {
259		$this->options[$key] = $value;
260		}
261
262		return $this;
263		}
264
265		/**
266		* Join options for woocommerce request.
267		*
268		* @param array $parameters
269		*
270		* @return object $this
271		*/
272		protected function where(...$parameters)
273		{
274		if (count($parameters) < 2 \|\| count($parameters) > 3) {
275		throw new \Exception('You can pass minimum 2 and maximum 3 paramneters');
276		}
277		$field = strtolower($parameters[0]);
278		$value = count($parameters) == 3 ? $parameters[2] : $parameters[1];
279
280		switch ($field) {
281		case 'name': case 'title': case 'description':
282		$this->options['search'] = $value;
283		break;
284		default:
285		$this->options[$field] = $value;
286		break;
287		}
288
289		return $this;
290		}
291
292		/**
293		* Set order direction.
294		*
295		* @param string $name
296		* @param string $direction
297		*
298		* @return object $this
299		*/
300		protected function orderBy($name, $direction = 'desc')
301		{
302		$this->options['orderby'] = $name;
303		$this->options['order'] = $direction;
304
305		return $this;
306		}
307
308		/**
309		* Paginate results.
310		*
311		* @param int $per_page
312		* @param int $current_page
313		* @param array $options
314		*
315		* @return array
316		*/
317		protected function paginate($per_page = 10, $current_page = 1, $options = [])
318		{
319		try {
320		$this->options['per_page'] = (int) $per_page;
321
322		if ($current_page > 0) {
323		$this->options['page'] = (int) $current_page;
324		}
325
326		foreach ($options as $option => $value) {
327		$this->options[$option] = $value;
328		}
329
330		$data = $this->get();
331		$totalResults = WooCommerce::countResults();
332		$totalPages = WooCommerce::countPages();
333		$currentPage = WooCommerce::current();
334		$previousPage = WooCommerce::previous();
335		$nextPage = WooCommerce::next();
336
337		$pagination = [
338		'total_results' => $totalResults,
339		'total_pages' => $totalPages,
340		'current_page' => $currentPage,
341		'previous_page' => $previousPage,
342		'next_page' => $nextPage,
343		'first_page' => 1,
344		'last_page' => $totalResults,
345		];
346
347		$results = [
348		'meta' => $pagination,
349		'data' => $data,
350		];
351
352		if ($this->isLazyCollection) {
353		return LazyCollection::make($results);
354		}
355
356		if ($this->isCollection) {
357		return collect($results);
358		}
359
360		return $results;
361		} catch (\Exception $ex) {
362		throw new \Exception($ex->getMessage(), 1);
363		}
364		}
365
366		/**
367		* Count all results.
368		*
369		* @return int
370		*/
371		protected function count()
372		{
373		try {
374		$results = WooCommerce::all($this->endpoint, $this->options);
		0 ignored issues – show Unused Code introduced 2020-04-28 08:01 UTC by Report Bug Copy Issue Report `$results` is not used, you could remove the assignment. This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently. $myVar = 'Value'; $higher = false; if (rand(1, 6) > 3) { $higher = true; } else { $higher = false; } Both the `$myVar` assignment in line 1 and the `$higher` assignment in line 2 are dead. The first because `$myVar` is never used and the second because `$higher` is always overwritten for every possible time line. Loading history...
375		$totalResults = WooCommerce::countResults();
376
377		return $totalResults;
378		} catch (\Exception $ex) {
379		throw new \Exception($ex->getMessage(), 1);
380		}
381		}
382
383		/**
384		* Store data.
385		*
386		* @return array
387		*/
388	View Code Duplication	public function save()
		0 ignored issues – show Duplication introduced 2020-10-28 12:48 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
389		{
390		$this->results = WooCommerce::create($this->endpoint, $this->properties);
		0 ignored issues – show Bug introduced 2020-03-27 10:36 UTC by Report Bug Copy Issue Report The property `results` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
391
392		if ($this->isLazyCollection) {
393		return LazyCollection::make($this->results);
394		}
395
396		if ($this->isCollection) {
397		return collect($this->results);
398		}
399
400		return $this->results;
401		}
402		}
403

Codexshaper / laravel-woocommerce

QueryBuilderTrait B last analyzed 2020-11-12 11:36 UTC