DomainEventPublisher - Code Metrics - cubiche/event-publisher - Measure and Improve Code Quality continuously with Scrutinizer

DomainEventPublisher A
last analyzed 2017-08-23 11:07 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	90
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
wmc	10
lcom	1
cbo	1
dl	0
loc	90
rs	10
c	1
b	0
f	1

9 Methods

Rating	Name	Size	Complexity
A	instance()	10	2
A	set()	4	1
A	eventBus()	4	1
A	publish()	4	1
A	subscribe()	4	1
A	dispatch()	4	1
A	addSubscriber()	4	1
A	setEventBus()	4	1
A	getEventBus()	4	1

<?php

/**
 * This file is part of the Cubiche package.
 *
 * Copyright (c) Cubiche
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Cubiche\Domain\EventPublisher;

use Cubiche\Core\EventBus\Event\EventBus;

/**
 * DomainEventPublisher class.
 *
 * @author Ivannis Suárez Jerez <[email protected]>
 */
class DomainEventPublisher
{
    /**
     * @var DomainEventPublisher
     */
    private static $instance = null;

    /**
     * @var EventBus
     */
    protected $eventBus;

    /**
     * @return DomainEventPublisher
     */
    private static function instance()
    {
        if (static::$instance === null) {
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
            static::$instance = new static();
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}

            static::$instance->setEventBus(EventBus::create());
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
        }

        return static::$instance;
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
    }

    /**
     * @param EventBus $eventBus
     */
    public static function set(EventBus $eventBus)
    {
        static::instance()->setEventBus($eventBus);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
    }

    /**
     * @return EventBus $eventBus
     */
    public static function eventBus()
    {
        return static::instance()->getEventBus();
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
    }

    /**
     * @param DomainEventInterface $event
     */
    public static function publish(DomainEventInterface $event)
    {
        static::instance()->dispatch($event);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
    }

    /**
     * @param DomainEventSubscriberInterface $subscriber
     */
    public static function subscribe(DomainEventSubscriberInterface $subscriber)
    {
        static::instance()->addSubscriber($subscriber);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
    }

    /**
     * @param DomainEventInterface $event
     */
    protected function dispatch(DomainEventInterface $event)
    {
        $this->eventBus->dispatch($event);
    }

    /**
     * @param DomainEventSubscriberInterface $subscriber
     */
    protected function addSubscriber(DomainEventSubscriberInterface $subscriber)
    {
        $this->eventBus->addSubscriber($subscriber);
    }

    /**
     * @param EventBus $eventBus
     */
    protected function setEventBus(EventBus $eventBus)
    {
        $this->eventBus = $eventBus;
    }

    /**
     * @return EventBus
     */
    protected function getEventBus()
    {
        return $this->eventBus;
    }
}


