Fixed #33 (#35)

Author: yaroslavche

README.md

@@ -34,25 +34,44 @@ $bitmask->set(EXECUTE);
 ```
 
 Exists [EnumBitMask](/src/EnumBitMask.php), which allows the same using PHP enum:
+The `EnumBitMask` allows you to work with bitmasks using PHP enums. It automatically detects if an enum is `int`-backed and uses the case's value. For `int`-backed enums, each case **must represent a single bit value** (e.g., 1, 2, 4, 8, etc.). Otherwise, an `InvalidEnumException` will be thrown.
 
 ```php
 use BitMask\EnumBitMask;
 
 enum Permissions
 {
-    case READ;
-    case WRITE;
-    case EXECUTE;
+    case READ; // Mapped to 1
+    case WRITE; // Mapped to 2
+    case EXECUTE; // Mapped to 4
 }
 
-// two arguments: required enum class-string and integer mask (default: 0)
+// Automatically maps UnitEnum based on their position
 $bitmask = new EnumBitMask(Permissions::class, 0b111);
 echo sprintf('mask: %d', $bitmask->get()); // mask: 7
 if ($bitmask->has(Permissions::READ)) {}
 $bitmask->remove(Permissions::EXECUTE);
 $bitmask->set(Permissions::EXECUTE);
 
