AbstractDsl::bool() - Code Metrics - Inspection of "Initial commit." - triadev/laravel-elasticsearch-dsl - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#1)

by Christopher

created 2018-12-24 08:53 UTC

AbstractDsl::bool() A

↳ Parent: AbstractDsl

Complexity

Conditions	1
Paths	1

Size

Total Lines	8
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	1

Importance

Changes

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

<?php
namespace Triadev\Es\Dsl\Dsl;

use ONGR\ElasticsearchDSL\BuilderInterface;
use ONGR\ElasticsearchDSL\Query\Compound\BoolQuery;
use ONGR\ElasticsearchDSL\Sort\FieldSort;
use Triadev\Es\Dsl\Dsl\Query\Compound;
use Triadev\Es\Dsl\Dsl\Query\Fulltext;
use Triadev\Es\Dsl\Dsl\Query\Geo;
use Triadev\Es\Dsl\Dsl\Query\InnerHit;
use Triadev\Es\Dsl\Dsl\Query\Joining;
use Triadev\Es\Dsl\Dsl\Query\Specialized;
use Triadev\Es\Dsl\Dsl\Query\TermLevel;
use Triadev\Es\Dsl\Facade\ElasticDsl;

/**
 * Class AbstractDsl
 * @package Triadev\Es\Dsl\Dsl
 *
 * @method TermLevel termLevel()
 * @method Fulltext fulltext()
 * @method Geo geo()
 * @method Compound compound()
 * @method Joining joining()
 * @method Specialized specialized()
 * @method InnerHit innerHit()
 */
abstract class AbstractDsl extends AbstractSearch
{
    /** @var string */
    private $boolState = BoolQuery::MUST;
    
    /**
     * Append
     *
     * @param BuilderInterface $query
     * @return AbstractDsl|Search|TermLevel|Compound|Fulltext|Geo|InnerHit|Joining|Specialized
     */
    public function append(BuilderInterface $query) : AbstractDsl
    {
        $this->search->addQuery($query, $this->boolState);
        return $this;
    }
    
    /**
     * Bool state: must
     *
     * @return AbstractDsl|Search|TermLevel|Compound|Fulltext|Geo|InnerHit|Joining|Specialized
     */
    public function must(): AbstractDsl
    {
        $this->boolState = BoolQuery::MUST;
        return $this;
    }
    
    /**
     * Bool state: must not
     *
     * @return AbstractDsl|Search|TermLevel|Compound|Fulltext|Geo|InnerHit|Joining|Specialized
     */
    public function mustNot(): AbstractDsl
    {
        $this->boolState = BoolQuery::MUST_NOT;
        return $this;
    }
    
    /**
     * Bool state: should
     *
     * @return AbstractDsl|Search|TermLevel|Compound|Fulltext|Geo|InnerHit|Joining|Specialized
     */
    public function should(): AbstractDsl
    {
        $this->boolState = BoolQuery::SHOULD;
        return $this;
    }
    
    /**
     * Bool state: filter
     *
     * @return AbstractDsl|Search|TermLevel|Compound|Fulltext|Geo|InnerHit|Joining|Specialized
     */
    public function filter(): AbstractDsl
    {
        $this->boolState = BoolQuery::FILTER;
        return $this;
    }
    
    /**
     * Paginate
     *
     * @param int $page
     * @param int $limit
     * @return AbstractDsl|Search|TermLevel|Compound|Fulltext|Geo|InnerHit|Joining|Specialized
     */
    public function paginate(int $page, int $limit = 25) : AbstractDsl
    {
        $this->search->setFrom($limit * ($page - 1))->setSize($limit);
        return $this;
    }
    
    /**
     * Min score
     *
     * @param int $minScore
     * @return AbstractDsl|Search|TermLevel|Compound|Fulltext|Geo|InnerHit|Joining|Specialized
     */
    public function minScore(int $minScore) : AbstractDsl
    {
        $this->search->setMinScore($minScore);
        return $this;
    }
    
