AbstractBuilder::getParameters() - Code Metrics - Inspection of "added getQueryBuilder callback" - phuria/under-query - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 460b86...e42d3c )

by Beniamin

created 2016-11-18 16:33 UTC

AbstractBuilder::getParameters() A

↳ Parent: AbstractBuilder

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

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

<?php

/**
 * This file is part of UnderQuery package.
 *
 * Copyright (c) 2016 Beniamin Jonatan Šimko
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Phuria\UnderQuery\QueryBuilder;

use Phuria\UnderQuery\Parameter\ParameterCollection;
use Phuria\UnderQuery\Parameter\ParameterCollectionInterface;
use Phuria\UnderQuery\Query\Query;
use Phuria\UnderQuery\Reference\ReferenceCollection;
use Phuria\UnderQuery\Reference\ReferenceCollectionInterface;
use Phuria\UnderQuery\Table\AbstractTable;

/**
 * @author Beniamin Jonatan Šimko <[email protected]>
 */
abstract class AbstractBuilder implements BuilderInterface
{
    /**
     * @var QueryBuilderFacade
     */
    private $facade;

    /**
     * @var ReferenceCollectionInterface
     */
    private $referenceCollection;

    /**
     * @var ParameterCollectionInterface
     */
    private $parameterCollection;

    /**
     * @var AbstractTable[] $tables
     */
    private $rootTables = [];

    /**
     * @param QueryBuilderFacade $facade
     */
    public function __construct(QueryBuilderFacade $facade)
    {
        $this->facade = $facade;
        $this->parameterCollection = new ParameterCollection();
        $this->referenceCollection = new ReferenceCollection();
    }

    /**
     * @param callable $callback

     *
     * @return BuilderInterface
     */
    public function getQueryBuilder(callable $callback = null)
    {
        $callback && $callback($this);

        return $this;
    }

    /**
     * @return ParameterCollectionInterface
     */
    public function getParameters()
    {
        return $this->parameterCollection;
    }

    /**
     * @return ReferenceCollectionInterface
     */
    public function getReferences()
    {
        return $this->referenceCollection;
    }

    /**
     * @param mixed  $table
     * @param string $alias

     *
     * @return AbstractTable
     */
    public function addRootTable($table, $alias = null)
    {
        $this->rootTables[] = $table = $this->createTable($table, $alias);

        return $table;
    }

    /**
     * @return AbstractTable[]
     */
    public function getRootTables()
    {
        return $this->rootTables;
    }

    /**
     * @param mixed       $table
     * @param string|null $alias
     *
     * @return AbstractTable
     */
    public function createTable($table, $alias = null)
    {
        $tableObject = $this->facade->createTable($this, $table);

        if ($alias) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            $tableObject->setAlias($alias);
        }

        if (is_callable($table)) {
            $table($tableObject);
        }

        return $tableObject;
    }

    /**
     * @inheritdoc
     */
    public function objectToString($object)
    {
        return $this->getReferences()->createReference($object);
    }

    /**
     * @inheritdoc
     */
    public function setParameter($name, $value)
    {
        $parameter = $this->getParameters()->getParameter($name);
        $parameter->setValue($value);

        return $this;
    }

    /**
     * @return Query
     */
    public function buildQuery()
    {
        return new Query(
            $this->buildSQL(),
            $this->parameterCollection->toArray(),
            $this->facade->getConnection()
        );
    }

    /**
     * @inheritdoc
     */
    public function buildSQL()
    {
        return $this->facade->buildSQL($this);
    }
}

