chore: Refactor memoization of time-consuming methods

Author: marienfressinaud

src/forms/collections/EditCollectionGroup.php

@@ -14,28 +14,25 @@
  */
 class EditCollectionGroup extends BaseForm
 {
+    use utils\Memoizer;
+
     #[Form\Field(transform: 'trim')]
     public string $name = '';
 
     public int $group_name_max_length = models\Group::NAME_MAX_LENGTH;
 
-    /** @var ?models\Group[] */
-    private ?array $cache_groups = null;
-
     /**
      * @return models\Group[]
      */
     public function groups(): array
     {
-        if ($this->cache_groups === null) {
+        return $this->memoize('groups', function (): array {
             $user = $this->user();
             $groups = models\Group::listBy([
                 'user_id' => $user->id,
             ]);
-            $this->cache_groups = utils\Sorter::localeSort($groups, 'name');
-        }
-
-        return $this->cache_groups;
+            return utils\Sorter::localeSort($groups, 'name');
+        });
     }
 
     /**

src/forms/collections/ShareCollection.php

@@ -4,6 +4,7 @@
 
 use App\forms\BaseForm;
 use App\models;
+use App\utils;
 use Minz\Form;
 use Minz\Request;
 use Minz\Translatable;
@@ -17,6 +18,8 @@
  */
 class ShareCollection extends BaseForm
 {
+    use utils\Memoizer;
+
     #[Form\Field]
     #[Validable\Presence(
         message: new Translatable('The type is required.'),
@@ -30,15 +33,11 @@ class ShareCollection extends BaseForm
     #[Form\Field(transform: 'trim')]
     public string $user_id = '';
 
-    private ?models\User $cache_user = null;
-
     public function user(): models\User
     {
-        if ($this->cache_user === null) {
-            $this->cache_user = models\User::require($this->user_id);
-        }
-
-        return $this->cache_user;
+        return $this->memoize('user', function (): models\User {
+            return models\User::require($this->user_id);
+        });
     }
 
     /**

src/forms/links/CollectionsSelector.php

@@ -14,6 +14,8 @@
  */
 trait CollectionsSelector
 {
+    use utils\Memoizer;
+
     /** @var string[] */
     #[Form\Field(bind: false)]
     public array $collection_ids = [];
@@ -24,9 +26,6 @@ trait CollectionsSelector
 
     public int $collection_name_max_length = models\Collection::NAME_MAX_LENGTH;
 
-    /** @var ?array<string, models\Collection[]> */
-    private ?array $cache_collection_values = null;
-
     public function user(): models\User
     {
         $user = $this->options->get('user');
@@ -48,45 +47,41 @@ public function user(): models\User
      */
     public function collectionsValues(): array
     {
-        if ($this->cache_collection_values !== null) {
-            return $this->cache_collection_values;
-        }
-
-        $user = $this->user();
+        return $this->memoize('collections_values', function (): array {
+            $user = $this->user();
 
-        $collection_values = [];
+            $collection_values = [];
 
-        $groups = models\Group::listBy(['user_id' => $user->id]);
-        $groups = utils\Sorter::localeSort($groups, 'name');
+            $groups = models\Group::listBy(['user_id' => $user->id]);
+            $groups = utils\Sorter::localeSort($groups, 'name');
 
-        $collections = $user->collections();
-        $collections = utils\Sorter::localeSort($collections, 'name');
-        $groups_to_collections = utils\Grouper::groupBy($collections, 'group_id');
+            $collections = $user->collections();
+            $collections = utils\Sorter::localeSort($collections, 'name');
+            $groups_to_collections = utils\Grouper::groupBy($collections, 'group_id');
 
-        $shared_collections = $user->sharedCollections(options: [
-            'access_type' => 'write',
-        ]);
-        $shared_collections = utils\Sorter::localeSort($shared_collections, 'name');
+            $shared_collections = $user->sharedCollections(options: [
+                'access_type' => 'write',
+            ]);
+            $shared_collections = utils\Sorter::localeSort($shared_collections, 'name');
 
-        // Add the collections with no groups first.
-        $collection_values[''] = $groups_to_collections[''] ?? [];
+            // Add the collections with no groups first.
+            $collection_values[''] = $groups_to_collections[''] ?? [];
 
-        // Add the collections with groups then
-        foreach ($groups as $group) {
-            if (isset($groups_to_collections[$group->id])) {
-                $collection_values[$group->name] = $groups_to_collections[$group->id];
+            // Add the collections with groups then
+            foreach ($groups as $group) {
+                if (isset($groups_to_collections[$group->id])) {
+                    $collection_values[$group->name] = $groups_to_collections[$group->id];
+                }
             }
-        }
 
-        // Finally, add the shared collections like it was a distinct group.
-        if ($shared_collections) {
-            $share_group_name = _('Shared with me');
-            $collection_values[$share_group_name] = $shared_collections;
-        }
-
-        $this->cache_collection_values = $collection_values;
+            // Finally, add the shared collections like it was a distinct group.
+            if ($shared_collections) {
+                $share_group_name = _('Shared with me');
+                $collection_values[$share_group_name] = $shared_collections;
+            }
 
-        return $collection_values;
+            return $collection_values;
+        });
     }
 
     /**

src/forms/links/RepairLink.php

@@ -4,6 +4,7 @@
 
 use App\forms\BaseForm;
 use App\models;
+use App\utils;
 use Minz\Form;
 use Minz\Translatable;
 use Minz\Validable;
@@ -14,6 +15,8 @@
  */
 class RepairLink extends BaseForm
 {
+    use utils\Memoizer;
+
     #[Form\Field(transform: '\SpiderBits\Url::sanitize')]
     #[Validable\Presence(
         message: new Translatable('The link is required.'),
@@ -26,15 +29,11 @@ class RepairLink extends BaseForm
     #[Form\Field]
     public bool $force_sync = false;
 
-    private ?string $cache_url_cleared = null;
-
     public function urlCleared(): string
     {
-        if ($this->cache_url_cleared === null) {
-            $this->cache_url_cleared = \SpiderBits\ClearUrls::clear($this->url);
-        }
-
-        return $this->cache_url_cleared;
+        return $this->memoize('url_cleared', function (): string {
+            return \SpiderBits\ClearUrls::clear($this->url);
+        });
     }
 
     public function hasDetectedTrackers(): bool

src/utils/Memoizer.php

@@ -0,0 +1,65 @@
+<?php
+
+namespace App\utils;
+
+/**
+ * The Memoizer trait can be used to cache the results of time-consuming functions.
+ *
+ * It wraps a function in a "memoize" callback. When the memoize() method is
+ * called, it checks if the result is present in the cache. If it's not, it
+ * calls the callback and caches the result.
+ *
+ *     use App\models;
+ *     use App\utils;
+ *
+ *     class MyClass
+ *     {
+ *         use utils\Memoizer;
+ *
+ *         public function timeConsumingMethod(): array
+ *         {
+ *             return $this->memoize('my_cache_key', function (): array {
+ *                 return models\User::listAll();
+ *             });
+ *         }
+ *     }
+ *
+ * In this example, `MyClass::timeConsumingMethod` can be called several time,
+ * but users will be fetched from the database only the first time.
+ *
+ * @author  Marien Fressinaud <dev@marienfressinaud.fr>
+ * @license http://www.gnu.org/licenses/agpl-3.0.en.html AGPL
+ */
+trait Memoizer
+{
+    /** @var array<string, mixed> */
+    private array $memoizer_cache = [];
+
+    /**
+     * Cache and return the result of a callback.
+     *
+     * @template T of mixed
+     *
+     * @param callable(): T $callback
+     *
+     * @return T
+     */
+    protected function memoize(string $key, callable $callback): mixed
+    {
+        if (!array_key_exists($key, $this->memoizer_cache)) {
+            $this->memoizer_cache[$key] = $callback();
+        }
+
+        return $this->memoizer_cache[$key];
+    }
+
+    /**
+     * Remove a result from the cache.
+     */
+    protected function unmemoize(string $key): void
+    {
+        if (array_key_exists($key, $this->memoizer_cache)) {
+            unset($this->memoizer_cache[$key]);
+        }
+    }
+}