Composer Semver

https://github.com/composer/semver
Admin
A PHP version comparison library that offers utilities for semantic versioning, version constraint...
Tokens:59,125
Snippets:401
Trust Score:9.2
License:MIT
Update:1 month ago
Show doc for...
Tokens:
Raw
### Using Interval::any() and echoing bounds

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/interval.md

Example of creating an any interval and echoing its start and end constraints.

```php
use Composer\Semver\Interval;

$all = Interval::any();
echo (string) $all->getStart(); // >= 0.0.0.0-dev
echo (string) $all->getEnd();   // < 9223372036854775807.0.0.0 (on 64-bit PHP; value depends on PHP_INT_MAX)
```

--------------------------------

### Install composer/semver with Composer

Source: https://github.com/composer/semver/blob/main/README.md

Install the latest version of the composer/semver library using Composer.

```bash
composer require composer/semver
```

--------------------------------

### Using Interval::fromZero()

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/interval.md

Example of calling fromZero() to get the canonical lowest version constraint.

```php
use Composer\Semver\Interval;

$zero = Interval::fromZero(); // Constraint('>=', '0.0.0.0-dev')
```

--------------------------------

### Usage example for Intervals::get()

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/intervals.md

Shows how to use Intervals::get() with a parsed constraint. It iterates over numeric intervals and prints start and end versions. Also demonstrates branch-aware constraints and clearing the cache.

```php
use Composer\Semver\Intervals;
use Composer\Semver\VersionParser;

$parser = new VersionParser();

$intervals = Intervals::get($parser->parseConstraints('^1.2'));

foreach ($intervals['numeric'] as $interval) {
    echo (string) $interval->getStart()->getVersion(), ' ', (string) $interval->getEnd()->getVersion(), PHP_EOL;
    // "1.2.0.0-dev 2.0.0.0-dev" (bounds as constraints: >= 1.2.0.0-dev, < 2.0.0.0-dev)
}

// Branch-aware constraints surface their dev-* coverage:
$branchSet = Intervals::get($parser->parseConstraints('!= dev-master'));
var_dump($branchSet['branches']); // array('names' => array('dev-master'), 'exclude' => true)

Intervals::clear(); // release memoized results
```

--------------------------------

### MultiConstraint::create() usage examples

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/multi-constraint.md

Examples showing how to call create() with zero constraints (returns MatchAllConstraint), one constraint (returns the constraint itself), and disjunctive merging of adjacent intervals that collapses to a single constraint.

```php
use Composer\Semver\Constraint\Constraint;
use Composer\Semver\Constraint\MatchAllConstraint;
use Composer\Semver\Constraint\MultiConstraint;

MultiConstraint::create(array());                        // MatchAllConstraint
MultiConstraint::create(array(new Constraint('>=', '1.0.0'))); // the Constraint itself

// Disjunctive merging of adjacent intervals:
$merged = MultiConstraint::create(array(
    new MultiConstraint(array(new Constraint('>=', '1.0.0'), new Constraint('<', '2.0.0')), true),
    new MultiConstraint(array(new Constraint('>=', '2.0.0'), new Constraint('<', '3.0.0')), true),
), false);
echo (string) $merged; // '[>= 1.0.0.0-dev < 3.0.0.0-dev]' (collapsed by optimizeConstraints)
```

--------------------------------

### Semver::sort() and rsort() usage example

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/semver.md

Example usage of Semver::sort() and Semver::rsort() with a list of versions, showing the sorted output and branch handling behavior.

```php
use Composer\Semver\Semver;

$versions = array('1.0.0', '2.0.0', '1.5.0', '2.0.0-rc1');

Semver::sort($versions);
// array('1.0.0', '1.5.0', '2.0.0-rc1', '2.0.0') — pre-releases sort before their release

Semver::rsort($versions);
// array('2.0.0', '2.0.0-rc1', '1.5.0', '1.0.0')

// Branch handling: normal branches sort low, default branches (dev-master) sort high
Semver::sort(array('1.0.0', 'dev-feature', 'dev-master'));
// array('dev-feature', '1.0.0', 'dev-master')
```

--------------------------------

### normalizeStability usage examples

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/version-parser.md

Examples of calling VersionParser::normalizeStability with various stability names, including a try-catch for an invalid stability string.

```php
use Composer\Semver\VersionParser;

VersionParser::normalizeStability('RC');       // 'RC'
VersionParser::normalizeStability('beta');     // 'beta'
VersionParser::normalizeStability('Dev');      // 'dev'

try {
    VersionParser::normalizeStability('unstable');
} catch (\InvalidArgumentException $e) {
    echo $e->getMessage(); // Invalid stability string "unstable", expected one of stable, RC, beta, alpha or dev
}
```

--------------------------------

### Creating Bound Instances

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/bound.md

Example of creating inclusive and exclusive bounds for version constraints.

```php
use Composer\Semver\Constraint\Bound;

$lower = new Bound('1.0.0.0', true);  // ">= 1.0.0.0"
$upper = new Bound('2.0.0.0', false); // "< 2.0.0.0"
```

--------------------------------

