ExtendedLoggerTrait::addCallable() - Code Metrics - Inspection of "almost done" - phossa2/logger - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( d53dcd...f61343 )

by Hong

created 2016-07-20 06:18 UTC

ExtendedLoggerTrait::addCallable() A

↳ Parent: ExtendedLoggerTrait

Complexity

Conditions	3
Paths	4

Size

Total Lines	22
Code Lines	13

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	22
rs	9.2
cc	3
eloc	13
nc	4
nop	4

<?php
/**
 * Phossa Project
 *
 * PHP version 5.4
 *
 * @category  Library
 * @package   Phossa2\Logger
 * @copyright Copyright (c) 2016 phossa.com
 * @license   http://mit-license.org/ MIT License
 * @link      http://www.phossa.com/
 */
/*# declare(strict_types=1); */

namespace Phossa2\Logger\Traits;

use Phossa2\Logger\Message\Message;
use Phossa2\Shared\Queue\PriorityQueue;
use Phossa2\Shared\Globbing\GlobbingTrait;
use Phossa2\Logger\Entry\LogEntryInterface;
use Phossa2\Logger\Exception\RuntimeException;

/**
 * ExtendedLoggerTrait
 *
 * @package Phossa2\Logger
 * @author  Hong Zhang <[email protected]>
 * @see     interface
 * @version 2.0.0
 * @since   2.0.0 added
 */
trait ExtendedLoggerTrait
{
    use GlobbingTrait;

    /**
     * Collection of handler queues
     *
     * @var    array
     * @access protected
     */
    protected $handlers = [];

    /**
     * Collection of processor queues
     *
     * @var    array
     * @access protected
     */
    protected $processors = [];

    /**
     * channel name
     *
     * @var    string
     * @access protected
     */
    protected $channel = 'LOGGER';

    /**
     * marker for set channel
     *
     * @var    bool
     * @access protected
     */
    protected $channel_set = false;

    /**
     * Set channel for this log
     *
     * @param  string $channel
     * @return $this
     * @access protected
     */
    protected function setChannel(/*# string */ $channel)
    {
        $this->channel_set = true;
        $this->channel = strtoupper($channel);
        return $this;
    }

    /**
     * Get logger channel
     *
     * @return string
     * @access protected
     */
    protected function getChannel()/*# : string */
    {
        return $this->channel;
    }

    /**
     * Add callable to the $type queue
     *
     * @param  string $type 'handlers' or 'processors'
     * @param  callable $callable
     * @param  string $channel
     * @param  int $priority  -100 - +100
     * @return $this
     * @access protected
     */
    protected function addCallable(
        /*# string */ $type,
        callable $callable,
        /*# string */ $channel,
        /*# int */ $priority
    ) {
        // use current $logger channel
        if (empty($channel)) {
            $channel = $this->getChannel();
        }

        $q = &$this->$type;
        if (!isset($q[$channel])) {
            $q[$channel] = new PriorityQueue();
        }

        /* @var PriorityQueue $queue */
        $queue = $q[$channel];
        $queue->insert($callable, $priority);

        return $this;
    }

    /**
     * Remove callable for $type
     *
     * @param  string $type
     * @param  callable $callable
     * @param  string $channel
     * @return $this
     * @access protected
     */
    protected function removeCallable(
        /*# string */ $type,
        callable $callable,
        /*# string */ $channel
    ) {
        $channels = $channel ? (array) $channel : $this->getAllChannels($type);

        $q = &$this->$type;
        foreach ($channels as $c) {
            /* @var PriorityQueue $queue */
            if (isset($q[$c])) {
                $queue = $q[$c];
                $queue->remove($callable);
            }
        }
        return $this;
    }

    /**
     * Get all the channels for handlers or processors
     *
     * @param  string $type 'handlers' or 'processors'
     * @return array
     * @access protected
     */
    protected function getAllChannels(/*# string */ $type)/*# : array */
    {
        return array_keys($this->$type);
    }

    /**
     * Execute related processors on the log entry
     *
     * @param  LogEntryInterface $logEntry
     * @return $this
     * @access protected
     */
    protected function runProcessors(LogEntryInterface $logEntry)
    {
        // get related processors
        $queue = $this->getCallables('processors', $logEntry->getChannel());

        // loop thru these processors
        foreach($queue as $data) {
            $processor = $data['data'];
            $processor($logEntry);
        }

        return $this;
    }

