chore: rename all enum cases to PascalCase instead of SHOUT_CASE (#450)

Signed-off-by: azjezz <azjezz@protonmail.com>

Author: azjezz

docs/README.md

@@ -6,9 +6,9 @@
 
 # Components
 
-* [Psl\Async](../src/Psl/Async/README.md)
-* [Psl\Default](../src/Psl/Default/README.md)
-* [Psl\Range](../src/Psl/Range/README.md)
+ * [Psl\Async](../src/Psl/Async/README.md)
+ * [Psl\Default](../src/Psl/Default/README.md)
+ * [Psl\Range](../src/Psl/Range/README.md)
 
 ---
 

docs/component/html.md

@@ -20,6 +20,6 @@
 
 #### `Enums`
 
-- [Encoding](./../../src/Psl/Html/Encoding.php#L20)
+- [Encoding](./../../src/Psl/Html/Encoding.php#L17)
 
 

docs/documenter.php

@@ -66,7 +66,7 @@ function regenerate_documentation(): void
 
     $readme_template = File\read(__DIR__ . '/templates/README.template.md');
     $readme = Str\replace($readme_template, '{{ list }}', $components_documentation);
-    $mode = Filesystem\is_file($readme) ? File\WriteMode::TRUNCATE : File\WriteMode::OPEN_OR_CREATE;
+    $mode = Filesystem\is_file($readme) ? File\WriteMode::Truncate : File\WriteMode::OpenOrCreate;
     File\write(__DIR__ . '/README.md', $readme, $mode);
 
     foreach ($components as $component) {
@@ -143,7 +143,7 @@ function document_component(string $component, string $index_link): void
         ), "\n"),
     ]);
 
-    $mode = Filesystem\is_file($current_filename) ? File\WriteMode::TRUNCATE : File\WriteMode::OPEN_OR_CREATE;
+    $mode = Filesystem\is_file($current_filename) ? File\WriteMode::Truncate : File\WriteMode::OpenOrCreate;
     File\write($current_filename, $documentation, $mode);
 }
 

docs/templates/README.template.md

@@ -7,6 +7,7 @@
 # Components
 
  * [Psl\Async](../src/Psl/Async/README.md)
+ * [Psl\Default](../src/Psl/Default/README.md)
  * [Psl\Range](../src/Psl/Range/README.md)
 
 ---

src/Psl/Encoding/Base64/Internal/Base64.php