### Using Interval::untilPositiveInfinity()

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/interval.md

Example of calling untilPositiveInfinity() to get the canonical highest upper bound constraint.

```php
use Composer\Semver\Interval;

$top = Interval::untilPositiveInfinity(); // Constraint('<', PHP_INT_MAX.'.0.0.0')
```

--------------------------------

### parseStability usage examples

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/version-parser.md

Examples of calling VersionParser::parseStability with various version strings, showing the returned stability values.

```php
use Composer\Semver\VersionParser;

VersionParser::parseStability('1.0.0-beta2'); // 'beta'
VersionParser::parseStability('2.0.0-RC1');   // 'RC'
VersionParser::parseStability('dev-master');  // 'dev'
VersionParser::parseStability('1.2.3');       // 'stable'
VersionParser::parseStability('1.0#abc');     // 'stable' ('#abc' stripped first)
```

--------------------------------

### Using getStart and getEnd on an any interval

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/interval.md

Demonstrates retrieving the start and end constraints from an Interval::any() instance and accessing their operators and versions.

```php
use Composer\Semver\Interval;

$interval = Interval::any();

$interval->getStart()->getVersion(); // '0.0.0.0-dev'
$interval->getStart()->getOperator(); // '>='
$interval->getEnd()->getOperator();   // '<'
$interval->getEnd()->getVersion();    // string(PHP_INT_MAX).'.0.0.0'
```

--------------------------------

### Instantiating and using VersionParser

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/version-parser.md

Shows how to create a VersionParser instance, validate a version with isValid(), and normalize it with normalize(). The example outputs '1.2.3.0' for input '1.2.3'.

```php
use Composer\Semver\VersionParser;

$parser = new VersionParser();

if ($parser->isValid('1.2.3')) {
    echo $parser->normalize('1.2.3'); // "1.2.3.0"
}
```

--------------------------------

### normalize usage examples

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/version-parser.md

Examples of normalizing various version strings, including numeric, prefixed, stability, build metadata, dev branches, and date-based versions. Also shows error handling for invalid versions and alias context.

```php
use Composer\Semver\VersionParser;

$parser = new VersionParser();

$parser->normalize('1.2.3');          // '1.2.3.0'
$parser->normalize('v1.2');           // '1.2.0.0'
$parser->normalize('1.0.0-beta2');    // '1.0.0.0-beta2'
$parser->normalize('1.0.0+build.5');  // '1.0.0.0' (build metadata dropped)
$parser->normalize('dev-feature/x');  // 'dev-feature/x'
$parser->normalize('20150520');       // '2015.05.20' (date-based)

try {
    $parser->normalize('not a version');
} catch (\UnexpectedValueException $e) {
    echo $e->getMessage(); // Invalid version string "not a version"
}

// $fullVersion adds context: when it ends with "as <version>" the alias
// target is blamed, when it starts with "<version> as " the alias source is:
try {
    $parser->normalize('1.0.x', '1.0.x as 2.0');
} catch (\UnexpectedValueException $e) {
    echo $e->getMessage(); // Invalid version string "1.0.x" in "1.0.x as 2.0", the alias source must be an exact version, if it is a branch name you should prefix it with dev-
}
```

--------------------------------

### Bound::zero and positiveInfinity usage

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/bound.md

Example usage of the zero and positiveInfinity factories, demonstrating their return values and methods.

```php
use Composer\Semver\Constraint\Bound;

$zero = Bound::zero();
$inf  = Bound::positiveInfinity();

$zero->isZero();               // true
$inf->isPositiveInfinity();    // true
$zero->compareTo($inf, '<');   // true
```

--------------------------------

### Usage example for matches()

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/multi-constraint.md

Creates a conjunctive MultiConstraint and tests it against provider constraints, showing true and false results.

```php
use Composer\Semver\Constraint\Constraint;
use Composer\Semver\Constraint\MultiConstraint;

$range = new MultiConstraint(array(
    new Constraint('>=', '1.0.0'),
    new Constraint('<', '2.0.0'),
), true);

$range->matches(new Constraint('==', '1.5.0')); // true
$range->matches(new Constraint('==', '2.5.0')); // false
```

--------------------------------

### Creating an Interval instance

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/interval.md

Example of creating an Interval with a lower bound '>=' 1.0.0.0 and an upper bound '<' 2.0.0.0.

```php
use Composer\Semver\Interval;
use Composer\Semver\Constraint\Constraint;

$interval = new Interval(
    new Constraint('>=', '1.0.0.0'),
    new Constraint('<', '2.0.0.0')
);
```

--------------------------------

### Using __toString() to get '*'

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/match-all-constraint.md

Example of casting a MatchAllConstraint instance to string, which yields '*'.

```php
echo (string) new MatchAllConstraint(); // '*'
```

--------------------------------

### getSupportedOperators usage example

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/constraint.md

Shows how to call Constraint::getSupportedOperators() and the resulting array of strings: ['=', '==', '<', '<=', '>', '>=', '<>', '!='].

```php
use Composer\Semver\Constraint\Constraint;

$operators = Constraint::getSupportedOperators();
// array('=', '==', '<', '<=', '>', '>=', '<>', '!=')
```