    /**
     * Execute related handlers on the log entry
     *
     * @param  LogEntryInterface $logEntry
     * @return $this
     * @access protected
     */
    protected function runHandlers(LogEntryInterface $logEntry)
    {
        // get related handlers
        $queue = $this->getCallables('handlers', $logEntry->getChannel());

        // loop thru these handlers
        foreach($queue as $data) {
            if ($logEntry->isPropagationStopped()) {
                break;
            }

            $handler = $data['data'];

            if ($this->isValidHandler($logEntry, $handler)) {
                $handler($logEntry);
            }
        }

        return $this;
    }

    /**
     * Get all matching handlers/processors with channel name globbing
     *
     * @param  string  $channel
     * @return PriorityQueue
     * @access protected
     */
    protected function getCallables(
        /*# string */ $type,
        /*# string */ $channel
    )/*# : PriorityQueue */ {

        // name globbing with all channels
        $matchedChannels = $this->globbingNames(
            $channel, $this->getAllChannels($type)
        );

        // type queues
        $q = &$this->$type;

        // merge queues
        $queue = new PriorityQueue();
        foreach ($matchedChannels as $c) {
            $queue = $queue->combine($q[$c]);
        }

        return $queue;
    }

    /**
     * Is this handler can do this log ?
     *
     * @param  LogEntryInterface $logEntry
     * @param  callable $handler
     * @return bool
     * @access protected
     */
    protected function isValidHandler(
        LogEntryInterface $logEntry,
        callable $handler
    )/*# : bool */ {
        if (is_a($handler, 'Phossa2\\Logger\\Handler\\HandlerInterface')) {
            return $handler->isHandling($logEntry->getLevel());

        } else {
            return true;
        }
    }

    /**
     * Check if channel is set with $logger($channel)
     *
     * @throws RuntimeException
     * @access protected
     */
    protected function isChannelSet()
    {
        if (!$this->channel_set) {
            throw new RuntimeException(
                Message::get(Message::LOG_CHANNEL_NOTSET),
                Message::LOG_CHANNEL_NOTSET
            );
        }
    }

    /**
     * Mark channel is unset
     *
     * @access protected
     */
    protected function unsetChannel()
    {
        $this->channel_set = false;
    }
}


