Pheanstalk\Pheanstalk

Complexity

Total Complexity

38

Size/Duplication

Total Lines	298
Duplicated Lines	0 %

Test Coverage

Coverage

35.16%

Importance

Changes	2
Bugs	0	Features	0

26 Methods

Rating	Name	Duplication	Size	Complexity
A	put()	0	4	1
A	statsJob()	0	3	1
A	getWorkflowInstances()	0	18	5
A	workflowExists()	0	6	2
A	createTask()	0	7	1
A	tubeExists()	0	3	1
A	setConnection()	0	5	1
A	createSchedule()	0	6	1
A	setCurrentClass()	0	4	1
A	createTube()	0	3	1
A	peek()	0	5	1
A	_dispatch()	0	3	1
A	getWorkflowInstancesDetails()	0	3	1
A	getCurrentClass()	0	3	1
A	getWorkflow()	0	3	1
A	cancel()	0	3	1
A	update()	0	4	1
A	listTubes()	0	3	1
A	kill()	0	3	1
A	delete()	0	5	1
A	stats()	0	3	1
B	create()	0	32	8
A	updateTube()	0	3	1
A	statsTube()	0	3	1
A	__construct()	0	3	1
A	getConnection()	0	3	1

<?php

namespace Pheanstalk;

use Doctrine\Common\Collections\ArrayCollection;
use Pheanstalk\Command\CreateCommand;
use Pheanstalk\Command\CreateScheduleCommand;
use Pheanstalk\Command\CreateTubeCommand;
use Pheanstalk\Command\GetWorkflowCommand;
use Pheanstalk\Command\GetWorkflowInstancesCommand;
use Pheanstalk\Command\GetWorkflowInstancesDetailCommand;
use Pheanstalk\Command\ListWorkflowsCommand;
use Pheanstalk\Command\ReleaseCommand;

The type Pheanstalk\Command\ReleaseCommand was not found. Maybe you did not declare it correctly or list all dependencies?

use Pheanstalk\Command\UpdateTubeCommand;
use Pheanstalk\Command\WorkflowExistsCommand;
use Pheanstalk\Exception\ServerDuplicateEntryException;
use Pheanstalk\Structure\Job;

This use statement conflicts with another class in this namespace, Pheanstalk\Job. Consider defining an alias.

use Pheanstalk\Structure\Task;
use Pheanstalk\Structure\TaskInstance;
use Pheanstalk\Structure\TimeSchedule;
use Pheanstalk\Structure\Tube;
use Pheanstalk\Structure\Workflow;
use Pheanstalk\Structure\WorkflowInstance;

/**
 * Pheanstalk is a PHP client for the beanstalkd workqueue.
 *
 * The Pheanstalk class is a simple facade for the various underlying components.
 *
 * @see http://github.com/kr/beanstalkd
 * @see http://xph.us/software/beanstalkd/
 *
 * @author  Paul Annesley
 * @package Pheanstalk
 * @license http://www.opensource.org/licenses/mit-license.php
 */
class Pheanstalk implements PheanstalkInterface
{
    const VERSION = '3.2.1';

    private $_connection;
    private $_using = PheanstalkInterface::DEFAULT_TUBE;

The private property $_using is not used, and could be removed.

    private $_watching = array(PheanstalkInterface::DEFAULT_TUBE => true);

The private property $_watching is not used, and could be removed.

Short array syntax must be used to define arrays

    /** @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;

    /**
     * @param string $host
     * @param string $user
     * @param string $password
     * @param int    $port
     * @param int    $connectTimeout
     * @param bool   $connectPersistent
     */
    public function __construct($host, $user = null, $password = null, $port = PheanstalkInterface::DEFAULT_PORT, $connectTimeout = null, $connectPersistent = false)
    {
        $this->setConnection(new Connection($host, $user, $password, $port, $connectTimeout, $connectPersistent));
    }

    /**
     * {@inheritdoc}
     */
    public function setConnection(Connection $connection)
    {
        $this->_connection = $connection;

        return $this;
    }

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

