Terah\ColourLog\Logger

Complexity

Total Complexity

29

Size/Duplication

Total Lines	302
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

62.89%

Importance

Changes	15
Bugs	0	Features	2

15 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	setLogFile()	0	5	1
A	addColour()	0	19	3
A	colourize()	0	4	1
A	setLogLevel()	0	9	2
A	lock()	0	5	1
A	gzipped()	0	5	1
A	formatter()	0	5	1
A	log()	0	20	4
A	formatMessage()	0	10	3
A	write()	0	13	3
A	getResource()	0	15	3
A	getLastLogEntry()	0	4	1
A	openResource()	0	8	2
A	__destruct()	0	7	2

<?php

namespace Terah\ColourLog;

use Psr\Log\AbstractLogger;
use Psr\Log\LogLevel;

class Logger extends AbstractLogger
{
    /**  @var resource $resource The file handle */
    protected $resource         = null;

    /** @var string $level */
    protected $level            = LogLevel::INFO;

    /** @var bool $closeLocally */
    protected $closeLocally     = false;

    /** @var bool */
    protected $addDate          = true;

    /** @var string  */
    protected $separator        = ' | ';

    /** @var \Closure */
    protected $formatter        = null;

    /** @var string  */
    protected $lastLogEntry     = '';

    /** @var bool|null  */
    protected $gzipFile         = null;

    /** @var bool  */
    protected $useLocking       = false;

    /**
     * @var array $logLevels List of supported levels
     */
    protected $logLevels       = [
        LogLevel::EMERGENCY => [1, 'white', 'red', 'default', 'EMERG'],
        LogLevel::ALERT     => [2, 'white', 'yellow', 'default', 'ALERT'],
        LogLevel::CRITICAL  => [3,'red', 'default', 'bold' , 'CRIT'],
        LogLevel::ERROR     => [4,'red', 'default', 'default', 'ERROR'],
        LogLevel::WARNING   => [5, 'yellow', 'default', 'default', 'WARN'],
        LogLevel::NOTICE    => [6, 'cyan', 'default', 'default', 'NOTE'],
        LogLevel::INFO      => [7, 'green', 'default', 'default', 'INFO'],
        LogLevel::DEBUG     => [8, 'dark_gray', 'default', 'default', 'DEBUG'],
    ];

    /**
     * @var array
     */
    static protected $colours   = [
        'fore' => [
            'black'         => '0;30',
            'dark_gray'     => '1;30',
            'blue'          => '0;34',
            'light_blue'    => '1;34',
            'green'         => '0;32',
            'light_green'   => '1;32',
            'cyan'          => '0;36',
            'light_cyan'    => '1;36',
            'red'           => '0;31',
            'light_red'     => '1;31',
            'purple'        => '0;35',
            'light_purple'  => '1;35',
            'brown'         => '0;33',
            'yellow'        => '1;33',
            'magenta'       => '0;35',
            'light_gray'    => '0;37',
            'white'         => '1;37',
        ],
        'back'  => [
            'default'       => '49',
            'black'         => '40',
            'red'           => '41',
            'green'         => '42',
            'yellow'        => '43',
            'blue'          => '44',
            'magenta'       => '45',
            'cyan'          => '46',
            'light_gray'    => '47',
        ],
        'bold' => [],
    ];

    /**
     * @param mixed  $resource
     * @param string $level
     * @param bool   $useLocking
     * @param bool   $gzipFile
     * @param bool   $addDate
     */
    public function __construct($resource, $level=LogLevel::INFO, $useLocking=false, $gzipFile=false, $addDate=true)
    {
        $this->resource     = $resource;
        $this->setLogLevel($level);
        $this->useLocking   = $useLocking;
        $this->gzipFile     = $gzipFile;
        $this->addDate      = $addDate;
    }

    /**
     * @param $resource
     * @return $this
     */
    public function setLogFile($resource)
    {
        $this->resource     = $resource;
        return $this;
    }

    /**
     * @param      $string
     * @param null $foregroundColor
     * @param null $backgroundColor
     * @param bool $bold
     * @return string
     */
    public static function addColour($string, $foregroundColor=null, $backgroundColor=null, $bold=false)
    {
        // todo: support bold
        unset($bold);
        $coloredString = '';
        // Check if given foreground color found
        if ( isset(static::$colours['fore'][$foregroundColor]) )
        {
            $coloredString .= "\033[" . static::$colours['fore'][$foregroundColor] . "m";
        }
        // Check if given background color found
        if ( isset(static::$colours['back'][$backgroundColor]) )
        {
            $coloredString .= "\033[" . static::$colours['back'][$backgroundColor] . "m";
        }
        // Add string and end coloring
        $coloredString .=  $string . "\033[0m";
        return $coloredString;
    }

