comparison vendor/squizlabs/php_codesniffer/src/Ruleset.php @ 5:12f9dff5fda9 tip

Update to Drupal core 8.7.1

      * An array of sniff objects that are being used to check files.
      *
      * The key is the fully qualified name of the sniff class
      * and the value is the sniff object.
      *
-     * @var array<string, \PHP_CodeSniffer\Sniff>
+     * @var array<string, \PHP_CodeSniffer\Sniffs\Sniff>
      */
     public $sniffs = [];
 
     /**
      * A mapping of sniff codes to fully qualified class names.

      * An array of token types and the sniffs that are listening for them.
      *
      * The key is the token name being listened for and the value
      * is the sniff object.
      *
-     * @var array<int, \PHP_CodeSniffer\Sniff>
+     * @var array<int, \PHP_CodeSniffer\Sniffs\Sniff>
      */
     public $tokenListeners = [];
 
     /**
      * An array of rules from the ruleset.xml file.

                 $standardName = (string) $ruleset['name'];
                 if ($this->name !== '') {
                     $this->name .= ', ';
                 }
 
-                $this->name   .= $standardName;
-                $this->paths[] = $standard;
+                $this->name .= $standardName;
 
                 // Allow autoloading of custom files inside this standard.
                 if (isset($ruleset['namespace']) === true) {
                     $namespace = (string) $ruleset['namespace'];
                 } else {

      * @param string $rulesetPath The path to a ruleset XML file.
      * @param int    $depth       How many nested processing steps we are in. This
      *                            is only used for debug output.
      *
      * @return string[]
-     * @throws RuntimeException If the ruleset path is invalid.
+     * @throws \PHP_CodeSniffer\Exceptions\RuntimeException If the ruleset path is invalid.
      */
     public function processRuleset($rulesetPath, $depth=0)
     {
         $rulesetPath = Util\Common::realpath($rulesetPath);
         if (PHP_CODESNIFFER_VERBOSITY > 1) {
             echo str_repeat("\t", $depth);
             echo 'Processing ruleset '.Util\Common::stripBasepath($rulesetPath, $this->config->basepath).PHP_EOL;
         }
 
-        $ruleset = @simplexml_load_string(file_get_contents($rulesetPath));
+        libxml_use_internal_errors(true);
+        $ruleset = simplexml_load_string(file_get_contents($rulesetPath));
         if ($ruleset === false) {
-            throw new RuntimeException("Ruleset $rulesetPath is not valid");
-        }
+            $errorMsg = "Ruleset $rulesetPath is not valid".PHP_EOL;
+            $errors   = libxml_get_errors();
+            foreach ($errors as $error) {
+                $errorMsg .= '- On line '.$error->line.', column '.$error->column.': '.$error->message;
+            }
+
+            libxml_clear_errors();
+            throw new RuntimeException($errorMsg);
+        }
+
+        libxml_use_internal_errors(false);
 
         $ownSniffs      = [];
         $includedSniffs = [];
         $excludedSniffs = [];
 
+        $this->paths[]       = $rulesetPath;
         $rulesetDir          = dirname($rulesetPath);
         $this->rulesetDirs[] = $rulesetDir;
 
         $sniffDir = $rulesetDir.DIRECTORY_SEPARATOR.'Sniffs';
         if (is_dir($sniffDir) === true) {

                         echo str_repeat("\t", $depth);
                         echo "\t\t=> severity set to 5".PHP_EOL;
                     }
                 } else if (empty($newSniffs) === false) {
                     $newSniff = $newSniffs[0];
-                    if (in_array($newSniff, $ownSniffs) === false) {
+                    if (in_array($newSniff, $ownSniffs, true) === false) {
                         // Including a sniff that hasn't been included higher up, but
                         // only including a single message from it. So turn off all messages in
                         // the sniff, except this one.
                         $this->ruleset[$sniffCode]['severity']            = 0;
                         $this->ruleset[(string) $rule['ref']]['severity'] = 5;

                             echo "\t\t=> severity set to 0".PHP_EOL;
                         }
                     } else {
                         $excludedSniffs = array_merge(
                             $excludedSniffs,
-                            $this->expandRulesetReference($exclude['name'], $rulesetDir, ($depth + 1))
+                            $this->expandRulesetReference((string) $exclude['name'], $rulesetDir, ($depth + 1))
                         );
                     }
                 }//end foreach
             }//end if
 

 
         // Merge our own sniff list with our externally included
         // sniff list, but filter out any excluded sniffs.
         $files = [];
         foreach ($includedSniffs as $sniff) {
-            if (in_array($sniff, $excludedSniffs) === true) {
+            if (in_array($sniff, $excludedSniffs, true) === true) {
                 continue;
             } else {
                 $files[] = Util\Common::realpath($sniff);
             }
         }

      *                           evaluate relative paths.
      * @param int    $depth      How many nested processing steps we are in. This
      *                           is only used for debug output.
      *
      * @return array
-     * @throws RuntimeException If the reference is invalid.
+     * @throws \PHP_CodeSniffer\Exceptions\RuntimeException If the reference is invalid.
      */
     private function expandRulesetReference($ref, $rulesetDir, $depth=0)
     {
         // Ignore internal sniffs codes as they are used to only
         // hide and change internal messages.

             // See if this is a whole standard being referenced.
             $path = Util\Standards::getInstalledStandardPath($ref);
             if (Util\Common::isPharFile($path) === true && strpos($path, 'ruleset.xml') === false) {
                 // If the ruleset exists inside the phar file, use it.
                 if (file_exists($path.DIRECTORY_SEPARATOR.'ruleset.xml') === true) {
-                    $path = $path.DIRECTORY_SEPARATOR.'ruleset.xml';
+                    $path .= DIRECTORY_SEPARATOR.'ruleset.xml';
                 } else {
                     $path = null;
                 }
             }
 

 
 
     /**
      * Processes a rule from a ruleset XML file, overriding built-in defaults.
      *
-     * @param SimpleXMLElement $rule      The rule object from a ruleset XML file.
-     * @param string[]         $newSniffs An array of sniffs that got included by this rule.
-     * @param int              $depth     How many nested processing steps we are in.
-     *                                    This is only used for debug output.
+     * @param \SimpleXMLElement $rule      The rule object from a ruleset XML file.
+     * @param string[]          $newSniffs An array of sniffs that got included by this rule.
+     * @param int               $depth     How many nested processing steps we are in.
+     *                                     This is only used for debug output.
      *
      * @return void
-     * @throws RuntimeException If rule settings are invalid.
+     * @throws \PHP_CodeSniffer\Exceptions\RuntimeException If rule settings are invalid.
      */
     private function processRule($rule, $newSniffs, $depth=0)
     {
         $ref  = (string) $rule['ref'];
         $todo = [$ref];

 
 
     /**
      * Determine if an element should be processed or ignored.
      *
-     * @param SimpleXMLElement $element An object from a ruleset XML file.
+     * @param \SimpleXMLElement $element An object from a ruleset XML file.
      *
      * @return bool
      */
     private function shouldProcessElement($element)
     {

 
     /**
      * Populates the array of PHP_CodeSniffer_Sniff's for this file.
      *
      * @return void
-     * @throws RuntimeException If sniff registration fails.
+     * @throws \PHP_CodeSniffer\Exceptions\RuntimeException If sniff registration fails.
      */
     public function populateTokenListeners()
     {
         // Construct a list of listeners indexed by token being listened for.
         $this->tokenListeners = [];