UpdateJob::handle() - Code Metrics - Inspection of "Allow multiple, customized records per model" - algolia/scout-extended - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Pull Request — master (#211)

unknown
created 2019-12-09 23:53 UTC
UpdateJob::handle() C

↳ Parent: UpdateJob
Complexity

Conditions	15
Paths	133
Size

Total Lines	63
Code Lines	38
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	35
CRAP Score	15.0356
Importance

Changes	4
Bugs	1	Features	0
Metric	Value
cc	15
eloc	38
c	4
b	1
f	0
nc	133
nop	1
dl	0
loc	63
ccs	35
cts	37
cp	0.9459
crap	15.0356
rs	5.6416
How to fix Long Method Complexity

<?php

declare(strict_types=1);

/**
 * This file is part of Scout Extended.
 *
 * (c) Algolia Team <[email protected]>
 *
 *  For the full copyright and license information, please view the LICENSE
 *  file that was distributed with this source code.
 */

namespace Algolia\ScoutExtended\Jobs;

use ReflectionClass;
use function in_array;
use function is_array;
use function get_class;
use function is_string;
use Illuminate\Support\Arr;
use Illuminate\Support\Str;
use Illuminate\Support\Collection;
use Algolia\AlgoliaSearch\SearchClient;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\SoftDeletes;
use Algolia\ScoutExtended\Searchable\ModelsResolver;
use Algolia\ScoutExtended\Contracts\SplitterContract;
use Algolia\ScoutExtended\Searchable\ObjectIdEncrypter;
use Algolia\ScoutExtended\Transformers\ConvertDatesToTimestamps;
use Algolia\ScoutExtended\Transformers\ConvertNumericStringsToNumbers;

/**
 * @internal
 */
final class UpdateJob
{
    /**
     * Contains a list of splittables searchables.
     *
     * Example: [
     *      '\App\Thread' => true,
     *      '\App\User' => false,
     * ];
     *
     * @var array
     */
    private $splittables = [];

    /**
     * @var \Illuminate\Support\Collection
     */
    private $searchables;

    /**
     * Holds the searchables with a declared
     * toSearchableArray method.
     *
     * @var array
     */
    private $searchablesWithToSearchableArray = [];

    /**
     * Holds a list of transformers to apply by
     * default.
     *
     * @var array
     */
    private static $transformers = [
        ConvertNumericStringsToNumbers::class,
        ConvertDatesToTimestamps::class,
    ];

    /**
     * UpdateJob constructor.
     *
     * @param \Illuminate\Support\Collection $searchables
     *
     * @return void
     */
    public function __construct(Collection $searchables)
    {
        $this->searchables = $searchables;
    }

    /**
     * @param \Algolia\AlgoliaSearch\SearchClient $client
     *
     * @return void
     */
    public function handle(SearchClient $client): void
    {
        if ($this->searchables->isEmpty()) {
            return;
        }

        if (config('scout.soft_delete', false) && $this->usesSoftDelete($this->searchables->first())) {
            $this->searchables->each->pushSoftDeleteMetadata();
        }

        $index = $client->initIndex($this->searchables->first()->searchableAs());

        $objectsToSave = [];
        $searchablesToDelete = [];

        foreach ($this->searchables as $key => $searchable) {
            $metadata = Arr::except($searchable->scoutMetadata(), ModelsResolver::$metadata);

            $model = $searchable->getModel();
            $hasToSearchableRecords = method_exists($model, 'toSearchableRecords');

            if ($hasToSearchableRecords) {
                $objects = $model->toSearchableRecords();
            } else {
                $objects = [$searchable->toSearchableArray()];
            }

            if (empty($objects) || empty($objects[0])) {
                continue;
            }

            foreach ($objects as $part => $object) {
                $object = array_merge($object, $metadata);

                if (! $this->hasToSearchableArray($searchable)) {
                    $object = $model->transform($object);
                }

                $object['_tags'] = (array) ($object['_tags'] ?? []);
                $object['_tags'][] = ObjectIdEncrypter::encrypt($searchable);
                $objects[$part] = $object;
            }

            if ($hasToSearchableRecords || $this->shouldBeSplitted($searchable)) {
                if (!$hasToSearchableRecords) {
                    $objects = $this->splitSearchable($searchable, $objects[0]);
                }
                foreach ($objects as $part => $object) {
                    $object['objectID'] = ObjectIdEncrypter::encrypt($searchable, (int) $part);
                    $objectsToSave[] = $object;
                }
                $searchablesToDelete[] = $searchable;
            } else {
                $objects[0]['objectID'] = ObjectIdEncrypter::encrypt($searchable);
                $objectsToSave[] = $objects[0];
            }
        }

        dispatch_now(new DeleteJob(collect($searchablesToDelete)));

        $result = $index->saveObjects($objectsToSave);
        if (config('scout.synchronous', false)) {
            $result->wait();
        }
    }

    /**
     * @param  object $searchable
     *
     * @return bool
     */
    private function shouldBeSplitted($searchable): bool
    {
        $class = get_class($searchable->getModel());

        if (! array_key_exists($class, $this->splittables)) {
            $this->splittables[$class] = false;

            foreach ($searchable->toSearchableArray() as $key => $value) {
                $method = 'split'.Str::camel($key);
                $model = $searchable->getModel();
                if (method_exists($model, $method)) {
                    $this->splittables[$class] = true;
                    break;
                }
            }
        }

        return $this->splittables[$class];
    }

    /**
     * @param  object $searchable
     * @param  array $array
     *
     * @return array
     */
    private function splitSearchable($searchable, array $array): array
    {
        $pieces = [];
        foreach ($array as $key => $value) {
            $method = 'split'.Str::camel((string) $key);
            $model = $searchable->getModel();
            if (method_exists($model, $method)) {
                $result = $model->{$method}($value);
                $splittedBy = $key;
                $pieces[$splittedBy] = [];
                switch (true) {
                    case is_array($result):
                        $pieces[$splittedBy] = $result;
                        break;
                    case is_string($result):
                        $pieces[$splittedBy] = app($result)->split($model, $value);
                        $pieces[$splittedBy] = app($result)->/** @scrutinizer ignore-call */ split($model, $value);
                        break;
                    case $result instanceof SplitterContract:
                        $pieces[$splittedBy] = $result->split($model, $value);
                        break;
                }
            }
        }

        $objects = [[]];
        foreach ($pieces as $splittedBy => $values) {
            $temp = [];
            foreach ($objects as $object) {
                foreach ($values as $value) {
                    $temp[] = array_merge($object, [$splittedBy => $value]);
                }
            }
            $objects = $temp;
        }

        return array_map(function ($object) use ($array) {
            return array_merge($array, $object);
        }, $objects);
    }

    /**
     * Determine if the given searchable uses soft deletes.
     *
     * @param  object $searchable
     *
     * @return bool
     */
    private function usesSoftDelete($searchable): bool
    {
        return $searchable instanceof Model && in_array(SoftDeletes::class, class_uses_recursive($searchable), true);
    }

    /**
     * @param  object $searchable
     *
     * @return bool
     */
    private function hasToSearchableArray($searchable): bool
    {
        $searchableClass = get_class($searchable);

        if (! array_key_exists($searchableClass, $this->searchablesWithToSearchableArray)) {
            $reflectionClass = new ReflectionClass(get_class($searchable));

            $this->searchablesWithToSearchableArray[$searchableClass] =
                Str::endsWith((string) $reflectionClass->getMethod('toSearchableArray')->getFileName(),
                    (string) $reflectionClass->getFileName());
        }

        return $this->searchablesWithToSearchableArray[$searchableClass];
    }

    /**
     * Returns the default update job transformers.
     *
     * @return array
     */
    public static function getTransformers(): array
    {
        return self::$transformers;
    }
}

algolia / scout-extended

Pull Request — master (#211)

UpdateJob::handle() C

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like