    /**
     * Sort
     *
     * @param string $field
     * @param string $order
     * @param array $params
     * @return AbstractDsl|Search|TermLevel|Compound|Fulltext|Geo|InnerHit|Joining|Specialized
     */
    public function sort(string $field, string $order = FieldSort::DESC, array $params = []) : AbstractDsl
    {
        $this->search->addSort(new FieldSort(
            $field,
            $order,
            $params
        ));
        
        return $this;
    }
    
    /**
     * Aggregation
     *
     * @param \Closure $aggregation
     * @return AbstractDsl|Search|TermLevel|Compound|Fulltext|Geo|InnerHit|Joining|Specialized
     */
    public function aggregation(\Closure $aggregation) : AbstractDsl
    {
        $aggregation(new Aggregation($this->search));
        return $this;
    }
    
    /**
     * Search
     *
     * @param \Closure $search
     * @return AbstractDsl|Search|TermLevel|Compound|Fulltext|Geo|InnerHit|Joining|Specialized
     */
    public function bool(\Closure $search) : AbstractDsl
    {
        $searchBuilder = ElasticDsl::search();
        $search($searchBuilder);
        
        $this->append($searchBuilder->getQuery());
        
        return $this;
    }
    
    /**
     * Call
     *
     * @param string $name
     * @param array $arguments
     *
     * @return AbstractDsl|null
     */
    public function __call(string $name, array $arguments) : ?AbstractDsl
    {
        $validFunctions = [
            'termLevel',
            'fulltext',
            'geo',
            'compound',
            'joining',
            'specialized',
            'innerHit'
        ];
        
        if (in_array($name, $validFunctions)) {
            return ElasticDsl::search($this->search)->$name();
        }
        
        return null;
    }
}


