TransportManager::createDriver() - Code Metrics - Inspection of "[Notify] Added a Notifiable Trait (currently depen..." - unyx/notify - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 03348d...edfc47 )

by Michał

created 2016-11-22 10:27 UTC

TransportManager::createDriver() A

↳ Parent: TransportManager

Complexity

Conditions	3
Paths	3

Size

Total Lines	14
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	14
rs	9.4285
c	0
b	0
f	0
cc	3
eloc	7
nc	3
nop	1

<?php namespace nyx\notify;

// External dependencies
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Contracts\Bus\Dispatcher;

/**
 * Notification Transport Manager
 *
 * @package     Nyx\Notify
 * @version     0.1.0
 * @author      Michal Chojnacki <[email protected]>
 * @copyright   2012-2017 Nyx Dev Team
 * @link        https://github.com/unyx/nyx
 * @todo        Proper eventing (beforeSend, afterSend, failedSend etc.) hooked into Nyx's Events component.
 * @todo        Add support for core Collections and PHP 7.1 iterables (Notifiable entities).
 */
class TransportManager extends \Illuminate\Support\Manager implements interfaces\Dispatcher
{
    /**
     * {@inheritDoc}
     */
    public function send($notifiables, interfaces\Notification $notification)
    {
        // In here, as opposed to self::sendNow(), we respect the ShouldQueue interface
        // and push the Notification onto the queue if it asks us to.
        if ($notification instanceof ShouldQueue) {
            $this->enqueue($notifiables, $notification);
            return;
        }

        $this->sendNow($notifiables, $notification);
    }

    /**
     * {@inheritDoc}
     */
    public function sendNow($notifiables, interfaces\Notification $notification)
    {
        if (!is_array($notifiables)) {
            $notifiables = [$notifiables];
        }

        foreach ($notifiables as $notifiable) {

            // Iterate over all transports the Notification specifies for the current Notifiable,
            // then determine whether it shall be sent and send it.
            foreach ($notification->via($notifiable) as $transport) {

                $transport = $this->driver($transport);

                if (!$this->shouldSend($notifiable, $notification, $transport)) {
                    continue;
                }

                // All clear at this point - let's dispatch the Notification.
                $transport->send($notifiable, $notification);
            }
        }
    }

    /**
     * {@inheritDoc}
     */
    public function getDefaultDriver() : string
    {
        return 'mail';
    }

    /**
     * Determines whether the Notification should be sent at all, given the context.
     *
     * @param   interfaces\Notifiable   $notifiable     The entity being notified.
     * @param   interfaces\Notification $notification   The Notification being sent.
     * @param   interfaces\Transport    $transport      The Transport the Notification should be sent over.
     * @return  bool                                    True when the Notification should be sent, false otherwise.
     * @todo    onBeforeSend event allowing listeners to prevent dispatching.
     */
    protected function shouldSend(interfaces\Notifiable $notifiable, interfaces\Notification $notification, interfaces\Transport $transport) : bool

    {
        if (!$transport->supports($notification)) {
            return false;
        }

        return true;
    }

    /**
     * Enqueues the given Notification.
     *
     * @param   mixed                   $notifiables    The entities which shall receive the Notification.
     * @param   interfaces\Notification $notification   The Notification to enqueue.
     */
    protected function enqueue($notifiables, interfaces\Notification $notification)
    {
        // @todo Laravel's ShouldQueue interface doesn't actually cover access to those properties
        // so we'll need a more robust solution later.
        $this->app->make(Dispatcher::class)->dispatch(
            (new jobs\Enqueue($notifiables, $notification))
                ->onConnection($notification->connection)
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                ->onQueue($notification->queue)
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                ->delay($notification->delay)
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
        );
    }

    /**
     * {@inheritDoc}
     */
    protected function createDriver($driver)
    {
        try {
            return parent::createDriver($driver);
        } catch (\InvalidArgumentException $exception) {

            // Re-throw if the driver wasn't recognized and isn't a fully-qualified (and existing) class name.
            if (!class_exists($driver)) {
                throw $exception;
            }

            return $this->app->make($driver);
        }
    }

    /**
     * Creates a Mail Transport.
     *
     * @return  transports\Mail
     */
    protected function createMailDriver() : transports\Mail
    {
        return $this->app->make(transports\Mail::class);
    }

    /**
     * Creates a Slack Transport.
     *
     * @return  transports\Slack
     */
    protected function createSlackDriver() : transports\Slack
    {
        return new transports\Slack($this->app->make('config')->get('services.slack'), new \GuzzleHttp\Client);
    }
}