1		<?php
2
3		/**
4		* This file is part of UnderQuery package.
5		*
6		* Copyright (c) 2016 Beniamin Jonatan Šimko
7		*
8		* For the full copyright and license information, please view the LICENSE
9		* file that was distributed with this source code.
10		*/
11
12		namespace Phuria\UnderQuery\QueryBuilder;
13
14		use Phuria\UnderQuery\Parameter\ParameterCollection;
15		use Phuria\UnderQuery\Parameter\ParameterCollectionInterface;
16		use Phuria\UnderQuery\Query\Query;
17		use Phuria\UnderQuery\Reference\ReferenceCollection;
18		use Phuria\UnderQuery\Reference\ReferenceCollectionInterface;
19		use Phuria\UnderQuery\Table\AbstractTable;
20
21		/**
22		* @author Beniamin Jonatan Šimko <[email protected]>
23		*/
24		abstract class AbstractBuilder implements BuilderInterface
25		{
26		/**
27		* @var QueryBuilderFacade
28		*/
29		private $facade;
30
31		/**
32		* @var ReferenceCollectionInterface
33		*/
34		private $referenceCollection;
35
36		/**
37		* @var ParameterCollectionInterface
38		*/
39		private $parameterCollection;
40
41		/**
42		* @var AbstractTable[] $tables
43		*/
44		private $rootTables = [];
45
46		/**
47		* @param QueryBuilderFacade $facade
48		*/
49	9	public function __construct(QueryBuilderFacade $facade)
50		{
51	9	$this->facade = $facade;
52	9	$this->parameterCollection = new ParameterCollection();
53	9	$this->referenceCollection = new ReferenceCollection();
54	9	}
55
56		/**
57		* @param callable $callback
		0 ignored issues – show Documentation introduced 2016-11-18 16:36 UTC by Report Bug Copy Issue Report Should the type for parameter `$callback` not be `null\|callable`? This check looks for `@param` annotations where the type inferred by our type inference engine differs from the declared type. It makes a suggestion as to what type it considers more descriptive. Most often this is a case of a parameter that can be null in addition to its declared types. Loading history...
58		*
59		* @return BuilderInterface
60		*/
61	2	public function getQueryBuilder(callable $callback = null)
62		{
63	2	$callback && $callback($this);
64
65	1	return $this;
66		}
67
68		/**
69		* @return ParameterCollectionInterface
70		*/
71	2	public function getParameters()
72		{
73	2	return $this->parameterCollection;
74		}
75
76		/**
77		* @return ReferenceCollectionInterface
78		*/
79	4	public function getReferences()
80		{
81	4	return $this->referenceCollection;
82		}
83
84		/**
85		* @param mixed $table
86		* @param string $alias
		0 ignored issues – show Documentation introduced 2016-11-06 04:24 UTC by Report Bug Copy Issue Report Should the type for parameter `$alias` not be `string\|null`? This check looks for `@param` annotations where the type inferred by our type inference engine differs from the declared type. It makes a suggestion as to what type it considers more descriptive. Most often this is a case of a parameter that can be null in addition to its declared types. Loading history...
87		*
88		* @return AbstractTable
89		*/
90	2	public function addRootTable($table, $alias = null)
91		{
92	2	$this->rootTables[] = $table = $this->createTable($table, $alias);
93
94	1	return $table;
95		}
96
97		/**
98		* @return AbstractTable[]
99		*/
100	3	public function getRootTables()
101		{
102	3	return $this->rootTables;
103		}
104
105		/**
106		* @param mixed $table
107		* @param string\|null $alias
108		*
109		* @return AbstractTable
110		*/
111	2	public function createTable($table, $alias = null)
112		{
113	2	$tableObject = $this->facade->createTable($this, $table);
114
115	2	if ($alias) {
		0 ignored issues – show Bug Best Practice introduced 2016-11-06 04:24 UTC by Report Bug Copy Issue Report The expression `$alias` of type `string\|null` is loosely compared to `true`; this is ambiguous if the string can be empty. You might want to explicitly use `!== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `string` values, the empty string `''` is a special case, in particular the following results might be unexpected: '' == false // true '' == null // true 'ab' == false // false 'ab' == null // false // It is often better to use strict comparison '' === false // false '' === null // false Loading history...
116	1	$tableObject->setAlias($alias);
117	1	}
118
119	2	if (is_callable($table)) {
120	1	$table($tableObject);
121		}
122
123	1	return $tableObject;
124		}
125
126		/**
127		* @inheritdoc
128		*/
129	1	public function objectToString($object)
130		{
131	1	return $this->getReferences()->createReference($object);
132		}
133
134		/**
135		* @inheritdoc
136		*/
137	1	public function setParameter($name, $value)
138		{
139	1	$parameter = $this->getParameters()->getParameter($name);
140	1	$parameter->setValue($value);
141
142	1	return $this;
143		}
144
145		/**
146		* @return Query
147		*/
148	1	public function buildQuery()
149		{
150	1	return new Query(
151	1	$this->buildSQL(),
152	1	$this->parameterCollection->toArray(),
153	1	$this->facade->getConnection()
154	1	);
155		}
156
157		/**
158		* @inheritdoc
159		*/
160	2	public function buildSQL()
161		{
162	2	return $this->facade->buildSQL($this);
163		}
164		}

phuria / under-query

Push — master ( 460b86...e42d3c )

AbstractBuilder::getParameters() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like