issue with sanitize

.github/workflows/lint.yaml

@@ -1,21 +1,40 @@
-name: Lint
-on: [push, pull_request]
+name: Coding standards
+on: [push]
 jobs:
-    lint:
-        name: PHP Lint
-        runs-on: ubuntu-latest
-        steps:
-            - name: Setup PHP
-              uses: shivammathur/setup-php@v2
-              with:
-                  php-version: 8.3
+  lint:
+    name: Coding standards
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        php: [ '8.3', '8.4' ]
 
-            - name: Cache Composer dependencies
-              uses: actions/cache@v4
-              with:
-                  path: /tmp/composer-cache
-                  key: ${{ runner.os }}-${{ hashFiles('**/composer.lock') }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
 
-            - uses: actions/checkout@v4
-            - name: lint
-              run: make app:lint
+      - name: Setup PHP
+        uses: shivammathur/setup-php@v2
+        with:
+          php-version: ${{ matrix.php }}
+          tools: composer:v2
+
+      - name: Setup cache
+        run: echo "COMPOSER_CACHE_DIR=$(composer config cache-dir)" >> $GITHUB_ENV
+
+      - name: Cache dependencies installed with composer
+        uses: actions/cache@v4
+        with:
+          path: ${{ env.COMPOSER_CACHE_DIR }}
+          key: php${{ matrix.php }}-composer-${{ hashFiles('**/composer.json') }}
+          restore-keys: |
+            php${{ matrix.php }}-composer-latest-
+
+      - name: Update composer
+        run: composer self-update
+
+      - name: Install dependencies with composer
+        run: composer install --prefer-dist --no-interaction --no-progress --optimize-autoloader --ansi
+
+      - name: Run code quality analysis
+        run: composer app:lint

.github/workflows/test.yaml

@@ -1,21 +1,40 @@
-name: Test
-on: [push, pull_request]
+name: Tests
+on: [push]
 jobs:
-    lint:
-        name: PHP Test
-        runs-on: ubuntu-latest
-        steps:
-            - name: Setup PHP
-              uses: shivammathur/setup-php@v2
-              with:
-                  php-version: 8.3
+  test:
+    name: Tests
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        php: [ '8.3', '8.4' ]
 
-            - name: Cache Composer dependencies
-              uses: actions/cache@v4
-              with:
-                  path: /tmp/composer-cache
-                  key: ${{ runner.os }}-${{ hashFiles('**/composer.lock') }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
 
-            - uses: actions/checkout@v4
-            - name: test
-              run: make app:test
+      - name: Setup PHP
+        uses: shivammathur/setup-php@v2
+        with:
+          php-version: ${{ matrix.php }}
+          tools: composer:v2
+
+      - name: Setup cache
+        run: echo "COMPOSER_CACHE_DIR=$(composer config cache-dir)" >> $GITHUB_ENV
+
+      - name: Cache dependencies installed with composer
+        uses: actions/cache@v4
+        with:
+          path: ${{ env.COMPOSER_CACHE_DIR }}
+          key: php${{ matrix.php }}-composer-${{ hashFiles('**/composer.json') }}
+          restore-keys: |
+            php${{ matrix.php }}-composer-latest-
+
+      - name: Update composer
+        run: composer self-update
+
+      - name: Install dependencies with composer
+        run: composer install --prefer-dist --no-interaction --no-progress --optimize-autoloader --ansi
+
+      - name: Run tests
+        run: composer app:test

composer.json

@@ -41,7 +41,7 @@
         ],
         "app:lint:fix": [
             "vendor/bin/ecs check --fix",
-            "venodr/bin/rector"
+            "vendor/bin/rector"
         ],
         "app:test": "vendor/bin/phpunit"
     }

src/BlockFactory.php

@@ -34,19 +34,36 @@
  *
  * @author bernard-ng <bernard@devscast.tech>
  */