--------------------------------

### Semver::satisfies() usage examples

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/semver.md

Usage examples for Semver::satisfies() showing true/false results for various constraints and a try/catch block that catches \UnexpectedValueException when parsing an invalid version.

```php
use Composer\Semver\Semver;

Semver::satisfies('1.2.3', '^1.0');          // true
Semver::satisfies('2.0.0', '^1.0');          // false
Semver::satisfies('1.5.0', '>=1.0 <2.0 || 3.*'); // true
Semver::satisfies('dev-master', 'dev-master');   // true

try {
    Semver::satisfies('not-a-version', '^1.0');
} catch (\UnexpectedValueException $e) {
    echo $e->getMessage(); // Invalid version string "not-a-version"
}
```

--------------------------------

### normalizeBranch usage example

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/version-parser.md

Example of using normalizeBranch with a VersionParser instance. Shows that '1.x' becomes '1.9999999.9999999.9999999-dev', '2.1' becomes '2.1.9999999.9999999.9999999-dev', and 'feature/foo' becomes 'dev-feature/foo'.

```php
use Composer\Semver\VersionParser;

$parser = new VersionParser();
$parser->normalizeBranch('1.x');        // '1.9999999.9999999.9999999-dev'
$parser->normalizeBranch('2.1');        // '2.1.9999999.9999999.9999999-dev'
$parser->normalizeBranch('feature/foo'); // 'dev-feature/foo'
```

--------------------------------

### getVersion / isInclusive usage example

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/bound.md

Shows creating a Bound and calling getVersion() and isInclusive(). The expected outputs are '1.0.0.0' and true.

```php
$b = new Bound('1.0.0.0', true);
$b->getVersion();  // '1.0.0.0'
$b->isInclusive(); // true
```

--------------------------------

### getVersion usage example

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/constraint.md

Creates a Constraint with operator '>=' and version '1.5.0', then calls getVersion() which returns '1.5.0'.

```php
$c = new Constraint('>=', '1.5.0');
$c->getVersion(); // '1.5.0'
```

--------------------------------

### isValid usage example

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/version-parser.md

Example of using isValid to check various version strings. Returns true for valid versions and false for invalid ones.

```php
use Composer\Semver\VersionParser;

$parser = new VersionParser();
$parser->isValid('1.2.3');        // true
$parser->isValid('v2.0.0-beta');  // true (leading "v" accepted)
$parser->isValid('not a version'); // false
```

--------------------------------

### setPrettyString and getPrettyString usage example

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/multi-constraint.md

Example usage of setPrettyString and getPrettyString. The setter stores the string verbatim, and the getter returns it exactly as stored.

```php
$multi->setPrettyString('>=1.0 <2.0');
$multi->getPrettyString(); // '>=1.0 <2.0'
```

--------------------------------

### Semver::satisfiedBy() usage example

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/semver.md

Example usage of Semver::satisfiedBy() with two constraint strings, showing the returned filtered arrays.

```php
use Composer\Semver\Semver;

$versions = array('1.0.0', '1.5.0', '2.0.0', '2.5.0');

Semver::satisfiedBy($versions, '^1.0'); // array('1.0.0', '1.5.0')
Semver::satisfiedBy($versions, '>=2.0'); // array('2.0.0', '2.5.0')
```

--------------------------------

### Usage example for isConjunctive() and isDisjunctive()

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/multi-constraint.md

Creates conjunctive and disjunctive MultiConstraint instances and demonstrates the return values of isConjunctive() and isDisjunctive().

```php
$and = new MultiConstraint(array(new Constraint('>=', '1.0.0'), new Constraint('<', '2.0.0')), true);
$or  = new MultiConstraint(array(new Constraint('>=', '1.0.0'), new Constraint('<', '2.0.0')), false);

$and->isConjunctive(); // true
$or->isDisjunctive();  // true
```

--------------------------------

### Usage examples for Comparator methods

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/comparator.md

Shows typical calls to the comparison methods, including handling of pre-release versions and branch comparisons. Note that branch comparisons follow versionCompare branch semantics.

```php
use Composer\Semver\Comparator;

Comparator::greaterThan('1.25.0', '1.24.0');           // true
Comparator::greaterThanOrEqualTo('1.25.0', '1.25.0');  // true
Comparator::lessThan('1.0.0-beta', '1.0.0');           // true (pre-release sorts lower)
Comparator::lessThanOrEqualTo('2.0', '2.0.0');         // true
Comparator::equalTo('1.2.3', 'v1.2.3');                // true
Comparator::notEqualTo('1.2.3', '1.2.4');              // true

// Branch comparisons follow versionCompare branch semantics:
Comparator::equalTo('dev-master', 'dev-master'); // true
```

--------------------------------

### Using CompilingMatcher::clear()

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/compiling-matcher.md

Example of calling clear() to free memoized closures and results when done.

```php
use Composer\Semver\CompilingMatcher;

CompilingMatcher::clear(); // free memoized closures and results when done
```

--------------------------------

### isSubsetOf usage example

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/intervals.md

