www.aleph1.co.uk Git - yaffs-website/blob - vendor/composer/semver/src/VersionParser.php

   1 <?php
   2
   3 /*
   4  * This file is part of composer/semver.
   5  *
   6  * (c) Composer <https://github.com/composer>
   7  *
   8  * For the full copyright and license information, please view
   9  * the LICENSE file that was distributed with this source code.
  10  */
  11
  12 namespace Composer\Semver;
  13
  14 use Composer\Semver\Constraint\ConstraintInterface;
  15 use Composer\Semver\Constraint\EmptyConstraint;
  16 use Composer\Semver\Constraint\MultiConstraint;
  17 use Composer\Semver\Constraint\Constraint;
  18
  19 /**
  20  * Version parser.
  21  *
  22  * @author Jordi Boggiano <j.boggiano@seld.be>
  23  */
  24 class VersionParser
  25 {
  26     /**
  27      * Regex to match pre-release data (sort of).
  28      *
  29      * Due to backwards compatibility:
  30      *   - Instead of enforcing hyphen, an underscore, dot or nothing at all are also accepted.
  31      *   - Only stabilities as recognized by Composer are allowed to precede a numerical identifier.
  32      *   - Numerical-only pre-release identifiers are not supported, see tests.
  33      *
  34      *                        |--------------|
  35      * [major].[minor].[patch] -[pre-release] +[build-metadata]
  36      *
  37      * @var string
  38      */
  39     private static $modifierRegex = '[._-]?(?:(stable|beta|b|RC|alpha|a|patch|pl|p)((?:[.-]?\d+)*+)?)?([.-]?dev)?';
  40
  41     /** @var array */
  42     private static $stabilities = array('stable', 'RC', 'beta', 'alpha', 'dev');
  43
  44     /**
  45      * Returns the stability of a version.
  46      *
  47      * @param string $version
  48      *
  49      * @return string
  50      */
  51     public static function parseStability($version)
  52     {
  53         $version = preg_replace('{#.+$}i', '', $version);
  54
  55         if ('dev-' === substr($version, 0, 4) || '-dev' === substr($version, -4)) {
  56             return 'dev';
  57         }
  58
  59         preg_match('{' . self::$modifierRegex . '(?:\+.*)?$}i', strtolower($version), $match);
  60         if (!empty($match[3])) {
  61             return 'dev';
  62         }
  63
  64         if (!empty($match[1])) {
  65             if ('beta' === $match[1] || 'b' === $match[1]) {
  66                 return 'beta';
  67             }
  68             if ('alpha' === $match[1] || 'a' === $match[1]) {
  69                 return 'alpha';
  70             }
  71             if ('rc' === $match[1]) {
  72                 return 'RC';
  73             }
  74         }
  75
  76         return 'stable';
  77     }
  78
  79     /**
  80      * @param string $stability
  81      *
  82      * @return string
  83      */
  84     public static function normalizeStability($stability)
  85     {
  86         $stability = strtolower($stability);
  87
  88         return $stability === 'rc' ? 'RC' : $stability;
  89     }
  90
  91     /**
  92      * Normalizes a version string to be able to perform comparisons on it.
  93      *
  94      * @param string $version
  95      * @param string $fullVersion optional complete version string to give more context
  96      *
  97      * @throws \UnexpectedValueException
  98      *
  99      * @return string
 100      */
 101     public function normalize($version, $fullVersion = null)
 102     {
 103         $version = trim($version);
 104         if (null === $fullVersion) {
 105             $fullVersion = $version;
 106         }
 107
 108         // strip off aliasing
 109         if (preg_match('{^([^,\s]++) ++as ++([^,\s]++)$}', $version, $match)) {
 110             $version = $match[1];
 111         }
 112
 113         // match master-like branches
 114         if (preg_match('{^(?:dev-)?(?:master|trunk|default)$}i', $version)) {
 115             return '9999999-dev';
 116         }
 117
 118         // if requirement is branch-like, use full name
 119         if ('dev-' === strtolower(substr($version, 0, 4))) {
 120             return 'dev-' . substr($version, 4);
 121         }
 122
 123         // strip off build metadata
 124         if (preg_match('{^([^,\s+]++)\+[^\s]++$}', $version, $match)) {
 125             $version = $match[1];
 126         }
 127
 128         // match classical versioning
 129         if (preg_match('{^v?(\d{1,5})(\.\d++)?(\.\d++)?(\.\d++)?' . self::$modifierRegex . '$}i', $version, $matches)) {
 130             $version = $matches[1]
 131                 . (!empty($matches[2]) ? $matches[2] : '.0')
 132                 . (!empty($matches[3]) ? $matches[3] : '.0')
 133                 . (!empty($matches[4]) ? $matches[4] : '.0');
 134             $index = 5;
 135         // match date(time) based versioning
 136         } elseif (preg_match('{^v?(\d{4}(?:[.:-]?\d{2}){1,6}(?:[.:-]?\d{1,3})?)' . self::$modifierRegex . '$}i', $version, $matches)) {
 137             $version = preg_replace('{\D}', '.', $matches[1]);
 138             $index = 2;
 139         }
 140
 141         // add version modifiers if a version was matched
 142         if (isset($index)) {
 143             if (!empty($matches[$index])) {
 144                 if ('stable' === $matches[$index]) {
 145                     return $version;
 146                 }
 147                 $version .= '-' . $this->expandStability($matches[$index]) . (!empty($matches[$index + 1]) ? ltrim($matches[$index + 1], '.-') : '');
 148             }
 149
 150             if (!empty($matches[$index + 2])) {
 151                 $version .= '-dev';
 152             }
 153
 154             return $version;
 155         }
 156
 157         // match dev branches
 158         if (preg_match('{(.*?)[.-]?dev$}i', $version, $match)) {
 159             try {
 160                 return $this->normalizeBranch($match[1]);
 161             } catch (\Exception $e) {
 162             }
 163         }
 164
 165         $extraMessage = '';
 166         if (preg_match('{ +as +' . preg_quote($version) . '$}', $fullVersion)) {
 167             $extraMessage = ' in "' . $fullVersion . '", the alias must be an exact version';
 168         } elseif (preg_match('{^' . preg_quote($version) . ' +as +}', $fullVersion)) {
 169             $extraMessage = ' in "' . $fullVersion . '", the alias source must be an exact version, if it is a branch name you should prefix it with dev-';
 170         }
 171
 172         throw new \UnexpectedValueException('Invalid version string "' . $version . '"' . $extraMessage);
 173     }
 174
 175     /**
 176      * Extract numeric prefix from alias, if it is in numeric format, suitable for version comparison.
 177      *
 178      * @param string $branch Branch name (e.g. 2.1.x-dev)
 179      *
 180      * @return string|false Numeric prefix if present (e.g. 2.1.) or false
 181      */
 182     public function parseNumericAliasPrefix($branch)
 183     {
 184         if (preg_match('{^(?P<version>(\d++\\.)*\d++)(?:\.x)?-dev$}i', $branch, $matches)) {
 185             return $matches['version'] . '.';
 186         }
 187
 188         return false;
 189     }
 190
 191     /**
 192      * Normalizes a branch name to be able to perform comparisons on it.
 193      *
 194      * @param string $name
 195      *
 196      * @return string
 197      */
 198     public function normalizeBranch($name)
 199     {
 200         $name = trim($name);
 201
 202         if (in_array($name, array('master', 'trunk', 'default'))) {
 203             return $this->normalize($name);
 204         }
 205
 206         if (preg_match('{^v?(\d++)(\.(?:\d++|[xX*]))?(\.(?:\d++|[xX*]))?(\.(?:\d++|[xX*]))?$}i', $name, $matches)) {
 207             $version = '';
 208             for ($i = 1; $i < 5; ++$i) {
 209                 $version .= isset($matches[$i]) ? str_replace(array('*', 'X'), 'x', $matches[$i]) : '.x';
 210             }
 211
 212             return str_replace('x', '9999999', $version) . '-dev';
 213         }
 214
 215         return 'dev-' . $name;
 216     }
 217
 218     /**
 219      * Parses a constraint string into MultiConstraint and/or Constraint objects.
 220      *
 221      * @param string $constraints
 222      *
 223      * @return ConstraintInterface
 224      */
 225     public function parseConstraints($constraints)
 226     {
 227         $prettyConstraint = $constraints;
 228
 229         if (preg_match('{^([^,\s]*?)@(' . implode('|', self::$stabilities) . ')$}i', $constraints, $match)) {
 230             $constraints = empty($match[1]) ? '*' : $match[1];
 231         }
 232
 233         if (preg_match('{^(dev-[^,\s@]+?|[^,\s@]+?\.x-dev)#.+$}i', $constraints, $match)) {
 234             $constraints = $match[1];
 235         }
 236
 237         $orConstraints = preg_split('{\s*\|\|?\s*}', trim($constraints));
 238         $orGroups = array();
 239         foreach ($orConstraints as $constraints) {
 240             $andConstraints = preg_split('{(?<!^|as|[=>< ,]) *(?<!-)[, ](?!-) *(?!,|as|$)}', $constraints);
 241             if (count($andConstraints) > 1) {
 242                 $constraintObjects = array();
 243                 foreach ($andConstraints as $constraint) {
 244                     foreach ($this->parseConstraint($constraint) as $parsedConstraint) {
 245                         $constraintObjects[] = $parsedConstraint;
 246                     }
 247                 }
 248             } else {
 249                 $constraintObjects = $this->parseConstraint($andConstraints[0]);
 250             }
 251
 252             if (1 === count($constraintObjects)) {
 253                 $constraint = $constraintObjects[0];
 254             } else {
 255                 $constraint = new MultiConstraint($constraintObjects);
 256             }
 257
 258             $orGroups[] = $constraint;
 259         }
 260
 261         if (1 === count($orGroups)) {
 262             $constraint = $orGroups[0];
 263         } elseif (2 === count($orGroups)
 264             // parse the two OR groups and if they are contiguous we collapse
 265             // them into one constraint
 266             && $orGroups[0] instanceof MultiConstraint
 267             && $orGroups[1] instanceof MultiConstraint
 268             && 2 === count($orGroups[0]->getConstraints())
 269             && 2 === count($orGroups[1]->getConstraints())
 270             && ($a = (string) $orGroups[0])
 271             && substr($a, 0, 3) === '[>=' && (false !== ($posA = strpos($a, '<', 4)))
 272             && ($b = (string) $orGroups[1])
 273             && substr($b, 0, 3) === '[>=' && (false !== ($posB = strpos($b, '<', 4)))
 274             && substr($a, $posA + 2, -1) === substr($b, 4, $posB - 5)
 275         ) {
 276             $constraint = new MultiConstraint(array(
 277                 new Constraint('>=', substr($a, 4, $posA - 5)),
 278                 new Constraint('<', substr($b, $posB + 2, -1)),
 279             ));
 280         } else {
 281             $constraint = new MultiConstraint($orGroups, false);
 282         }
 283
 284         $constraint->setPrettyString($prettyConstraint);
 285
 286         return $constraint;
 287     }
 288
 289     /**
 290      * @param string $constraint
 291      *
 292      * @throws \UnexpectedValueException
 293      *
 294      * @return array
 295      */
 296     private function parseConstraint($constraint)
 297     {
 298         if (preg_match('{^([^,\s]+?)@(' . implode('|', self::$stabilities) . ')$}i', $constraint, $match)) {
 299             $constraint = $match[1];
 300             if ($match[2] !== 'stable') {
 301                 $stabilityModifier = $match[2];
 302             }
 303         }
 304
 305         if (preg_match('{^v?[xX*](\.[xX*])*$}i', $constraint)) {
 306             return array(new EmptyConstraint());
 307         }
 308
 309         $versionRegex = 'v?(\d++)(?:\.(\d++))?(?:\.(\d++))?(?:\.(\d++))?' . self::$modifierRegex . '(?:\+[^\s]+)?';
 310
 311         // Tilde Range
 312         //
 313         // Like wildcard constraints, unsuffixed tilde constraints say that they must be greater than the previous
 314         // version, to ensure that unstable instances of the current version are allowed. However, if a stability
 315         // suffix is added to the constraint, then a >= match on the current version is used instead.
 316         if (preg_match('{^~>?' . $versionRegex . '$}i', $constraint, $matches)) {
 317             if (substr($constraint, 0, 2) === '~>') {
 318                 throw new \UnexpectedValueException(
 319                     'Could not parse version constraint ' . $constraint . ': ' .
 320                     'Invalid operator "~>", you probably meant to use the "~" operator'
 321                 );
 322             }
 323
 324             // Work out which position in the version we are operating at
 325             if (isset($matches[4]) && '' !== $matches[4]) {
 326                 $position = 4;
 327             } elseif (isset($matches[3]) && '' !== $matches[3]) {
 328                 $position = 3;
 329             } elseif (isset($matches[2]) && '' !== $matches[2]) {
 330                 $position = 2;
 331             } else {
 332                 $position = 1;
 333             }
 334
 335             // Calculate the stability suffix
 336             $stabilitySuffix = '';
 337             if (!empty($matches[5])) {
 338                 $stabilitySuffix .= '-' . $this->expandStability($matches[5]) . (!empty($matches[6]) ? $matches[6] : '');
 339             }
 340
 341             if (!empty($matches[7])) {
 342                 $stabilitySuffix .= '-dev';
 343             }
 344
 345             if (!$stabilitySuffix) {
 346                 $stabilitySuffix = '-dev';
 347             }
 348
 349             $lowVersion = $this->manipulateVersionString($matches, $position, 0) . $stabilitySuffix;
 350             $lowerBound = new Constraint('>=', $lowVersion);
 351
 352             // For upper bound, we increment the position of one more significance,
 353             // but highPosition = 0 would be illegal
 354             $highPosition = max(1, $position - 1);
 355             $highVersion = $this->manipulateVersionString($matches, $highPosition, 1) . '-dev';
 356             $upperBound = new Constraint('<', $highVersion);
 357
 358             return array(
 359                 $lowerBound,
 360                 $upperBound,
 361             );
 362         }
 363
 364         // Caret Range
 365         //
 366         // Allows changes that do not modify the left-most non-zero digit in the [major, minor, patch] tuple.
 367         // In other words, this allows patch and minor updates for versions 1.0.0 and above, patch updates for
 368         // versions 0.X >=0.1.0, and no updates for versions 0.0.X
 369         if (preg_match('{^\^' . $versionRegex . '($)}i', $constraint, $matches)) {
 370             // Work out which position in the version we are operating at
 371             if ('0' !== $matches[1] || '' === $matches[2]) {
 372                 $position = 1;
 373             } elseif ('0' !== $matches[2] || '' === $matches[3]) {
 374                 $position = 2;
 375             } else {
 376                 $position = 3;
 377             }
 378
 379             // Calculate the stability suffix
 380             $stabilitySuffix = '';
 381             if (empty($matches[5]) && empty($matches[7])) {
 382                 $stabilitySuffix .= '-dev';
 383             }
 384
 385             $lowVersion = $this->normalize(substr($constraint . $stabilitySuffix, 1));
 386             $lowerBound = new Constraint('>=', $lowVersion);
 387
 388             // For upper bound, we increment the position of one more significance,
 389             // but highPosition = 0 would be illegal
 390             $highVersion = $this->manipulateVersionString($matches, $position, 1) . '-dev';
 391             $upperBound = new Constraint('<', $highVersion);
 392
 393             return array(
 394                 $lowerBound,
 395                 $upperBound,
 396             );
 397         }
 398
 399         // X Range
 400         //
 401         // Any of X, x, or * may be used to "stand in" for one of the numeric values in the [major, minor, patch] tuple.
 402         // A partial version range is treated as an X-Range, so the special character is in fact optional.
 403         if (preg_match('{^v?(\d++)(?:\.(\d++))?(?:\.(\d++))?(?:\.[xX*])++$}', $constraint, $matches)) {
 404             if (isset($matches[3]) && '' !== $matches[3]) {
 405                 $position = 3;
 406             } elseif (isset($matches[2]) && '' !== $matches[2]) {
 407                 $position = 2;
 408             } else {
 409                 $position = 1;
 410             }
 411
 412             $lowVersion = $this->manipulateVersionString($matches, $position) . '-dev';
 413             $highVersion = $this->manipulateVersionString($matches, $position, 1) . '-dev';
 414
 415             if ($lowVersion === '0.0.0.0-dev') {
 416                 return array(new Constraint('<', $highVersion));
 417             }
 418
 419             return array(
 420                 new Constraint('>=', $lowVersion),
 421                 new Constraint('<', $highVersion),
 422             );
 423         }
 424
 425         // Hyphen Range
 426         //
 427         // Specifies an inclusive set. If a partial version is provided as the first version in the inclusive range,
 428         // then the missing pieces are replaced with zeroes. If a partial version is provided as the second version in
 429         // the inclusive range, then all versions that start with the supplied parts of the tuple are accepted, but
 430         // nothing that would be greater than the provided tuple parts.
 431         if (preg_match('{^(?P<from>' . $versionRegex . ') +- +(?P<to>' . $versionRegex . ')($)}i', $constraint, $matches)) {
 432             // Calculate the stability suffix
 433             $lowStabilitySuffix = '';
 434             if (empty($matches[6]) && empty($matches[8])) {
 435                 $lowStabilitySuffix = '-dev';
 436             }
 437
 438             $lowVersion = $this->normalize($matches['from']);
 439             $lowerBound = new Constraint('>=', $lowVersion . $lowStabilitySuffix);
 440
 441             $empty = function ($x) {
 442                 return ($x === 0 || $x === '0') ? false : empty($x);
 443             };
 444
 445             if ((!$empty($matches[11]) && !$empty($matches[12])) || !empty($matches[14]) || !empty($matches[16])) {
 446                 $highVersion = $this->normalize($matches['to']);
 447                 $upperBound = new Constraint('<=', $highVersion);
 448             } else {
 449                 $highMatch = array('', $matches[10], $matches[11], $matches[12], $matches[13]);
 450                 $highVersion = $this->manipulateVersionString($highMatch, $empty($matches[11]) ? 1 : 2, 1) . '-dev';
 451                 $upperBound = new Constraint('<', $highVersion);
 452             }
 453
 454             return array(
 455                 $lowerBound,
 456                 $upperBound,
 457             );
 458         }
 459
 460         // Basic Comparators
 461         if (preg_match('{^(<>|!=|>=?|<=?|==?)?\s*(.*)}', $constraint, $matches)) {
 462             try {
 463                 $version = $this->normalize($matches[2]);
 464
 465                 if (!empty($stabilityModifier) && $this->parseStability($version) === 'stable') {
 466                     $version .= '-' . $stabilityModifier;
 467                 } elseif ('<' === $matches[1] || '>=' === $matches[1]) {
 468                     if (!preg_match('/-' . self::$modifierRegex . '$/', strtolower($matches[2]))) {
 469                         if (substr($matches[2], 0, 4) !== 'dev-') {
 470                             $version .= '-dev';
 471                         }
 472                     }
 473                 }
 474
 475                 return array(new Constraint($matches[1] ?: '=', $version));
 476             } catch (\Exception $e) {
 477             }
 478         }
 479
 480         $message = 'Could not parse version constraint ' . $constraint;
 481         if (isset($e)) {
 482             $message .= ': ' . $e->getMessage();
 483         }
 484
 485         throw new \UnexpectedValueException($message);
 486     }
 487
 488     /**
 489      * Increment, decrement, or simply pad a version number.
 490      *
 491      * Support function for {@link parseConstraint()}
 492      *
 493      * @param array $matches Array with version parts in array indexes 1,2,3,4
 494      * @param int $position 1,2,3,4 - which segment of the version to increment/decrement
 495      * @param int $increment
 496      * @param string $pad The string to pad version parts after $position
 497      *
 498      * @return string The new version
 499      */
 500     private function manipulateVersionString($matches, $position, $increment = 0, $pad = '0')
 501     {
 502         for ($i = 4; $i > 0; --$i) {
 503             if ($i > $position) {
 504                 $matches[$i] = $pad;
 505             } elseif ($i === $position && $increment) {
 506                 $matches[$i] += $increment;
 507                 // If $matches[$i] was 0, carry the decrement
 508                 if ($matches[$i] < 0) {
 509                     $matches[$i] = $pad;
 510                     --$position;
 511
 512                     // Return null on a carry overflow
 513                     if ($i === 1) {
 514                         return;
 515                     }
 516                 }
 517             }
 518         }
 519
 520         return $matches[1] . '.' . $matches[2] . '.' . $matches[3] . '.' . $matches[4];
 521     }
 522
 523     /**
 524      * Expand shorthand stability string to long version.
 525      *
 526      * @param string $stability
 527      *
 528      * @return string
 529      */
 530     private function expandStability($stability)
 531     {
 532         $stability = strtolower($stability);
 533
 534         switch ($stability) {
 535             case 'a':
 536                 return 'alpha';
 537             case 'b':
 538                 return 'beta';
 539             case 'p':
 540             case 'pl':
 541                 return 'patch';
 542             case 'rc':
 543                 return 'RC';
 544             default:
 545                 return $stability;
 546         }
 547     }
 548 }