Merge pull request #39 from nikolaposa/php8-syntax

PHP 8.0 as minimal requirement
nikolaposa · Dec 29, 2023 · 6a9911c · 6a9911c
2 parents f6bdd64 + a222161
commit 6a9911c
Show file tree

Hide file tree

Showing 21 changed files with 100 additions and 188 deletions.
diff --git a/.github/workflows/build.yaml b/.github/workflows/build.yaml
@@ -17,7 +17,7 @@ jobs:
     strategy:
       matrix:
         php-version:
-          - 7.2
+          - 8.0
 
     steps:
       - name: Checkout
@@ -54,7 +54,7 @@ jobs:
     strategy:
       matrix:
         php-version:
-          - 7.2
+          - 8.0
 
     steps:
       - name: Checkout
@@ -91,10 +91,10 @@ jobs:
     strategy:
       matrix:
         php-version:
-          - 7.2
-          - 7.3
-          - 7.4
           - 8.0
+          - 8.1
+          - 8.2
+          - 8.3
 
     steps:
       - name: Checkout
@@ -131,7 +131,7 @@ jobs:
     strategy:
       matrix:
         php-version:
-          - 7.2
+          - 8.0
 
     steps:
       - name: Checkout commit

diff --git a/composer.json b/composer.json
@@ -21,7 +21,7 @@
         "sort-packages": true
     },
     "require": {
-        "php": "^7.2 || ^8.0",
+        "php": "^8.0",
         "beberlei/assert": "^3.2"
     },
     "require-dev": {

diff --git a/phpstan.neon.dist b/phpstan.neon.dist
@@ -6,9 +6,6 @@ parameters:
     checkMissingIterableValueType: false
     checkGenericClassInNonGenericObjectType: false
     ignoreErrors:
-        - '~Method [a-zA-Z0-9\\_]+::from[a-zA-Z0-9_]*\(\) has no return typehint specified.~'
-        - '~Method [a-zA-Z0-9\\_]+OperationConstraint::[a-zA-Z0-9_]*\(\) has no return typehint specified.~'
-        - '~Method [a-zA-Z0-9\\_]+OperationConstraint::assert\(\) should return bool but return statement is missing.~'
         - '~Method [a-zA-Z0-9\\_]+OperationConstraintParser::buildConstraint\(\) should return [a-zA-Z0-9\\_]+OperationConstraint but return statement is missing.~'
 
 includes:

diff --git a/src/Comparison/Constraint/CompositeConstraint.php b/src/Comparison/Constraint/CompositeConstraint.php
@@ -12,11 +12,9 @@ class CompositeConstraint implements Constraint
     public const OPERATOR_AND = 'AND';
     public const OPERATOR_OR = 'OR';
 
-    /** @var string */
-    protected $operator;
+    protected string $operator;
 
-    /** @var Constraint[] */
-    protected $constraints;
+    protected array $constraints;
 
     final public function __construct(string $operator, Constraint $constraint, Constraint ...$constraints)
     {
@@ -60,7 +58,7 @@ public function assert(Version $version): bool
     protected function assertAnd(Version $version): bool
     {
         foreach ($this->constraints as $constraint) {
-            if (! $constraint->assert($version)) {
+            if (!$constraint->assert($version)) {
                 return false;
             }
         }

diff --git a/src/Comparison/Constraint/OperationConstraint.php b/src/Comparison/Constraint/OperationConstraint.php
@@ -17,11 +17,9 @@ class OperationConstraint implements Constraint
     public const OPERATOR_LT = '<';
     public const OPERATOR_LTE = '<=';
 
-    /** @var string */
-    protected $operator;
+    protected string $operator;
 
-    /** @var Version */
-    protected $operand;
+    protected Version $operand;
 
     final public function __construct(string $operator, Version $operand)
     {
@@ -31,41 +29,37 @@ final public function __construct(string $operator, Version $operand)
         $this->operand = $operand;
     }
 
-    public static function equalTo(Version $operand)
+    public static function equalTo(Version $operand): static
     {
         return new static(self::OPERATOR_EQ, $operand);
     }
 
-    public static function notEqualTo(Version $operand)
+    public static function notEqualTo(Version $operand): static
     {
         return new static(self::OPERATOR_NEQ, $operand);
     }
 
-    public static function greaterThan(Version $operand)
+    public static function greaterThan(Version $operand): static
     {
         return new static(self::OPERATOR_GT, $operand);
     }
 
-    public static function greaterOrEqualTo(Version $operand)
+    public static function greaterOrEqualTo(Version $operand): static
     {
         return new static(self::OPERATOR_GTE, $operand);
     }
 
-    public static function lessThan(Version $operand)
+    public static function lessThan(Version $operand): static
     {
         return new static(self::OPERATOR_LT, $operand);
     }
 
-    public static function lessOrEqualTo(Version $operand)
+    public static function lessOrEqualTo(Version $operand): static
     {
         return new static(self::OPERATOR_LTE, $operand);
     }
 
-    /**
-     * @param string $constraintString
-     * @return OperationConstraint|CompositeConstraint
-     */
-    public static function fromString(string $constraintString)
+    public static function fromString(string $constraintString): CompositeConstraint|OperationConstraint
     {
         static $parser = null;
 
@@ -88,31 +82,26 @@ public function getOperand(): Version
 
     public function assert(Version $version): bool
     {
-        switch ($this->operator) {
-            case self::OPERATOR_EQ:
-                return $version->isEqualTo($this->operand);
-            case self::OPERATOR_NEQ:
-                return !$version->isEqualTo($this->operand);
-            case self::OPERATOR_GT:
-                return $version->isGreaterThan($this->operand);
-            case self::OPERATOR_GTE:
-                return $version->isGreaterOrEqualTo($this->operand);
-            case self::OPERATOR_LT:
-                return $version->isLessThan($this->operand);
-            case self::OPERATOR_LTE:
-                return $version->isLessOrEqualTo($this->operand);
-        }
+        return match ($this->operator) {
+            self::OPERATOR_EQ => $version->isEqualTo($this->operand),
+            self::OPERATOR_NEQ => !$version->isEqualTo($this->operand),
+            self::OPERATOR_GT => $version->isGreaterThan($this->operand),
+            self::OPERATOR_GTE => $version->isGreaterOrEqualTo($this->operand),
+            self::OPERATOR_LT => $version->isLessThan($this->operand),
+            self::OPERATOR_LTE => $version->isLessOrEqualTo($this->operand),
+            default => throw InvalidOperationConstraint::unsupportedOperator($this->operator),
+        };
     }
 
     protected function validateOperator(string $operator): void
     {
         static $validOperators = null;
 
-        if (null === $validOperators) {
+        if ($validOperators === null) {
             $validOperators = (new ReflectionClass($this))->getConstants();
         }
 
-        if (! in_array($operator, $validOperators, true)) {
+        if (!in_array($operator, $validOperators, true)) {
             throw InvalidOperationConstraint::unsupportedOperator($operator);
         }
     }

diff --git a/src/Comparison/Constraint/OperationConstraintParser.php b/src/Comparison/Constraint/OperationConstraintParser.php
@@ -12,27 +12,24 @@ class OperationConstraintParser
 {
     public const OPERATOR_OR = '||';
 
-    /** @var string */
-    protected $constraintString;
+    protected string $constraintString;
 
-    /** @var array */
-    protected $constraintParts = [];
+    protected array $constraintParts = [];
 
     /**
-     * @param string $constraintString
      * @return OperationConstraint|CompositeConstraint
      */
     public function parse(string $constraintString)
     {
         $constraintString = trim($constraintString);
 
-        if ('' === $constraintString) {
+        if ($constraintString === '') {
             throw InvalidConstraintString::empty();
         }
 
         $this->constraintString = $constraintString;
 
-        if (! $this->isMultiPartConstraint()) {
+        if (!$this->isMultiPartConstraint()) {
             return $this->buildConstraint($this->constraintString);
         }
 
@@ -43,7 +40,7 @@ public function parse(string $constraintString)
 
     protected function isMultiPartConstraint(): bool
     {
-        return (false !== strpos($this->constraintString, ' '));
+        return str_contains($this->constraintString, ' ');
     }
 
     protected function splitConstraintParts(): void
@@ -65,7 +62,7 @@ protected function buildConstraint(string $constraintPart): OperationConstraint
                 $operator ?: OperationConstraint::OPERATOR_EQ,
                 Version::fromString($operandString)
             );
-        } catch (VersionException $ex) {
+        } catch (VersionException) {
             $this->error();
         }
     }

diff --git a/src/Comparison/Exception/InvalidCompositeConstraint.php b/src/Comparison/Exception/InvalidCompositeConstraint.php
@@ -7,7 +7,7 @@
 use InvalidArgumentException;
 use Version\Exception\VersionException;
 
-class InvalidCompositeConstraint extends InvalidArgumentException implements VersionException
+class InvalidCompositeConstraint extends InvalidArgumentException implements VersionComparisonException
 {
     public static function unsupportedOperator(string $operator): self
     {

diff --git a/src/Comparison/Exception/InvalidConstraintString.php b/src/Comparison/Exception/InvalidConstraintString.php
@@ -7,17 +7,17 @@
 use InvalidArgumentException;
 use Version\Exception\VersionException;
 
-class InvalidConstraintString extends InvalidArgumentException implements VersionException
+class InvalidConstraintString extends InvalidArgumentException implements VersionComparisonException
 {
     public static function empty(): self
     {
-        return new self('Comparision constraint string must not be empty');
+        return new self('Comparison constraint string must not be empty');
     }
 
     public static function notParsable(string $constraintString): self
     {
         return new self(sprintf(
-            "Comparision constraint string: '%s' is not valid and cannot be parsed",
+            "Comparison constraint string: '%s' is not valid and cannot be parsed",
             $constraintString
         ));
     }

diff --git a/src/Comparison/Exception/InvalidOperationConstraint.php b/src/Comparison/Exception/InvalidOperationConstraint.php
@@ -7,7 +7,7 @@
 use InvalidArgumentException;
 use Version\Exception\VersionException;
 
-class InvalidOperationConstraint extends InvalidArgumentException implements VersionException
+class InvalidOperationConstraint extends InvalidArgumentException implements VersionComparisonException
 {
     public static function unsupportedOperator(string $operator): self
     {

diff --git a/src/Comparison/Exception/VersionComparisonException.php b/src/Comparison/Exception/VersionComparisonException.php
@@ -4,8 +4,8 @@
 
 namespace Version\Comparison\Exception;
 
-use Throwable;
+use Version\Exception\VersionException;
 
-interface VersionComparisonException extends Throwable
+interface VersionComparisonException extends VersionException
 {
 }
diff --git a/src/Exception/InvalidVersionString.php b/src/Exception/InvalidVersionString.php
@@ -8,8 +8,7 @@
 
 class InvalidVersionString extends InvalidArgumentException implements VersionException
 {
-    /** @var string */
-    protected $versionString;
+    protected string $versionString;
 
     public static function notParsable(string $versionString): self
     {

diff --git a/src/Extension/Extension.php b/src/Extension/Extension.php
@@ -10,8 +10,7 @@ abstract class Extension
 {
     protected const IDENTIFIERS_SEPARATOR = '.';
 
-    /** @var array */
-    private $identifiers;
+    private array $identifiers;
 
     final protected function __construct(array $identifiers)
     {
@@ -25,17 +24,17 @@ final protected function __construct(array $identifiers)
      */
     abstract protected function validate(array $identifiers): void;
 
-    public static function from(string $identifier, string ...$identifiers)
+    public static function from(string $identifier, string ...$identifiers): static
     {
         return new static(func_get_args());
     }
 
-    public static function fromArray(array $identifiers)
+    public static function fromArray(array $identifiers): static
     {
         return new static($identifiers);
     }
 
-    public static function fromString(string $extension)
+    public static function fromString(string $extension): static
     {
         return new static(explode(self::IDENTIFIERS_SEPARATOR, trim($extension)));
     }