Example of using Intervals::isSubsetOf with VersionParser. Shows that '~1.2.0' is a subset of '^1.0' (true) and '^2.0' is not a subset of '^1.0' (false).

```php
use Composer\Semver\Intervals;
use Composer\Semver\VersionParser;

$parser = new VersionParser();

Intervals::isSubsetOf(
    $parser->parseConstraints('~1.2.0'),
    $parser->parseConstraints('^1.0')
); // true

Intervals::isSubsetOf(
    $parser->parseConstraints('^2.0'),
    $parser->parseConstraints('^1.0')
); // false
```

--------------------------------

### Using compile() to get 'true' expression

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/match-all-constraint.md

Example of compile() returning the literal expression 'true', which can be used directly as a PHP expression.

```php
$all = new MatchAllConstraint();
$all->compile(Constraint::OP_EQ); // 'true' — usable directly as a PHP expression
```

--------------------------------

### compareTo usage examples

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/bound.md

Shows compareTo with different versions and equal versions disambiguated by inclusivity. Includes a try/catch for an unsupported operator, printing the exception message.

```php
use Composer\Semver\Constraint\Bound;

$low  = new Bound('1.0.0.0', true);
$high = new Bound('2.0.0.0', false);

$low->compareTo($high, '<');  // true
$high->compareTo($low, '>');  // true

// Equal versions are disambiguated by inclusivity:
$a = new Bound('1.0.0.0', true);
$b = new Bound('1.0.0.0', false);
$a->compareTo($b, '>'); // false (b is inclusive, so a is not strictly higher)
$a->compareTo($b, '<'); // false

try {
    $low->compareTo($high, '>='); // unsupported operator
} catch (\InvalidArgumentException $e) {
    echo $e->getMessage(); // Does not support any other operator other than > or <.
}
```

--------------------------------

### Class overview of Intervals

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/intervals.md

Shows the public static method signatures of the `Intervals` class, including `clear()`, `isSubsetOf()`, `haveIntersections()`, `compactConstraint()`, and `get()`. The `get()` method returns an array with numeric intervals and branch information.

```php
class Intervals
{
    public static function clear();                              // -> void
    public static function isSubsetOf(ConstraintInterface $candidate, ConstraintInterface $constraint); // -> bool
    public static function haveIntersections(ConstraintInterface $a, ConstraintInterface $b);           // -> bool
    public static function compactConstraint(ConstraintInterface $constraint);                          // -> ConstraintInterface
    public static function get(ConstraintInterface $constraint);                                        // -> array{numeric: Interval[], branches: array{names: string[], exclude: bool}}
}
```

--------------------------------

### __toString usage example for conjunctive and disjunctive sets

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/multi-constraint.md

Example usage of __toString for both conjunctive (AND) and disjunctive (OR) MultiConstraint instances. The output shows the bracket format with spaces for AND and ' || ' for OR.

```php
$and = new MultiConstraint(array(new Constraint('>=', '1.0.0'), new Constraint('<', '2.0.0')), true);
echo (string) $and; // '[>= 1.0.0 < 2.0.0]'

$or = new MultiConstraint(array(new Constraint('>=', '1.0.0'), new Constraint('<', '2.0.0')), false);
echo (string) $or; // '[>= 1.0.0 || < 2.0.0]'
```

--------------------------------

### Usage example for compactConstraint

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/intervals.md

Example showing how to use Intervals::compactConstraint to collapse a degenerate interval constraint [>=1.0.0.0-dev <=1.0.0.0-dev] into an equality constraint. The output shows the resulting class, operator, version, and pretty string.

```php
use Composer\Semver\Intervals;
use Composer\Semver\VersionParser;

$parser = new VersionParser();

// A degenerate interval [>=1.0.0.0-dev <=1.0.0.0-dev] collapses to == 1.0.0.0-dev:
$constraint = $parser->parseConstraints('>=1.0.0.0-dev <=1.0.0.0-dev');
$compact = Intervals::compactConstraint($constraint);

echo get_class($compact);       // Composer\Semver\Constraint\Constraint
$compact->getOperator();        // '=='
$compact->getVersion();         // '1.0.0.0-dev'
$compact->getPrettyString();    // '== 1.0.0.0-dev'
```

--------------------------------

### haveIntersections usage example

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/intervals.md

Example of using Intervals::haveIntersections with VersionParser. Shows that '>=1.0 <2.0' and '^1.5' intersect (true) while '>=1.0 <2.0' and '^3.0' do not (false).

```php
use Composer\Semver\Intervals;
use Composer\Semver\VersionParser;

$parser = new VersionParser();

Intervals::haveIntersections(
    $parser->parseConstraints('>=1.0 <2.0'),
    $parser->parseConstraints('^1.5')
); // true

Intervals::haveIntersections(
    $parser->parseConstraints('>=1.0 <2.0'),
    $parser->parseConstraints('^3.0')
); // false
```

--------------------------------

### Using anyDev and noDev with var_export

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/interval.md

Example of calling anyDev() and noDev() and modifying the returned array to include a dev branch.

