Plop.php

<?php
/*
    This file is part of Plop, a simple logging library for PHP.

    Copyright © 2010-2014 François Poirotte

    Plop is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Plop is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Plop.  If not, see <http://www.gnu.org/licenses/>.
*/

namespace Plop;

const NOTSET    =  0;

const DEBUG     = 10;

const INFO      = 20;

const NOTICE    = 30;

const WARNING   = 40;

const WARN      = \Plop\WARNING;

const ERROR     = 50;

const CRITICAL  = 60;

const ALERT     = 70;

const EMERGENCY = 80;


class Plop extends \Plop\IndirectLoggerAbstract implements \ArrayAccess, \Countable
{
    const BASIC_FORMAT  = '[%(levelname)s] %(message)s';

    protected static $instance = null;

    protected $loggers;
    protected $levelNames;
    protected $created;

    protected function __construct()
    {
        $this->loggers      = array();
        $rootLogger         = new \Plop\Logger(null, null);
        $basicHandler       = new \Plop\Handler\Stream(fopen('php://stderr', 'w'));
        $this[]             = $rootLogger;
        $handlers           = $rootLogger->getHandlers();
        $formatter          = new \Plop\Formatter(self::BASIC_FORMAT);
        $handlers[]         = $basicHandler->setFormatter($formatter);
        $this->created      = microtime(true);
        $this->levelNames   = array(
            \Plop\NOTSET    => 'NOTSET',
            \Plop\DEBUG     => 'DEBUG',
            \Plop\INFO      => 'INFO',
            \Plop\NOTICE    => 'NOTICE',
            \Plop\WARNING   => 'WARNING',
            \Plop\ERROR     => 'ERROR',
            \Plop\CRITICAL  => 'CRITICAL',
            \Plop\ALERT     => 'ALERT',
            \Plop\EMERGENCY => 'EMERGENCY',
        );
    }

    public function __clone()
    {
        throw new \Plop\Exception('Cloning this class is forbidden');
    }

    public static function & getInstance()
    {
        if (static::$instance === null) {
            $c = __CLASS__;
            static::$instance = new $c();
        }
        return static::$instance;
    }

    public function getCreationDate()
    {
        return $this->created;
    }

    public function addLevelName($levelName, $levelValue)
    {
        if (!is_int($levelValue)) {
            throw new \Plop\Exception('Invalid level value');
        }
        if (!is_string($levelName)) {
            throw new \Plop\Exception('Invalid level name');
        }
        $this->levelNames[$levelValue] = $levelName;
        return $this;
    }

    public function getLevelName($level)
    {
        if (!is_int($level)) {
            throw new \Plop\Exception('Invalid level value');
        }
        if (!isset($this->levelNames[$level])) {
            return "Level $level";
        }
        return $this->levelNames[$level];
    }

    public function getLevelValue($levelName)
    {
        if (!is_string($levelName)) {
            throw new \Plop\Exception('Invalid level name');
        }
        $key = array_search($levelName, $this->levelNames, true);
        return (int) $key; // false is silently converted to 0.
    }

    public function getLogger($namespace = '', $class = '', $method = '')
    {
        // Remove any potential namespace from the class and method names.
        $class = substr($class, strrpos('\\' . $class, '\\'));
        $method = substr($method, strrpos('\\' . $method, '\\'));

        // If __METHOD__ was used instead of __FUNCTION__, it also contains
        // the class name as a prefix. We get rid of that too.
        $method = substr((string) $method, strrpos(':' . $method, ':'));

        return $this["$method:$class:$namespace"];
    }

    public function addLogger(\Plop\LoggerInterface $logger /*, ... */)
    {
        $loggers = func_get_args();
        foreach ($loggers as $logger) {
            if (!($logger instanceof \Plop\LoggerInterface)) {
                throw new \Plop\Exception('Not a logger');
            }
        }

        foreach ($loggers as $logger) {
            $this[] = $logger;
        }
        return $this;
    }

    protected static function getLoggerId(\Plop\LoggerInterface $logger)
    {
        $func   = $logger->getMethod();
        $cls    = $logger->getClass();
        $ns     = $logger->getNamespace();
        return "$func:$cls:$ns";
    }

    public function count()
    {
        return count($this->loggers);
    }

