Pyrowman\PheanstalkBundle\Proxy\PheanstalkProxy

Complexity

Total Complexity

35

Size/Duplication

Total Lines	368
Duplicated Lines	0 %

Test Coverage

Coverage

88.43%

Importance

Changes	16
Bugs	0	Features	0

34 Methods

Rating	Name	Duplication	Size	Complexity
A	setConnection()	0	5	1
A	getCurrentClass()	0	3	1
A	setCurrentClass()	0	4	1
A	getConnection()	0	3	1
A	statsTube()	0	5	1
A	getWorkflow()	0	5	1
A	getWorkflowInstances()	0	9	1
A	setPheanstalk()	0	6	1
A	cancel()	0	5	1
A	put()	0	5	1
A	delete()	0	7	1
A	setName()	0	5	1
A	createTask()	0	15	1
A	listSchedules()	0	5	1
A	create()	0	6	1
A	listTubes()	0	5	1
A	kill()	0	5	1
A	getName()	0	3	1
A	tubeExists()	0	5	1
A	setDispatcher()	0	3	1
A	peek()	0	5	1
A	update()	0	5	1
A	workflowExists()	0	5	1
A	getPheanstalk()	0	3	1
A	createTube()	0	5	1
A	getSchedule()	0	7	1
A	stats()	0	5	1
A	updateTube()	0	5	1
A	createSchedule()	0	8	1
A	deleteSchedule()	0	7	1
A	updateSchedule()	0	7	1
A	dispatch()	0	4	2
A	getDispatcher()	0	3	1
A	getWorkflowInstancesDetails()	0	6	1

<?php

namespace Pyrowman\PheanstalkBundle\Proxy;

use Pheanstalk\Command\CreateScheduleCommand;
use Pheanstalk\Command\GetWorkflowInstancesCommand;
use Pheanstalk\Pheanstalk;
use Pheanstalk\Structure\Schedule;
use Pheanstalk\Structure\TaskInstance;
use Pheanstalk\Structure\TimeSchedule;
use Pheanstalk\Structure\Tube;
use Pheanstalk\Structure\Workflow;
use Pheanstalk\Structure\WorkflowInstance;
use Pyrowman\PheanstalkBundle\Event\CommandEvent;
use Pheanstalk\Connection;
use Pheanstalk\PheanstalkInterface;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;

class PheanstalkProxy implements PheanstalkProxyInterface
{
    /**
     * @var EventDispatcherInterface
     */
    protected $dispatcher;

    /**
     * @var string
     */
    protected $name;

    /**
     * @var Pheanstalk
     */
    protected $pheanstalk;

    /** @var $currentClass PheanstalkInterface */

The doc comment $currentClass at position 0 could not be parsed: Unknown type name '$currentClass' at position 0 in $currentClass.

    private $currentClass;

    /**
     * {@inheritDoc}
     */
    public function setConnection(Connection $connection)
    {
        $this->pheanstalk->setConnection($connection);

        return $this;
    }

    /**
     * {@inheritDoc}
     */
    public function getConnection()
    {
        return $this->pheanstalk->getConnection();
    }

    /**
     * @return PheanstalkInterface
     */
    public function getCurrentClass(): PheanstalkInterface
    {
        return $this->currentClass ?? $this;
    }

    /**
     * @param PheanstalkInterface $currentClass
     *
     * @return Pheanstalk
     */
    public function setCurrentClass(PheanstalkInterface $currentClass): PheanstalkInterface
    {
        $this->currentClass = $currentClass;
        return $this;

The expression return $this returns the type Pyrowman\PheanstalkBundle\Proxy\PheanstalkProxy which is incompatible with the documented return type Pheanstalk\Pheanstalk.

    }

    /**
     * {@inheritDoc}
     */
    public function delete(Workflow $workflow)
    {
        $this->dispatch(new CommandEvent($this, ['workflow' => $workflow]), CommandEvent::DELETE);

        $this->pheanstalk->delete($workflow);

        return $this;

The expression return $this returns the type Pyrowman\PheanstalkBundle\Proxy\PheanstalkProxy which is incompatible with the return type mandated by Pheanstalk\PheanstalkInterface::delete() of boolean.

    }