```php
use Composer\Semver\Interval;

var_export(Interval::anyDev()); // array('names' => array(), 'exclude' => true)
var_export(Interval::noDev());  // array('names' => array(), 'exclude' => false)

$branches = Interval::anyDev();
$branches['names'][] = 'dev-master'; // e.g. exclude everything except dev-master... (keys kept consistent by consumers)
```

--------------------------------

### Constructor signature for Interval

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/interval.md

Shows the constructor signature with PHPDoc annotations for the start and end constraints.

```php
/**
 * @param Constraint $start
 * @param Constraint $end
 */
public function __construct(Constraint $start, Constraint $end)
```

--------------------------------

### parseNumericAliasPrefix usage example

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/version-parser.md

Example of using parseNumericAliasPrefix with a VersionParser instance. Shows that '2.1.x-dev' returns '2.1.', '2.1.3-dev' returns '2.1.3.', and 'dev-foo' returns false.

```php
use Composer\Semver\VersionParser;

$parser = new VersionParser();
$parser->parseNumericAliasPrefix('2.1.x-dev'); // '2.1.'
$parser->parseNumericAliasPrefix('2.1.3-dev'); // '2.1.3.'
$parser->parseNumericAliasPrefix('dev-foo');   // false
```

--------------------------------

### matchSpecific usage example

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/constraint.md

Example usage of matchSpecific with a >= constraint. Shows that equality and not-equal constraints match, while a less-than constraint with the same version does not due to the special case guard.

```php
use Composer\Semver\Constraint\Constraint;

$c = new Constraint('>=', '1.0.0');
$c->matchSpecific(new Constraint('==', '1.5.0')); // true
$c->matchSpecific(new Constraint('<', '1.0.0'));  // false (special case guard)
$c->matchSpecific(new Constraint('!=', '0.5.0')); // true
```

--------------------------------

### Using setPrettyString() and getPrettyString()

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/match-all-constraint.md

Example of getPrettyString() returning '*' by default, then setPrettyString() storing a custom string, and getPrettyString() returning that custom string.

```php
$all = new MatchAllConstraint();
$all->getPrettyString(); // '*'
$all->setPrettyString('any version');
$all->getPrettyString(); // 'any version'
```

--------------------------------

### parseConstraints method and usage examples

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/version-parser.md

Parses a constraint string into a constraint tree. The example shows various valid inputs and their resulting constraint types, as well as the exceptions thrown for invalid operators like '~>' and unparseable strings. The final matching example demonstrates how to use the parsed result with `Constraint::matches()`. Note that `~>` throws `\UnexpectedValueException` with a helpful message.

```php
/**
 * Parses a constraint string into MultiConstraint and/or Constraint objects.
 *
 * @param string $constraints
 *
 * @return ConstraintInterface
 */
public function parseConstraints($constraints)

```

```php
use Composer\Semver\VersionParser;

$parser = new VersionParser();

$parser->parseConstraints('*');                  // MatchAllConstraint
$parser->parseConstraints('^1.2');               // MultiConstraint (>= 1.2.0.0-dev, < 2.0.0.0-dev)
$parser->parseConstraints('>=1.0 <2.0 || 3.*');  // disjunctive MultiConstraint
$parser->parseConstraints('~2.0');               // MultiConstraint (>= 2.0.0.0-dev, < 3.0.0.0-dev)

try {
    $parser->parseConstraints('~>2.0'); // invalid operator
} catch (\UnexpectedValueException $e) {
    echo $e->getMessage(); // Could not parse version constraint ~>2.0: Invalid operator "~>", you probably meant to use the "~" operator
}

try {
    $parser->parseConstraints('foo bar baz'); // first unparseable part
} catch (\UnexpectedValueException $e) {
    echo $e->getMessage(); // Could not parse version constraint foo: Invalid version string "foo"
}

// The result can be matched against normalized versions:
use Composer\Semver\Constraint\Constraint;
$constraint = $parser->parseConstraints('^1.2');
$constraint->matches(new Constraint('==', $parser->normalize('1.9.0'))); // true
$constraint->matches(new Constraint('==', $parser->normalize('2.0.0'))); // false

```

--------------------------------

### compile() returns 'false'

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/match-none-constraint.md

Example usage of compile() showing it returns the string 'false'.

```php
$none = new MatchNoneConstraint();
$none->compile(Constraint::OP_EQ); // 'false'
```

--------------------------------

### versionCompare usage example with branch semantics

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/constraint.md

Creates a Constraint for '>= 1.0.0' and calls versionCompare with various operators, including dev-* branches, demonstrating the special branch handling: string inequality for '!=', equality for '==', and the effect of $compareBranches.

```php
use Composer\Semver\Constraint\Constraint;

$c = new Constraint('>=', '1.0.0');

$c->versionCompare('1.5.0', '1.0.0', '>');    // true
$c->versionCompare('1.0.0', '1.0.0', '==');   // true

// Branch semantics:
$c->versionCompare('dev-master', 'dev-other', '!=');       // true (string inequality)
$c->versionCompare('dev-master', 'dev-master', '==');      // true
$c->versionCompare('dev-master', 'dev-master', '==', true); // true (compareBranches)
```

--------------------------------

