Issues in ToArray.php - All Issues - Inspection of "Merge branch 'master' of https://github.com/antoni..." - antonioribeiro/health - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — master ( 6cb9f0...7deac3 )

by Antonio Carlos

created 2018-09-12 19:45 UTC

src/Support/Traits/ToArray.php (7 issues)

Labels

Severity

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

<?php

namespace PragmaRX\Health\Support\Traits;

use Illuminate\Contracts\Support\Arrayable;

trait ToArray
{
    private static $__depth;

    private static $__maxDepth;

    /**
     * Reset depth and convert object to array.
     *
     * @param $subject
     * @param int $maxDepth
     * @return array|null
     */
    public function __toArray($subject, $maxDepth = 3)
    {
        static::$__depth = 0;
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}

        static::$__maxDepth = $maxDepth;
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}

        return $this->___toArray($subject, $maxDepth);

    }

    /**
     * Convert object to array.
     *
     * @param $subject
     * @return array|null
     */
    public function ___toArray($subject)
    {
        $callback = $this->__getToArrayCallBack();

        return $callback($subject);
    }

    /**
     * Generate a callback to transform object to array.
     *
     * @return \Closure
     */
    public function __getToArrayCallBack()
    {
        return function ($subject) {
            static::$__depth++;
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}

            if ($subject instanceof Arrayable) {
                $subject = $subject->toArray();
            }

            if (is_object($subject)) {
                $subject = get_object_vars($subject);
            }

            if (is_array($subject)) {
                if (static::$__depth <= static::$__maxDepth) {
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
                    $subject = array_map(
                        $this->__getToArrayCallBack(),
                        $subject
                    );
                } else {
                    $subject = null;
                }
            }

            static::$__depth--;
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}

            return $subject;
        };
    }
}


1			<?php
2
3			namespace PragmaRX\Health\Support\Traits;
4
5			use Illuminate\Contracts\Support\Arrayable;
6
7			trait ToArray
8			{
9			private static $__depth;
10
11			private static $__maxDepth;
12
13			/**
14			* Reset depth and convert object to array.
15			*
16			* @param $subject
17			* @param int $maxDepth
18			* @return array\|null
19			*/
20			public function __toArray($subject, $maxDepth = 3)
21			{
22			static::$__depth = 0;
			0 ignored issues – show Bug introduced 2018-09-09 22:51 UTC by Report Bug Copy Issue Report Show Similar Issues like this Since `$__depth` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$__depth` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
23
24			static::$__maxDepth = $maxDepth;
			0 ignored issues – show Bug introduced 2018-09-09 22:51 UTC by Report Bug Copy Issue Report Show Similar Issues like this Since `$__maxDepth` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$__maxDepth` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
25
26			return $this->___toArray($subject, $maxDepth);
			0 ignored issues – show Unused Code introduced 2018-09-09 22:51 UTC by Report Bug Copy Issue Report Show Similar Issues like this The call to `ToArray::___toArray()` has too many arguments starting with `$maxDepth`. This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the `@ignore` PhpDoc annotation to the duplicate definition and it will be ignored. Loading history...
27			}
28
29			/**
30			* Convert object to array.
31			*
32			* @param $subject
33			* @return array\|null
34			*/
35			public function ___toArray($subject)
36			{
37			$callback = $this->__getToArrayCallBack();
38
39			return $callback($subject);
40			}
41
42			/**
43			* Generate a callback to transform object to array.
44			*
45			* @return \Closure
46			*/
47			public function __getToArrayCallBack()
48			{
49			return function ($subject) {
50			static::$__depth++;
			0 ignored issues – show Bug introduced 2018-09-09 22:51 UTC by Report Bug Copy Issue Report Show Similar Issues like this Since `$__depth` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$__depth` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
51
52			if ($subject instanceof Arrayable) {
53			$subject = $subject->toArray();
54			}
55
56			if (is_object($subject)) {
57			$subject = get_object_vars($subject);
58			}
59
60			if (is_array($subject)) {
61			if (static::$__depth <= static::$__maxDepth) {
			0 ignored issues – show Bug introduced 2018-09-09 22:51 UTC by Report Bug Copy Issue Report Show Similar Issues like this Since `$__depth` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$__depth` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history... Bug introduced 2018-09-09 22:51 UTC by Report Bug Copy Issue Report Show Similar Issues like this Since `$__maxDepth` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$__maxDepth` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
62			$subject = array_map(
63			$this->__getToArrayCallBack(),
64			$subject
65			);
66			} else {
67			$subject = null;
68			}
69			}
70
71			static::$__depth--;
			0 ignored issues – show Bug introduced 2018-09-09 22:51 UTC by Report Bug Copy Issue Report Show Similar Issues like this Since `$__depth` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$__depth` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
72
73			return $subject;
74			};
75			}
76			}
77

antonioribeiro / health

Push — master ( 6cb9f0...7deac3 )

src/Support/Traits/ToArray.php (7 issues)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like