'fix' memory leak issue, namespace functions and composer

Author: azjezz

README.md

@@ -1,14 +1,21 @@
 # Typed
 
-This libaray allows you to create typed variables in PHP 7.4 +
+This library allows you to create typed variables in PHP 7.4 +
 
-example :
+### Composer installation :
+```console
+$ composer require azjezz/typed
+```
+
+### Usage Example :
 
 ```php
 <?php declare(strict_types=1);
 
-$name = &string('saif');
-$age = &int(19);
+use Typed as t;
+
+$name = &t\string('saif');
+$age = &t\int(19);
 
 try {
 
@@ -18,45 +25,91 @@ try {
 
 } catch(TypeError $error) {
 
+} finally {
+    t\clean();
 }
-
-// based on the passed variable type
-$string = &typed('saif');
-$traversable = &traversable(new ArrayObject());
-$countable = &countable(new ArrayObject());
-$func = &func('strtolower');
-$object = &object((object) []);
-$stdClass = &stdClass((object) []);
-$iterable = &iterable([]);
-$bool = &bool(false);
-$bool = &boolean(true);
-$set = &set(['a', 'b', 'b', 'a']); // ['a', 'b']
-$vector = &vector(['a' => 1, 'b' => 2]); // [1, 2]
-$array = &arr(['a' => 1 , 'b' => 2]); // ['a' => 1, 'b' => 2]
-$keyset = &keyset(['a' => 1, 'b' => 2]); // ['a', 'b']
-$int = &integer(5);
-$int = &int(48);
-$string = &string('f');
-$float = &float(1.56);
 ```
 
-### callable => func, array => { arr, keyset, vector, set }
+#### callable => `func`, array => { `arr`, `keyset`, `vector`, `set` }
 Since `callable` and `array` cant be used for function names, instead i have used `func` for callable and `arr` for array.
 `keyset`, `vector` and `set` are just helper to help you create an array of keys ( `keyset = arr(array_keys($value))` ), an array of values ( `vector = arr(array_values($value))` ) and an array of unique values ( `set = arr(array_unique($value))` ).
 
