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

Completed

Push — master ( 5802ed...900bc8 )

by Hong

created 2016-07-20 12:08 UTC

ExtendedLoggerTrait::isValidHandler() A

↳ Parent: ExtendedLoggerTrait

Complexity

Conditions	3
Paths	2

Size

Total Lines	10
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

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

<?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;
use Phossa2\Logger\Handler\HandlerInterface;

/**
 * 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) {
            ($data['data'])($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) {
            // stopped ?
            if ($logEntry->isPropagationStopped()) {
                break;
            }

            // run handler
            ($data['data'])($logEntry);
        }

        return $this;
    }

    /**
     * Get all matching handlers/processors with channel name globbing
     *
     * @param  string $type
     * @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;
    }

    /**
     * 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			use Phossa2\Logger\Handler\HandlerInterface;
23
24			/**
25			* ExtendedLoggerTrait
26			*
27			* @package Phossa2\Logger
28			* @author Hong Zhang <[email protected]>
29			* @see interface
30			* @version 2.0.0
31			* @since 2.0.0 added
32			*/
33			trait ExtendedLoggerTrait
34			{
35			use GlobbingTrait;
36
37			/**
38			* Collection of handler queues
39			*
40			* @var array
41			* @access protected
42			*/
43			protected $handlers = [];
44
45			/**
46			* Collection of processor queues
47			*
48			* @var array
49			* @access protected
50			*/
51			protected $processors = [];
52
53			/**
54			* channel name
55			*
56			* @var string
57			* @access protected
58			*/
59			protected $channel = 'LOGGER';
60
61			/**
62			* marker for set channel
63			*
64			* @var bool
65			* @access protected
66			*/
67			protected $channel_set = false;
68
69			/**
70			* Set channel for this log
71			*
72			* @param string $channel
73			* @return $this
74			* @access protected
75			*/
76			protected function setChannel(/# string / $channel)
77			{
78			$this->channel_set = true;
79			$this->channel = strtoupper($channel);
80			return $this;
81			}
82
83			/**
84			* Get logger channel
85			*
86			* @return string
87			* @access protected
88			*/
89			protected function getChannel()/# : string /
90			{
91			return $this->channel;
92			}
93
94			/**
95			* Add callable to the $type queue
96			*
97			* @param string $type 'handlers' or 'processors'
98			* @param callable $callable
99			* @param string $channel
100			* @param int $priority -100 - +100
101			* @return $this
102			* @access protected
103			*/
104			protected function addCallable(
105			/# string / $type,
106			callable $callable,
107			/# string / $channel,
108			/# int / $priority
109			) {
110			// use current $logger channel
111			if (empty($channel)) {
112			$channel = $this->getChannel();
113			}
114
115			$q = &$this->$type;
116			if (!isset($q[$channel])) {
117			$q[$channel] = new PriorityQueue();
118			}
119
120			/* @var PriorityQueue $queue */
121			$queue = $q[$channel];
122			$queue->insert($callable, $priority);
123
124			return $this;
125			}
126
127			/**
128			* Remove callable for $type
129			*
130			* @param string $type
131			* @param callable $callable
132			* @param string $channel
133			* @return $this
134			* @access protected
135			*/
136			protected function removeCallable(
137			/# string / $type,
138			callable $callable,
139			/# string / $channel
140			) {
141			$channels = $channel ? (array) $channel : $this->getAllChannels($type);
142
143			$q = &$this->$type;
144			foreach ($channels as $c) {
145			/* @var PriorityQueue $queue */
146			if (isset($q[$c])) {
147			$queue = $q[$c];
148			$queue->remove($callable);
149			}
150			}
151			return $this;
152			}
153
154			/**
155			* Get all the channels for handlers or processors
156			*
157			* @param string $type 'handlers' or 'processors'
158			* @return array
159			* @access protected
160			*/
161			protected function getAllChannels(/# string / $type)/# : array /
162			{
163			return array_keys($this->$type);
164			}
165
166			/**
167			* Execute related processors on the log entry
168			*
169			* @param LogEntryInterface $logEntry
170			* @return $this
171			* @access protected
172			*/
173			protected function runProcessors(LogEntryInterface $logEntry)
174			{
175			// get related processors
176			$queue = $this->getCallables('processors', $logEntry->getChannel());
177
178			// loop thru these processors
179			foreach($queue as $data) {
180			($data['data'])($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			// stopped ?
201			if ($logEntry->isPropagationStopped()) {
202			break;
203			}
204
205			// run handler
206			($data['data'])($logEntry);
207			}
208
209			return $this;
210			}
211
212			/**
213			* Get all matching handlers/processors with channel name globbing
214			*
215			* @param string $type
216			* @param string $channel
217			* @return PriorityQueue
218			* @access protected
219			*/
220			protected function getCallables(
221			/# string / $type,
222			/# string / $channel
223			)/# : PriorityQueue / {
224
225			// name globbing with all channels
226			$matchedChannels = $this->globbingNames(
227			$channel, $this->getAllChannels($type)
228			);
229
230			// type queues
231			$q = &$this->$type;
232
233			// merge queues
234			$queue = new PriorityQueue();
235			foreach ($matchedChannels as $c) {
236			$queue = $queue->combine($q[$c]);
237			}
238
239			return $queue;
240			}
241
242			/**
243			* Check if channel is set with $logger($channel)
244			*
245			* @throws RuntimeException
246			* @access protected
247			*/
248			protected function isChannelSet()
249			{
250			if (!$this->channel_set) {
251			throw new RuntimeException(
252			Message::get(Message::LOG_CHANNEL_NOTSET),
253			Message::LOG_CHANNEL_NOTSET
254			);
255			}
256			}
257
258			/**
259			* Mark channel is unset
260			*
261			* @access protected
262			*/
263			protected function unsetChannel()
264			{
265			$this->channel_set = false;
266			}
267			}
268

phossa2 / logger

GitHub Access Token became invalid

Push — master ( 5802ed...900bc8 )

ExtendedLoggerTrait::isValidHandler() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like