Add Intervals class to allow checking for subsets and intersections between constraints

src/Constraint/Bound.php

@@ -103,14 +103,14 @@ public function __toString()
      */
     public static function zero()
     {
-        return new Bound('0', true);
+        return new Bound('0.0.0.0-dev', true);
     }
 
     /**
      * @return self
      */
     public static function positiveInfinity()
     {
-        return new Bound((string) PHP_INT_MAX, false);
+        return new Bound(PHP_INT_MAX.'.0.0.0', false);
     }
 }

src/Constraint/Constraint.php

@@ -74,6 +74,38 @@ class Constraint implements CompilableConstraintInterface
     /** @var Bound */
     protected $upperBound;
 
+    /**
+     * Sets operator and version to compare with.
+     *
+     * @param string $operator
+     * @param string $version
+     *
+     * @throws \InvalidArgumentException if invalid operator is given.
+     */
+    public function __construct($operator, $version)
+    {
+        if (!isset(self::$transOpStr[$operator])) {
+            throw new \InvalidArgumentException(sprintf(
+                'Invalid operator "%s" given, expected one of: %s',
+                $operator,
+                implode(', ', self::getSupportedOperators())
+            ));
+        }
+
+        $this->operator = self::$transOpStr[$operator];
+        $this->version = $version;
+    }
+
+    public function getVersion()
+    {
+        return $this->version;
+    }
+
+    public function getOperator()
+    {
+        return self::$transOpInt[$this->operator];
+    }
+
     /**
      * @param ConstraintInterface $provider
      *
@@ -119,28 +151,6 @@ public static function getSupportedOperators()
         return array_keys(self::$transOpStr);
     }
 
-    /**
-     * Sets operator and version to compare with.
-     *
-     * @param string $operator
-     * @param string $version
-     *
-     * @throws \InvalidArgumentException if invalid operator is given.
-     */
-    public function __construct($operator, $version)
-    {
-        if (!isset(self::$transOpStr[$operator])) {
-            throw new \InvalidArgumentException(sprintf(
-                'Invalid operator "%s" given, expected one of: %s',
-                $operator,
-                implode(', ', self::getSupportedOperators())
-            ));
-        }
-
-        $this->operator = self::$transOpStr[$operator];
-        $this->version = $version;
-    }
-
     /**
      * @param string $a
      * @param string $b
@@ -180,7 +190,8 @@ public function versionCompare($a, $b, $operator, $compareBranches = false)
         return \version_compare($a, $b, $operator);
     }
 
-    public function compile($otherOperator) {
+    public function compile($otherOperator)
+    {
         if ($this->version[0] === 'd' && 'dev-' === substr($this->version, 0, 4)) {
             if (self::OP_EQ === $this->operator) {
                 if (self::OP_EQ === $otherOperator) {

src/Constraint/ConstraintInterface.php

@@ -11,9 +11,17 @@
 
 namespace Composer\Semver\Constraint;
 
+/**
+ * DO NOT IMPLEMENT this interface. It is only meant for usage as a type hint
+ * in libraries relying on composer/semver but creating your own constraint class
+ * that implements this interface is not a supported use case and will cause the
+ * composer/semver components to return unexpected results.
+ */
 interface ConstraintInterface
 {
     /**
+     * Checks whether the given constraint intersects in any way with this constraint
+     *
      * @param ConstraintInterface $provider
      *
      * @return bool

src/Constraint/MultiConstraint.php

@@ -233,7 +233,7 @@ private static function optimizeConstraints(array $constraints, $conjunctive)
             $left = $constraints[0];
             $mergedConstraints = array();
             $optimized = false;
-            for ($i = 1, $l = \count($constraints); $i <$l; $i++) {
+            for ($i = 1, $l = \count($constraints); $i < $l; $i++) {
                 $right = $constraints[$i];
                 if (
                     $left instanceof MultiConstraint

src/Interval.php

@@ -0,0 +1,96 @@
+<?php
+
+/*
+ * This file is part of composer/semver.
+ *
+ * (c) Composer <https://github.com/composer>
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+namespace Composer\Semver;
+
+use Composer\Semver\Constraint\Constraint;
+
+class Interval
+{
+    /** @var Constraint */
+    private $start;
+    /** @var Constraint */
+    private $end;
+
+    public function __construct(Constraint $start, Constraint $end)
+    {
+        $this->start = $start;
+        $this->end = $end;
+    }
+
+    /**
+     * @return Constraint
+     */
+    public function getStart()
+    {
+        return $this->start;
+    }
+
+    /**
+     * @return Constraint
+     */
+    public function getEnd()
+    {
+        return $this->end;
+    }
+
+    /**
+     * @return Constraint
+     */
+    public static function zero()
+    {
+        static $zero;
+
+        if (null === $zero) {
+            $zero = new Constraint('>=', '0.0.0.0-dev');
+        }
+
+        return $zero;
+    }
+
+    /**
+     * @return Constraint
+     */
+    public static function positiveInfinity()
+    {
+        static $positiveInfinity;
+
+        if (null === $positiveInfinity) {
+            $positiveInfinity = new Constraint('<', PHP_INT_MAX.'.0.0.0');
+        }
+
+        return $positiveInfinity;
+    }
+
+    /**
+     * @return self
+     */
+    public static function any()
+    {
+        return new self(self::zero(), self::positiveInfinity());
+    }
+
+    /**
+     * @return Constraint
+     */
+    public static function anyDev()
+    {
+        static $anyDev;
+
+        if (null === $anyDev) {
+            // this ideally should be an EmptyConstraint but the code expects Constraint instances so
+            // this makes it work with less workarounds/checks above
+            $anyDev = new Constraint('==', 'dev*');
+        }
+
+        return $anyDev;
+    }
+}