-### typed 
-`typed()` is a function to help you create a typed variables based on the type of the passed variable, currently it supports `string`, `int`, `float`, `bool`, `object` and `iterable`. it was suggected by @mikesherov on [twitter](https://twitter.com/mikesherov/status/1084512906388144128).
+#### `typed` 
+`typed()` is a function to help you create a typed variables based on the type of the passed variable, currently it supports `string`, `int`, `float`, `bool`, `object` and `iterable`. it was suggested by @mikesherov on [twitter](https://twitter.com/mikesherov/status/1084512906388144128).
 
----
+#### `purge`, `clean`, `delete` and `c`
+As mentioned [here](https://twitter.com/drealecs/status/1084658093252849665) and [here](https://www.reddit.com/r/PHP/comments/afq3it/typed_variables_for_php_74/ee1belg), memory leak is a huge issue here, if a specific function created a typed variable, the variable will still exist inside the repository even after execution,
+for this i made some helper functions that allow you to remove variables from the repository.
 
-check this [twitter thread](https://twitter.com/dshafik/status/1084248443118219264).
+- `Typed\purge()` will delete every reference registered in the repository, you can call this function at the end of every request/response cycle in a web application per example.
+- `Typed\clean(string $namespace = 'default')` this function will delete every reference to a typed variable in a specific namespace as shown in the example above, its recommended to use a unique namespace every time you use typed variables and call `clean()` to ensure there's no memory leak.
+- `Typed\delete(mixed $value, string $namespace = 'default')` this function will delete the last created reference to typed variable with the given value in a specific namespace. example : 
+```php
+<?php declare(strict_types=1);
 
----
+use Typed as t;
+    
+$name = &t\string('azjezz', 'data');
+$age = &t\int(19, 'data');
 
-### Compoer installation :
-```console
-soon
+t\delete('azjezz', 'data');
+
+/**
+ * the reference to the `$name` variable has been deleted.
+ * therefor we can assign any type to the variable `$name` now. 
+ */
+$name = []; // works
 ```
+- `Typed\c` this function accepted a callable that take no arguments, the callable will be called inside `c` ( container ) and all the assigned typed variables in the time of the call would be deleted afterward, this makes it easier to ensure that function calls don't cause any memory leak. example :
+```php
+<?php declare(strict_types=1);
+
+use Typed as t;
+use function Typed\c;
+
+/**
+ * all assigned variables inside the callable will be destroyed after execution. 
+ */
+c(function(): void {
+    $name = &t\string('saif eddin');
+    $age = &t\int(5);
+    $arr = &t\arr([
+        'age' => $age,
+        'name' => $name    
+    ]);
+});
+
+```
+
+#### More :
+A cool PSR-15 Middleware to delete all typed variables created inside the next middleware/handler
+
+```php
+<?php declare(strict_types=1);
+
+use Psr\Http\Server\MiddlewareInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Message\ResponseInterface;
+use function Typed\c;
+
+class TypedMiddleware implements MiddlewareInterface 
+{
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
+    {
+        $response = null;
+        c(function() use($request, &$response, $handler) {
+            /**
+             * if any typed variable is created in the handler, it would be deleted after execution.
+             */
+            $response = $handler->handle($request);
+        });
+        return $response;
+    }
+}
+
+```
+
 
 #### TODO :
 - add `nullable*` functions.

composer.json

@@ -14,7 +14,7 @@
             "Typed\\": "src/Typed"
         },
         "files": [
-            "src/bootstrap.php"
+            "src/functions.php"
         ]
     },
     "require": {

src/Typed/InvalidArgumentException.php

@@ -4,4 +4,6 @@
 
 use InvalidArgumentException as ParentException;
 
-class InvalidArgumentException extends ParentException {}
+class InvalidArgumentException extends ParentException
+{
+}

src/Typed/Repository.php

@@ -2,12 +2,114 @@
 
 namespace Typed;
 
-final class Repository 
+use function array_key_exists;
+use function array_keys;
+use function array_reverse;
+use Typed\Variable\VariableInterface;
+
+final class Repository
 {
+    /**
+     * @var array<string, array<int, VariableInterface>> $variables
+     */
     private static array $variables = [];
-    private function __construct() {}
-    public static function add(Variable $var): void 
+
+    private function __construct()
+    {
+    }
+
+    /**
+     * Add a variable to the registry mapped by the given namespace.
+     *
+     * @param VariableInterface $var
+     * @param string            $namespace
+     */
+    public static function add(VariableInterface $var, string $namespace): void
+    {
+        static::$variables[$namespace][] = $var;
+    }
+
+    /**
+     * remove reference to all variables in the given namespace.
+     *
+     * @param string $namespace
+     */
+    public static function clean(string $namespace): void
+    {
+        unset(static::$variables[$namespace]);
+    }
+
+    /**
+     * Delete all references.
+     */
+    public static function purge(): void
+    {
+        static::$variables = [];
+    }
+
+    /**
+     * Delete all references to variables with the given value.
+     *
+     * @param mixed         $value      value to check.
+     * @param string|null   $namespace
+     */
+    public static function filter($value, string $namespace): void
+    {
+        foreach (static::$variables as $ns) {
+            if ($namespace !== $ns) {
+                continue;
+            }
+
+            /**
+             * @var VariableInterface $var
+             */
+            foreach ($ns as $i => $var) {
+                if ($var->getValue() === $value) {
+                    unset(static::$variables[$ns][$i]);
+                }
+            }
+        }
+    }
+
+    /**
+     * remove the last reference to variable with the given value in a specific namespace.
+     *
+     * @param        $value
+     * @param string $namespace
+     */
+    public static function delete($value, string $namespace): void
+    {
+        if (!array_key_exists($namespace, static::$variables)) {
+            return;
+        }
+
+        $keys = array_reverse(array_keys(static::$variables[$namespace]));
+        foreach ($keys as $k) {
+            /**
+             * @var VariableInterface $var
+             */
+            $var = static::$variables[$namespace][$k];
+            if ($var->getValue() === $value) {
+                unset(static::$variables[$namespace][$k]);
+                return;
+            }
+        }
+    }
+
+    /**
+     * Contain all typed variables in 1 call.
+     * All typed variables created during the callable execution, will be deleted.
+     *
+     * @param callable $call
+     */
+    public static function c(callable $call): void
     {
-        static::$variables[] = $var;
+        $variables = static::$variables;
+        static::$variables = [];
+        try {
+            $call();
+        } finally {
+            static::$variables = $variables;
+        }
     }
 }