    public function offsetSet($offset, $logger)
    {
        if (!($logger instanceof \Plop\LoggerInterface)) {
            throw new \Plop\Exception('Invalid logger');
        }

        $id = static::getLoggerId($logger);
        if (is_string($offset)) {
            if ($offset != $id) {
                throw new \Plop\Exception('Identifier mismatch');
            }
        }

        $this->loggers[$id] = $logger;
    }

    public function offsetGet($offset)
    {
        if (!is_string($offset)) {
            throw new \Plop\Exception('Invalid identifier');
        }

        $parts = explode(':', $offset, 3);
        if (count($parts) != 3) {
            throw new \Plop\Exception('Invalid identifier');
        }
        list($method, $class, $ns) = $parts;

        $len = -strlen('\\');
        while (substr($ns, $len) == '\\') {
            $ns = (string) substr($ns, 0, $len);
        }

        // Namespace, class and method/function match.
        if (isset($this->loggers["$method:$class:$ns"])) {
            return $this->loggers["$method:$class:$ns"];
        }

        // Namespace and class match.
        if ($class != "" && isset($this->loggers[":$class:$ns"])) {
            return $this->loggers[":$class:$ns"];
        }

        // Namespace match.
        $parts = explode('\\', $ns);
        while (count($parts)) {
            $offset = implode('\\', $parts);
            if ($offset == '') {
                break;
            }

            if (isset($this->loggers["::$offset"])) {
                return $this->loggers["::$offset"];
            }
            array_pop($parts);
        }

        // Root logger.
        return $this->loggers['::'];
    }

    public function offsetExists($offset)
    {
        if ($offset instanceof \Plop\LoggerInterface) {
            $offset = static::getLoggerId($offset);
        }
        if (!is_string($offset)) {
            throw new \Plop\Exception('Invalid identifier');
        }
        return isset($this->loggers[$offset]);
    }

    public function offsetUnset($offset)
    {
        if ($offset instanceof \Plop\LoggerInterface) {
            $offset = static::getLoggerId($offset);
        }
        if ($offset == "::") {
            throw new \Plop\Exception('The root logger cannot be unset');
        }
        unset($this->loggers[$offset]);
    }

    protected function getIndirectLogger()
    {
        $caller = static::findCaller();
        return $this["{$caller['func']}:{$caller['cls']}:{$caller['ns']}"];
    }

    public static function findCaller()
    {
        if (version_compare(PHP_VERSION, '5.3.6', '>=')) {
            $bt = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS);
        } else {
            $bt = debug_backtrace(false);
        }

        $max    = count($bt);
        $ns     = __NAMESPACE__ . '\\';
        $len    = strlen($ns);
        $ns2    = $ns . 'Tests' . '\\';
        for ($i = 0; $i < $max; $i++) {
            if (isset($bt[$i]['function']) &&
                !strncmp($ns, $bt[$i]['function'], $len) &&
                strncmp($ns2, $bt[$i]['function'], $len + 6)) {
                // Skip frames until we get out of Plop's code.
                continue;
            }

            if (isset($bt[$i]['class']) &&
                !strncmp($ns, $bt[$i]['class'], $len) &&
                strncmp($ns2, $bt[$i]['class'], $len + 6)) {
                // Skip frames until we get out of Plop's code.
                continue;
            }

            break;
        }

        if ($i == $max) {
            return array(
                'ns'    => null,
                'file'  => null,
                'line'  => 0,
                'func'  => null,
                'cls'   => null,
            );
        }

        $ns     = '';
        $func   = isset($bt[$i]['function']) ? $bt[$i]['function'] : null;
        $cls    = isset($bt[$i]['class']) ? $bt[$i]['class'] : null;
        $file   = isset($bt[$i - 1]['file']) ? $bt[$i - 1]['file'] : null;
        $line   = isset($bt[$i - 1]['line']) ? $bt[$i - 1]['line'] : 0;

        if (($pos = strrpos($func, '\\')) !== false) {
            $ns     = substr($func, 0, $pos);
            $func   = substr($func, $pos + 1);
        } elseif (($pos = strrpos($cls, '\\')) !== false) {
            $ns     = substr($cls, 0, $pos);
            $cls    = substr($cls, $pos + 1);
        }

        return array(
            'ns'    => $ns,
            'file'  => $file,
            'line'  => $line,
            'func'  => $func,
            'cls'   => $cls,
        );
    }
}