    /**
     * @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;
    }

    // ----------------------------------------

    /**
     * {@inheritdoc}
     */
    public function delete(Workflow $workflow)
    {
        $this->_dispatch(new Command\DeleteCommand($workflow));

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function workflowExists($name)
    {
        $workflow = $this->_dispatch(new Command\WorkflowExistsCommand($name));
        if ($workflow instanceof Workflow)

It is generally a best practice to always use braces with control structures.

            return $this->getCurrentClass()->getWorkflow($workflow);

The expression return $this->getCurrentClass()->getWorkflow($workflow) returns the type Pheanstalk\Response which is incompatible with the return type mandated by Pheanstalk\PheanstalkInterface::workflowExists() of Pheanstalk\Structure\Workflow|boolean.

        return false;
    }

    /**
     * {@inheritdoc}
     */
    public function getWorkflow(Workflow $workflow)
    {
        return $this->_dispatch(new Command\GetWorkflowCommand($workflow));

The expression return $this->_dispatch(new Pheanstalk\Command\GetWorkflowCommand($workflow)) returns the type Pheanstalk\Response which is incompatible with the return type mandated by Pheanstalk\PheanstalkInterface::getWorkflow() of Pheanstalk\Structure\Workflow|boolean.

    }

    /**
     * {@inheritdoc}
     */
    public function getWorkflowInstances(?Workflow $workflow, string $status = null)
    {
        $status = empty($status) ? GetWorkflowInstancesDetailCommand::FILTERS : [$status];
        $instances = new ArrayCollection([]);
        foreach($status as $stat) {

Expected 1 space(s) after FOREACH keyword; 0 found

            $instances[strtolower($stat)] = $this->_dispatch(new Command\GetWorkflowInstancesCommand($workflow, $stat));
//            if ($stat === GetWorkflowInstancesCommand::FILTER_EXECUTING) {
                /** @var ArrayCollection $workflowCollection */
                $workflowCollection = $instances[strtolower($stat)]->get('workflow_instances');

The method get() does not exist on null.

                if (!empty($workflowCollection)) {
                    foreach($workflowCollection as $instance) {

Expected 1 space(s) after FOREACH keyword; 0 found

                        $this->getCurrentClass()->getWorkflowInstancesDetails($instance);
                    }
                }
//            }
        }

        return $instances;
    }

    /**
     * {@inheritdoc}
     */
    public function getWorkflowInstancesDetails(WorkflowInstance $workflowInstance)
    {
        return $this->_dispatch(new Command\GetWorkflowInstancesDetailCommand($workflowInstance));

The expression return $this->_dispatch(new Pheanstalk\Command\GetWorkflowInstancesDetailCommand($workflowInstance)) returns the type Pheanstalk\Response which is incompatible with the return type mandated by Pheanstalk\PheanstalkInterface::getWorkflowInstancesDetails() of Pheanstalk\Structure\WorkflowInstance|false.

    }

    /**
     * {@inheritdoc}
     */
    public function tubeExists($name)
    {
        return $this->_dispatch(new Command\TubeExistsCommand($name));

The expression return $this->_dispatch(new Pheanstalk\Command\TubeExistsCommand($name)) returns the type Pheanstalk\Response which is incompatible with the return type mandated by Pheanstalk\PheanstalkInterface::tubeExists() of Pheanstalk\Structure\Tube|boolean.

    }

    /**
     * {@inheritdoc}
     */
    public function listTubes()
    {
        return $this->_dispatch(new Command\ListTubesCommand());
    }

    /**
     * {@inheritdoc}
     */
    public function peek()
    {
        $response = $this->_dispatch(new Command\PeekCommand());

        return $response;
    }

    /**
     * {@inheritdoc}
     */
    public function put(Workflow $workflow) {
        $response = $this->_dispatch(new Command\PutCommand($workflow));

        return $response['workflow-instance-id'];
    }

    /**
     * {@inheritdoc}
     */
    public function statsJob($job)
    {
        return $this->_dispatch(new Command\StatsJobCommand($job));

The type Pheanstalk\Command\StatsJobCommand was not found. Maybe you did not declare it correctly or list all dependencies?

    }

    /**
     * {@inheritdoc}
     */
    public function statsTube($tube)
    {
        return $this->_dispatch(new Command\StatsTubeCommand($tube));
    }

    /**
     * {@inheritdoc}
     */
    public function stats()
    {
        return $this->_dispatch(new Command\StatsCommand());
    }

    // ----------------------------------------

    /**
     * Dispatches the specified command to the connection object.
     *
     * If a SocketException occurs, the connection is reset, and the command is
     * re-attempted once.
     *
     * @param Command $command
     *
     * @return Response
     */
    private function _dispatch($command)
    {
        return $this->_connection->dispatchCommand($command);
    }

    /**
     * {@inheritdoc}
     */
    public function create(Workflow $workflow, $force = false): Workflow
    {
        try{

Expected 1 space(s) after TRY keyword; 0 found

            $tubes = [];
            /** @var Job $job */
            foreach($workflow->getJobs() as $job) {

Expected 1 space(s) after FOREACH keyword; 0 found

                /** @var Task $task */
                foreach ($job->getTasks() as $task) {
                    $tubes = array_merge($tubes, [$task->getQueue()]);
                }
            }
            foreach($tubes as $tube) {

Expected 1 space(s) after FOREACH keyword; 0 found

                if (!$this->getCurrentClass()->tubeExists($tube)) {
                    $this->getCurrentClass()->createTube(new Tube($tube, 1));
                };
            }
            $workflow = $this->_dispatch(new Command\CreateCommand($workflow));
        } catch(ServerDuplicateEntryException $e) {

Expected 1 space(s) after CATCH keyword; 0 found

            if ($force) {
                $workflows = $this->_dispatch(new Command\ListWorkflowsCommand());
                $workflowToDelete = $workflows->filter(function(Workflow $listedWorkflow) use ($workflow) {

The method filter() does not exist on Pheanstalk\Response.

Expected 1 space after FUNCTION keyword; 0 found

                    return $listedWorkflow->getName() === $workflow->getName()

The method getName() does not exist on Pheanstalk\Response.

                        && $listedWorkflow->getGroup() === $workflow->getGroup();

The method getGroup() does not exist on Pheanstalk\Response.

                })->first();
                $this->getCurrentClass()->delete($workflowToDelete);

                return $this->getCurrentClass()->create($workflow);

It seems like $workflow can also be of type Pheanstalk\Response; however, parameter $workflow of Pheanstalk\Pheanstalk::create() does only seem to accept Pheanstalk\Structure\Workflow, maybe add an additional type check?

            }
            throw $e;
        }

        return $workflow;

The expression return $workflow returns the type Pheanstalk\Response which is incompatible with the type-hinted return Pheanstalk\Structure\Workflow.

    }

    /**
     * {@inheritdoc}
     */
    public function update(Workflow $workflow): Workflow
    {
        $workflow = $this->_dispatch(new Command\UpdateCommand($workflow));
        return $workflow;

The expression return $workflow returns the type Pheanstalk\Response which is incompatible with the type-hinted return Pheanstalk\Structure\Workflow.

    }

    /**
     * {@inheritdoc}
     */
    public function createSchedule(Workflow $workflow, TimeSchedule $schedule, $onFailure = CreateScheduleCommand::FAILURE_TYPE_CONTINUE, $active = true, $comment = null)
    {
        $workflowSchedule = $this->_dispatch(
            new Command\CreateScheduleCommand($workflow, $schedule, $onFailure, $active, $comment)
        );
        return $workflowSchedule;
    }

    /**
     * {@inheritdoc}
     */
    public function createTask(string $name, string $group, string $path, $queue = 'default', $useAgent = false, $user = null, $host = null, $comment = null): Workflow
    {
        $task = new Task($path, $queue, $useAgent, $user, $host);
        $job = new Job(new ArrayCollection([$task]));
        $workflow = new Workflow($name, $group, new ArrayCollection([$job]), $comment);

        return $this->getCurrentClass()->create($workflow, true);
    }

    /**
     * {@inheritDoc}
     */
    public function createTube(Tube $tube): Tube
    {
        return $this->_dispatch(new Command\CreateTubeCommand($tube));

The expression return $this->_dispatch(new Pheanstalk\Command\CreateTubeCommand($tube)) returns the type Pheanstalk\Response which is incompatible with the type-hinted return Pheanstalk\Structure\Tube.

    }

    /**
     * {@inheritdoc}
     */
    public function updateTube(Tube $tube): Tube
    {
        return $this->_dispatch(new Command\UpdateTubeCommand($tube));

The expression return $this->_dispatch(new Pheanstalk\Command\UpdateTubeCommand($tube)) returns the type Pheanstalk\Response which is incompatible with the type-hinted return Pheanstalk\Structure\Tube.

    }

    /**
     * {@inheritdoc}
     */
    public function cancel(WorkflowInstance $workflowInstance)
    {
        return $this->_dispatch(new Command\CancelCommand($workflowInstance));
    }

    /**
     * {@inheritdoc}
     */
    public function kill(WorkflowInstance $workflowInstance, TaskInstance $taskInstance)
    {
        return $this->_dispatch(new Command\KillCommand($workflowInstance, $taskInstance));
    }
}