1			<?php namespace nyx\notify;
2
3			// External dependencies
4			use Illuminate\Contracts\Queue\ShouldQueue;
5			use Illuminate\Contracts\Bus\Dispatcher;
6
7			/**
8			* Notification Transport Manager
9			*
10			* @package Nyx\Notify
11			* @version 0.1.0
12			* @author Michal Chojnacki <[email protected]>
13			* @copyright 2012-2017 Nyx Dev Team
14			* @link https://github.com/unyx/nyx
15			* @todo Proper eventing (beforeSend, afterSend, failedSend etc.) hooked into Nyx's Events component.
16			* @todo Add support for core Collections and PHP 7.1 iterables (Notifiable entities).
17			*/
18			class TransportManager extends \Illuminate\Support\Manager implements interfaces\Dispatcher
19			{
20			/**
21			* {@inheritDoc}
22			*/
23			public function send($notifiables, interfaces\Notification $notification)
24			{
25			// In here, as opposed to self::sendNow(), we respect the ShouldQueue interface
26			// and push the Notification onto the queue if it asks us to.
27			if ($notification instanceof ShouldQueue) {
28			$this->enqueue($notifiables, $notification);
29			return;
30			}
31
32			$this->sendNow($notifiables, $notification);
33			}
34
35			/**
36			* {@inheritDoc}
37			*/
38			public function sendNow($notifiables, interfaces\Notification $notification)
39			{
40			if (!is_array($notifiables)) {
41			$notifiables = [$notifiables];
42			}
43
44			foreach ($notifiables as $notifiable) {
45
46			// Iterate over all transports the Notification specifies for the current Notifiable,
47			// then determine whether it shall be sent and send it.
48			foreach ($notification->via($notifiable) as $transport) {
49
50			$transport = $this->driver($transport);
51
52			if (!$this->shouldSend($notifiable, $notification, $transport)) {
53			continue;
54			}
55
56			// All clear at this point - let's dispatch the Notification.
57			$transport->send($notifiable, $notification);
58			}
59			}
60			}
61
62			/**
63			* {@inheritDoc}
64			*/
65			public function getDefaultDriver() : string
66			{
67			return 'mail';
68			}
69
70			/**
71			* Determines whether the Notification should be sent at all, given the context.
72			*
73			* @param interfaces\Notifiable $notifiable The entity being notified.
74			* @param interfaces\Notification $notification The Notification being sent.
75			* @param interfaces\Transport $transport The Transport the Notification should be sent over.
76			* @return bool True when the Notification should be sent, false otherwise.
77			* @todo onBeforeSend event allowing listeners to prevent dispatching.
78			*/
79			protected function shouldSend(interfaces\Notifiable $notifiable, interfaces\Notification $notification, interfaces\Transport $transport) : bool
			0 ignored issues – show Unused Code introduced 2016-11-22 10:35 UTC by Report Bug Copy Issue Report The parameter `$notifiable` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
80			{
81			if (!$transport->supports($notification)) {
82			return false;
83			}
84
85			return true;
86			}
87
88			/**
89			* Enqueues the given Notification.
90			*
91			* @param mixed $notifiables The entities which shall receive the Notification.
92			* @param interfaces\Notification $notification The Notification to enqueue.
93			*/
94			protected function enqueue($notifiables, interfaces\Notification $notification)
95			{
96			// @todo Laravel's ShouldQueue interface doesn't actually cover access to those properties
97			// so we'll need a more robust solution later.
98			$this->app->make(Dispatcher::class)->dispatch(
99			(new jobs\Enqueue($notifiables, $notification))
100			->onConnection($notification->connection)
			0 ignored issues – show Bug introduced 2016-11-22 10:35 UTC by Report Bug Copy Issue Report Accessing `connection` on the interface `nyx\notify\interfaces\Notification` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
101			->onQueue($notification->queue)
			0 ignored issues – show Bug introduced 2016-11-22 10:35 UTC by Report Bug Copy Issue Report Accessing `queue` on the interface `nyx\notify\interfaces\Notification` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
102			->delay($notification->delay)
			0 ignored issues – show Bug introduced 2016-11-22 10:35 UTC by Report Bug Copy Issue Report Accessing `delay` on the interface `nyx\notify\interfaces\Notification` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
103			);
104			}
105
106			/**
107			* {@inheritDoc}
108			*/
109			protected function createDriver($driver)
110			{
111			try {
112			return parent::createDriver($driver);
113			} catch (\InvalidArgumentException $exception) {
114
115			// Re-throw if the driver wasn't recognized and isn't a fully-qualified (and existing) class name.
116			if (!class_exists($driver)) {
117			throw $exception;
118			}
119
120			return $this->app->make($driver);
121			}
122			}
123
124			/**
125			* Creates a Mail Transport.
126			*
127			* @return transports\Mail
128			*/
129			protected function createMailDriver() : transports\Mail
130			{
131			return $this->app->make(transports\Mail::class);
132			}
133
134			/**
135			* Creates a Slack Transport.
136			*
137			* @return transports\Slack
138			*/
139			protected function createSlackDriver() : transports\Slack
140			{
141			return new transports\Slack($this->app->make('config')->get('services.slack'), new \GuzzleHttp\Client);
142			}
143			}
144

unyx / notify

Push — master ( 03348d...edfc47 )

TransportManager::createDriver() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like