comparison vendor/symfony/phpunit-bridge/DeprecationErrorHandler.php @ 17:129ea1e6d783

Update, including to Drupal core 8.6.10

      * - use "weak" to hide the deprecation report but keep a global count;
      * - use "weak_vendors" to act as "weak" but only for vendors;
      * - use "/some-regexp/" to stop the test suite whenever a deprecation
      *   message matches the given regular expression;
      * - use a number to define the upper bound of allowed deprecations,
-     *   making the test suite fail whenever more notices are trigerred.
+     *   making the test suite fail whenever more notices are triggered.
      *
      * @param int|string|false $mode The reporting mode, defaults to not allowing any deprecations
      */
     public static function register($mode = 0)
     {

                 return $memoizedMode;
             }
             if (false === $mode) {
                 $mode = getenv('SYMFONY_DEPRECATIONS_HELPER');
             }
-            if (DeprecationErrorHandler::MODE_WEAK !== $mode && DeprecationErrorHandler::MODE_WEAK_VENDORS !== $mode && (!isset($mode[0]) || '/' !== $mode[0])) {
+            if (self::MODE_DISABLED !== $mode
+                && self::MODE_WEAK !== $mode
+                && self::MODE_WEAK_VENDORS !== $mode
+                && (!isset($mode[0]) || '/' !== $mode[0])
+            ) {
                 $mode = preg_match('/^[1-9][0-9]*$/', $mode) ? (int) $mode : 0;
             }
 
             return $memoizedMode = $mode;
         };

             static $vendors;
             if (null === $vendors) {
                 foreach (get_declared_classes() as $class) {
                     if ('C' === $class[0] && 0 === strpos($class, 'ComposerAutoloaderInit')) {
                         $r = new \ReflectionClass($class);
-                        $v = dirname(dirname($r->getFileName()));
+                        $v = \dirname(\dirname($r->getFileName()));
                         if (file_exists($v.'/composer/installed.json')) {
                             $vendors[] = $v;
                         }
                     }
                 }

             $realPath = realpath($path);
             if (false === $realPath && '-' !== $path && 'Standard input code' !== $path) {
                 return true;
             }
             foreach ($vendors as $vendor) {
-                if (0 === strpos($realPath, $vendor) && false !== strpbrk(substr($realPath, strlen($vendor), 1), '/'.DIRECTORY_SEPARATOR)) {
+                if (0 === strpos($realPath, $vendor) && false !== strpbrk(substr($realPath, \strlen($vendor), 1), '/'.\DIRECTORY_SEPARATOR)) {
                     return true;
                 }
             }
 
             return false;

             'other' => array(),
             'remaining vendor' => array(),
         );
         $deprecationHandler = function ($type, $msg, $file, $line, $context = array()) use (&$deprecations, $getMode, $UtilPrefix, $inVendors) {
             $mode = $getMode();
-            if ((E_USER_DEPRECATED !== $type && E_DEPRECATED !== $type) || DeprecationErrorHandler::MODE_DISABLED === $mode) {
+            if ((E_USER_DEPRECATED !== $type && E_DEPRECATED !== $type) || self::MODE_DISABLED === $mode) {
                 $ErrorHandler = $UtilPrefix.'ErrorHandler';
 
                 return $ErrorHandler::handleError($type, $msg, $file, $line, $context);
             }
 
-            $trace = debug_backtrace(true);
+            $trace = debug_backtrace();
             $group = 'other';
-            $isVendor = DeprecationErrorHandler::MODE_WEAK_VENDORS === $mode && $inVendors($file);
-
-            $i = count($trace);
+            $isVendor = self::MODE_WEAK_VENDORS === $mode && $inVendors($file);
+
+            $i = \count($trace);
             while (1 < $i && (!isset($trace[--$i]['class']) || ('ReflectionMethod' === $trace[$i]['class'] || 0 === strpos($trace[$i]['class'], 'PHPUnit_') || 0 === strpos($trace[$i]['class'], 'PHPUnit\\')))) {
                 // No-op
             }
 
             if (isset($trace[$i]['object']) || isset($trace[$i]['class'])) {

                     $method = $parsedMsg['method'];
                     // If the deprecation has been triggered via
                     // \Symfony\Bridge\PhpUnit\Legacy\SymfonyTestsListenerTrait::endTest()
                     // then we need to use the serialized information to determine
                     // if the error has been triggered from vendor code.
-                    $isVendor = DeprecationErrorHandler::MODE_WEAK_VENDORS === $mode && isset($parsedMsg['triggering_file']) && $inVendors($parsedMsg['triggering_file']);
+                    $isVendor = self::MODE_WEAK_VENDORS === $mode && isset($parsedMsg['triggering_file']) && $inVendors($parsedMsg['triggering_file']);
                 } else {
-                    $class = isset($trace[$i]['object']) ? get_class($trace[$i]['object']) : $trace[$i]['class'];
+                    $class = isset($trace[$i]['object']) ? \get_class($trace[$i]['object']) : $trace[$i]['class'];
                     $method = $trace[$i]['function'];
                 }
 
                 $Test = $UtilPrefix.'Test';
 

                     $group = 'unsilenced';
                 } elseif (0 === strpos($method, 'testLegacy')
                     || 0 === strpos($method, 'provideLegacy')
                     || 0 === strpos($method, 'getLegacy')
                     || strpos($class, '\Legacy')
-                    || in_array('legacy', $Test::getGroups($class, $method), true)
+                    || \in_array('legacy', $Test::getGroups($class, $method), true)
                 ) {
                     $group = 'legacy';
                 } elseif ($isVendor) {
                     $group = 'remaining vendor';
                 } else {

 
                 if (isset($mode[0]) && '/' === $mode[0] && preg_match($mode, $msg)) {
                     $e = new \Exception($msg);
                     $r = new \ReflectionProperty($e, 'trace');
                     $r->setAccessible(true);
-                    $r->setValue($e, array_slice($trace, 1, $i));
+                    $r->setValue($e, \array_slice($trace, 1, $i));
 
                     echo "\n".ucfirst($group).' deprecation triggered by '.$class.'::'.$method.':';
                     echo "\n".$msg;
                     echo "\nStack trace:";
-                    echo "\n".str_replace(' '.getcwd().DIRECTORY_SEPARATOR, ' ', $e->getTraceAsString());
+                    echo "\n".str_replace(' '.getcwd().\DIRECTORY_SEPARATOR, ' ', $e->getTraceAsString());
                     echo "\n";
 
                     exit(1);
                 }
-                if ('legacy' !== $group && DeprecationErrorHandler::MODE_WEAK !== $mode) {
+                if ('legacy' !== $group && self::MODE_WEAK !== $mode) {
                     $ref = &$deprecations[$group][$msg]['count'];
                     ++$ref;
                     $ref = &$deprecations[$group][$msg][$class.'::'.$method];
                     ++$ref;
                 }
-            } elseif (DeprecationErrorHandler::MODE_WEAK !== $mode) {
+            } elseif (self::MODE_WEAK !== $mode) {
                 $ref = &$deprecations[$group][$msg]['count'];
                 ++$ref;
             }
             ++$deprecations[$group.'Count'];
         };

                     return;
                 }
                 $currErrorHandler = set_error_handler('var_dump');
                 restore_error_handler();
 
-                if (DeprecationErrorHandler::MODE_WEAK === $mode) {
+                if (self::MODE_WEAK === $mode) {
                     $colorize = function ($str) { return $str; };
                 }
                 if ($currErrorHandler !== $deprecationHandler) {
                     echo "\n", $colorize('THE ERROR HANDLER HAS CHANGED!', true), "\n";
                 }

                 $cmp = function ($a, $b) {
                     return $b['count'] - $a['count'];
                 };
 
                 $groups = array('unsilenced', 'remaining');
-                if (DeprecationErrorHandler::MODE_WEAK_VENDORS === $mode) {
+                if (self::MODE_WEAK_VENDORS === $mode) {
                     $groups[] = 'remaining vendor';
                 }
                 array_push($groups, 'legacy', 'other');
 
                 $displayDeprecations = function ($deprecations) use ($colorize, $cmp, $groups) {

                 };
 
                 $displayDeprecations($deprecations);
 
                 // store failing status
-                $isFailing = DeprecationErrorHandler::MODE_WEAK !== $mode && $mode < $deprecations['unsilencedCount'] + $deprecations['remainingCount'] + $deprecations['otherCount'];
+                $isFailing = self::MODE_WEAK !== $mode && $mode < $deprecations['unsilencedCount'] + $deprecations['remainingCount'] + $deprecations['otherCount'];
 
                 // reset deprecations array
                 foreach ($deprecations as $group => $arrayOrInt) {
-                    $deprecations[$group] = is_int($arrayOrInt) ? 0 : array();
+                    $deprecations[$group] = \is_int($arrayOrInt) ? 0 : array();
                 }
 
                 register_shutdown_function(function () use (&$deprecations, $isFailing, $displayDeprecations, $mode) {
                     foreach ($deprecations as $group => $arrayOrInt) {
-                        if (0 < (is_int($arrayOrInt) ? $arrayOrInt : count($arrayOrInt))) {
+                        if (0 < (\is_int($arrayOrInt) ? $arrayOrInt : \count($arrayOrInt))) {
                             echo "Shutdown-time deprecations:\n";
                             break;
                         }
                     }
                     $displayDeprecations($deprecations);
-                    if ($isFailing || DeprecationErrorHandler::MODE_WEAK !== $mode && $mode < $deprecations['unsilencedCount'] + $deprecations['remainingCount'] + $deprecations['otherCount']) {
+                    if ($isFailing || self::MODE_WEAK !== $mode && $mode < $deprecations['unsilencedCount'] + $deprecations['remainingCount'] + $deprecations['otherCount']) {
                         exit(1);
                     }
                 });
             });
         }

      *
      * @return bool
      */
     private static function hasColorSupport()
     {
-        if (!defined('STDOUT')) {
+        if (!\defined('STDOUT')) {
             return false;
         }
 
-        if (DIRECTORY_SEPARATOR === '\\') {
-            return (function_exists('sapi_windows_vt100_support')
+        if ('Hyper' === getenv('TERM_PROGRAM')) {
+            return true;
+        }
+
+        if (\DIRECTORY_SEPARATOR === '\\') {
+            return (\function_exists('sapi_windows_vt100_support')
                 && sapi_windows_vt100_support(STDOUT))
                 || false !== getenv('ANSICON')
                 || 'ON' === getenv('ConEmuANSI')
                 || 'xterm' === getenv('TERM');
         }
 
-        if (function_exists('stream_isatty')) {
+        if (\function_exists('stream_isatty')) {
             return stream_isatty(STDOUT);
         }
 
-        if (function_exists('posix_isatty')) {
+        if (\function_exists('posix_isatty')) {
             return posix_isatty(STDOUT);
         }
 
         $stat = fstat(STDOUT);
         // Check if formatted mode is S_IFCHR