### Using CompilingMatcher::match() with operators

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/compiling-matcher.md

Example of using match() with different operators (OP_EQ, OP_LT, OP_NE) to test version constraints. Shows that OP_EQ checks equality, while other operators relate the constraint to the version.

```php
use Composer\Semver\CompilingMatcher;
use Composer\Semver\Constraint\Constraint;
use Composer\Semver\VersionParser;

$parser = new VersionParser();
$constraint = $parser->parseConstraints('^1.2');

// Equivalent of "$constraint == 1.5.0":
CompilingMatcher::match($constraint, Constraint::OP_EQ, '1.5.0'); // true
CompilingMatcher::match($constraint, Constraint::OP_EQ, '2.0.0'); // false

// Other operators relate the constraint to the version, e.g. "$constraint < 2.0.0":
CompilingMatcher::match($constraint, Constraint::OP_LT, '2.0.0'); // true
CompilingMatcher::match($constraint, Constraint::OP_NE, '2.1.0'); // true

CompilingMatcher::clear();
```

--------------------------------

### setPrettyString and getPrettyString usage example

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/constraint.md

Creates a Constraint '>= 1.0.0' and demonstrates getPrettyString() returning the fallback __toString() output, then setPrettyString() storing a custom string and getPrettyString() returning it.

```php
use Composer\Semver\Constraint\Constraint;

$c = new Constraint('>=', '1.0.0');
$c->getPrettyString(); // '>= 1.0.0' (falls back to __toString)

$c->setPrettyString('1.0.0 or later');
$c->getPrettyString(); // '1.0.0 or later'
```

--------------------------------

### Bound::__toString usage

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/bound.md

Example usage of __toString showing the output format for inclusive and exclusive bounds.

```php
echo (string) new Bound('1.0.0.0', true);  // '1.0.0.0 [inclusive]'
echo (string) new Bound('2.0.0.0', false); // '2.0.0.0 [exclusive]'
```

--------------------------------

### isZero usage example

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/bound.md

Shows that Bound::zero()->isZero() returns true, while an exclusive '0.0.0.0-dev' bound returns false.

```php
Bound::zero()->isZero(); // true
new Bound('0.0.0.0-dev', false)->isZero(); // false
```

--------------------------------

### Using getLowerBound() and getUpperBound()

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/match-all-constraint.md

Example of getLowerBound() returning a zero bound and getUpperBound() returning a positive infinity bound, together spanning the entire numeric range.

```php
use Composer\Semver\Constraint\MatchAllConstraint;

$all = new MatchAllConstraint();
$all->getLowerBound()->isZero();               // true
$all->getUpperBound()->isPositiveInfinity();   // true
```

--------------------------------

### matches usage example

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/constraint.md

Creates a Constraint '>= 1.0.0' and tests matches() against two other constraints: one with version 1.5.0 returns true, one with 0.9.0 returns false.

```php
use Composer\Semver\Constraint\Constraint;

$c = new Constraint('>=', '1.0.0');
$c->matches(new Constraint('==', '1.5.0')); // true
$c->matches(new Constraint('==', '0.9.0')); // false
```

--------------------------------

### getPrettyString() returns '[]'

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/match-none-constraint.md

Example usage of getPrettyString() showing it returns '[]' when no pretty string has been set.

```php
$none = new MatchNoneConstraint();
$none->getPrettyString(); // '[]'
```

--------------------------------

### __toString() returns '[]'

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/match-none-constraint.md

Example usage of __toString() showing it returns '[]'.

```php
echo (string) new MatchNoneConstraint(); // '[]'
```

--------------------------------

### Constraint getLowerBound and getUpperBound usage example

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/constraint.md

Creates a Constraint with operator '>=' and version '1.0.0', then retrieves the lower and upper bounds. The lower bound version is '1.0.0' and is inclusive; the upper bound is positive infinity.

```php
use Composer\Semver\Constraint\Constraint;

$c = new Constraint('>=', '1.0.0');
$c->getLowerBound()->getVersion(); // '1.0.0'
$c->getLowerBound()->isInclusive(); // true
$c->getUpperBound()->isPositiveInfinity(); // true
```

--------------------------------

### isPositiveInfinity usage example

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/bound.md

Shows that Bound::positiveInfinity()->isPositiveInfinity() returns true, while an inclusive PHP_INT_MAX bound returns false.

```php
Bound::positiveInfinity()->isPositiveInfinity(); // true
new Bound(PHP_INT_MAX . '.0.0.0', true)->isPositiveInfinity(); // false
```

--------------------------------

### Use Intervals static methods for constraint intervals

Source: https://github.com/composer/semver/blob/main/README.md

Shows the static methods available on the Intervals class for working with complex constraints. Includes isSubsetOf, haveIntersections, compactConstraint, get, and clear. Note that compactConstraint is not very fast and the resulting constraint has no human-readable prettyConstraint configured.