    /**
     * {@inheritDoc}
     */
    public function workflowExists($name)
    {
        $this->dispatch(new CommandEvent($this, ['name' => $name]), CommandEvent::WORKFLOW_EXISTS);

        return $this->pheanstalk->workflowExists($name);
    }

    /**
     * {@inheritDoc}
     */
    public function getWorkflow(Workflow $workflow)
    {
        $this->dispatch(new CommandEvent($this, ['workflow' => $workflow]), CommandEvent::TASK_EXISTS);

        return $this->pheanstalk->getWorkflow($workflow);
    }

    /**
     * {@inheritDoc}
     */
    public function getWorkflowInstances(?Workflow $workflow = null, ?string $status = null)
    {
        $this->dispatch(new CommandEvent($this, [
            'workflow'  => $workflow,
            'status'    => $status
        ]), CommandEvent::WORKFLOW_INSTANCES);


        return $this->pheanstalk->getWorkflowInstances($workflow, $status);
    }

    /**
     * {@inheritDoc}
     */
    public function getWorkflowInstancesDetails(WorkflowInstance $workflowInstance)
    {
        $this->dispatch(new CommandEvent($this, ['workflowInstance'  => $workflowInstance]),
            CommandEvent::WORKFLOW_INSTANCES_DETAILS);

        return $this->pheanstalk->getWorkflowInstancesDetails($workflowInstance);
    }

    /**
     * {@inheritDoc}
     */
    public function tubeExists($name)
    {
        $this->dispatch(new CommandEvent($this, ['name' => $name]), CommandEvent::TUBE_EXISTS);

        return $this->pheanstalk->tubeExists($name);
    }

    /**
     * {@inheritDoc}
     */
    public function listTubes()
    {
        $this->dispatch(new CommandEvent($this), CommandEvent::LIST_TUBES);

        return $this->pheanstalk->listTubes();
    }

    /**
     * {@inheritDoc}
     */
    public function peek()
    {
        $this->dispatch(new CommandEvent($this), CommandEvent::PEEK);

        return $this->pheanstalk->peek();
    }

    /**
     * {@inheritDoc}
     */
    public function put(Workflow $workflow)
    {
        $this->dispatch(new CommandEvent($this, ['workflow' => $workflow]), CommandEvent::PUT);

        return $this->pheanstalk->put($workflow);
    }

    /**
     * {@inheritDoc}
     */
    public function statsTube(Tube $tube)
    {
        $this->dispatch(new CommandEvent($this, ['tube' => $tube]), CommandEvent::STATS_TUBE);

        return $this->pheanstalk->statsTube($tube);

The expression return $this->pheanstalk->statsTube($tube) returns the type array which is incompatible with the return type mandated by Pheanstalk\PheanstalkInterface::statsTube() of object.

    }

    /**
     * {@inheritDoc}
     */
    public function stats()
    {
        $this->dispatch(new CommandEvent($this), CommandEvent::STATS);

        return $this->pheanstalk->stats();

The expression return $this->pheanstalk->stats() returns the type array which is incompatible with the return type mandated by Pheanstalk\PheanstalkInterface::stats() of object.

    }

    /**
     * @return EventDispatcherInterface
     */
    public function getDispatcher()
    {
        return $this->dispatcher;
    }

    /**
     * @param EventDispatcherInterface $dispatch
     */
    public function setDispatcher(EventDispatcherInterface $dispatch)
    {
        $this->dispatcher = $dispatch;
    }

    /**
     * {@inheritDoc}
     */
    public function getPheanstalk()
    {
        return $this->pheanstalk;
    }

    /**
     * {@inheritDoc}
     */
    public function setPheanstalk(PheanstalkInterface $pheanstalk)
    {
        $this->pheanstalk = $pheanstalk;

$pheanstalk is of type Pheanstalk\PheanstalkInterface, but the property $pheanstalk was declared to be of type Pheanstalk\Pheanstalk. Are you sure that you always receive this specific sub-class here, or does it make sense to add an instanceof check?

        $this->pheanstalk->setCurrentClass($this);

        return $this;
    }

    /**
     * {@inheritDoc}
     */
    public function getName()
    {
        return $this->name;
    }

