Added new version for PHP >= 8.0

Author: Lawondyss

README.md

@@ -11,12 +11,12 @@ composer require lawondyss/config
 ```php
 class DbConfig extend Lawondyss\Config
 {
-  public $driver;
-  public $host;
-  public $database;
-  public $username;
-  public $password;
-  public $charset;
+  public string $driver;
+  public string $host;
+  public string $database;
+  public string $username;
+  public string $password;
+  public string $charset;
 }
 
 $dbConfig = DbConfig::fromArray([
@@ -29,7 +29,7 @@ $dbConfig = DbConfig::fromArray([
 ]);
 ```
 
-Simple call individual option.
+Simple get and set individual option.
 ```php
 $charset = $dbConfig->charset;
 $dbConfig->charset = 'latin1';
@@ -45,12 +45,12 @@ If you want default values, then defined in class.
 ```php
 class DbConfig extend Lawondyss\Config
 {
-  public $driver = 'mysqli';
-  public $host = 'localhost';
-  public $database;
-  public $username;
-  public $password;
-  public $charset = 'utf8';
+  public string $driver = 'mysqli';
+  public string $host = 'localhost';
+  public string $database;
+  public string $username;
+  public string $password;
+  public string $charset = 'utf8';
 }
 
 $defaultConfig = new DbConfig;

composer.json

@@ -3,24 +3,24 @@
   "description": "Base class for creating own class of configuration. Better than a associative array :-)",
   "type": "library",
   "license": "MIT",
+  "version": "2.0.0",
   "authors": [
     {
       "name": "Ladislav Vondráček",
       "email": "lad.von@gmail.com"
     }
   ],
   "require": {
-    "php": ">=7.1"
+    "php": ">=8.0"
   },
   "require-dev": {
-    "nette/tester": "^2.3",
-    "tracy/tracy": "^2.7"
+    "nette/tester": "^2.5",
+    "tracy/tracy": "^2.10"
   },
   "autoload": {
     "psr-4": {
       "Lawondyss\\Config\\": "src/Config"
-    },
-    "files": ["src/Config/exceptions.php"]
+    }
   },
   "scripts": {
     "tests": "tester tests/"

src/Config/Config.php

@@ -5,7 +5,18 @@
 
 namespace Lawondyss\Config;
 
-abstract class Config implements \ArrayAccess, \Countable, \IteratorAggregate
+use ArrayAccess;
+use Countable;
+use IteratorAggregate;
+use RecursiveArrayIterator;
+use ReflectionObject;
+use ReflectionProperty;
+use function array_map;
+use function count;
+use function is_array;
+use function property_exists;
+
+abstract class Config implements ArrayAccess, Countable, IteratorAggregate
 {
   /**
    * @param array<string, mixed> $options
@@ -30,17 +41,14 @@ public function toArray(): array
   {
     $arr = [];
     $properties = $this->getProperties();
+
     foreach ($properties as $name) {
       $value = $this->$name;
 
       if ($value instanceof self) {
         $value = $value->toArray();
-      } elseif (is_array($value) && count($value) === count(array_filter($value, function($item) {
-            return $item instanceof self;
-          }))) {
-        $value = array_map(function(Config $item) {
-          return $item->toArray();
-        }, $value);
+      } elseif (is_array($value)) {
+        $value = array_map(fn(mixed $val) => $val instanceof Config ? $val->toArray() : $val, $value);
       }
 
       $arr[$name] = $value;
@@ -57,67 +65,60 @@ public function toArray(): array
   public function withOptions(array $options): Config
   {
     $dolly = clone $this;
-    foreach ($options as $option => $value) {
-      $dolly->$option = $value;
+
+    foreach ($options as $name => $value) {
+      $dolly->$name = $value;
     }
 
     return $dolly;
   }
 
 
-  public function offsetExists($offset)
+  public function offsetExists($offset): bool
   {
-    return property_exists(static::class, $offset) && $this->$offset !== null;
+    return property_exists($this::class, $offset) && $this->$offset !== null;
   }
 
 
-  public function offsetGet($offset)
+  public function offsetGet($offset): mixed
   {
     return $this->$offset;
   }
 
 
-  public function offsetSet($offset, $value)
+  public function offsetSet($offset, $value): void
   {
     $this->$offset = $value;
   }
 
 
-  public function offsetUnset($offset)
+  public function offsetUnset($offset): void
   {
     $this->$offset = null;
   }
 
 
-  public function count()
+  public function count(): int
   {
     return count($this->getProperties());
   }
 
 
-  public function getIterator()
+  public function getIterator(): RecursiveArrayIterator
   {
-    return new \RecursiveArrayIterator($this->toArray());
+    return new RecursiveArrayIterator($this->toArray());
   }
 
 
   public function __get($name)
   {
-    $this->assertOptionDefined($name);
+    throw UndefinedOption::create($this::class, $name, $this->getProperties());
   }
 
 
   public function __set($name, $value)
   {
-    $this->assertOptionDefined($name);
-  }
-
-
-  private function assertOptionDefined(string $optionName): void
-  {
-    if (!property_exists(static::class, $optionName)) {
-      throw UndefinedOption::create(static::class, $optionName);
-    }
+    throw UndefinedOption::create($this::class, $name, $this->getProperties());
   }
 
 
@@ -126,17 +127,11 @@ private function assertOptionDefined(string $optionName): void
    */
   private function getProperties(): array
   {
-    static $cachedProperties = null;
-
-    if (!isset($cachedProperties)) {
-      $cachedProperties = [];
-
-      $rf = new \ReflectionObject($this);
-      foreach ($rf->getProperties() as $property) {
-        $cachedProperties[] = $property->name;
-      }
-    }
+    static $cachedProperties = [];
 
-    return $cachedProperties;
+    return $cachedProperties[$this::class] ??= (fn(): array  => array_map(
+      fn(ReflectionProperty $rp): string => $rp->name,
+      (new ReflectionObject($this))->getProperties(~ReflectionProperty::IS_STATIC)
+    ))();
   }
 }

src/Config/UndefinedOption.php

@@ -0,0 +1,47 @@
+<?php
+/**
+ * @author Ladislav Vondráček <lad.von@gmail.com>
+ */
+
+namespace Lawondyss\Config;
+
+use InvalidArgumentException;
+use function levenshtein;
+use function sprintf;
+use function strlen;
+
+class UndefinedOption extends InvalidArgumentException
+{
+  /**
+   * @param string[] $possibilities
+   */
+  public static function create(string $configuratorName, string $optionName, array $possibilities): self
+  {
+    $message = sprintf('Option %s::$%s is not defined', $configuratorName, $optionName);
+    $suggestion = self::getSuggestion($possibilities, $optionName);
+
+    if (isset($suggestion)) {
+      $message .= sprintf(', do you mean "%s"?', $suggestion);
+    }
+
+    return new self($message);
+  }
+
+
+  private static function getSuggestion(array $possibilities, string $name): ?string
+  {
+    $best = null;
+    $min = (strlen($name) / 4 + 1) * 10 + .1;
+
+    foreach ($possibilities as $item) {
+      $len = levenshtein($item, $name, 10, 11, 10);
+
+      if ($len > 0 && $len < $min) {
+        $min = $len;
+        $best = $item;
+      }
+    }
+
+    return $best;
+  }
+}