-$bitmask->set(Unknown::Case); // throws an exception, only Permissions cases available
+// Works with int-backed enums
+enum Flags: int
+{
+    case User = 1;      // 0b001
+    case Admin = 8;     // 0b1000
+    case Guest = 32;    // 0b100000
+}
+
+$flagmask = new EnumBitMask(Flags::class, Flags::User | Flags::Admin);
+echo sprintf('mask: %d', $flagmask->get()); // mask: 9
+$flagmask->set(Flags::Guest);
+
+// Throws an InvalidEnumException if a value is not a single bit
+enum BadFlags: int
+{
+    case Bad = 3; // 0b11 - not a single bit
+}
+
+new EnumBitMask(BadFlags::class, 3); // Throws InvalidEnumException
 ```
 
 `EnumBitMask` have a factory methods:

composer.json

@@ -19,9 +19,9 @@
     "phpstan/phpstan": "*",
     "thecodingmachine/phpstan-strict-rules": "*",
     "infection/infection": "*",
-    "vimeo/psalm": "^5.22",
-    "psalm/plugin-phpunit": "^0.18.4",
-    "friendsofphp/php-cs-fixer": "^3.51"
+    "vimeo/psalm": "*",
+    "psalm/plugin-phpunit": "*",
+    "friendsofphp/php-cs-fixer": "*"
   },
   "authors": [
     {

src/BitMask.php

@@ -22,6 +22,7 @@ public function __toString(): string
         return (string) $this->mask;
     }
 
+    #[\Override]
     public function get(): int
     {
         return $this->mask;

src/EnumBitMask.php

@@ -4,12 +4,13 @@
 
 namespace BitMask;
 
+use BackedEnum;
+use BitMask\Exception\InvalidEnumException;
 use BitMask\Exception\NotSingleBitException;
 use BitMask\Exception\UnknownEnumException;
 use BitMask\Util\Bits;
 use UnitEnum;
 
-/** @psalm-suppress UnusedClass */
 final class EnumBitMask implements BitMaskInterface
 {
     private BitMask $bitmask;
@@ -19,6 +20,7 @@ final class EnumBitMask implements BitMaskInterface
 
     /**
      * @param class-string $enum
+     * @throws InvalidEnumException
      * @throws UnknownEnumException
      */
     public function __construct(
@@ -28,29 +30,51 @@ public function __construct(
         if (!is_subclass_of($this->enum, UnitEnum::class)) {
             throw new UnknownEnumException('EnumBitMask enum must be subclass of UnitEnum');
         }
-        foreach ($this->enum::cases() as $index => $case) {
-            $this->map[$case->name] = Bits::indexToBit($index);
+
+        $reflection = new \ReflectionEnum($this->enum);
+        /** @var null|\ReflectionNamedType $backingType */
+        $backingType = $reflection->getBackingType();
+        $backingTypeName = $backingType?->getName();
+        if ($reflection->isBacked() && $backingTypeName === 'int') {
+            /** @var \ReflectionEnumBackedCase $case */
+            foreach ($reflection->getCases() as $case) {
+                $value = $case->getBackingValue();
+                if (!is_int($value)) {
+                    throw new InvalidEnumException('Enum must be an int-backed enum with integer values');
+                }
+
+                if (!Bits::isSingleBit($value)) {
+                    throw new InvalidEnumException(sprintf('Enum case "%s" value is not a single bit', $case->name));
+                }
+
+                $this->map[$case->name] = $value;
+            }
+        } else {
+            foreach ($this->enum::cases() as $index => $case) {
+                $this->map[$case->name] = Bits::indexToBit($index);
+            }
         }
-        $this->bitmask = new BitMask($mask, count($this->enum::cases()) - 1);
+
+        $this->bitmask = new BitMask($mask, count($this->map) > 0 ? Bits::getMostSignificantBit(max($this->map)) : null);
     }
 
     /**
      * Create an instance with given flags on
      *
      * @param class-string $enum
-     * @throws UnknownEnumException|NotSingleBitException
+     * @throws UnknownEnumException|NotSingleBitException|InvalidEnumException
      */
     public static function create(string $enum, UnitEnum ...$bits): self
     {
-        return (new EnumBitMask($enum))->set(...$bits);
+        return (new self($enum))->set(...$bits);
     }
 
     /**
      * Create an instance with all flags on
      *
      * @psalm-suppress MixedMethodCall, MixedArgument
      * @param class-string $enum
-     * @throws UnknownEnumException|NotSingleBitException
+     * @throws UnknownEnumException|NotSingleBitException|InvalidEnumException
      */
     public static function all(string $enum): self
     {
@@ -62,25 +86,26 @@ public static function all(string $enum): self
      *
      * @psalm-suppress PossiblyUnusedMethod
      * @param class-string $enum
-     * @throws UnknownEnumException|NotSingleBitException
+     * @throws UnknownEnumException|NotSingleBitException|InvalidEnumException
      */
     public static function none(string $enum): self
     {
-        return self::create($enum);
+        return new self($enum);
     }
 
     /**
      * Create an instance without given flags on
      *
      * @psalm-suppress PossiblyUnusedMethod
      * @param class-string $enum
-     * @throws UnknownEnumException|NotSingleBitException
+     * @throws UnknownEnumException|NotSingleBitException|InvalidEnumException
      */
     public static function without(string $enum, UnitEnum ...$bits): self
     {
         return self::all($enum)->remove(...$bits);
     }
 
+    #[\Override]
     public function get(): int
     {
         return $this->bitmask->get();

src/Exception/InvalidEnumException.php

@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace BitMask\Exception;
+
+use Exception;
+
+final class InvalidEnumException extends Exception implements BitMaskExceptionInterface {}

tests/EnumBitMaskTest.php

@@ -7,9 +7,10 @@
 use BitMask\EnumBitMask;
 use BitMask\Exception\OutOfRangeException;
 use BitMask\Exception\UnknownEnumException;
-use BitMask\Tests\fixtures\Enum\BackedInt;
 use BitMask\Tests\fixtures\Enum\BackedString;
+use BitMask\Tests\fixtures\Enum\EmptyEnum;
 use BitMask\Tests\fixtures\Enum\Permissions;
+use BitMask\Tests\fixtures\Enum\RandomBackedInt;
 use BitMask\Tests\fixtures\Enum\Unknown;
 use PHPUnit\Framework\TestCase;
 
@@ -115,24 +116,15 @@ public function testRemoveTwice(): void
         assertSame(0, $enumBitmask->get());
     }
 
-    public function testBackedEnum(): void
+    public function testBackedStringEnum(): void
     {
-        // backed string
         $backedStringEnumBitmask = new EnumBitMask(BackedString::class, 3);
         assertTrue($backedStringEnumBitmask->has(BackedString::Create, BackedString::Read));
         assertFalse($backedStringEnumBitmask->has(BackedString::Update, BackedString::Delete));
         $backedStringEnumBitmask->remove(BackedString::Create, BackedString::Read);
         $backedStringEnumBitmask->set(BackedString::Update, BackedString::Delete);
         assertFalse($backedStringEnumBitmask->has(BackedString::Create, BackedString::Read));
         assertTrue($backedStringEnumBitmask->has(BackedString::Update, BackedString::Delete));
-        // backed int
-        $backedIntEnumBitmask = new EnumBitMask(BackedInt::class, 3);
-        assertTrue($backedIntEnumBitmask->has(BackedInt::Create, BackedInt::Read));
-        assertFalse($backedIntEnumBitmask->has(BackedInt::Update, BackedInt::Delete));
-        $backedIntEnumBitmask->remove(BackedInt::Create, BackedInt::Read);
-        $backedIntEnumBitmask->set(BackedInt::Update, BackedInt::Delete);
-        assertFalse($backedIntEnumBitmask->has(BackedInt::Create, BackedInt::Read));
-        assertTrue($backedIntEnumBitmask->has(BackedInt::Update, BackedInt::Delete));
     }
 
     public function testCreateFactory(): void
@@ -174,4 +166,37 @@ public function testWithoutFactory(): void
         $enumBitmask = EnumBitMask::without(Permissions::class, Permissions::Delete);
         assertSame(7, $enumBitmask->get());
     }
+
+    public function testIsIntBackedEnumRandom(): void
+    {
+        // random backed int
+        $backedIntEnumBitmask = new EnumBitMask(RandomBackedInt::class, 17);
+        assertTrue($backedIntEnumBitmask->has(RandomBackedInt::Bit1, RandomBackedInt::Bit3));
+        assertFalse($backedIntEnumBitmask->has(RandomBackedInt::Bit2));
+    }
+
+    public function testIsIntBackedEnumRandom2(): void
+    {
+        // random backed int
+        $enumBitmask = new EnumBitMask(RandomBackedInt::class);
+        $enumBitmask->set(RandomBackedInt::Bit3, RandomBackedInt::Bit4);
+        assertTrue($enumBitmask->has(RandomBackedInt::Bit3, RandomBackedInt::Bit4));
+    }
+
+    public function testWithNormalUnitEnum(): void
+    {
+        $bitmask = new EnumBitMask(Permissions::class, 1);
+        $this->assertInstanceOf(EnumBitMask::class, $bitmask);
+        $this->assertTrue($bitmask->has(Permissions::Create));
+        $this->assertFalse($bitmask->has(Permissions::Delete));
+        $bitmask->set(Permissions::Delete);
+        $this->assertTrue($bitmask->has(Permissions::Delete));
+    }
+
+    public function testWithEmptyEnum(): void
+    {
+        $bitmask = new EnumBitMask(EmptyEnum::class);
+        $this->assertInstanceOf(EnumBitMask::class, $bitmask);
+        $this->assertSame(0, $bitmask->get());
+    }
 }

tests/fixtures/Enum/EmptyEnum.php

@@ -0,0 +1,5 @@
+<?php
+
+namespace BitMask\Tests\fixtures\Enum;
+
+enum EmptyEnum {}

tests/fixtures/Enum/RandomBackedInt.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace BitMask\Tests\fixtures\Enum;
+
+enum RandomBackedInt: int
+{
+    case Bit1 = 1 << 0;
+    case Bit2 = 1 << 1;
+    case Bit4 = 1 << 3;
+    case Bit3 = 1 << 4;
+}