BestServedCold\LaravelZendSearch\Lucene\Index

Complexity

Total Complexity

12

Size/Duplication

Total Lines	117
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

90.63%

Importance

Changes	2
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	open()	0	7	2
A	close()	0	5	1
A	limit()	0	5	1
A	createIndex()	0	14	3
A	setPath()	0	4	1
A	path()	0	8	2
A	get()	0	4	1

<?php

namespace BestServedCold\LaravelZendSearch\Lucene;

use ZendSearch\Lucene\Lucene;
use ZendSearch\Exception\ExceptionInterface;
use ZendSearch\Lucene\Index as LuceneIndex;
use ZendSearch\Lucene\SearchIndexInterface;

/**
 * Class Index
 * @package BestServedCold\LaravelZendSearch\Lucene
 */
class Index
{
    /**
     * @var LuceneIndex
     */
    private $index;

    /**
     * @var string|boolean $path
     */
    protected $path;

    /**
     * @var Filter
     */
    protected $filter;

    /**
     * Index constructor.
     *
     * @param Filter $filter
     */
    public function __construct(Filter $filter)
    {
        $this->filter = $filter;
    }

    /**
     * Open
     *
     * @param  string|boolean $path
     * @param  bool           $forceCreate
     * @return $this
     * @throws ExceptionInterface
     * @throws \Exception
     */
    public function open($path = false, $forceCreate = true)
    {
        $this->path = $path ? $path : $this->path;
        $this->index = $this->createIndex($this->path(), $forceCreate);
        $this->filter->setFilters();
        return $this;
    }

    /**
     * @return $this
     */
    public function close()
    {
        $this->index = false;

It seems like false of type false is incompatible with the declared type object<ZendSearch\Lucene\Index> of property $index.

        return $this;
    }

    /**
     * @param integer $limit
     * @return $this
     */
    public function limit($limit)
    {
        Lucene::setResultSetLimit($limit);
        return $this;
    }

    /**
     * Create Index
     *
     * Extends the Lucene "open" method to create the index if it doesn't exist.
     *
     * @param  string|boolean $path
     * @param  boolean        $forceCreate
     * @return SearchIndexInterface
     * @throws \Exception
     */
    private function createIndex($path, $forceCreate = true)
    {
        try {
            $index = Lucene::open($path);
        } catch (ExceptionInterface $error) {
            if ($forceCreate) {
                $index = Lucene::create($path);
            } else {
                throw $error;
            }
        }
        
        return $index;
    }

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

    /**
     * @return string
     * @throws \Exception
     */
    protected function path()
    {
        if (!$this->path) {
            throw new \Exception('No path specified nor config variable set.');
        }

        return $this->path;
    }

    /**
     * @return LuceneIndex
     */
    public function get()
    {
        return $this->index;
    }
}