```php
use Composer\Semver\Intervals;

// Checks whether $candidate is a subset of $constraint
Intervals::isSubsetOf(ConstraintInterface $candidate, ConstraintInterface $constraint);

// Checks whether $a and $b have any intersection, equivalent to $a->matches($b)
Intervals::haveIntersections(ConstraintInterface $a, ConstraintInterface $b);

// Optimizes a complex multi constraint by merging all intervals down to the smallest
// possible multi constraint. The drawbacks are this is not very fast, and the resulting
// multi constraint will have no human readable prettyConstraint configured on it
Intervals::compactConstraint(ConstraintInterface $constraint);

// Creates an array of numeric intervals and branch constraints representing a given constraint
Intervals::get(ConstraintInterface $constraint);

// Clears the memoization cache when you are done processing constraints
Intervals::clear()
```

--------------------------------

### Using matches() and parsing wildcard constraint

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/match-all-constraint.md

Example usage of matches() and the canonical origin of MatchAllConstraint from parsing a wildcard constraint. Shows that matches() always returns true and that parseConstraints('*') produces a MatchAllConstraint instance.

```php
use Composer\Semver\Constraint\Constraint;
use Composer\Semver\Constraint\MatchAllConstraint;
use Composer\Semver\VersionParser;

$all = new MatchAllConstraint();
$all->matches(new Constraint('==', '0.0.1')); // true

// Canonical origin: parsing a wildcard constraint
$parsed = (new VersionParser())->parseConstraints('*');
get_class($parsed); // Composer\Semver\Constraint\MatchAllConstraint
```

--------------------------------

### Constraint __toString usage example

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/constraint.md

Creates a Constraint with operator '>=' and version '1.5.0', then casts it to string to output '>= 1.5.0'.

```php
$c = new Constraint('>=', '1.5.0');
echo (string) $c; // '>= 1.5.0'
```

--------------------------------

### Compare versions with Comparator::greaterThan

Source: https://github.com/composer/semver/blob/main/README.md

Compares two version strings using the Comparator class. The example checks if version 1.25.0 is greater than 1.24.0 and returns a boolean.

```php
use Composer\Semver\Comparator;

Comparator::greaterThan('1.25.0', '1.24.0'); // 1.25.0 > 1.24.0
```

--------------------------------

### getOperator usage example

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/constraint.md

Creates a Constraint with operator '=' and version '1.5.0', then calls getOperator() which returns '==' (the canonical form).

```php
$c = new Constraint('=', '1.5.0');
$c->getOperator(); // '=='
```

--------------------------------

### getStart method signature

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/interval.md

Shows the getStart method with its PHPDoc return annotation.

```php
/**
 * @return Constraint
 */
public function getStart()
```

--------------------------------

### fromZero method signature

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/interval.md

Shows the fromZero static method with its PHPDoc return annotation.

```php
/**
 * @return Constraint
 */
public static function fromZero()
```

--------------------------------

### Semver class overview

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/semver.md

Shows the public static API of the Semver class, including the SORT_ASC and SORT_DESC constants and the signatures for satisfies(), satisfiedBy(), sort(), and rsort().

```php
class Semver
{
    const SORT_ASC = 1;
    const SORT_DESC = -1;

    public static function satisfies($version, $constraints);        // -> bool
    public static function satisfiedBy(array $versions, $constraints); // -> list<string>
    public static function sort(array $versions);                    // -> list<string>
    public static function rsort(array $versions);                   // -> list<string>
}
```

--------------------------------

### Using getConstraints()

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/multi-constraint.md

Demonstrates getConstraints() returning the array of constraints; count returns 2 for the two constraints.

```php
$multi = new MultiConstraint(array(
    new Constraint('>=', '1.0.0'),
    new Constraint('<', '2.0.0'),
));
count($multi->getConstraints()); // 2
```

--------------------------------

### setPrettyString / getPrettyString

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/match-none-constraint.md

Sets and gets the pretty string representation of the constraint. The getter returns the stored string or '[]' if unset.

```APIDOC
## setPrettyString / getPrettyString

### Description
Sets and gets the pretty string representation of the constraint. The getter returns the stored string or '[]' if unset.

### Method
setPrettyString / getPrettyString

### Parameters
- **$prettyString** (string) - Required (setter) - Stored verbatim

### Return
getPrettyString() returns string - the stored string, or '[]' when unset. The setter returns void.

### Example
php
$none = new MatchNoneConstraint();
$none->getPrettyString(); // '[]'

```

--------------------------------

### MultiConstraint::create

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/multi-constraint.md

Static factory method to create a MultiConstraint instance.

```APIDOC
## MultiConstraint::create

### Description
Static factory method that creates a new MultiConstraint instance. It may return a single constraint if only one is provided, or a MultiConstraint otherwise.

### Method
`public static function create(array $constraints, $conjunctive = true)`

### Parameters
- **$constraints** (array) - Required - An array of `ConstraintInterface` objects.
- **$conjunctive** (bool) - Optional - Defaults to `true`. If true, the constraint is conjunctive (AND); if false, disjunctive (OR).

### Returns
- **ConstraintInterface** - A `ConstraintInterface` instance, either a single constraint or a `MultiConstraint`.
```

--------------------------------

### getOperatorConstant usage example

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/constraint.md