1			<?php
2
3			/**
4			* This file is part of the Cubiche package.
5			*
6			* Copyright (c) Cubiche
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			namespace Cubiche\Domain\EventPublisher;
13
14			use Cubiche\Core\EventBus\Event\EventBus;
15
16			/**
17			* DomainEventPublisher class.
18			*
19			* @author Ivannis Suárez Jerez <[email protected]>
20			*/
21			class DomainEventPublisher
22			{
23			/**
24			* @var DomainEventPublisher
25			*/
26			private static $instance = null;
27
28			/**
29			* @var EventBus
30			*/
31			protected $eventBus;
32
33			/**
34			* @return DomainEventPublisher
35			*/
36			private static function instance()
37			{
38			if (static::$instance === null) {
			0 ignored issues – show Bug introduced 2016-10-18 09:52 UTC by Report Bug Copy Issue Report Since `$instance` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$instance` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
39			static::$instance = new static();
			0 ignored issues – show Bug introduced 2016-10-18 09:52 UTC by Report Bug Copy Issue Report Since `$instance` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$instance` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
40
41			static::$instance->setEventBus(EventBus::create());
			0 ignored issues – show Bug introduced 2016-10-18 09:52 UTC by Report Bug Copy Issue Report Since `$instance` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$instance` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
42			}
43
44			return static::$instance;
			0 ignored issues – show Bug introduced 2016-10-18 09:52 UTC by Report Bug Copy Issue Report Since `$instance` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$instance` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
45			}
46
47			/**
48			* @param EventBus $eventBus
49			*/
50			public static function set(EventBus $eventBus)
51			{
52			static::instance()->setEventBus($eventBus);
			0 ignored issues – show Bug introduced 2016-10-18 09:52 UTC by Report Bug Copy Issue Report Since `instance()` is declared private, calling it with `static` will lead to errors in possible sub-classes. You can either use `self`, or increase the visibility of `instance()` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static function getTemperature() { return "3422 °C"; } public static function getSomeVariable() { return static::getTemperature(); } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { private static function getTemperature() { return "-182 °C"; } } print YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class YourClass { private static function getTemperature() { return "3422 °C"; } public static function getSomeVariable() { return self::getTemperature(); } } Loading history...
53			}
54
55			/**
56			* @return EventBus $eventBus
57			*/
58			public static function eventBus()
59			{
60			return static::instance()->getEventBus();
			0 ignored issues – show Bug introduced 2016-10-18 09:52 UTC by Report Bug Copy Issue Report Since `instance()` is declared private, calling it with `static` will lead to errors in possible sub-classes. You can either use `self`, or increase the visibility of `instance()` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static function getTemperature() { return "3422 °C"; } public static function getSomeVariable() { return static::getTemperature(); } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { private static function getTemperature() { return "-182 °C"; } } print YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class YourClass { private static function getTemperature() { return "3422 °C"; } public static function getSomeVariable() { return self::getTemperature(); } } Loading history...
61			}
62
63			/**
64			* @param DomainEventInterface $event
65			*/
66			public static function publish(DomainEventInterface $event)
67			{
68			static::instance()->dispatch($event);
			0 ignored issues – show Bug introduced 2016-10-18 09:52 UTC by Report Bug Copy Issue Report Since `instance()` is declared private, calling it with `static` will lead to errors in possible sub-classes. You can either use `self`, or increase the visibility of `instance()` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static function getTemperature() { return "3422 °C"; } public static function getSomeVariable() { return static::getTemperature(); } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { private static function getTemperature() { return "-182 °C"; } } print YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class YourClass { private static function getTemperature() { return "3422 °C"; } public static function getSomeVariable() { return self::getTemperature(); } } Loading history...
69			}
70
71			/**
72			* @param DomainEventSubscriberInterface $subscriber
73			*/
74			public static function subscribe(DomainEventSubscriberInterface $subscriber)
75			{
76			static::instance()->addSubscriber($subscriber);
			0 ignored issues – show Bug introduced 2016-10-18 09:52 UTC by Report Bug Copy Issue Report Since `instance()` is declared private, calling it with `static` will lead to errors in possible sub-classes. You can either use `self`, or increase the visibility of `instance()` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static function getTemperature() { return "3422 °C"; } public static function getSomeVariable() { return static::getTemperature(); } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { private static function getTemperature() { return "-182 °C"; } } print YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class YourClass { private static function getTemperature() { return "3422 °C"; } public static function getSomeVariable() { return self::getTemperature(); } } Loading history...
77			}
78
79			/**
80			* @param DomainEventInterface $event
81			*/
82			protected function dispatch(DomainEventInterface $event)
83			{
84			$this->eventBus->dispatch($event);
85			}
86
87			/**
88			* @param DomainEventSubscriberInterface $subscriber
89			*/
90			protected function addSubscriber(DomainEventSubscriberInterface $subscriber)
91			{
92			$this->eventBus->addSubscriber($subscriber);
93			}
94
95			/**
96			* @param EventBus $eventBus
97			*/
98			protected function setEventBus(EventBus $eventBus)
99			{
100			$this->eventBus = $eventBus;
101			}
102
103			/**
104			* @return EventBus
105			*/
106			protected function getEventBus()
107			{
108			return $this->eventBus;
109			}
110			}
111

cubiche / event-publisher

DomainEventPublisher A last analyzed 2017-08-23 11:07 UTC

Complexity

Size/Duplication

Coupling/Cohesion

Importance

9 Methods

Duplication Side-by-Side

Filter issues like

DomainEventPublisher A
last analyzed 2017-08-23 11:07 UTC