-abstract readonly class BlockFactory
+abstract class BlockFactory
 {
+    /**
+     * @throws EditorException
+     *
+     * reduire la complexite de O(n) a O(1) evitant de tout le temps checker toutes les conditions
+     */
+    private static array $blockFactories = [];
+
     /**
      * @throws EditorException
      */
     public static function parse(string $data, ?array $tools = null, array $allowedTags = []): array
     {
         try {
+            /** @var array{time: int, blocks: array<array{id: string, type: string, data: mixed}>} $blocks */
             $blocks = json_decode($data, true, flags: JSON_THROW_ON_ERROR);
             $mapper = fn (array $block): Block => self::create($block, self::getAllowedTags($block, $allowedTags));
 
+            // TODO: whitelist tools and supported blocks
+            //            if ($tools !== null) {
+            //                $blocks = self::filter($blocks['blocks'], $tools);
+            //            }
+
             if ($tools !== null) {
-                $blocks = self::filter($blocks['blocks'], $tools);
+                $blocks['blocks'] = self::filter($blocks['blocks'], $tools);
+
+                if (empty($blocks['blocks'])) {
+                    throw new EditorException('No valid blocks found after filtering');
+                }
             }
 
             return array_map($mapper, $blocks['blocks']);
@@ -55,57 +72,68 @@ public static function parse(string $data, ?array $tools = null, array $allowedT
         }
     }
 
-    private static function filter(array $data, array $tools): array
+    //    private static function filter(array $data, array $tools): array
+    //    {
+    //        return array_filter($data, fn (array $block): bool => isset($tools[$block['type']]));
+    //    }
+
+    private static function filter(array $blocks, array $tools): array
     {
-        return array_filter($data, fn (array $block): bool => isset($tools[$block['type']]));
+        return array_filter($blocks, fn (array $block) => in_array($block['type'], $tools, true));
+    }
+
+    private static function initializeFactories(): void
+    {
+        if (self::$blockFactories !== []) {
+            return;
+        }
+        self::$blockFactories = [
+            'attaches' => static fn (array $data, array $allowedTags) => Attaches::create($data, $allowedTags),
+            'code' => static fn (array $data, array $allowedTags) => Code::create($data, $allowedTags),
+            'delimiter' => static fn (array $data, array $allowedTags) => Delimiter::create($data, $allowedTags),
+            'embed' => static fn (array $data, array $allowedTags) => Embed::create($data, $allowedTags),
+            'header' => static fn (array $data, array $allowedTags) => Header::create($data, $allowedTags),
+            'image' => static fn (array $data, array $allowedTags) => Image::create($data, $allowedTags),
+            'list' => static fn (array $data, array $allowedTags) => Listing::create($data, $allowedTags),
+            'paragraph' => static fn (array $data, array $allowedTags) => Paragraph::create($data, $allowedTags),
+            'quote' => static fn (array $data, array $allowedTags) => Quote::create($data, $allowedTags),
+            'raw' => static fn (array $data, array $allowedTags) => Raw::create($data, $allowedTags),
+            'table' => static fn (array $data, array $allowedTags) => Table::create($data, $allowedTags),
+            'warning' => static fn (array $data, array $allowedTags) => Warning::create($data, $allowedTags),
+        ];
     }
 
-    /**
-     * @throws EditorException
-     */
     private static function create(array $data, array $allowedTags = []): Block
     {
         try {
-            // TODO: I think this may be very slow for large data need to think of a better way
-
-            //dd(self::getSchema($data['type']), $data);
-
-            $schema = Schema::import(self::getSchema($data['type']));
-
-            dd($schema);
-
-            return match ($data['type']) {
-                'attaches' => Attaches::create($data, $allowedTags),
-                'code' => Code::create($data, $allowedTags),
-                'delimiter' => Delimiter::create($data, $allowedTags),
-                'embed' => Embed::create($data, $allowedTags),
-                'header' => Header::create($data, $allowedTags),
-                'image' => Image::create($data, $allowedTags),
-                'list' => Listing::create($data, $allowedTags),
-                'paragraph' => Paragraph::create($data, $allowedTags),
-                'quote' => Quote::create($data, $allowedTags),
-                'raw' => Raw::create($data, $allowedTags),
-                'table' => Table::create($data, $allowedTags),
-                'warning' => Warning::create($data, $allowedTags),
-            };
+            self::initializeFactories();
+
+            $type = $data['type'];
+            if (! isset(self::$blockFactories[$type])) {
+                throw new EditorException(sprintf('Block type %s not supported', $type));
+            }
+            return self::$blockFactories[$type]($data, $allowedTags);
         } catch (\Throwable $e) {
             throw new EditorException($e->getMessage(), previous: $e);
         }
     }
 
-    private static function getAllowedTags(mixed $block, array $allowedTags): array
+    private static function getAllowedTags(array $block, array $allowedTags): array
     {
         Assert::keyExists($block, 'type');
 
         return $allowedTags[$block['type']] ?? [];
     }
 
-    private static function getSchema(string $schema): array
-    {
-        $filename = sprintf("%s/schemas/%s.schema.json", dirname(__DIR__), $schema);
-        $content = file_get_contents($filename);
-        Assert::string($content, sprintf('Schema for block type %s not found', $schema));
-
-        return json_decode($content, true);
-    }
+    //    private static function getSchema(string $schema): array
+    //    {
+    //        $filename = sprintf('%s/schemas/%s.schema.json', dirname(__DIR__), $schema);
+    //        $content = file_get_contents($filename);
+    //        Assert::string($content, sprintf('Schema for block type %s not found', $schema));
+    //
+    //        /** @var array $schema */
+    //        $schema = json_decode($content, true);
+    //
+    //        return $schema;
+    //    }
 }

src/Blocks/Attaches.php

@@ -27,7 +27,7 @@
  */
 final readonly class Attaches extends Block
 {
-    public function __construct(string $id, string $type, array $data, ?array $tunes, array $rules)
+    public function __construct(string $id, string $type, array $data, ?array $tunes = [], ?array $allowedTags = null)
     {
         Assert::eq($type, 'attaches');
         Assert::keyExists($data, 'file');
@@ -37,6 +37,18 @@ public function __construct(string $id, string $type, array $data, ?array $tunes
         Assert::keyExists($data['file'], 'extension');
         Assert::keyExists($data, 'title');
 
-        parent::__construct($id, $type, $data, $tunes, $rules);
+        parent::__construct($id, $type, $data, $tunes, $allowedTags);
+    }
+
+    #[\Override]
+    public function toHtml(): string
+    {
+        return <<<HTML
+            <div id="{$this->id}">
+                <a href="{$this->data['file']['url']}" title="{$this->data['title']}">
+                    <strong>{$this->data['file']['name']}</strong> ({$this->data['file']['size']} bytes)
+                </a>
+            </div>
+        HTML;
     }
 }

src/Blocks/Block.php

@@ -19,6 +19,8 @@
 /**
  * Class Block.
  *
+ * @phpstan-consistent-constructor
+ *
  * @author bernard-ng <bernard@devscast.tech>
  */
 abstract readonly class Block
@@ -33,6 +35,8 @@ public function __construct(
         Assert::notEmpty($id);
     }
 
+    abstract public function toHtml(): string;
+
     public static function create(array $data, array $allowedTags = []): static
     {
         return new static(
@@ -44,18 +48,10 @@ public static function create(array $data, array $allowedTags = []): static
         );
     }
 
-//    private function sanitize(array $data, array|string $allowedTags = []): array
-//    {
-//        $sanitizer = Sanitizer::create($allowedTags);
-//
-//        foreach ($data as $key => $value) {
-//            if (is_array($value)) {
-//                $data[$key] = $this->sanitize($value, $allowedTags);
-//            } else {
-//                $data[$key] = $sanitizer->sanitize($value);
-//            }
-//        }
-//
-//        return $data;
-//    }
+    public function sanitize(): string
+    {
+        $sanitizer = Sanitizer::create($this->allowedTags ?? []);
+
+        return $sanitizer->sanitize($this->toHtml());
+    }
 }