@@ -36,11 +36,11 @@ abstract class Base64
     public static function encode(string $binary, bool $padding = true): string
     {
         $dest = '';
-        $binary_length = Str\length($binary, encoding: Str\Encoding::ASCII_8BIT);
+        $binary_length = Str\length($binary, encoding: Str\Encoding::Ascii8bit);
 
         for ($i = 0; $i + 3 <= $binary_length; $i += 3) {
             /** @var array<int, int> $chunk */
-            $chunk = unpack('C*', Str\slice($binary, $i, 3, encoding: Str\Encoding::ASCII_8BIT));
+            $chunk = unpack('C*', Str\slice($binary, $i, 3, encoding: Str\Encoding::Ascii8bit));
             $byte0 = $chunk[1];
             $byte1 = $chunk[2];
             $byte2 = $chunk[3];
@@ -55,7 +55,7 @@ public static function encode(string $binary, bool $padding = true): string
              *
              * @var array<int, int> $chunk
              */
-            $chunk = unpack('C*', Str\slice($binary, $i, $binary_length - $i, encoding: Str\Encoding::ASCII_8BIT));
+            $chunk = unpack('C*', Str\slice($binary, $i, $binary_length - $i, encoding: Str\Encoding::Ascii8bit));
             $byte0 = $chunk[1];
             if ($i + 1 < $binary_length) {
                 $byte1 = $chunk[2];
@@ -92,7 +92,7 @@ public static function encode(string $binary, bool $padding = true): string
      */
     public static function decode(string $base64, bool $explicit_padding = true): string
     {
-        $base64_length = Str\length($base64, encoding: Str\Encoding::ASCII_8BIT);
+        $base64_length = Str\length($base64, encoding: Str\Encoding::Ascii8bit);
         if ($base64_length === 0) {
             return '';
         }
@@ -105,13 +105,13 @@ public static function decode(string $base64, bool $explicit_padding = true): st
 
         /** @psalm-suppress MissingThrowsDocblock */
         $base64 = Str\trim_right($base64, '=');
-        $base64_length = Str\length($base64, encoding: Str\Encoding::ASCII_8BIT);
+        $base64_length = Str\length($base64, encoding: Str\Encoding::Ascii8bit);
 
         $err = 0;
         $dest = '';
         for ($i = 0; $i + 4 <= $base64_length; $i += 4) {
             /** @var array<int, int> $chunk */
-            $chunk = unpack('C*', Str\slice($base64, $i, 4, encoding: Str\Encoding::ASCII_8BIT));
+            $chunk = unpack('C*', Str\slice($base64, $i, 4, encoding: Str\Encoding::Ascii8bit));
             $char0 = static::decode6Bits($chunk[1]);
             $char1 = static::decode6Bits($chunk[2]);
             $char2 = static::decode6Bits($chunk[3]);
@@ -130,7 +130,7 @@ public static function decode(string $base64, bool $explicit_padding = true): st
              *
              * @var array<int, int> $chunk
              */
-            $chunk = unpack('C*', Str\slice($base64, $i, $base64_length - $i, encoding: Str\Encoding::ASCII_8BIT));
+            $chunk = unpack('C*', Str\slice($base64, $i, $base64_length - $i, encoding: Str\Encoding::Ascii8bit));
             $char0 = static::decode6Bits($chunk[1]);
             if ($i + 2 < $base64_length) {
                 $char1 = static::decode6Bits($chunk[2]);

src/Psl/Encoding/Base64/Variant.php

@@ -21,7 +21,7 @@ enum Variant implements DefaultInterface
      *
      * This variant is typically used in MIME messages and XML data.
      */
-    case Default;
+    case Standard;
 
     /**
      * A URL and filename safe Base64 encoding variant.
@@ -64,8 +64,17 @@ enum Variant implements DefaultInterface
      */
     case DotSlashOrdered;
 
+    /**
+     * Provides the default variant for Base64 encoding.
+     *
+     * By default, this method returns the `Standard` variant, which is widely used across
+     * various applications, including MIME messages and XML data. It represents a safe
+     * and common choice for general-purpose encoding needs.
+     *
+     * @return static The `Standard` variant of Base64 encoding.
+     */
     public static function default(): static
     {
-        return self::Default;
+        return self::Standard;
     }
 }

src/Psl/Encoding/Base64/decode.php

@@ -15,10 +15,10 @@
  *                                  the base64 characters range.
  * @throws Exception\IncorrectPaddingException If the encoded string has an incorrect padding.
  */
-function decode(string $base64, Variant $variant = Variant::Default, bool $explicit_padding = true): string
+function decode(string $base64, Variant $variant = Variant::Standard, bool $explicit_padding = true): string
 {
     return match ($variant) {
-        Variant::Default => Internal\Base64::decode($base64, $explicit_padding),
+        Variant::Standard => Internal\Base64::decode($base64, $explicit_padding),
         Variant::UrlSafe => Internal\Base64UrlSafe::decode($base64, $explicit_padding),
         Variant::DotSlash => Internal\Base64DotSlash::decode($base64, $explicit_padding),
         Variant::DotSlashOrdered => Internal\Base64DotSlashOrdered::decode($base64, $explicit_padding),

src/Psl/Encoding/Base64/encode.php

@@ -9,10 +9,10 @@
  *
  * @pure
  */
-function encode(string $binary, Variant $variant = Variant::Default, bool $padding = true): string
+function encode(string $binary, Variant $variant = Variant::Standard, bool $padding = true): string
 {
     return match ($variant) {
-        Variant::Default => Internal\Base64::encode($binary, $padding),
+        Variant::Standard => Internal\Base64::encode($binary, $padding),
         Variant::UrlSafe => Internal\Base64UrlSafe::encode($binary, $padding),
         Variant::DotSlash => Internal\Base64DotSlash::encode($binary, $padding),
         Variant::DotSlashOrdered => Internal\Base64DotSlashOrdered::encode($binary, $padding),

src/Psl/Encoding/Hex/decode.php

@@ -27,7 +27,7 @@ function decode(string $hexadecimal): string
         );
     }
 
-    $hex_len = Str\length($hexadecimal, Str\Encoding::ASCII_8BIT);
+    $hex_len = Str\length($hexadecimal, Str\Encoding::Ascii8bit);
     if (($hex_len & 1) !== 0) {
         throw new Exception\RangeException(
             'Expected an even number of hexadecimal characters.',

src/Psl/File/HandleInterface.php

@@ -35,7 +35,7 @@ public function getSize(): int;
      * Example:
      *
      * ```php
-     * $lock = $file->lock(LockType::SHARED);
+     * $lock = $file->lock(LockType::Shared);
      * // lock has been acquired.
      * $lock->release();
      * ```
@@ -53,7 +53,7 @@ public function lock(LockType $type): Lock;
      *
      * ```php
      * try {
-     *   $lock = $file->tryLock(LockType::SHARED);
+     *   $lock = $file->tryLock(LockType::Shared);
      *   // lock has been acquired.
      *   $lock->release();
      * } catch(AlreadyLockedException) {

src/Psl/File/Internal/ResourceHandle.php

@@ -108,7 +108,7 @@ public function tryLock(LockType $type): Lock
             throw new Exception\AlreadyClosedException('Handle has already been closed.');
         }
 
-        $operations = LOCK_NB | ($type === LockType::EXCLUSIVE ? LOCK_EX : LOCK_SH);
+        $operations = LOCK_NB | ($type === LockType::Exclusive ? LOCK_EX : LOCK_SH);
         $success = @flock($this->stream, $operations, $would_block);
         // @codeCoverageIgnoreStart
         if ($would_block) {
@@ -118,7 +118,7 @@ public function tryLock(LockType $type): Lock
         if (!$success) {
             throw new File\Exception\RuntimeException(Str\format(
                 'Could not acquire %s lock for "%s".',
-                $type === LockType::EXCLUSIVE ? 'exclusive' : 'shared',
+                $type === LockType::Exclusive ? 'exclusive' : 'shared',
                 $this->getPath(),
             ));
         }

src/Psl/File/Lock.php

@@ -11,9 +11,9 @@ final class Lock
     private bool $released = false;
 
     /**
-     * @param (Closure(): void) $release
+     * @param (Closure(): void) $releaseCallback
      *
-     * @internal use HandleInterface::lock() to create a lock.
+     * @internal use {@see HandleInterface::lock()} to create a lock.
      */
     public function __construct(
         public readonly LockType $type,

src/Psl/File/LockType.php

@@ -11,11 +11,11 @@ enum LockType
      * commonly called a reader lock. The creation of a Lock will block until
      * the lock is acquired.
      */
-    case SHARED;
+    case Shared;
 
     /**
      * Only a single process may possess an exclusive lock to a given file at a
      * time. The creation of a Lock will block until the lock is acquired.
      */
-    case EXCLUSIVE;
+    case Exclusive;
 }

src/Psl/File/ReadWriteHandle.php

@@ -25,14 +25,14 @@ final class ReadWriteHandle extends Internal\AbstractHandleWrapper implements Re
      * @throws Exception\NotReadableException If $file exists, and is non-readable.
      * @throws Exception\RuntimeException If unable to create the $file if it does not exist.
      */
-    public function __construct(string $file, WriteMode $write_mode = WriteMode::OPEN_OR_CREATE)
+    public function __construct(string $file, WriteMode $write_mode = WriteMode::OpenOrCreate)
     {
         $is_file = Filesystem\is_file($file);
         if (!$is_file && Filesystem\exists($file)) {
             throw Exception\NotFileException::for($file);
         }
 
-        $must_create = $write_mode === WriteMode::MUST_CREATE;
+        $must_create = $write_mode === WriteMode::MustCreate;
         if ($must_create && $is_file) {
             throw Exception\AlreadyCreatedException::for($file);
         }

src/Psl/File/WriteHandle.php

@@ -23,14 +23,14 @@ final class WriteHandle extends Internal\AbstractHandleWrapper implements WriteH
      * @throws Exception\NotWritableException If $file is non-writable.
      * @throws Exception\RuntimeException If unable to create the $file if it does not exist.
      */
-    public function __construct(string $file, WriteMode $write_mode = WriteMode::OPEN_OR_CREATE)
+    public function __construct(string $file, WriteMode $write_mode = WriteMode::OpenOrCreate)
     {
         $is_file = Filesystem\is_file($file);
         if (!$is_file && Filesystem\exists($file)) {
             throw Exception\NotFileException::for($file);
         }
 
-        $must_create = $write_mode === WriteMode::MUST_CREATE;
+        $must_create = $write_mode === WriteMode::MustCreate;
         if ($must_create && $is_file) {
             throw Exception\AlreadyCreatedException::for($file);
         }

src/Psl/File/WriteMode.php

@@ -10,29 +10,29 @@ enum WriteMode: string
      * Open the file for writing only; place the file pointer at the beginning of
      * the file.
      *
-     * If the file exits, it is not truncated (as with `TRUNCATE`), and the call
-     * succeeds (unlike `MUST_CREATE`).
+     * If the file exits, it is not truncated (as with `Truncate`), and the call
+     * succeeds (unlike `MustCreate`).
      */
-    case OPEN_OR_CREATE = 'cb';
+    case OpenOrCreate = 'cb';
 
     /**
      * Open for writing only; place the file pointer at the beginning of the
      * file and truncate the file to zero length. If the file does not exist,
      * attempt to create it.
      */
-    case TRUNCATE = 'wb';
+    case Truncate = 'wb';
 
     /**
      * Open for writing only; place the file pointer at the end of the file. If
      * the file does not exist, attempt to create it. In this mode, seeking has
      * no effect, writes are always appended.
      */
-    case APPEND = 'ab';
+    case Append = 'ab';
 
     /**
      * Create and open for writing only; place the file pointer at the beginning
      * of the file. If the file already exists, the filesystem call will throw an
      * exception. If the file does not exist, attempt to create it.
      */
-    case MUST_CREATE = 'xb';
+    case MustCreate = 'xb';
 }

src/Psl/File/open_read_write.php

@@ -16,7 +16,7 @@
  * @throws Exception\NotReadableException If $file exists, and is non-readable.
  * @throws Exception\RuntimeException If unable to create the $file if it does not exist.
  */
-function open_read_write(string $path, WriteMode $write_mode = WriteMode::OPEN_OR_CREATE): ReadWriteHandleInterface
+function open_read_write(string $path, WriteMode $write_mode = WriteMode::OpenOrCreate): ReadWriteHandleInterface
 {
     return new ReadWriteHandle($path, $write_mode);
 }

src/Psl/File/open_write_only.php

@@ -15,7 +15,7 @@
  * @throws Exception\NotWritableException If $file exists, and is non-writable.
  * @throws Exception\RuntimeException If unable to create the $file if it does not exist.
  */
-function open_write_only(string $file, WriteMode $mode = WriteMode::OPEN_OR_CREATE): WriteHandleInterface
+function open_write_only(string $file, WriteMode $mode = WriteMode::OpenOrCreate): WriteHandleInterface
 {
     return new WriteHandle($file, $mode);
 }

src/Psl/File/read.php

@@ -24,7 +24,7 @@ function read(string $file, int $offset = 0, ?int $length = null): string
 {
     try {
         $handle = namespace\open_read_only($file);
-        $lock = $handle->lock(namespace\LockType::SHARED);
+        $lock = $handle->lock(namespace\LockType::Shared);
 
         $handle->seek($offset);
         $content = $handle->readAll($length);

src/Psl/File/write.php

@@ -21,13 +21,13 @@
  * @throws Exception\NotWritableException If $file exists, and is non-writable.
  * @throws Exception\RuntimeException In case of an error.
  */
-function write(string $file, string $content, WriteMode $mode = WriteMode::OPEN_OR_CREATE): void
+function write(string $file, string $content, WriteMode $mode = WriteMode::OpenOrCreate): void
 {
     clearstatcache();
 
     try {
         $handle = File\open_write_only($file, $mode);
-        $lock = $handle->lock(File\LockType::EXCLUSIVE);
+        $lock = $handle->lock(File\LockType::Exclusive);
 
         $handle->writeAll($content);
 

src/Psl/Filesystem/copy.php

@@ -40,11 +40,11 @@ function copy(string $source, string $destination, bool $overwrite = false): voi
         $source_handle = File\open_read_only($source);
         $destination_handle = File\open_write_only(
             $destination,
-            $destination_exists ? File\WriteMode::TRUNCATE : File\WriteMode::OPEN_OR_CREATE,
+            $destination_exists ? File\WriteMode::Truncate : File\WriteMode::OpenOrCreate,
         );
 
-        $source_lock = $source_handle->lock(File\LockType::SHARED);
-        $destination_lock = $destination_handle->lock(File\LockType::EXCLUSIVE);
+        $source_lock = $source_handle->lock(File\LockType::Shared);
+        $destination_lock = $destination_handle->lock(File\LockType::Exclusive);
 
         while ($chunk = $source_handle->read()) {
             $destination_handle->writeAll($chunk);