1			<?php
2			/**
3			* Phossa Project
4			*
5			* PHP version 5.4
6			*
7			* @category Library
8			* @package Phossa2\Logger
9			* @copyright Copyright (c) 2016 phossa.com
10			* @license http://mit-license.org/ MIT License
11			* @link http://www.phossa.com/
12			*/
13			/# declare(strict_types=1); /
14
15			namespace Phossa2\Logger\Traits;
16
17			use Phossa2\Logger\Message\Message;
18			use Phossa2\Shared\Queue\PriorityQueue;
19			use Phossa2\Shared\Globbing\GlobbingTrait;
20			use Phossa2\Logger\Entry\LogEntryInterface;
21			use Phossa2\Logger\Exception\RuntimeException;
22
23			/**
24			* ExtendedLoggerTrait
25			*
26			* @package Phossa2\Logger
27			* @author Hong Zhang <[email protected]>
28			* @see interface
29			* @version 2.0.0
30			* @since 2.0.0 added
31			*/
32			trait ExtendedLoggerTrait
33			{
34			use GlobbingTrait;
35
36			/**
37			* Collection of handler queues
38			*
39			* @var array
40			* @access protected
41			*/
42			protected $handlers = [];
43
44			/**
45			* Collection of processor queues
46			*
47			* @var array
48			* @access protected
49			*/
50			protected $processors = [];
51
52			/**
53			* channel name
54			*
55			* @var string
56			* @access protected
57			*/
58			protected $channel = 'LOGGER';
59
60			/**
61			* marker for set channel
62			*
63			* @var bool
64			* @access protected
65			*/
66			protected $channel_set = false;
67
68			/**
69			* Set channel for this log
70			*
71			* @param string $channel
72			* @return $this
73			* @access protected
74			*/
75			protected function setChannel(/# string / $channel)
76			{
77			$this->channel_set = true;
78			$this->channel = strtoupper($channel);
79			return $this;
80			}
81
82			/**
83			* Get logger channel
84			*
85			* @return string
86			* @access protected
87			*/
88			protected function getChannel()/# : string /
89			{
90			return $this->channel;
91			}
92
93			/**
94			* Add callable to the $type queue
95			*
96			* @param string $type 'handlers' or 'processors'
97			* @param callable $callable
98			* @param string $channel
99			* @param int $priority -100 - +100
100			* @return $this
101			* @access protected
102			*/
103			protected function addCallable(
104			/# string / $type,
105			callable $callable,
106			/# string / $channel,
107			/# int / $priority
108			) {
109			// use current $logger channel
110			if (empty($channel)) {
111			$channel = $this->getChannel();
112			}
113
114			$q = &$this->$type;
115			if (!isset($q[$channel])) {
116			$q[$channel] = new PriorityQueue();
117			}
118
119			/* @var PriorityQueue $queue */
120			$queue = $q[$channel];
121			$queue->insert($callable, $priority);
122
123			return $this;
124			}
125
126			/**
127			* Remove callable for $type
128			*
129			* @param string $type
130			* @param callable $callable
131			* @param string $channel
132			* @return $this
133			* @access protected
134			*/
135			protected function removeCallable(
136			/# string / $type,
137			callable $callable,
138			/# string / $channel
139			) {
140			$channels = $channel ? (array) $channel : $this->getAllChannels($type);
141
142			$q = &$this->$type;
143			foreach ($channels as $c) {
144			/* @var PriorityQueue $queue */
145			if (isset($q[$c])) {
146			$queue = $q[$c];
147			$queue->remove($callable);
148			}
149			}
150			return $this;
151			}
152
153			/**
154			* Get all the channels for handlers or processors
155			*
156			* @param string $type 'handlers' or 'processors'
157			* @return array
158			* @access protected
159			*/
160			protected function getAllChannels(/# string / $type)/# : array /
161			{
162			return array_keys($this->$type);
163			}
164
165			/**
166			* Execute related processors on the log entry
167			*
168			* @param LogEntryInterface $logEntry
169			* @return $this
170			* @access protected
171			*/
172			protected function runProcessors(LogEntryInterface $logEntry)
173			{
174			// get related processors
175			$queue = $this->getCallables('processors', $logEntry->getChannel());
176
177			// loop thru these processors
178			foreach($queue as $data) {
179			$processor = $data['data'];
180			$processor($logEntry);
181			}
182
183			return $this;
184			}
185
186			/**
187			* Execute related handlers on the log entry
188			*
189			* @param LogEntryInterface $logEntry
190			* @return $this
191			* @access protected
192			*/
193			protected function runHandlers(LogEntryInterface $logEntry)
194			{
195			// get related handlers
196			$queue = $this->getCallables('handlers', $logEntry->getChannel());
197
198			// loop thru these handlers
199			foreach($queue as $data) {
200			if ($logEntry->isPropagationStopped()) {
201			break;
202			}
203
204			$handler = $data['data'];
205
206			if ($this->isValidHandler($logEntry, $handler)) {
207			$handler($logEntry);
208			}
209			}
210
211			return $this;
212			}
213
214			/**
215			* Get all matching handlers/processors with channel name globbing
216			*
217			* @param string $channel
218			* @return PriorityQueue
219			* @access protected
220			*/
221			protected function getCallables(
222			/# string / $type,
223			/# string / $channel
224			)/# : PriorityQueue / {
225
226			// name globbing with all channels
227			$matchedChannels = $this->globbingNames(
228			$channel, $this->getAllChannels($type)
229			);
230
231			// type queues
232			$q = &$this->$type;
233
234			// merge queues
235			$queue = new PriorityQueue();
236			foreach ($matchedChannels as $c) {
237			$queue = $queue->combine($q[$c]);
238			}
239
240			return $queue;
241			}
242
243			/**
244			* Is this handler can do this log ?
245			*
246			* @param LogEntryInterface $logEntry
247			* @param callable $handler
248			* @return bool
249			* @access protected
250			*/
251			protected function isValidHandler(
252			LogEntryInterface $logEntry,
253			callable $handler
254			)/# : bool / {
255			if (is_a($handler, 'Phossa2\\Logger\\Handler\\HandlerInterface')) {
256			return $handler->isHandling($logEntry->getLevel());
			0 ignored issues – show Bug introduced 2016-07-20 06:20 UTC by Report Bug Copy Issue Report The method `isHandling` cannot be called on `$handler` (of type `callable`). Methods can only be called on objects. This check looks for methods being called on variables that have been inferred to never be objects. Loading history...
257			} else {
258			return true;
259			}
260			}
261
262			/**
263			* Check if channel is set with $logger($channel)
264			*
265			* @throws RuntimeException
266			* @access protected
267			*/
268			protected function isChannelSet()
269			{
270			if (!$this->channel_set) {
271			throw new RuntimeException(
272			Message::get(Message::LOG_CHANNEL_NOTSET),
273			Message::LOG_CHANNEL_NOTSET
274			);
275			}
276			}
277
278			/**
279			* Mark channel is unset
280			*
281			* @access protected
282			*/
283			protected function unsetChannel()
284			{
285			$this->channel_set = false;
286			}
287			}
288

phossa2 / logger

GitHub Access Token became invalid

Push — master ( d53dcd...f61343 )

ExtendedLoggerTrait::addCallable() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like