Base::setColumnCallback() - Code Metrics - tsukasa-mixer/QueryBuilder - Measure and Improve Code Quality continuously with Scrutinizer

Base::setColumnCallback() A
last analyzed 2020-01-30 14:21 UTC

↳ Parent: Base

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

namespace Tsukasa\QueryBuilder\LookupBuilder;

use Tsukasa\QueryBuilder\Callbacks\AbstractColumnCallback;
use Tsukasa\QueryBuilder\Callbacks\AbstractFetchColumnCallback;
use Tsukasa\QueryBuilder\Callbacks\AbstractJoinCallback;
use Tsukasa\QueryBuilder\Exception\QBException;
use Tsukasa\QueryBuilder\Interfaces\IAdapter;
use Tsukasa\QueryBuilder\Interfaces\ILookupBuilder;
use Tsukasa\QueryBuilder\Interfaces\ILookupCollection;
use Tsukasa\QueryBuilder\Interfaces\QueryBuilderInterface;

abstract class Base implements ILookupBuilder
{
    /**
     * @var string
     */
    protected $default = 'exact';
    /**
     * @var string
     */
    protected $separator = '__';
    /**
     * @var AbstractColumnCallback|null
     */
    protected $columnCallback;
    /**
     * @var AbstractJoinCallback|null
     */
    protected $joinCallback;
    /**
     * @var AbstractFetchColumnCallback|null
     */
    protected $fetchColumnCallback;
    /**
     * @var ILookupCollection[]
     */
    private $_lookupCollections = [];

    public function __clone()
    {
        foreach ($this as $key => $val) {
            $this->{$key} = clone $val;
        }
    }

    /**
     * @param ILookupCollection $lookupCollection
     * @return $this
     */
    public function addLookupCollection(ILookupCollection $lookupCollection)
    {
        $this->_lookupCollections[] = $lookupCollection;
        return $this;
    }

    /**
     * @param mixed $columnCallback
     * @return $this
     */
    public function setColumnCallback($columnCallback)
    {
        $this->columnCallback = $columnCallback;
        return $this;
    }

    /**
     * @param $callback
     * @return $this
     */
    public function setJoinCallback($callback)
    {
        $this->joinCallback = $callback;
        return $this;
    }
    
    public function setFetchColumnCallback($callback)
    {
        $this->fetchColumnCallback = $callback;
        return $this;
    }

    public function getColumnCallback()
    {
        return $this->columnCallback;
    }

    public function getJoinCallback()
    {
        return $this->joinCallback;
    }

    public function fetchColumnName($column)
    {
        if ($this->fetchColumnCallback !== null) {
            if ($this->fetchColumnCallback instanceof \Closure) {

                $call = $this->fetchColumnCallback;
                return $call($column);
            }


            if ($this->fetchColumnCallback instanceof AbstractFetchColumnCallback) {

                return $this->fetchColumnCallback->run($column);
            }
        }

        return $column;
    }

    public function runCallback(QueryBuilderInterface $queryBuilder, $lookupNodes, $value)
    {
        if ($this->columnCallback !== null) {
            if ($this->columnCallback instanceof \Closure) {

                $call = $this->columnCallback;
                return $call($queryBuilder, $this, $lookupNodes, $value);
            }

            if ($this->columnCallback instanceof AbstractColumnCallback) {

                return $this->columnCallback->run($queryBuilder, $this, $lookupNodes, $value);
            }
        }

        return null;
    }

    public function runJoinCallback(QueryBuilderInterface $queryBuilder, $lookupNodes)
    {
        if ($this->joinCallback !== null) {
            if ($this->joinCallback instanceof \Closure) {

                $call = $this->joinCallback->bindTo($this, $this);
                return $call($queryBuilder, $this, $lookupNodes);
            }

            if ($this->joinCallback instanceof AbstractJoinCallback) {

                return $this->joinCallback->run($queryBuilder, $this, $lookupNodes);
            }
        }

        return null;
    }

