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

Passed

Pull Request — master (#1)

by Christopher

created 2018-12-22 13:49 UTC

Bucketing::histogram() A

↳ Parent: Bucketing

Complexity

Conditions	1
Paths	1

Size

Total Lines	26
Code Lines	12

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
cc	1
eloc	12
nc	1
nop	9
dl	0
loc	26
ccs	0
cts	13
cp	0
crap	2
rs	9.8666
c	0
b	0
f	0

How to fix Many Parameters

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

use ONGR\ElasticsearchDSL\Aggregation\Bucketing\ChildrenAggregation;
use ONGR\ElasticsearchDSL\Aggregation\Bucketing\DateHistogramAggregation;
use ONGR\ElasticsearchDSL\Aggregation\Bucketing\DateRangeAggregation;
use ONGR\ElasticsearchDSL\Aggregation\Bucketing\DiversifiedSamplerAggregation;
use ONGR\ElasticsearchDSL\Aggregation\Bucketing\FilterAggregation;
use ONGR\ElasticsearchDSL\Aggregation\Bucketing\FiltersAggregation;
use ONGR\ElasticsearchDSL\Aggregation\Bucketing\GeoDistanceAggregation;
use ONGR\ElasticsearchDSL\Aggregation\Bucketing\GeoHashGridAggregation;
use ONGR\ElasticsearchDSL\Aggregation\Bucketing\HistogramAggregation;
use ONGR\ElasticsearchDSL\Aggregation\Bucketing\Ipv4RangeAggregation;
use ONGR\ElasticsearchDSL\Aggregation\Bucketing\MissingAggregation;
use ONGR\ElasticsearchDSL\Aggregation\Bucketing\NestedAggregation;
use ONGR\ElasticsearchDSL\Aggregation\Bucketing\RangeAggregation;
use ONGR\ElasticsearchDSL\Aggregation\Bucketing\SamplerAggregation;
use ONGR\ElasticsearchDSL\Aggregation\Bucketing\SignificantTermsAggregation;
use ONGR\ElasticsearchDSL\Aggregation\Bucketing\TermsAggregation;
use ONGR\ElasticsearchDSL\BuilderInterface;

class Bucketing extends Aggs
{
    /**
     * Children
     *
     * @param string $name
     * @param string $children
     * @param \Closure $bucketing
     * @return Bucketing
     */
    public function children(string $name, string $children, \Closure $bucketing) : Bucketing
    {
        $resultAgg = new ChildrenAggregation($name, $children);
        
        $bucketingBuilder = new self();
        $bucketing($bucketingBuilder);
        
        foreach ($bucketingBuilder->getAggregations() as $agg) {
            $resultAgg->addAggregation($agg);
        }
        
        $this->addAggregation($resultAgg);
        return $this;
    }
    
    /**
     * Date histogram
     *
     * @param string $name
     * @param string $field
     * @param string $interval
     * @param string|null $format
     * @return Bucketing
     *
     * @throws \InvalidArgumentException
     */
    public function dateHistogram(
        string $name,
        string $field,
        string $interval,
        ?string $format = null
    ) : Bucketing {
        $validInterval = [
            'year',
            'quarter',
            'month',
            'week',
            'day',
            'hour',
            'minute',
            'second',
        ];
        
        if (!in_array($interval, $validInterval)) {
            throw new \InvalidArgumentException();
        }
        
        $this->addAggregation(new DateHistogramAggregation($name, $field, $interval, $format));
        return $this;
    }
    
    /**
     * Date range
     *
     * @param string $name
     * @param string $field
     * @param string $format
     * @param array $ranges
     * @return Bucketing
     */
    public function dateRange(
        string $name,
        string $field,
        string $format,
        array $ranges = []
    ) : Bucketing {
        $this->addAggregation(new DateRangeAggregation($name, $field, $format, $ranges));
        return $this;
    }
    
    /**
     * Diversified sampler
     *
     * @param string $name
     * @param string $field
     * @param int|null $shardSize
     * @return Bucketing
     */
    public function diversifiedSampler(string $name, string $field, ?int $shardSize = null) : Bucketing
    {
        $this->addAggregation(new DiversifiedSamplerAggregation($name, $field, $shardSize));
        return $this;
    }
    
    /**
     * Filter
     *
     * @param string $name
     * @param BuilderInterface $aggregation
     * @param BuilderInterface[] $aggregations
     * @return Bucketing
     */
    public function filter(string $name, BuilderInterface $aggregation, array $aggregations) : Bucketing
    {
        $agg = new FilterAggregation($name, $aggregation);
        
        foreach ($aggregations as $a) {
            if ($a instanceof BuilderInterface) {
                $agg->addAggregation($a);
            }
        }
        
        $this->addAggregation($agg);
        return $this;
    }
    
    /**
     * Filters
     *
     * @param string $name
     * @param BuilderInterface[] $filters
     * @param BuilderInterface[] $aggregations
     * @param bool $anonymous
     * @return Bucketing
     */
    public function filters(string $name, array $filters, array $aggregations, bool $anonymous = false) : Bucketing
    {
        $agg = new FiltersAggregation($name, $filters, $anonymous);
    
        foreach ($aggregations as $a) {
            if ($a instanceof BuilderInterface) {
                $agg->addAggregation($a);
            }
        }
    
        $this->addAggregation($agg);
        
        return $this;
    }
    
    /**
     * Geo distance
     *
     * @param string $name
     * @param string $field
     * @param string $origin
     * @param array $ranges
     * @param string|null $unit
     * @param string|null $distanceType
     * @return Bucketing
     */
    public function geoDistance(
        string $name,
        string $field,
        string $origin,
        array $ranges = [],
        string $unit = null,
        string $distanceType = null
    ) : Bucketing {
        $this->addAggregation(
            new GeoDistanceAggregation(
                $name,
                $field,
                $origin,
                $ranges,
                $unit,
                $distanceType
            )
        );
        
        return $this;
    }
    
    /**
     * Geo hash grid
     *
     * @param string $name
     * @param string $field
     * @param int|null $precision
     * @param int|null $size
     * @param int|null $shardSize
     * @return Bucketing
     */
    public function geoHashGrid(
        string $name,
        string $field,
        ?int $precision = null,
        ?int $size = null,
        ?int $shardSize = null
    ) : Bucketing {
        $this->addAggregation(
            new GeoHashGridAggregation(
                $name,
                $field,
                $precision,
                $size,
                $shardSize
            )
        );
        
        return $this;
    }
    
    /**
     * Histogram
     *
     * @param string $name
     * @param string $field
     * @param int $interval
     * @param int|null $minDocCount
     * @param string|null $orderMode
     * @param string $orderDirection
     * @param int|null $extendedBoundsMin
     * @param int|null $extendedBoundsMax
     * @param bool|null $keyed
     * @return Bucketing
     */
    public function histogram(
        string $name,
        string $field,
        int $interval,
        ?int $minDocCount = null,
        ?string $orderMode = null,
        string $orderDirection = HistogramAggregation::DIRECTION_ASC,
        ?int $extendedBoundsMin = null,
        ?int $extendedBoundsMax = null,
        bool $keyed = null
    ) : Bucketing {
        $this->addAggregation(
            new HistogramAggregation(
                $name,
                $field,
                $interval,
                $minDocCount,
                $orderMode,
                $orderDirection,
                $extendedBoundsMin,
                $extendedBoundsMax,
                $keyed
            )
        );
        
        return $this;
    }
    
    /**
     * Ipv4
     *
     * @param string $name
     * @param string $field
     * @param array $ranges
     * @return Bucketing
     */
    public function ipv4Range(string $name, string $field, array $ranges = []) : Bucketing
    {
        $this->addAggregation(
            new Ipv4RangeAggregation(
                $name,
                $field,
                $ranges
            )
        );
        
        return $this;
    }
    
    /**
     * Missing
     *
     * @param string $name
     * @param string $field
     * @return Bucketing
     */
    public function missing(string $name, string $field) : Bucketing
    {
        $this->addAggregation(new MissingAggregation($name, $field));
        return $this;
    }
    
    /**
     * Nested
     *
     * @param string $name
     * @param string $path
     * @param array $aggregations
     * @return Bucketing
     */
    public function nested(string $name, string $path, array $aggregations = []) : Bucketing
    {
        $agg = new NestedAggregation($name, $path);
        
        foreach ($aggregations as $aggregation) {
            if ($aggregation instanceof BuilderInterface) {
                $agg->addAggregation($aggregation);
            }
        }
        
        $this->addAggregation($agg);
        return $this;
    }
    
    /**
     * Range
     *
     * @param string $name
     * @param string $field
     * @param array $ranges
     * @param bool $keyed
     * @return Bucketing
     */
    public function range(string $name, string $field, array $ranges = [], bool $keyed = false) : Bucketing
    {
        $this->addAggregation(new RangeAggregation($name, $field, $ranges, $keyed));
        return $this;
    }
    
    public function reverseNested() : Bucketing
    {
        return $this;
    }
    
    /**
     * Sampler
     *
     * @param string $name
     * @param string $field
     * @param int|null $shardSize
     * @param array $aggregations
     * @return Bucketing
     */
    public function sampler(string $name, string $field, ?int $shardSize = null, array $aggregations = []) : Bucketing
    {
        $agg = new SamplerAggregation($name, $field, $shardSize);
        
        foreach ($aggregations as $aggregation) {
            if ($aggregation instanceof BuilderInterface) {
                $agg->addAggregation($aggregation);
            }
        }
        
        $this->addAggregation($agg);
        return $this;
    }
    
    /**
     * Significant terms
     *
     * @param string $name
     * @param string $field
     * @param string|null $script
     * @return Bucketing
     */
    public function significantTerms(string $name, string $field, ?string $script = null) : Bucketing
    {
        $this->addAggregation(new SignificantTermsAggregation($name, $field, $script));
        return $this;
    }
    
    /**
     * Terms
     *
     * @param string $name
     * @param string|null $field
     * @param string|null $script
     * @return Bucketing
     */
    public function terms(string $name, ?string $field = null, ?string $script = null) : Bucketing
    {
        $this->addAggregation(new TermsAggregation($name, $field, $script));
        return $this;
    }
}


1			<?php
2			namespace Triadev\Es\Dsl\Dsl\Aggregation;
3
4			use ONGR\ElasticsearchDSL\Aggregation\Bucketing\ChildrenAggregation;
5			use ONGR\ElasticsearchDSL\Aggregation\Bucketing\DateHistogramAggregation;
6			use ONGR\ElasticsearchDSL\Aggregation\Bucketing\DateRangeAggregation;
7			use ONGR\ElasticsearchDSL\Aggregation\Bucketing\DiversifiedSamplerAggregation;
8			use ONGR\ElasticsearchDSL\Aggregation\Bucketing\FilterAggregation;
9			use ONGR\ElasticsearchDSL\Aggregation\Bucketing\FiltersAggregation;
10			use ONGR\ElasticsearchDSL\Aggregation\Bucketing\GeoDistanceAggregation;
11			use ONGR\ElasticsearchDSL\Aggregation\Bucketing\GeoHashGridAggregation;
12			use ONGR\ElasticsearchDSL\Aggregation\Bucketing\HistogramAggregation;
13			use ONGR\ElasticsearchDSL\Aggregation\Bucketing\Ipv4RangeAggregation;
14			use ONGR\ElasticsearchDSL\Aggregation\Bucketing\MissingAggregation;
15			use ONGR\ElasticsearchDSL\Aggregation\Bucketing\NestedAggregation;
16			use ONGR\ElasticsearchDSL\Aggregation\Bucketing\RangeAggregation;
17			use ONGR\ElasticsearchDSL\Aggregation\Bucketing\SamplerAggregation;
18			use ONGR\ElasticsearchDSL\Aggregation\Bucketing\SignificantTermsAggregation;
19			use ONGR\ElasticsearchDSL\Aggregation\Bucketing\TermsAggregation;
20			use ONGR\ElasticsearchDSL\BuilderInterface;
21
22			class Bucketing extends Aggs
23			{
24			/**
25			* Children
26			*
27			* @param string $name
28			* @param string $children
29			* @param \Closure $bucketing
30			* @return Bucketing
31			*/
32			public function children(string $name, string $children, \Closure $bucketing) : Bucketing
33			{
34			$resultAgg = new ChildrenAggregation($name, $children);
35
36			$bucketingBuilder = new self();
37			$bucketing($bucketingBuilder);
38
39			foreach ($bucketingBuilder->getAggregations() as $agg) {
40			$resultAgg->addAggregation($agg);
41			}
42
43			$this->addAggregation($resultAgg);
44			return $this;
45			}
46
47			/**
48			* Date histogram
49			*
50			* @param string $name
51			* @param string $field
52			* @param string $interval
53			* @param string\|null $format
54			* @return Bucketing
55			*
56			* @throws \InvalidArgumentException
57			*/
58			public function dateHistogram(
59			string $name,
60			string $field,
61			string $interval,
62			?string $format = null
63			) : Bucketing {
64			$validInterval = [
65			'year',
66			'quarter',
67			'month',
68			'week',
69			'day',
70			'hour',
71			'minute',
72			'second',
73			];
74
75			if (!in_array($interval, $validInterval)) {
76			throw new \InvalidArgumentException();
77			}
78
79			$this->addAggregation(new DateHistogramAggregation($name, $field, $interval, $format));
80			return $this;
81			}
82
83			/**
84			* Date range
85			*
86			* @param string $name
87			* @param string $field
88			* @param string $format
89			* @param array $ranges
90			* @return Bucketing
91			*/
92			public function dateRange(
93			string $name,
94			string $field,
95			string $format,
96			array $ranges = []
97			) : Bucketing {
98			$this->addAggregation(new DateRangeAggregation($name, $field, $format, $ranges));
99			return $this;
100			}
101
102			/**
103			* Diversified sampler
104			*
105			* @param string $name
106			* @param string $field
107			* @param int\|null $shardSize
108			* @return Bucketing
109			*/
110			public function diversifiedSampler(string $name, string $field, ?int $shardSize = null) : Bucketing
111			{
112			$this->addAggregation(new DiversifiedSamplerAggregation($name, $field, $shardSize));
113			return $this;
114			}
115
116			/**
117			* Filter
118			*
119			* @param string $name
120			* @param BuilderInterface $aggregation
121			* @param BuilderInterface[] $aggregations
122			* @return Bucketing
123			*/
124			public function filter(string $name, BuilderInterface $aggregation, array $aggregations) : Bucketing
125			{
126			$agg = new FilterAggregation($name, $aggregation);
127
128			foreach ($aggregations as $a) {
129			if ($a instanceof BuilderInterface) {
130			$agg->addAggregation($a);
131			}
132			}
133
134			$this->addAggregation($agg);
135			return $this;
136			}
137
138			/**
139			* Filters
140			*
141			* @param string $name
142			* @param BuilderInterface[] $filters
143			* @param BuilderInterface[] $aggregations
144			* @param bool $anonymous
145			* @return Bucketing
146			*/
147			public function filters(string $name, array $filters, array $aggregations, bool $anonymous = false) : Bucketing
148			{
149			$agg = new FiltersAggregation($name, $filters, $anonymous);
150
151			foreach ($aggregations as $a) {
152			if ($a instanceof BuilderInterface) {
153			$agg->addAggregation($a);
154			}
155			}
156
157			$this->addAggregation($agg);
158
159			return $this;
160			}
161
162			/**
163			* Geo distance
164			*
165			* @param string $name
166			* @param string $field
167			* @param string $origin
168			* @param array $ranges
169			* @param string\|null $unit
170			* @param string\|null $distanceType
171			* @return Bucketing
172			*/
173			public function geoDistance(
174			string $name,
175			string $field,
176			string $origin,
177			array $ranges = [],
178			string $unit = null,
179			string $distanceType = null
180			) : Bucketing {
181			$this->addAggregation(
182			new GeoDistanceAggregation(
183			$name,
184			$field,
185			$origin,
186			$ranges,
187			$unit,
188			$distanceType
189			)
190			);
191
192			return $this;
193			}
194
195			/**
196			* Geo hash grid
197			*
198			* @param string $name
199			* @param string $field
200			* @param int\|null $precision
201			* @param int\|null $size
202			* @param int\|null $shardSize
203			* @return Bucketing
204			*/
205			public function geoHashGrid(
206			string $name,
207			string $field,
208			?int $precision = null,
209			?int $size = null,
210			?int $shardSize = null
211			) : Bucketing {
212			$this->addAggregation(
213			new GeoHashGridAggregation(
214			$name,
215			$field,
216			$precision,
217			$size,
218			$shardSize
219			)
220			);
221
222			return $this;
223			}
224
225			/**
226			* Histogram
227			*
228			* @param string $name
229			* @param string $field
230			* @param int $interval
231			* @param int\|null $minDocCount
232			* @param string\|null $orderMode
233			* @param string $orderDirection
234			* @param int\|null $extendedBoundsMin
235			* @param int\|null $extendedBoundsMax
236			* @param bool\|null $keyed
237			* @return Bucketing
238			*/
239			public function histogram(
240			string $name,
241			string $field,
242			int $interval,
243			?int $minDocCount = null,
244			?string $orderMode = null,
245			string $orderDirection = HistogramAggregation::DIRECTION_ASC,
246			?int $extendedBoundsMin = null,
247			?int $extendedBoundsMax = null,
248			bool $keyed = null
249			) : Bucketing {
250			$this->addAggregation(
251			new HistogramAggregation(
252			$name,
253			$field,
254			$interval,
255			$minDocCount,
256			$orderMode,
257			$orderDirection,
258			$extendedBoundsMin,
259			$extendedBoundsMax,
260			$keyed
261			)
262			);
263
264			return $this;
265			}
266
267			/**
268			* Ipv4
269			*
270			* @param string $name
271			* @param string $field
272			* @param array $ranges
273			* @return Bucketing
274			*/
275			public function ipv4Range(string $name, string $field, array $ranges = []) : Bucketing
276			{
277			$this->addAggregation(
278			new Ipv4RangeAggregation(
279			$name,
280			$field,
281			$ranges
282			)
283			);
284
285			return $this;
286			}
287
288			/**
289			* Missing
290			*
291			* @param string $name
292			* @param string $field
293			* @return Bucketing
294			*/
295			public function missing(string $name, string $field) : Bucketing
296			{
297			$this->addAggregation(new MissingAggregation($name, $field));
298			return $this;
299			}
300
301			/**
302			* Nested
303			*
304			* @param string $name
305			* @param string $path
306			* @param array $aggregations
307			* @return Bucketing
308			*/
309			public function nested(string $name, string $path, array $aggregations = []) : Bucketing
310			{
311			$agg = new NestedAggregation($name, $path);
312
313			foreach ($aggregations as $aggregation) {
314			if ($aggregation instanceof BuilderInterface) {
315			$agg->addAggregation($aggregation);
316			}
317			}
318
319			$this->addAggregation($agg);
320			return $this;
321			}
322
323			/**
324			* Range
325			*
326			* @param string $name
327			* @param string $field
328			* @param array $ranges
329			* @param bool $keyed
330			* @return Bucketing
331			*/
332			public function range(string $name, string $field, array $ranges = [], bool $keyed = false) : Bucketing
333			{
334			$this->addAggregation(new RangeAggregation($name, $field, $ranges, $keyed));
335			return $this;
336			}
337
338			public function reverseNested() : Bucketing
339			{
340			return $this;
341			}
342
343			/**
344			* Sampler
345			*
346			* @param string $name
347			* @param string $field
348			* @param int\|null $shardSize
349			* @param array $aggregations
350			* @return Bucketing
351			*/
352			public function sampler(string $name, string $field, ?int $shardSize = null, array $aggregations = []) : Bucketing
353			{
354			$agg = new SamplerAggregation($name, $field, $shardSize);
355
356			foreach ($aggregations as $aggregation) {
357			if ($aggregation instanceof BuilderInterface) {
358			$agg->addAggregation($aggregation);
359			}
360			}
361
362			$this->addAggregation($agg);
363			return $this;
364			}
365
366			/**
367			* Significant terms
368			*
369			* @param string $name
370			* @param string $field
371			* @param string\|null $script
372			* @return Bucketing
373			*/
374			public function significantTerms(string $name, string $field, ?string $script = null) : Bucketing
375			{
376			$this->addAggregation(new SignificantTermsAggregation($name, $field, $script));
377			return $this;
378			}
379
380			/**
381			* Terms
382			*
383			* @param string $name
384			* @param string\|null $field
385			* @param string\|null $script
386			* @return Bucketing
387			*/
388			public function terms(string $name, ?string $field = null, ?string $script = null) : Bucketing
389			{
390			$this->addAggregation(new TermsAggregation($name, $field, $script));
391			return $this;
392			}
393			}
394

triadev / laravel-elasticsearch-dsl

Pull Request — master (#1)

Bucketing::histogram() A

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Many Parameters

Many Parameters

Duplication Side-by-Side

Filter issues like