ExceptionEncoder::stackTraceArgsToArray() - Code Metrics - understand/understand-monolog - Measure and Improve Code Quality continuously with Scrutinizer

ExceptionEncoder::stackTraceArgsToArray() D
last analyzed 2016-01-13 17:07 UTC

↳ Parent: ExceptionEncoder

Complexity

Conditions	10
Paths	10

Size

Total Lines	43
Code Lines	20

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
c	1
b	0
f	1
dl	0
loc	43
rs	4.8197
cc	10
eloc	20
nc	10
nop	1

How to fix Complexity

<?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;
    }
}


1			<?php namespace UnderstandMonolog\Encoder;
2
3			class ExceptionEncoder
4			{
5
6			/**
7			* Serialize exception object
8			*
9			* @param \Exception $exception
10			* @return type
11			*/
12			public function exceptionToArray(\Exception $exception)
13			{
14			$trace = $exception->getTrace();
15			$className = get_class($exception);
16
17			return [
18			'class' => $className,
19			'code' => $exception->getCode(),
20			'file' => $exception->getFile(),
21			'line' => $exception->getLine(),
22			'stack' => $this->stackTraceToArray($trace)
23			];
24			}
25
26			/**
27			* Serialize stack trace to array
28			*
29			* @param array $stackTrace
30			* @return array
31			*/
32			public function stackTraceToArray(array $stackTrace)
33			{
34			$stack = [];
35
36			foreach ($stackTrace as $trace)
37			{
38			$type = $this->stackTraceCallToString($trace);
39			$args = $this->stackTraceArgsToArray($trace);
40
41			$stack[] = [
42			'class' => isset($trace['class']) ? $trace['class'] : '',
43			'function' => $trace['function'],
44			'args' => $args,
45			'type' => $type,
46			'file' => $this->getStackTraceFile($trace),
47			'line' => $this->getStackTraceLine($trace)
48			];
49			}
50
51			return $stack;
52			}
53
54			/**
55			* Return stack trace line number
56			*
57			* @param array $trace
58			* @return mixed
59			*/
60			protected function getStackTraceLine(array $trace)
61			{
62			if (isset($trace['line']))
63			{
64			return $trace['line'];
65			}
66			}
67
68			/**
69			* Return stack trace file
70			*
71			* @param array $trace
72			* @return mixed
73			*/
74			protected function getStackTraceFile(array $trace)
75			{
76			if (isset($trace['file']))
77			{
78			return $trace['file'];
79			}
80			}
81
82			/**
83			* Return call type
84			*
85			* @param array $trace
86			* @return string
87			*/
88			protected function stackTraceCallToString(array $trace)
89			{
90			if (! isset($trace['type']))
91			{
92			return 'function';
93			}
94
95			if ($trace['type'] == '::')
96			{
97			return 'static';
98			}
99
100			if ($trace['type'] == '->')
101			{
102			return 'method';
103			}
104			}
105
106			/**
107			* Serialize stack trace function arguments
108			*
109			* @param array $trace
110			* @return array
111			*/
112			protected function stackTraceArgsToArray(array $trace)
113			{
114			$params = [];
115
116			if (! isset($trace['args']))
117			{
118			return $params;
119			}
120
121			foreach ($trace['args'] as $arg)
122			{
123			if (is_array($arg))
124			{
125			$params[] = 'array(' . count($arg) . ')';
126			}
127			else if (is_object($arg))
128			{
129			$params[] = get_class($arg);
130			}
131			else if (is_string($arg))
132			{
133			$params[] = 'string(' . $arg . ')';
134			}
135			else if (is_int($arg))
136			{
137			$params[] = 'int(' . $arg . ')';
138			}
139			else if (is_float($arg))
140			{
141			$params[] = 'float(' . $arg . ')';
142			}
143			else if (is_bool($arg))
144			{
145			$params[] = 'bool(' . ($arg ? 'true' : 'false') . ')';
146			}
147			else
148			{
149			$params[] = (string) $arg;
150			}
151			}
152
153			return $params;
154			}
155			}
156

understand / understand-monolog

ExceptionEncoder::stackTraceArgsToArray() D last analyzed 2016-01-13 17:07 UTC

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like

ExceptionEncoder::stackTraceArgsToArray() D
last analyzed 2016-01-13 17:07 UTC