Understand\UnderstandLaravel5\ExceptionEncoder

Complexity

Total Complexity

54

Size/Duplication

Total Lines	333
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	setStackTraceLimit()	0	4	1
A	setProjectRoot()	0	4	1
A	exceptionToArray()	0	20	4
B	setCurrentStackTrace()	0	24	6
C	getCurrentStackTrace()	0	36	7
C	stackTraceToArray()	0	40	8
B	getCode()	0	36	6
A	getStackTraceLine()	0	7	2
A	getStackTraceFile()	0	7	2
A	stackTraceCallToString()	0	17	4
C	stackTraceArgsToArray()	0	47	11
A	removeProjectRoot()	0	7	2

<?php namespace Understand\UnderstandLaravel5;

use Exception;
use Throwable;
use InvalidArgumentException;
use SplFileObject;

class ExceptionEncoder
{

    /**
     * @var string
     */
    protected $projectRoot;

    /**
     * @var int
     */
    protected $stackTraceLimit = 100;

    /**
     * @param integer $limit
     */
    public function setStackTraceLimit($limit)
    {
        $this->stackTraceLimit = $limit;
    }

    /**
     * @param string $projectRoot
     */
    public function setProjectRoot($projectRoot)
    {
        $this->projectRoot = $projectRoot;
    }

    /**
     * Serialize exception object
     *
     * @param mixed $exception
     * @return array
     */
    public function exceptionToArray($exception)
    {
        if ( ! ($exception instanceof Exception || $exception instanceof Throwable))

The class Throwable does not exist. Is this class maybe located in a folder that is not analyzed, or in a newer version of your dependencies than listed in your composer.lock/composer.json?

        {
            throw new InvalidArgumentException('$exception must be instance of Exception or Throwable');
        }

        $trace = $exception->getTrace();
        $className = get_class($exception);
        $message = $exception->getMessage() ? $exception->getMessage() : $className;

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

    /**
     * @param array $errorLog
     * @return array
     */
    public function setCurrentStackTrace(array $errorLog)
    {
        $level = isset($errorLog['level']) ? $errorLog['level'] : null;
        $stackTrace = $this->getCurrentStackTrace($level);

The call to ExceptionEncoder::getCurrentStackTrace() has too many arguments starting with $level.

        $firstLineSet = false;

        foreach($stackTrace as $trace)
        {
            if ($firstLineSet)
            {
                break;
            }

            $firstLineSet = true;

            $errorLog['class'] = null;
            $errorLog['file'] = isset($trace['file']) ? $trace['file'] : null;
            $errorLog['line'] = isset($trace['line']) ? $trace['line'] : null;
        }

        $errorLog['stack'] = $stackTrace;

        return $errorLog;
    }

    /**
     * @return array
     */
    protected function getCurrentStackTrace()
    {
        $stackTrace = debug_backtrace(DEBUG_BACKTRACE_PROVIDE_OBJECT, $this->stackTraceLimit);
        $vendorExcluded = false;

        foreach($stackTrace as $index => $trace)
        {
            // exclude Understand service provider and helper classes
            if (isset($trace['class']) && strpos($trace['class'], 'Understand\UnderstandLaravel5\\') === 0)
            {
                unset($stackTrace[$index]);
            }

            if ( ! isset($trace['file']))
            {
                $vendorExcluded = true;
            }

            if ($vendorExcluded)
            {
                continue;
            }

            // exclude `vendor` folder until project path reached
            if (strpos($trace['file'], $this->projectRoot . 'vendor' . DIRECTORY_SEPARATOR) === 0)
            {
                unset($stackTrace[$index]);
            }
            else
            {
                $vendorExcluded = true;
            }
        }

        return $this->stackTraceToArray($stackTrace);
    }

    /**
     * Serialize stack trace to array
     *
     * @param array $stackTrace
     * @return array
     */
    public function stackTraceToArray(array $stackTrace, $topFile = null, $topLine = null)
    {
        $stack = [];
        $counter = 0;

        foreach ($stackTrace as $trace)
        {
            // Exception object `getTrace` does not return file and line number for the first line
            // http://php.net/manual/en/exception.gettrace.php#107563
            if (isset($topFile, $topLine) && $topFile && $topLine)
            {
                $trace['file'] = $topFile;
                $trace['line'] = $topLine;

                unset($topFile, $topLine);
            }

            $type = $this->stackTraceCallToString($trace);
            $args = $this->stackTraceArgsToArray($trace);

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

            $counter++;

            if ($counter >= $this->stackTraceLimit)
            {
                break;
            }
        }

        return $stack;
    }

    /**
     * @param $relativePath
     * @param $line
     * @param int $linesAround
     * @return array|void
     */
    public function getCode($relativePath, $line, $linesAround = 6)
    {
        if ( ! $relativePath || ! $line)
        {
            return;
        }

        $filePath = $this->projectRoot . $relativePath;

        try
        {
            $file = new SplFileObject($filePath);
            $file->setMaxLineLen(250);
            $file->seek(PHP_INT_MAX);
            $codeLines = [];

            $from = max(0, $line - $linesAround - 2);
            $to = min($line + $linesAround -1, $file->key() + 1);

            $file->seek($from);

            while ($file->key() < $to && ! $file->eof())
            {
                $file->next();
                // `key()` returns 0 as the first line
                $codeLines[] = [
                    'line' => $file->key() + 1,
                    'code' => rtrim($file->current())
                ];
            }

            return $codeLines;
        }
        catch (\Exception $e)

Consider adding a comment why this CATCH block is empty.

        {}
    }

    /**
     * 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 $this->removeProjectRoot($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 if ($arg instanceof \__PHP_Incomplete_Class)
            {
                $params[] = 'object(__PHP_Incomplete_Class)'; 
            }
            else
            {
                $params[] = gettype($arg);
            }
        }

        return $params;
    }

    /**
     * @param $path
     * @return string
     */
    protected function removeProjectRoot($path)
    {
        if (substr($path, 0, strlen($this->projectRoot)) == $this->projectRoot)
        {
            return substr($path, strlen($this->projectRoot));
        }
    }
}