BestServedCold\LaravelZendSearch\Lucene\Search

Complexity

Total Complexity

19

Size/Duplication

Total Lines	192
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	11

Test Coverage

Coverage

22.41%

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	__call()	0	13	3
A	limit()	0	5	1
A	path()	0	5	1
A	raw()	0	5	1
A	phrase()	0	6	1
A	fuzzy()	0	5	1
A	term()	0	4	1
A	wildcard()	0	4	1
A	where()	0	8	2
A	multiTerm()	0	11	2
A	mapWhereArray()	0	8	1
A	singleTerm()	0	4	1
A	hits()	0	4	1
A	mapIds()	0	8	1

<?php

namespace BestServedCold\LaravelZendSearch\Lucene;

use BestServedCold\LaravelZendSearch\Search\Wildcard;
use ZendSearch\Lucene\Index\Term;
use ZendSearch\Lucene\Search\Query\Fuzzy;
use ZendSearch\Lucene\Search\Query\MultiTerm;
use ZendSearch\Lucene\Search\Query\Phrase;
use ZendSearch\Lucene\Search\Query\Term as QueryTerm;
use ZendSearch\Lucene\Search\QueryHit;
use ZendSearch\Lucene\Search\QueryParser;

class Search
{
    protected $index;
    protected $query;
    private $path;
    private $limit = 25;

    /**
     * Search constructor.
     *
     * @param Index $index
     * @param Query $query
     */
    public function __construct(Index $index, Query $query)
    {
        $this->index = $index;
        $this->query = $query;
    }

    /**
     * @param  $name
     * @param  $arguments
     * @return $this
     * @throws \BadMethodCallException
     */
    public function __call($name, $arguments)
    {
        if (method_exists($this, $name)) {
            return $this->$name($arguments);
        }

        if (method_exists($this->query, $name)) {
            $this->query->$name($arguments);
            return $this;
        }

        throw new \BadMethodCallException;
    }

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

    /**
     * @param bool $path
     * @return $this
     */
    public function path($path = false)
    {
        $this->path = $path;
        return $this;
    }

    /**
     * @param $string
     * @return $this
     */
    public function raw($string)
    {
        $this->query->add(QueryParser::parse($string));
        return $this;
    }

    /**
     * @param $string
     * @param bool   $field
     * @param null   $offsets
     * @return $this
     * @return $this
     */
    public function phrase($string, $field = false, $offsets = null)
    {
        $this->query->add(new Phrase(explode(' ', $string), $offsets, $field));

$field is of type boolean, but the function expects a string|null.

        return $this;

    }

    /**
     * @param $string
     * @param bool   $field
     * @return $this
     */
    public function fuzzy($string, $field = false)
    {
        $this->query->add(new Fuzzy($this->term($field, $string)));
        return $this;
    }

    /**
     * @param $string
     * @param bool   $field
     * @return Term
     */
    protected function term($string, $field = false)
    {
        return new Term(strtoupper($string), $field);
    }

    /**
     * @param $string
     * @param bool   $field
     * @param array  $options
     */
    public function wildcard($string, $field = false, $options = [ ])
    {
        $this->query->add((new Wildcard($field, $string, $options))->get());
    }

    /**
     * @param $string
     * @param bool|string $field
     * @return $this|bool
     * @todo  Work out why the search only works if the string is uppercase...
     */
    public function where($string, $field = false)
    {
        is_array($field)
            ? $this->multiTerm($this->mapWhereArray($string, $field))
            : $this->query->add($this->singleTerm($string, $field));

It seems like $field defined by parameter $field on line 134 can also be of type string; however, BestServedCold\LaravelZendSearch\Lucene\Search::singleTerm() does only seem to accept boolean, maybe add an additional type check?

        return $this;
    }

    /**
     * @param array $terms
     * @return $this
     */
    public function multiTerm(array $terms)
    {
        $multiTerm = new MultiTerm;
        foreach ($terms as $field => $value) {
            $multiTerm->addTerm($this->term($value, $field), $this->query->getSign());

$field is of type integer|string, but the function expects a boolean.

        }

        $this->query->add($multiTerm);

        return $this;
    }

    /**
     * @param $string
     * @param array  $array
     * @return mixed
     * @todo abstract this out
     */
    private function mapWhereArray($string, array $array)
    {
        return array_map(
            function () use ($string) {
                return $string;
            }, array_flip($array)
        );
    }

    /**
     * @param $string
     * @param $field
     * @return QueryTerm
     */
    public function singleTerm($string, $field = false)
    {
        return new QueryTerm($this->term($string, $field));
    }

    /**
     * @return mixed
     */
    public function hits()
    {
        return $this->mapIds($this->index->limit($this->limit)->open($this->path)->find($this->query->getBoolean()));

It seems like $this->index->limit($this->limit)->open($this->path)->find($this->query->getBoolean()) targeting ZendSearch\Lucene\SearchIndexInterface::find() can also be of type object<ZendSearch\Lucene\Search\QueryHit>; however, BestServedCold\LaravelZendSearch\Lucene\Search::mapIds() does only seem to accept array, maybe add an additional type check?

    }

    /**
     * @param array $array
     * @return mixed
     * @todo abstract this out
     */
    private function mapIds(array $array)
    {
        return array_map(
            function (QueryHit $hit) {
                return $hit->id;
            }, $array
        );
    }
}