AsyncPHP\Icicle\Database\Manager

Complexity

Total Complexity

13

Size/Duplication

Total Lines	180
Duplicated Lines	18.33 %

Coupling/Cohesion

Components	2
Dependencies	3

Test Coverage

Coverage

75.86%

Importance

Changes	4
Bugs	2	Features	2

12 Methods

Rating	Name	Duplication	Size	Complexity
A	update()	11	11	1
A	delete()	11	11	1
A	__construct()	0	5	1
A	__call()	0	7	1
A	table()	0	4	1
A	select()	0	4	1
A	first()	0	7	1
A	get()	0	10	1
A	interpolate()	0	12	1
A	quote()	0	4	1
A	insert()	11	11	1
A	applyOperationsTo()	0	9	2

<?php

namespace AsyncPHP\Icicle\Database;

use AsyncPHP\Icicle\Database\Method\CloneWithMethod;
use Icicle\Coroutine;
use Icicle\Promise\PromiseInterface;

final class Manager
{
    use CloneWithMethod;

    /**
     * @var Connector
     */
    private $connector;

    /**
     * @var Builder
     */
    private $builder;

    /**
     * @var array
     */
    private $operations = [];

    /**
     * @param Connector $connector
     * @param Builder $builder
     */
    public function __construct(Connector $connector, Builder $builder)
    {
        $this->connector = $connector;
        $this->builder = $builder;
    }

    /**
     * @param string $method
     * @param array $parameters
     *
     * @return mixed
     */
    public function __call($method, array $parameters = [])
    {
        $operations = $this->operations;
        $operations[] = [$method, $parameters];

        return $this->cloneWith("operations", $operations);
    }

    /**
     * @param string $table
     *
     * @return static
     */
    public function table($table)
    {
        return $this->cloneWith("builder", $this->builder->table($table));
    }

    /**
     * @param string $columns
     *
     * @return static
     */
    public function select($columns = "*")
    {
        return $this->cloneWith("builder", $this->builder->select($columns));
    }

    /**
     * @return PromiseInterface
     */
    public function first()
    {
        return Coroutine\create(function () {
            $rows = (yield $this->limit(1)->get());
            yield reset($rows);
        });
    }

    /**
     * @return PromiseInterface
     */
    public function get()
    {
        return Coroutine\create(function () {
            $builder = $this->applyOperationsTo($this->builder);

            yield $this->connector->query(
                $this->interpolate($builder->build())
            );
        });
    }

    /**
     * @param array $build
     *
     * @return string
     */
    private function interpolate(array $build)
    {
        list($statement, $values) = $build;

        $pattern = "/\\:([_0-9a-zA-Z]+)/";

        $replacement = function ($matches) use ($values) {
            return $this->quote($values[$matches[1]]);
        };

        return preg_replace_callback($pattern, $replacement, $statement);
    }

    /**
     * @param mixed $value
     *
     * @return string
     */
    private function quote($value)
    {
        return "'" . $this->connector->escape($value) . "'";
    }

    /**
     * @param array $data
     *
     * @return PromiseInterface
     */
    public function insert(array $data)

This method seems to be duplicated in your project.

    {
        return Coroutine\create(function () use ($data) {
            $builder = $this->builder->insert($data);
            $builder = $this->applyOperationsTo($builder);

            yield $this->connector->query(
                $this->interpolate($builder->build())
            );
        });
    }

    /**
     * @param Builder $builder
     *
     * @return Builder
     */
    private function applyOperationsTo($builder)
    {
        foreach ($this->operations as $operation) {
            list($method, $parameters) = $operation;
            $builder = call_user_func_array([$builder, $method], $parameters);
        }

        return $builder;
    }

    /**
     * @param array $data
     *
     * @return PromiseInterface
     */
    public function update(array $data)

This method seems to be duplicated in your project.

    {
        return Coroutine\create(function () use ($data) {
            $builder = $this->builder->update($data);
            $builder = $this->applyOperationsTo($builder);

            yield $this->connector->query(
                $this->interpolate($builder->build())
            );
        });
    }

    /**
     * @return PromiseInterface
     */
    public function delete()

This method seems to be duplicated in your project.

    {
        return Coroutine\create(function () {
            $builder = $this->builder->delete();
            $builder = $this->applyOperationsTo($builder);

            yield $this->connector->query(
                $this->interpolate($builder->build())
            );
        });
    }
}