    /**
     * @param            $string
     * @param null       $foregroundColor
     * @param null       $backgroundColor
     * @param bool|false $bold
     * @return string
     */
    public function colourize($string, $foregroundColor = null, $backgroundColor = null, $bold=false)
    {
        return static::addColour($string, $foregroundColor, $backgroundColor, $bold);
    }

    /**
     * @param string $level Ignore logging attempts at a level less the $level
     * @return static
     */
    public function setLogLevel($level)
    {
        if ( ! isset($this->logLevels[$level]) )
        {
            throw new \InvalidArgumentException("Log level is invalid");
        }
        $this->level = $this->logLevels[$level][0];
        return $this;
    }

    /**
     * @return $this
     */
    public function lock()
    {
        $this->useLocking = true;
        return $this;
    }

    /**
     * @return $this
     */
    public function gzipped()
    {
        $this->gzipFile = true;
        return $this;
    }

    /**
     * @param callable $fnFormatter
     *
     * @return $this
     */
    public function formatter(callable $fnFormatter)
    {
        $this->formatter = $fnFormatter;

It seems like $fnFormatter of type callable is incompatible with the declared type object<Closure> of property $formatter.

        return $this;
    }

    /**
     * Log messages to resource
     *
     * @param mixed          $level    The level of the log message
     * @param string|object  $message  If an object is passed it must implement __toString()
     * @param array          $context  Placeholders to be substituted in the message
     *
     * @return static
     */
    public function log($level, $message, array $context = [])
    {
        $level = isset($this->logLevels[$level]) ? $level : LogLevel::INFO;
        list($logLevel, $fore, $back, $style) = $this->logLevels[$level];
        if ( $logLevel > $this->level )
        {
            return $this;
        }
        if ( is_callable($this->formatter) )
        {
            $message = $this->formatter->__invoke($this->logLevels[$level][4], $message, $context);
        }
        else
        {
            $message = $this->formatMessage($level, $message, $context);
        }
        $this->lastLogEntry = $message;
        $this->write($this->colourize($message, $fore, $back, $style) . PHP_EOL);
        return $this;
    }

    /**
     * @param       $level
     * @param       $message
     * @param array $context
     * @return string
     */
    protected function formatMessage($level, $message, array $context = [])
    {
        # Handle objects implementing __toString
        $message            = (string) $message;
        $message            .= empty($context) ? '' : PHP_EOL . json_encode($context, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES);
        $data               = $this->addDate ? ['date' => date('Y-m-d H:i:s')] : [];
        $data['level']      = strtoupper(str_pad($this->logLevels[$level][4], 5, ' ', STR_PAD_RIGHT));
        $data['message']    = $message;
        return implode($this->separator, $data);
    }

    /**
     * Write the content to the stream
     *
     * @param  string $content
     */
    public function write($content)
    {
        $resource = $this->getResource();
        if ( $this->useLocking )
        {
            flock($resource, LOCK_EX);
        }
        gzwrite($resource, $content);
        if ( $this->useLocking )
        {
            flock($resource, LOCK_UN);
        }
    }

    /**
     * @return mixed|resource
     * @throws \Exception
     */
    protected function getResource()
    {
        if ( is_resource($this->resource) )
        {
            return $this->resource;
        }
        $fileName = $this->resource;
        $this->closeLocally = true;
        $this->resource = $this->openResource();
        if ( ! is_resource($this->resource) )
        {
            throw new \Exception("The resource ({$fileName}) could not be opened");
        }
        return $this->resource;
    }

    /**
     * @return string
     */
    public function getLastLogEntry()
    {
        return $this->lastLogEntry;
    }

    /**
     * @return resource
     */
    protected function openResource()
    {
        if ( $this->gzipFile )
        {
            return gzopen($this->resource, 'a');
        }
        return fopen($this->resource, 'a');
    }

    public function __destruct()
    {
        if ($this->closeLocally)
        {
            gzclose($this->getResource());
        }
    }
}