Searchable::buildDocumentFromArray() - Code Metrics - Inspection of "Changed namespace path to leopard." - triadev/Leopard - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Branch — master (8cb5b2)

by Christopher

created 2018-12-17 13:11 UTC

Searchable::buildDocumentFromArray() A

↳ Parent: Searchable

Complexity

Conditions	4
Paths	4

Size

Total Lines	19
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	9
CRAP Score	4.0961

Importance

Changes

Metric	Value
cc	4
eloc	11
nc	4
nop	1
dl	0
loc	19
ccs	9
cts	11
cp	0.8182
crap	4.0961
rs	9.9
c	0
b	0
f	0

<?php

namespace Triadev\Leopard;


use Carbon\Carbon;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Collection;
use Triadev\Leopard\Contract\ElasticsearchManagerContract;
use Triadev\Leopard\Contract\Repository\ElasticsearchRepositoryContract;
use Triadev\Leopard\Facade\Leopard;

/**
 * Trait Searchable
 * @package Triadev\Leopard

 *
 * @property string $documentIndex
 * @property string $documentType
 * @property bool $syncDocument
 * @property array $searchable
 *
 * @method static ElasticsearchManagerContract search()
 * @methdo static ElasticsearchManagerContract suggest()
 * @method array buildDocument()

 * @method array toArray()
 * @method string getTable()
 */

trait Searchable
{

    /** @var bool */

    public $isDocument = false;

    
    /** @var float|null */

    public $documentScore;
    
    /** @var int|null */

    public $documentVersion;
    
    /**
     * Searchable boot model.
     */

    public static function bootSearchable()

    {
        static::saved(function (Model $model) {

            /** @var Model|Searchable $model */

            if ($model->shouldSyncDocument()) {
                $model->repository()->save(/** @scrutinizer ignore-type */$model);

            }
        });
someFunctionCall(
    $firstArgument,
    $secondArgument,
    $thirdArgument
); // Closing parenthesis on a new line.
    
        static::deleted(function (Model $model) {

            /** @var Model|Searchable $model */

            if ($model->shouldSyncDocument()) {
                $model->repository()->delete(/** @scrutinizer ignore-type */$model);
                $model->repository()->/** @scrutinizer ignore-call */ delete(/** @scrutinizer ignore-type */$model);
            }
        });
someFunctionCall(
    $firstArgument,
    $secondArgument,
    $thirdArgument
); // Closing parenthesis on a new line.
    }

    
    /**
     * Repository
     *
     * @return ElasticsearchRepositoryContract
     */
    public function repository() : ElasticsearchRepositoryContract
    {
        return app(ElasticsearchRepositoryContract::class);
    }

    
    /**
     * Get document index
     *
     * @return string|null
     */
    public function getDocumentIndex(): ?string
    {
        if (property_exists($this, 'documentIndex')) {
            return $this->documentIndex;
        }
        
        return null;
    }

    
    /**
     * Get document type
     *
     * @return string
     */
    public function getDocumentType(): string
    {
        if (property_exists($this, 'documentType')) {
            return (string)$this->documentType;
        }
        
        return (string)$this->getTable();
    }

    
    /**
     * Should sync document
     *
     * @return bool

     */
    public function shouldSyncDocument() : bool
    {
        if (property_exists($this, 'syncDocument')) {
            return (bool)$this->syncDocument;
        }
        
        return true;
    }

    
    /**
     * Get document data
     *
     * @return array
     */
    public function getDocumentData() : array
    {
        if (method_exists($this, 'buildDocument')) {
            return $this->buildDocument();
        }
        
        if (property_exists($this, 'searchable') && is_array($this->searchable)) {
            return $this->buildDocumentFromArray($this->searchable);
        }
        
        return $this->toArray();
    }

    
    private function buildDocumentFromArray(array $searchable)

    {
        $document = [];
        
        foreach ($searchable as $value) {
            $result = $this->$value;
            
            if ($result instanceof Collection) {
                $result = $result->toArray();
            } elseif ($result instanceof Carbon) {

                $result = $result->toDateTimeString();
            } else {
                $result = $this->$value;
            }
            
            $document[$value] = $result;
        }
        
        return $document;
    }

    
    /**

     * @param $name

     * @param $arguments

     * @return mixed
     */
    public function __call($name, $arguments)

    {
        if ($name == 'search') {

            return Leopard::search()->model($this);
            return Leopard::search()->model(/** @scrutinizer ignore-type */ $this);
        }
        
        if ($name == 'suggest') {

            return Leopard::suggest();
        }
        
        return parent::__call($name, $arguments);
    }

}



triadev / Leopard

Branch — master (8cb5b2)

Searchable::buildDocumentFromArray() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like