1		<?php
2		namespace Triadev\Es\Dsl\Dsl;
3
4		use ONGR\ElasticsearchDSL\BuilderInterface;
5		use ONGR\ElasticsearchDSL\Query\Compound\BoolQuery;
6		use ONGR\ElasticsearchDSL\Sort\FieldSort;
7		use Triadev\Es\Dsl\Dsl\Query\Compound;
8		use Triadev\Es\Dsl\Dsl\Query\Fulltext;
9		use Triadev\Es\Dsl\Dsl\Query\Geo;
10		use Triadev\Es\Dsl\Dsl\Query\InnerHit;
11		use Triadev\Es\Dsl\Dsl\Query\Joining;
12		use Triadev\Es\Dsl\Dsl\Query\Specialized;
13		use Triadev\Es\Dsl\Dsl\Query\TermLevel;
14		use Triadev\Es\Dsl\Facade\ElasticDsl;
15
16		/**
17		* Class AbstractDsl
18		* @package Triadev\Es\Dsl\Dsl
19		*
20		* @method TermLevel termLevel()
21		* @method Fulltext fulltext()
22		* @method Geo geo()
23		* @method Compound compound()
24		* @method Joining joining()
25		* @method Specialized specialized()
26		* @method InnerHit innerHit()
27		*/
28		abstract class AbstractDsl extends AbstractSearch
29		{
30		/** @var string */
31		private $boolState = BoolQuery::MUST;
32
33		/**
34		* Append
35		*
36		* @param BuilderInterface $query
37		* @return AbstractDsl\|Search\|TermLevel\|Compound\|Fulltext\|Geo\|InnerHit\|Joining\|Specialized
38		*/
39	19	public function append(BuilderInterface $query) : AbstractDsl
40		{
41	19	$this->search->addQuery($query, $this->boolState);
42	19	return $this;
43		}
44
45		/**
46		* Bool state: must
47		*
48		* @return AbstractDsl\|Search\|TermLevel\|Compound\|Fulltext\|Geo\|InnerHit\|Joining\|Specialized
49		*/
50	3	public function must(): AbstractDsl
51		{
52	3	$this->boolState = BoolQuery::MUST;
53	3	return $this;
54		}
55
56		/**
57		* Bool state: must not
58		*
59		* @return AbstractDsl\|Search\|TermLevel\|Compound\|Fulltext\|Geo\|InnerHit\|Joining\|Specialized
60		*/
61	1	public function mustNot(): AbstractDsl
62		{
63	1	$this->boolState = BoolQuery::MUST_NOT;
64	1	return $this;
65		}
66
67		/**
68		* Bool state: should
69		*
70		* @return AbstractDsl\|Search\|TermLevel\|Compound\|Fulltext\|Geo\|InnerHit\|Joining\|Specialized
71		*/
72	1	public function should(): AbstractDsl
73		{
74	1	$this->boolState = BoolQuery::SHOULD;
75	1	return $this;
76		}
77
78		/**
79		* Bool state: filter
80		*
81		* @return AbstractDsl\|Search\|TermLevel\|Compound\|Fulltext\|Geo\|InnerHit\|Joining\|Specialized
82		*/
83	6	public function filter(): AbstractDsl
84		{
85	6	$this->boolState = BoolQuery::FILTER;
86	6	return $this;
87		}
88
89		/**
90		* Paginate
91		*
92		* @param int $page
93		* @param int $limit
94		* @return AbstractDsl\|Search\|TermLevel\|Compound\|Fulltext\|Geo\|InnerHit\|Joining\|Specialized
95		*/
96	1	public function paginate(int $page, int $limit = 25) : AbstractDsl
97		{
98	1	$this->search->setFrom($limit * ($page - 1))->setSize($limit);
99	1	return $this;
100		}
101
102		/**
103		* Min score
104		*
105		* @param int $minScore
106		* @return AbstractDsl\|Search\|TermLevel\|Compound\|Fulltext\|Geo\|InnerHit\|Joining\|Specialized
107		*/
108		public function minScore(int $minScore) : AbstractDsl
109		{
110		$this->search->setMinScore($minScore);
111		return $this;
112		}
113
114		/**
115		* Sort
116		*
117		* @param string $field
118		* @param string $order
119		* @param array $params
120		* @return AbstractDsl\|Search\|TermLevel\|Compound\|Fulltext\|Geo\|InnerHit\|Joining\|Specialized
121		*/
122	1	public function sort(string $field, string $order = FieldSort::DESC, array $params = []) : AbstractDsl
123		{
124	1	$this->search->addSort(new FieldSort(
125	1	$field,
126	1	$order,
127	1	$params
128		));
129
130	1	return $this;
131		}
132
133		/**
134		* Aggregation
135		*
136		* @param \Closure $aggregation
137		* @return AbstractDsl\|Search\|TermLevel\|Compound\|Fulltext\|Geo\|InnerHit\|Joining\|Specialized
138		*/
139	1	public function aggregation(\Closure $aggregation) : AbstractDsl
140		{
141	1	$aggregation(new Aggregation($this->search));
142	1	return $this;
143		}
144
145		/**
146		* Search
147		*
148		* @param \Closure $search
149		* @return AbstractDsl\|Search\|TermLevel\|Compound\|Fulltext\|Geo\|InnerHit\|Joining\|Specialized
150		*/
151	1	public function bool(\Closure $search) : AbstractDsl
152		{
153	1	$searchBuilder = ElasticDsl::search();
154	1	$search($searchBuilder);
155
156	1	$this->append($searchBuilder->getQuery());
157
158	1	return $this;
159		}
160
161		/**
162		* Call
163		*
164		* @param string $name
165		* @param array $arguments
166		*
167		* @return AbstractDsl\|null
168		*/
169	1	public function __call(string $name, array $arguments) : ?AbstractDsl
170		{
171		$validFunctions = [
172	1	'termLevel',
173		'fulltext',
174		'geo',
175		'compound',
176		'joining',
177		'specialized',
178		'innerHit'
179		];
180
181	1	if (in_array($name, $validFunctions)) {
182	1	return ElasticDsl::search($this->search)->$name();
183		}
184
185		return null;
186		}
187		}
188

triadev / laravel-elasticsearch-dsl

Pull Request — master (#1)

AbstractDsl::bool() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like