    /**
     * {@inheritDoc}
     */
    public function setName($name)
    {
        $this->name = $name;

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function create(Workflow $workflow, $force = false): Workflow
    {
        $this->dispatch(new CommandEvent($this, ['workflow' => $workflow]), CommandEvent::CREATE_WORKFLOW);

        $workflow = $this->pheanstalk->create($workflow);
        return $workflow;
    }

    /**
     * {@inheritdoc}
     */
    public function update(Workflow $workflow): Workflow
    {
        $this->dispatch(new CommandEvent($this, ['workflow' => $workflow]), CommandEvent::UPDATE_WORKFLOW);

        return $this->pheanstalk->update($workflow);
    }

    /**
     * {@inheritdoc}
     */
    public function createSchedule(Schedule $schedule)
    {
        $this->dispatch(new CommandEvent($this, [
                'schedule'  => $schedule,
            ]), CommandEvent::CREATE_SCHEDULE);

        $workflowSchedule = $this->pheanstalk->createSchedule($schedule);
        return $workflowSchedule;
    }

    /**
     * {@inheritdoc}
     */
    public function deleteSchedule(Schedule $schedule)
    {
            $this->dispatch(new CommandEvent($this, [
                'schedule'  => $schedule,
            ]), CommandEvent::DELETE_SCHEDULE);

        return $this->pheanstalk->deleteSchedule($schedule);
    }

    /**
     * {@inheritdoc}
     */
    public function getSchedule(int $schedule)
    {
        $this->dispatch(new CommandEvent($this, [
                'schedule'  => $schedule,
            ]), CommandEvent::GET_SCHEDULE);

        return $this->pheanstalk->getSchedule($schedule);
    }

    /**
     * {@inheritdoc}
     */
    public function updateSchedule(Schedule $schedule): Schedule
    {
        $this->dispatch(new CommandEvent($this, [
                'schedule'  => $schedule,
            ]), CommandEvent::UPDATE_SCHEDULE);

        return $this->pheanstalk->updateSchedule($schedule);
    }

    /**
     * {@inheritdoc}
     */
    public function listSchedules()
    {
        $this->dispatch(new CommandEvent($this, []), CommandEvent::LIST_SCHEDULE);

        return $this->pheanstalk->listSchedules();
    }

    /**
     * {@inheritdoc}
     */
    public function createTask(string $name, string $group, string $path, $queue = 'default', $useAgent = false, $user = null, $host = null, $comment = null): Workflow
    {
        $this->dispatch(new CommandEvent($this, [
            'name'      => $name,
            'group'     => $group,
            'path'      => $path,
            'queue'     => $queue,
            'useAgent'  => $useAgent,
            'user'      => $user,
            'host'      => $host,
            'comment'   => $comment
        ]), CommandEvent::CREATE_TASK);


        return $this->pheanstalk->createTask($name, $group, $path, $queue, $useAgent, $user, $host, $comment);
    }

    /**
     * {@inheritdoc}
     */
    public function createTube(Tube $tube): Tube
    {
        $this->dispatch(new CommandEvent($this, ['tube' => $tube]), CommandEvent::CREATE_TUBE);

        return $this->pheanstalk->createTube($tube);
    }

    /**
     * {@inheritdoc}
     */
    public function updateTube(Tube $tube): Tube
    {
        $this->dispatch(new CommandEvent($this, ['tube' => $tube]), COmmandEvent::CREATE_TUBE);

        return $this->pheanstalk->updateTube($tube);
    }

    /**
     * {@inheritdoc}
     */
    public function cancel(WorkflowInstance $workflowInstance)
    {
        $this->dispatch(new CommandEvent($this, ['workflowInstance' => $workflowInstance]), COmmandEvent::CANCEL);

        return $this->pheanstalk->cancel($workflowInstance);
    }

    public function kill(WorkflowInstance $workflowInstance, TaskInstance $taskInstance)
    {
        $this->dispatch(new CommandEvent($this, ['workflowInstance' => $workflowInstance, 'taskInstance' => $taskInstance]), COmmandEvent::CANCEL);

        return $this->pheanstalk->kill($workflowInstance, $taskInstance);
    }

    protected function dispatch(CommandEvent $commandEvent, string $eventName = null)
    {
        if ($this->dispatcher) {
            $this->dispatcher->dispatch($commandEvent, $eventName);

The call to Symfony\Contracts\EventDispatcher\EventDispatcherInterface::dispatch() has too many arguments starting with $eventName.

        }
    }
}