LaravelFreelancerNL\Aranguent\Schema\Concerns\Indexes

Complexity

Total Complexity

24

Size/Duplication

Total Lines	250
Duplicated Lines	0 %

Test Coverage

Coverage

72.86%

Importance

Changes	2
Bugs	1	Features	0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	executeIndexCommand()	0	20	4
A	createIndexName()	0	13	1
A	executeDropIndexCommand()	0	8	2
A	ttlIndex()	0	3	1
A	index()	0	5	1
A	skiplistIndex()	0	3	1
A	unique()	0	8	1
A	hashIndex()	0	3	1
A	indexCommand()	0	17	5
A	spatialIndex()	0	3	1
A	fulltextIndex()	0	3	1
A	persistentIndex()	0	3	1
A	geoIndex()	0	3	1
A	dropIndex()	0	9	1
A	mapIndexAlgorithm()	0	11	2

<?php

namespace LaravelFreelancerNL\Aranguent\Schema\Concerns;

use ArangoDBClient\Exception;
use Illuminate\Support\Fluent;

trait Indexes
{
    /**
     * Add a new index command to the blueprint.
     *
     * @param string            $type
     * @param string|array|null $columns
     * @param $name
     * @param array $indexOptions
     *
     * @return Fluent
     */
    protected function indexCommand($type = '', $columns = null, $name = null, $indexOptions = [])
    {
        if ($type == '') {
            $type = $this->mapIndexAlgorithm('persistent');
        }

        if ($columns === null) {
            $columns = end($this->columns);
        }

        if (is_string($columns)) {
            $columns = [$columns];
        }

        $indexOptions['name'] = $name ?: $this->createIndexName($type, $columns, $indexOptions);

It seems like $columns can also be of type null and string; however, parameter $columns of LaravelFreelancerNL\Aranguent\Schema\Concerns\Indexes::createIndexName() does only seem to accept array, maybe add an additional type check?

        return $this->addCommand('index', compact('type', 'columns', 'indexOptions'));

It seems like addCommand() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    /**
     * Specify an index for the table.
     *
     * @param string|array $columns
     * @param string       $name
     * @param string|null  $algorithm
     *
     * @return Fluent
     */
    public function index($columns = null, $name = null, $algorithm = null)
    {
        $type = $this->mapIndexAlgorithm($algorithm);

        return $this->indexCommand($type, $columns, $name);
    }

    /**
     * Create a hash index for fast exact matching.
     *
     * @param null  $columns

Are you sure the doc-type for parameter $columns is correct as it would always require null to be passed?

     * @param array $indexOptions
     *
     * @return Fluent
     */
    public function hashIndex($columns = null, $indexOptions = [])
    {
        return $this->indexCommand('hash', $columns, $indexOptions);
    }

    /**
     * @param null|string $column
     * @param $name
     * @param array $indexOptions
     *
     * @return Fluent
     */
    public function fulltextIndex($column = null, $name = null, $indexOptions = [])
    {
        return $this->indexCommand('fulltext', $column, $name, $indexOptions);
    }

    /**
     *  Specify a spatial index for the table.
     *
     * @param $columns
     * @param null  $name

Are you sure the doc-type for parameter $name is correct as it would always require null to be passed?

     * @param array $indexOptions
     *
     * @return Fluent
     */
    public function geoIndex($columns, $name = null, $indexOptions = [])
    {
        return $this->indexCommand('geo', $columns, $name, $indexOptions);
    }

    /**
     * Specify a spatial index for the table.
     *
     * @param string|array $columns
     * @param string       $name
     *
     * @return Fluent
     */
    public function spatialIndex($columns, $name = null)
    {
        return $this->geoIndex($columns, $name);

It seems like $name can also be of type string; however, parameter $name of LaravelFreelancerNL\Aranguent\Schema\Concerns\Indexes::geoIndex() does only seem to accept null, maybe add an additional type check?

    }

    /**
     * @param $columns
     * @param string|null $name
     * @param array       $indexOptions
     *
     * @return Fluent
     */
    public function skiplistIndex($columns, $name = null, $indexOptions = [])
    {
        return $this->indexCommand('skiplist', $columns, $name, $indexOptions);
    }

    public function persistentIndex($columns, $name = null, $indexOptions = [])
    {
        return $this->indexCommand('persistent', $columns, $name, $indexOptions);
    }

    /**
     * Create a TTL index for the table.
     *
     * @param $columns
     * @param null  $name

Are you sure the doc-type for parameter $name is correct as it would always require null to be passed?

     * @param array $indexOptions
     *
     * @return Fluent
     */
    public function ttlIndex($columns, $name = null, $indexOptions = [])
    {
        return $this->indexCommand('ttl', $columns, $name, $indexOptions);
    }

    /**
     * Specify a unique index for the table.
     *
     * @param string|array $columns
     * @param string       $name
     * @param string|null  $algorithm
     *
     * @return Fluent
     */
    public function unique($columns = null, $name = null, $algorithm = null)
    {
        $type = $this->mapIndexAlgorithm($algorithm);

        $indexOptions = [];
        $indexOptions['unique'] = true;

        return $this->indexCommand($type, $columns, $name, $indexOptions);
    }

    /**
     * @param $command
     *
     * @throws Exception
     */
    public function executeIndexCommand($command)
    {
        if ($this->connection->pretending()) {
            $this->connection->logQuery('/* ' . $command->explanation . " */\n", []);

            return;
        }

        $options = [
            'type'    => $command->type,
            'fields'  => $command->columns,
            'unique'  => $command->unique,
            'options' => $command->indexOptions,
        ];

        if (isset($command->indexOptions) && is_array($command->indexOptions)) {
            $options = array_merge($options, $command->indexOptions);
        }

        $this->collectionHandler->createIndex($this->table, $options);
    }

    /**
     * Indicate that the given index should be dropped.
     *
     * @param $name
     *
     * @return Fluent
     */
    public function dropIndex($name)
    {
        $parameters = [];
        $parameters['name'] = 'dropIndex';
        $parameters['index'] = $name;
        $parameters['explanation'] = "Drop the '" . $name . "' index on the {$this->table} table.";
        $parameters['handler'] = 'collection';

        return $this->addCommand('dropIndex', $parameters);
    }

    /**
     * Drop the index by first getting all the indexes on the table; then selecting the matching one
     * by type and columns.
     *
     * @param $command
     */
    public function executeDropIndexCommand($command)
    {
        if ($this->connection->pretending()) {
            $this->connection->logQuery('/* ' . $command->explanation . " */\n", []);

            return;
        }
        $this->collectionHandler->dropIndex($this->table, $command->index);
    }

    /**
     * @param string|null $algorithm
     *
     * @return mixed|string
     */
    protected function mapIndexAlgorithm($algorithm)
    {
        $algorithmConversion = [
            'HASH'  => 'hash',
            'BTREE' => 'persistent',
            'RTREE' => 'geo',
            'TTL'   => 'ttl',
        ];
        $algorithm = strtoupper($algorithm);

        return (isset($algorithmConversion[$algorithm])) ? $algorithmConversion[$algorithm] : 'persistent';
    }

    /**
     * Create a default index name for the table.
     *
     * @param string $type
     * @param array  $columns
     * @param array  $options
     *
     * @return string
     */
    public function createIndexName($type, array $columns, array $options = [])
    {
        $nameParts = [];
        $nameParts[] = $this->prefix . $this->table;
        $nameParts = array_merge($nameParts, $columns);
        $nameParts[] = $type;
        $nameParts = array_merge($nameParts, array_keys($options));
        array_filter($nameParts);

        $index = strtolower(implode('_', $nameParts));
        $index = preg_replace("/\[\*+\]+/", '_array', $index);

        return preg_replace('/[^A-Za-z0-9]+/', '_', $index);
    }
}