    public function getSeparator()
    {
        return $this->separator;
    }

    public function getDefault()
    {
        return $this->default;
    }

    /**
     * @param $lookup
     * @return bool
     */
    public function hasLookup($lookup)
    {
        foreach ($this->_lookupCollections as $collection) {
            if ($collection->has($lookup)) {
                return true;
            }
        }
        return false;
    }


    /**
     * @param IAdapter $adapter
     * @param $lookup
     * @param $column
     * @param $value
     * @return string
     * @exception \Exception
     */
    public function runLookup(IAdapter $adapter, $lookup, $column, $value)
    {
        foreach ($this->_lookupCollections as $collection) {
            if ($collection->has($lookup)) {
                return $collection->process($adapter, $lookup, $column, $value);
            }
        }
        throw new QBException('Unknown lookup: ' . $lookup . ', column: ' . $column . ', value: ' . (is_array($value) ? print_r($value, true) : $value));
    }

    abstract public function parse(QueryBuilderInterface $queryBuilder, array $where);
}

1			<?php
2
3			namespace Tsukasa\QueryBuilder\LookupBuilder;
4
5			use Tsukasa\QueryBuilder\Callbacks\AbstractColumnCallback;
6			use Tsukasa\QueryBuilder\Callbacks\AbstractFetchColumnCallback;
7			use Tsukasa\QueryBuilder\Callbacks\AbstractJoinCallback;
8			use Tsukasa\QueryBuilder\Exception\QBException;
9			use Tsukasa\QueryBuilder\Interfaces\IAdapter;
10			use Tsukasa\QueryBuilder\Interfaces\ILookupBuilder;
11			use Tsukasa\QueryBuilder\Interfaces\ILookupCollection;
12			use Tsukasa\QueryBuilder\Interfaces\QueryBuilderInterface;
13
14			abstract class Base implements ILookupBuilder
15			{
16			/**
17			* @var string
18			*/
19			protected $default = 'exact';
20			/**
21			* @var string
22			*/
23			protected $separator = '__';
24			/**
25			* @var AbstractColumnCallback\|null
26			*/
27			protected $columnCallback;
28			/**
29			* @var AbstractJoinCallback\|null
30			*/
31			protected $joinCallback;
32			/**
33			* @var AbstractFetchColumnCallback\|null
34			*/
35			protected $fetchColumnCallback;
36			/**
37			* @var ILookupCollection[]
38			*/
39			private $_lookupCollections = [];
40
41			public function __clone()
42			{
43			foreach ($this as $key => $val) {
44			$this->{$key} = clone $val;
45			}
46			}
47
48			/**
49			* @param ILookupCollection $lookupCollection
50			* @return $this
51			*/
52			public function addLookupCollection(ILookupCollection $lookupCollection)
53			{
54			$this->_lookupCollections[] = $lookupCollection;
55			return $this;
56			}
57
58			/**
59			* @param mixed $columnCallback
60			* @return $this
61			*/
62			public function setColumnCallback($columnCallback)
63			{
64			$this->columnCallback = $columnCallback;
65			return $this;
66			}
67
68			/**
69			* @param $callback
70			* @return $this
71			*/
72			public function setJoinCallback($callback)
73			{
74			$this->joinCallback = $callback;
75			return $this;
76			}
77
78			public function setFetchColumnCallback($callback)
79			{
80			$this->fetchColumnCallback = $callback;
81			return $this;
82			}
83
84			public function getColumnCallback()
85			{
86			return $this->columnCallback;
87			}
88
89			public function getJoinCallback()
90			{
91			return $this->joinCallback;
92			}
93
94			public function fetchColumnName($column)
95			{
96			if ($this->fetchColumnCallback !== null) {
97			if ($this->fetchColumnCallback instanceof \Closure) {
			0 ignored issues – show introduced 2019-01-11 22:38 UTC by Report Bug Copy Issue Report `$this->fetchColumnCallback` is never a sub-type of `Closure`. Loading history...
98			$call = $this->fetchColumnCallback;
99			return $call($column);
100			}
101
102
103			if ($this->fetchColumnCallback instanceof AbstractFetchColumnCallback) {
			0 ignored issues – show introduced 2019-01-11 22:38 UTC by Report Bug Copy Issue Report `$this->fetchColumnCallback` is always a sub-type of `Tsukasa\QueryBuilder\Cal...ractFetchColumnCallback`. Loading history...
104			return $this->fetchColumnCallback->run($column);
105			}
106			}
107
108			return $column;
109			}
110
111			public function runCallback(QueryBuilderInterface $queryBuilder, $lookupNodes, $value)
112			{
113			if ($this->columnCallback !== null) {
114			if ($this->columnCallback instanceof \Closure) {
			0 ignored issues – show introduced 2019-01-11 22:38 UTC by Report Bug Copy Issue Report `$this->columnCallback` is never a sub-type of `Closure`. Loading history...
115			$call = $this->columnCallback;
116			return $call($queryBuilder, $this, $lookupNodes, $value);
117			}
118
119			if ($this->columnCallback instanceof AbstractColumnCallback) {
			0 ignored issues – show introduced 2019-01-11 22:38 UTC by Report Bug Copy Issue Report `$this->columnCallback` is always a sub-type of `Tsukasa\QueryBuilder\Cal...\AbstractColumnCallback`. Loading history...
120			return $this->columnCallback->run($queryBuilder, $this, $lookupNodes, $value);
121			}
122			}
123
124			return null;
125			}
126
127			public function runJoinCallback(QueryBuilderInterface $queryBuilder, $lookupNodes)
128			{
129			if ($this->joinCallback !== null) {
130			if ($this->joinCallback instanceof \Closure) {
			0 ignored issues – show introduced 2019-01-11 22:38 UTC by Report Bug Copy Issue Report `$this->joinCallback` is never a sub-type of `Closure`. Loading history...
131			$call = $this->joinCallback->bindTo($this, $this);
132			return $call($queryBuilder, $this, $lookupNodes);
133			}
134
135			if ($this->joinCallback instanceof AbstractJoinCallback) {
			0 ignored issues – show introduced 2019-01-11 22:38 UTC by Report Bug Copy Issue Report `$this->joinCallback` is always a sub-type of `Tsukasa\QueryBuilder\Cal...ks\AbstractJoinCallback`. Loading history...
136			return $this->joinCallback->run($queryBuilder, $this, $lookupNodes);
137			}
138			}
139
140			return null;
141			}
142
143			public function getSeparator()
144			{
145			return $this->separator;
146			}
147
148			public function getDefault()
149			{
150			return $this->default;
151			}
152
153			/**
154			* @param $lookup
155			* @return bool
156			*/
157			public function hasLookup($lookup)
158			{
159			foreach ($this->_lookupCollections as $collection) {
160			if ($collection->has($lookup)) {
161			return true;
162			}
163			}
164			return false;
165			}
166
167
168			/**
169			* @param IAdapter $adapter
170			* @param $lookup
171			* @param $column
172			* @param $value
173			* @return string
174			* @exception \Exception
175			*/
176			public function runLookup(IAdapter $adapter, $lookup, $column, $value)
177			{
178			foreach ($this->_lookupCollections as $collection) {
179			if ($collection->has($lookup)) {
180			return $collection->process($adapter, $lookup, $column, $value);
181			}
182			}
183			throw new QBException('Unknown lookup: ' . $lookup . ', column: ' . $column . ', value: ' . (is_array($value) ? print_r($value, true) : $value));
184			}
185
186			abstract public function parse(QueryBuilderInterface $queryBuilder, array $where);
187			}

tsukasa-mixer / QueryBuilder

Base::setColumnCallback() A last analyzed 2020-01-30 14:21 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Base::setColumnCallback() A
last analyzed 2020-01-30 14:21 UTC