TechDivision\Import\Loggers\Handlers\HandlerWrapper

Complexity

Total Complexity

11

Size/Duplication

Total Lines	163
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

0%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	1
A	reset()	0	19	3
A	isHandling()	0	4	1
A	handle()	0	4	1
A	handleBatch()	0	4	1
A	getFormatter()	0	4	1
A	pushProcessor()	0	5	1
A	popProcessor()	0	5	1
A	setFormatter()	0	5	1

<?php

/**
 * TechDivision\Import\Loggers\Handlers\HandlerWrapper
 *
 * NOTICE OF LICENSE
 *
 * This source file is subject to the Open Software License (OSL 3.0)
 * that is available through the world-wide-web at this URL:
 * http://opensource.org/licenses/osl-3.0.php
 *
 * PHP version 5
 *
 * @author    Tim Wagner <t.wagner@techdivision.com>
 * @copyright 2019 TechDivision GmbH <info@techdivision.com>
 * @license   http://opensource.org/licenses/osl-3.0.php Open Software License (OSL 3.0)
 * @link      https://github.com/techdivision/import
 * @link      http://www.techdivision.com
 */

namespace TechDivision\Import\Loggers\Handlers;

use Monolog\Handler\HandlerInterface;
use Monolog\Formatter\FormatterInterface;
use TechDivision\Import\Loggers\HandlerFactoryInterface;
use TechDivision\Import\Configuration\Logger\HandlerConfigurationInterface;

/**
 * A wrapper implementation for log handlers that adds a reset() method that allows to reset
 * log handlers e. g. in case the target directory changes during the import process.
 *
 * @author    Tim Wagner <t.wagner@techdivision.com>
 * @copyright 2019 TechDivision GmbH <info@techdivision.com>
 * @license   http://opensource.org/licenses/osl-3.0.php Open Software License (OSL 3.0)
 * @link      https://github.com/techdivision/import
 * @link      http://www.techdivision.com
 */
class HandlerWrapper implements ResetAwareHandlerInterface
{

    /**
     * The wrapped handler instance.
     *
     * @var \Monolog\Handler\HandlerInterface
     */
    protected $handler;

    /**
     * The handler factory instance.
     *
     * @var \TechDivision\Import\Loggers\HandlerFactoryInterface
     */
    protected $handlerFactory;

    /**
     * The handler configuration instance.
     *
     * @var \TechDivision\Import\Configuration\Logger\HandlerConfigurationInterface
     */
    protected $handlerConfiguration;

    /**
     * Initializes the wrapper with the handler instance.
     *
     * @param \TechDivision\Import\Loggers\HandlerFactoryInterface                    $handlerFactory       The handler factory instance
     * @param \TechDivision\Import\Configuration\Logger\HandlerConfigurationInterface $handlerConfiguration The handler configuration instance
     */
    public function __construct(HandlerFactoryInterface $handlerFactory, HandlerConfigurationInterface $handlerConfiguration)
    {

        // initialize the handler factory and the configuration
        $this->handlerFactory = $handlerFactory;
        $this->handlerConfiguration = $handlerConfiguration;

        // initialze the wrapper
        $this->reset();
    }

    /**
     * Reset's the handler instance.
     *
     * @return void
     */
    public function reset()
    {

        // initialize the variable for the old formatter instance
        $oldFormatter = null;

        // try to preserve the old formatter instance
        if ($this->handler instanceof HandlerInterface) {
            $oldFormatter = $this->handler->getFormatter();
        }

        // create a new handler instance
        $this->handler = $this->handlerFactory->factory($this->handlerConfiguration);

        // set the old formatter instance, if available
        if ($oldFormatter instanceof FormatterInterface) {
            $this->handler->setFormatter($oldFormatter);
        }
    }

    /**
     * Checks whether the given record will be handled by this handler.
     *
     * This is mostly done for performance reasons, to avoid calling processors for nothing.
     *
     * Handlers should still check the record levels within handle(), returning false in isHandling()
     * is no guarantee that handle() will not be called, and isHandling() might not be called
     * for a given record.
     *
     * @param array $record Partial log record containing only a level key
     *
     * @return boolean TRUE if the handler has to handle the record, FALSE otherwise
     */
    public function isHandling(array $record)
    {
        return $this->handler->isHandling($record);
    }

    /**
     * Handles a record.
     *
     * All records may be passed to this method, and the handler should discard
     * those that it does not want to handle.
     *
     * The return value of this function controls the bubbling process of the handler stack.
     * Unless the bubbling is interrupted (by returning true), the Logger class will keep on
     * calling further handlers in the stack with a given log record.
     *
     * @param  array $record The record to handle
     *
     * @return boolean TRUE means that this handler handled the record, and that bubbling is not permitted.
     *                 FALSE means the record was either not processed or that this handler allows bubbling.
     */
    public function handle(array $record)
    {
        return $this->handler->handle($record);
    }

    /**
     * Handles a set of records at once.
     *
     * @param array $records The records to handle (an array of record arrays)
     *
     * @return void
     */
    public function handleBatch(array $records)
    {
        $this->handler->handleBatch($records);
    }

    /**
     * Return's the handlers formatter instance.
     *
     * @return \Monolog\Formatter\FormatterInterface The formatter instance
     */
    public function getFormatter()
    {
        return $this->handler->getFormatter();
    }

    /**
     * Adds a processor in the stack.
     *
     * @param callable $callback The processor to add
     *
     * @return \TechDivision\Import\Loggers\Handlers\HandlerWrapper The handler instance
     */
    public function pushProcessor($callback)
    {
        $this->handler->pushProcessor($callback);
        return $this;
    }

    /**
     * Removes the processor on top of the stack and returns it.
     *
     * @return \TechDivision\Import\Loggers\Handlers\HandlerWrapper The handler instance
     */
    public function popProcessor()
    {
        $this->handler->popProcessor();
        return $this;
    }

    /**
     * Sets the handler's formatter instance.
     *
     * @param  \Monolog\Formatter\FormatterInterface $formatter The formatter instance
     *
     * @return \TechDivision\Import\Loggers\Handlers\HandlerWrapper The handler instance
     */
    public function setFormatter(FormatterInterface $formatter)
    {
        $this->handler->setFormatter($formatter);
        return $this;
    }
}