Cycle\ORM\Command\Special\WrappedCommand

Complexity

Total Complexity

15

Size/Duplication

Total Lines	80
Duplicated Lines	0 %

Test Coverage

Coverage

79.31%

Importance

Changes	1
Bugs	0	Features	0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	getDatabase()	0	3	1
A	__construct()	0	3	1
A	isReady()	0	3	1
A	isExecuted()	0	3	1
A	getCommand()	0	3	1
A	createUpdate()	0	8	1
A	execute()	0	8	3
A	withBeforeExecution()	0	5	2
A	wrapCommand()	0	3	1
A	createInsert()	0	9	1
A	withAfterExecution()	0	5	2

<?php

declare(strict_types=1);

namespace Cycle\ORM\Command\Special;

use Closure;
use Cycle\ORM\Command\CommandInterface;
use Cycle\ORM\Command\Database\Insert;
use Cycle\ORM\Command\Database\Update;
use Cycle\ORM\Heap\State;
use Cycle\Database\DatabaseInterface;
use Cycle\ORM\MapperInterface;

class WrappedCommand implements CommandInterface
{
    private ?Closure $beforeExecute = null;

    private ?Closure $afterExecute = null;

    protected function __construct(
        protected CommandInterface $command
    ) {
    }

    public static function createInsert(
        DatabaseInterface $db,
        string $table,
        State $state,
        ?MapperInterface $mapper,
        array $primaryKeys = [],
        string $pkColumn = null
    ): WrappedStoreCommand {
        return new WrappedStoreCommand(new Insert($db, $table, $state, $mapper, $primaryKeys, $pkColumn));
    }

    public static function createUpdate(
        DatabaseInterface $db,
        string $table,
        State $state,
        ?MapperInterface $mapper,
        array $primaryKeys = []
    ): WrappedStoreCommand {
        return new WrappedStoreCommand(new Update($db, $table, $state, $mapper, $primaryKeys));
    }

    public static function wrapCommand(CommandInterface $command): static
    {
        return new static($command);
    }

    public function withBeforeExecution(?callable $callable): static
    {
        $clone = clone $this;
        $clone->beforeExecute = $callable instanceof Closure ? $callable : Closure::fromCallable($callable);

It seems like $callable can also be of type null; however, parameter $callback of Closure::fromCallable() does only seem to accept callable, maybe add an additional type check?

        return $clone;
    }

    public function withAfterExecution(?callable $callable): static
    {
        $clone = clone $this;
        $clone->afterExecute = $callable instanceof Closure ? $callable : Closure::fromCallable($callable);

It seems like $callable can also be of type null; however, parameter $callback of Closure::fromCallable() does only seem to accept callable, maybe add an additional type check?

        return $clone;
    }

    public function isReady(): bool
    {
        return $this->command->isReady();
    }

    public function isExecuted(): bool
    {
        return $this->command->isExecuted();
    }

    public function execute(): void
    {
        if ($this->beforeExecute !== null) {
            Closure::bind($this->beforeExecute, null, static::class)($this->command);
        }
        $this->command->execute();
        if ($this->afterExecute !== null) {
            Closure::bind($this->afterExecute, null, static::class)($this->command);
        }
    }

    public function getDatabase(): ?DatabaseInterface
    {
        return $this->command->getDatabase();
    }

    public function getCommand(): CommandInterface
    {
        return $this->command;
    }
}