Shows calling Constraint::getOperatorConstant with '>=' and '!=' to obtain the integer constants 4 (OP_GE) and 5 (OP_NE).

```php
use Composer\Semver\Constraint\Constraint;

Constraint::getOperatorConstant('>='); // 4 (OP_GE)
Constraint::getOperatorConstant('!='); // 5 (OP_NE)
```

--------------------------------

### getLowerBound() returns exclusive zero bound

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/match-none-constraint.md

Example usage of getLowerBound() showing it returns an exclusive bound with version '0.0.0.0-dev'.

```php
use Composer\Semver\Constraint\MatchNoneConstraint;

$none = new MatchNoneConstraint();
$none->getLowerBound()->getVersion(); // '0.0.0.0-dev'
$none->getLowerBound()->isInclusive(); // false
```

--------------------------------

### any method signature

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/interval.md

Shows the any static method with its PHPDoc return annotation.

```php
/**
 * @return self
 */
public static function any()
```

--------------------------------

### matches() always returns false

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/match-none-constraint.md

Example usage of matches() showing it always returns false even when given a valid constraint.

```php
use Composer\Semver\Constraint\Constraint;
use Composer\Semver\Constraint\MatchNoneConstraint;

$none = new MatchNoneConstraint();
$none->matches(new Constraint('==', '1.0.0')); // false
```

--------------------------------

### Bound Class Methods

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/bound.md

Documentation for the Bound class methods, including constructor, getters, comparison, and static factory methods.

```APIDOC
## `__construct`

### Description
Creates a new Bound instance representing a single endpoint of a version interval.

### Method
`public function __construct($version, $isInclusive)`

### Parameters
- **$version** (string) - Required - Normalized version string at the bound
- **$isInclusive** (bool) - Required - `true` = the bound version itself is part of the interval, `false` = exclusive

### Request Example
```php
use Composer\Semver\Constraint\Bound;

$lower = new Bound('1.0.0.0', true);  // ">= 1.0.0.0"
$upper = new Bound('2.0.0.0', false); // "< 2.0.0.0"
```
```

```APIDOC
## `getVersion`

### Description
Returns the version string of the bound.

### Method
`public function getVersion()`

### Returns
- **string** - The normalized version string at the bound
```

```APIDOC
## `isInclusive`

### Description
Checks whether the bound is inclusive.

### Method
`public function isInclusive()`

### Returns
- **bool** - `true` if the bound version is part of the interval, `false` otherwise
```

```APIDOC
## `isZero`

### Description
Checks whether the bound represents the zero version.

### Method
`public function isZero()`

### Returns
- **bool** - `true` if the bound is zero, `false` otherwise
```

```APIDOC
## `isPositiveInfinity`

### Description
Checks whether the bound represents positive infinity.

### Method
`public function isPositiveInfinity()`

### Returns
- **bool** - `true` if the bound is positive infinity, `false` otherwise
```

```APIDOC
## `compareTo`

### Description
Compares this bound to another bound using the given operator.

### Method
`public function compareTo(Bound $other, $operator)`

### Parameters
- **$other** (Bound) - Required - The other bound to compare against
- **$operator** (string) - Required - The comparison operator (e.g., `==`, `<`, `>`)

### Returns
- **bool** - The result of the comparison
```

```APIDOC
## `__toString`

### Description
Returns a string representation of the bound.

### Method
`public function __toString()`

### Returns
- **string** - A string representation of the bound
```

```APIDOC
## `zero`

### Description
Creates a Bound instance representing the zero version (inclusive).

### Method
`public static function zero()`

### Returns
- **self** - A Bound instance for the zero version
```

```APIDOC
## `positiveInfinity`

### Description
Creates a Bound instance representing positive infinity (exclusive).

### Method
`public static function positiveInfinity()`

### Returns
- **self** - A Bound instance for positive infinity
```

--------------------------------

### VersionParser class overview

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/version-parser.md

Shows the public API of the VersionParser class with method signatures and return types. The class holds no instance state and is not final.

```php
class VersionParser
{
    public static function parseStability($version);            // -> string
    public static function normalizeStability($stability);      // -> string
    public function isValid($version);                          // -> bool
    public function normalize($version, $fullVersion = null);   // -> string
    public function parseNumericAliasPrefix($branch);           // -> string|false
    public function normalizeBranch($name);                     // -> string
    public function normalizeDefaultBranch($name);              // -> string (deprecated)
    public function parseConstraints($constraints);             // -> ConstraintInterface
}
```

--------------------------------

### Class overview of Interval

Source: https://github.com/composer/semver/blob/main/_autodocs/api-reference/interval.md

Shows the public API of the Interval class, including constructor, getters, and static methods.

```php
class Interval
{
    public function __construct(Constraint $start, Constraint $end);
    public function getStart();                     // -> Constraint
    public function getEnd();                       // -> Constraint
    public static function fromZero();              // -> Constraint
    public static function untilPositiveInfinity(); // -> Constraint
    public static function any();                   // -> self
    public static function anyDev();                // -> array{'names': string[], 'exclude': bool}
    public static function noDev();                 // -> array{'names': string[], 'exclude': bool}
}
```
Tokens:
Raw