PheanstalkProxy::create() - Code Metrics - Inspection of "Fix tests" - PyRowMan/pheanstalk-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 0a782c...aa238d )

by Valentin
created 2019-11-27 15:54 UTC
PheanstalkProxy::create() A

↳ Parent: PheanstalkProxy
Complexity

Conditions	2
Paths	2
Size

Total Lines	8
Code Lines	4
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	5
CRAP Score	2
Importance

Changes	2
Bugs	0	Features	0
Metric	Value
cc	2
eloc	4
c	2
b	0
f	0
nc	2
nop	2
dl	0
loc	8
ccs	5
cts	5
cp	1
crap	2
rs	10
<?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 */

    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;

    }

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

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

        return $this;
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /**
     * {@inheritDoc}
     */
    public function put(Workflow $workflow)
    {
        if ($this->dispatcher)
// Without braces (not recommended)
if (true)
    doSomething();

// Recommended
if (true) {
    doSomething();
}
            $this->dispatcher->dispatch(new CommandEvent($this, ['workflow' => $workflow]), CommandEvent::PUT);
                               dispatch(new CommandEvent($this, ['workflow' => $workflow]), CommandEvent::PUT);

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

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

        return $this->pheanstalk->statsTube($tube);
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
    }

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

        return $this->pheanstalk->stats();
interface HasName {
    /** @return string */
    public function getName();
}

class Name {
    public $name;
}

class User implements HasName {
    /** @return string|Name */
    public function getName() {
        return new Name('foo'); // This is a violation of the ``HasName`` interface
                                // which only allows a string value to be returned.
    }
}
    }

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

class Dalek extends Alien {}

class Plot
{
    /** @var  Dalek */
    public $villain;
}

$alien = new Alien();
$plot = new Plot();
if ($alien instanceof Dalek) {
    $plot->villain = $alien;
}
        $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
    {
        if ($this->dispatcher) {
            $this->dispatcher->dispatch(new CommandEvent($this, ['workflow' => $workflow]), CommandEvent::CREATE_WORKFLOW);
                               dispatch(new CommandEvent($this, ['workflow' => $workflow]), CommandEvent::CREATE_WORKFLOW);
        }

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

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

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

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

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

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

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

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

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

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

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

    /**
     * {@inheritdoc}
     */
    public function listSchedules()
    {
        if ($this->dispatcher) {
            $this->dispatcher->dispatch(new CommandEvent($this, []), CommandEvent::LIST_SCHEDULE);
                               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
    {
        if ($this->dispatcher) {
            $this->dispatcher->dispatch(new CommandEvent($this, [
                'name'      => $name,
                'group'     => $group,
                'path'      => $path,
                'queue'     => $queue,
                'useAgent'  => $useAgent,
                'user'      => $user,
                'host'      => $host,
                'comment'   => $comment
            ]), CommandEvent::CREATE_TASK);
                               dispatch(new CommandEvent($this, [
        }

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

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

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

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

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

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

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

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

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

PyRowMan / pheanstalk-bundle

Push — master ( 0a782c...aa238d )

PheanstalkProxy::create() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
