UnderstandMonolog\Encoder\ExceptionEncoder

Complexity

Total Complexity

22

Size/Duplication

Total Lines	153
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Importance

Changes	2
Bugs	0	Features	1

6 Methods

Rating	Name	Duplication	Size	Complexity
A	exceptionToArray()	0	13	1
A	stackTraceToArray()	0	21	3
A	getStackTraceLine()	0	7	2
A	getStackTraceFile()	0	7	2
A	stackTraceCallToString()	0	17	4
D	stackTraceArgsToArray()	0	43	10

<?php namespace UnderstandMonolog\Encoder;

class ExceptionEncoder
{

    /**
     * Serialize exception object
     *
     * @param \Exception $exception
     * @return type
     */
    public function exceptionToArray(\Exception $exception)
    {
        $trace = $exception->getTrace();
        $className = get_class($exception);

        return [
            'class' => $className,
            'code' => $exception->getCode(),
            'file' => $exception->getFile(),
            'line' => $exception->getLine(),
            'stack' => $this->stackTraceToArray($trace)
        ];
    }

    /**
     * Serialize stack trace to array
     *
     * @param array $stackTrace
     * @return array
     */
    public function stackTraceToArray(array $stackTrace)
    {
        $stack = [];

        foreach ($stackTrace as $trace)
        {
            $type = $this->stackTraceCallToString($trace);
            $args = $this->stackTraceArgsToArray($trace);

            $stack[] = [
                'class' => isset($trace['class']) ? $trace['class'] : '',
                'function' => $trace['function'],
                'args' => $args,
                'type' => $type,
                'file' => $this->getStackTraceFile($trace),
                'line' => $this->getStackTraceLine($trace)
            ];
        }

        return $stack;
    }

    /**
     * Return stack trace line number
     *
     * @param array $trace
     * @return mixed
     */
    protected function getStackTraceLine(array $trace)
    {
        if (isset($trace['line']))
        {
            return $trace['line'];
        }
    }

    /**
     * Return stack trace file
     *
     * @param array $trace
     * @return mixed
     */
    protected function getStackTraceFile(array $trace)
    {
        if (isset($trace['file']))
        {
            return $trace['file'];
        }
    }

    /**
     * Return call type
     *
     * @param array $trace
     * @return string
     */
    protected function stackTraceCallToString(array $trace)
    {
        if (! isset($trace['type']))
        {
            return 'function';
        }

        if ($trace['type'] == '::')
        {
            return 'static';
        }

        if ($trace['type'] == '->')
        {
            return 'method';
        }
    }

    /**
     * Serialize stack trace function arguments
     *
     * @param array $trace
     * @return array
     */
    protected function stackTraceArgsToArray(array $trace)
    {
        $params = [];

        if (! isset($trace['args']))
        {
            return $params;
        }

        foreach ($trace['args'] as $arg)
        {
            if (is_array($arg))
            {
                $params[] = 'array(' . count($arg) . ')';
            }
            else if (is_object($arg))
            {
                $params[] = get_class($arg);
            }
            else if (is_string($arg))
            {
                $params[] = 'string(' . $arg . ')';
            }
            else if (is_int($arg))
            {
                $params[] = 'int(' . $arg . ')';
            }
            else if (is_float($arg))
            {
                $params[] = 'float(' . $arg . ')';
            }
            else if (is_bool($arg))
            {
                $params[] = 'bool(' . ($arg ? 'true' : 'false') . ')';
            }
            else
            {
                $params[] = (string) $arg;
            }
        }

        return $params;
    }
}