janniclas.loosenandClaude Opus 5.5
cfc81ddbb2
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
7317 lines
313 KiB
Markdown
7317 lines
313 KiB
Markdown
# Etappe 3a – Divi-Bibliothek: Auflisten, Speichern, Einfügen, Kopieren, globale Module bearbeiten – Implementation Plan
|
||
|
||
> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
|
||
|
||
**Goal:** Der KI-Assistent arbeitet mit der Divi-Bibliothek: Einträge auflisten und lesen (`lit/library-list`), Knoten als normalen oder globalen Eintrag speichern (`lit/library-save`), Einträge als Kopie oder als globale Instanz im Format des Visual Builders einfügen (`lit/library-insert`, direkt), Knoten zwischen Seiten kopieren (`lit/divi-node-copy`), Bibliothekseinträge – auch globale, mit Probelauf, `confirm` und Sicherung – mit den vorhandenen Divi-Werkzeugen bearbeiten, verfügbare Dynamic-Content-Quellen abfragen (`lit/divi-dynamic-sources`); dazu die Übernahmen aus Etappe 2 (`{{link:ID}}`, `lit-guide` mit allen Themen, S19) und der Hinweis auf globale Module in `lit/page-render-summary`.
|
||
|
||
**Architecture:** Reines PHP in `Divi/BlockTree/` bekommt die Bausteine für globale Module (`Block::copyAs()`, `GlobalInstance` – Instanz im Builder-Format und Entglobalisieren wie Divis `maybe_deglobalize_nested_global_modules` –, `LibraryContent` – Rahmen `divi/placeholder`, Wurzeln, Formregeln). Divi-Interna liegen hinter Adaptern mit Live-Kompatibilitätsprüfung (Entscheidung E15): `DiviRoles` (`et_pb_is_allowed`), `DiviLibraryStore` (Post-Typ `et_pb_layout`, Terme, Meta, `GlobalLayout::is_global_layout_template`), `DiviCompatibility` (Befund in `lit/site-status`). `LibraryAccess` bündelt die Rechte je Objekt (E3) und wird in `DiviPageLoader` eingehängt, damit alle Divi-Werkzeuge Bibliotheks-IDs annehmen (E1); `GlobalEdits` ergänzt `DiviWriter::commit()` um Formregeln, Probelauf mit betroffenen Seiten, `confirm` und Sicherung (E2, Antwort F2). Jeder neue Weg nach `post_content` läuft weiter über `Composer`/`TreeEditor`/`DiviSaver`; übernommene gespeicherte Knoten prüft `StoredNodeGuard` gegen die S7/S26-Sperren (E6). Die neuen Tools bilden die Gruppe „Divi-Bibliothek“ (`LibraryIntegration`), `lit/divi-node-copy` und `lit/divi-dynamic-sources` gehören zur Gruppe „Divi“.
|
||
|
||
**Tech Stack:** PHP ≥ 8.1, WordPress 7.x (Abilities API, `wp_insert_post`/`wp_update_post`, Revisionen, kses, Taxonomien), Divi 5.2.1 (`et_pb_layout`, `et_pb_is_allowed`, `GlobalLayout`, `DynamicContentOptions`, `ET_Core_PageResource`), `wordpress/mcp-adapter` 0.5, `wp-media/mcp-oauth` 1.1, PHPUnit 9.6 + Brain Monkey + Mockery, phpcs (WPCS, PHPCompatibilityWP), DDEV + bash/jq-Smokes.
|
||
|
||
**Spec:** `docs/superpowers/specs/2026-09-25-wp-lit-mcp-design.md` (insb. §4.3, §4.5, §5.1–5.7, §8.1–8.2, §9, §10, §12 Etappe 3) und die Entscheidungen `docs/superpowers/notes/2026-09-27-etappe-3-entscheidungen-entwurf.md` (Fakten F1–F32, Empfehlungen E1–E17, Schnittstellen-Einordnung Abschnitt 5; **die Antworten des Benutzers in „5. Antworten des Benutzers“ sind verbindlich**), dazu die Rulings `2026-09-26-etappe-{1a,1b,2a,2b}-rulings.md`, `2026-09-26-etappe-2-entscheidungen.md` (D1–D12, R2), Security-Audit und Praxistest 2b sowie die Fixtures `tests/Fixtures/divi/stage3/` mit `README.md` (Commit e7cc4ef).
|
||
|
||
**Voraussetzung:** Branch `etappe-3` mit Stand 30788f2 (Etappe 2b vollständig, 1597 Tests grün). Pods ist lokal deaktiviert; `lit/divi-dynamic-sources` wird für Pods über Unit-Tests abgesichert.
|
||
|
||
## Global Constraints
|
||
|
||
- **Dateien nur im Plugin-Verzeichnis** `/home/janniclas/Projekte/WordPress/wp-content/plugins/WP-LIT-MCP` anlegen oder ändern. Integrationsskripte schreiben nur in die DDEV-Datenbank und räumen Seiten, Bibliothekseinträge, Benutzer, Rollen und die Optionen `lit_mcp_allowed_roles`/`lit_mcp_exposure` wieder auf.
|
||
- PHP ≥ 8.1 ohne 8.2+-Features; WordPress ≥ 6.9 (getestet 7.x); Divi 5.2.1. Namespace `LIT\MCP\` → `src/`, PSR-4, eine Klasse pro Datei, jede Datei mit `defined('ABSPATH') || exit;`, höchstens 120 Zeichen pro Zeile. Nach jedem Task: `composer test` und `composer lint` sauber.
|
||
- `src/Integrations/Divi/BlockTree/*` und `src/Integrations/Divi/Compose/*` bleiben reines PHP ohne WordPress-Aufrufe (Spec §4.4). WordPress/Divi nur in `Divi/Pages/`, `Divi/Library/`, `Divi/Design/`, `Divi/Schema/` und in `DiviCompatibility`.
|
||
- **Eine Engstelle nach `post_content` (D7, S39, E17):** Jeder neue Schreibweg in `post_content` – Seiten wie Bibliothekseinträge – geht über `Composer`/`AttrWriter`/`ShortformWriter`/`ValueCleaner` (Client-Werte) bzw. `TreeEditor` (Struktur) und wird ausschließlich von `DiviSaver::save()`/`saveNew()` gespeichert (kses-Fenster nur dort). Abilities rufen `setAttrs()`/`insertChild()` nie mit Client-Werten auf. Gespeicherte Knoten, die den Post wechseln (Seite → Seite, Bibliothek → Seite, Seite → Bibliothek), laufen durch `StoredNodeGuard` (S7/S26-Pfade, Code-Modul, `$variable`-Einstellungen) – für Benutzer ohne `unfiltered_html` wird abgelehnt statt bereinigt; alles andere bleibt byte-identisch. Keine Builder-Route (`divi/v1/…`), kein `et_pb_submit_layout`/`et_pb_create_layout`.
|
||
- **Rechte je Objekt (Spec §4.5, E3 – strenger als Divi, nie lockerer):** Bibliothek lesen/auflisten = `edit_posts` + Divi-Rolle `divi_library`; einen Eintrag lesen = zusätzlich `edit_post` auf den Eintrag; speichern/anlegen = + `publish_posts` des Typs `et_pb_layout` + `save_library`; bearbeiten = `edit_post` + `save_library`, bei globalen Einträgen + `edit_global_library`; einfügen = + `add_library`; Dynamic-Content-Feldliste nur mit `read_dynamic_content_custom_fields`. Divi-Rollen nur über `DiviRoles`. Ohne Bibliothekszugang bleiben Bibliotheks-IDs für alle Werkzeuge `not_found` wie bisher (`ContentSchema::EXCLUDED` bleibt unverändert).
|
||
- **Sperren und Alles-oder-nichts:** Jede Divi-Schreibung verlangt `tree_rev` (Ruling P16); Werkzeuge mit Quellknoten (`lit/library-save`, `lit/divi-node-copy`) verlangen zusätzlich die `tree_rev` der Quelle. Abweichung → `rev_mismatch`, nichts geschrieben. Erst vollständig validieren, dann einmal speichern; beim Anlegen eines Bibliothekseintrags wird der Eintrag bei jedem Fehler endgültig gelöscht (wie `lit/content-create`). Unberührte Bytes bleiben identisch (Spec §1.3 Nr. 3, Ausnahme S7).
|
||
- **Globale Einträge (Antwort F2, verbindlich):** Jede Änderung an einem globalen Bibliothekseintrag ist zuerst ein Probelauf (`confirm_required` mit `affected`/`affected_count`, nichts gespeichert); mit `confirm: true` wird vorher eine Revision des Eintrags angelegt – sind Revisionen abgeschaltet, eine Sicherung (`PostCloner::backup`, `backup_id`) –, danach seitenweit `remove_static_resources('all', 'all', true)` und `et_theme_builder_clear_wp_cache('all')` (Spec §5.6 Schritt 5).
|
||
- **Exposition:** Direkt ist nur `lit/library-insert` (22 direkte Tools, Spec §4.3). Indirekt: `lit/library-list`, `lit/library-save`, `lit/divi-node-copy`, `lit/divi-dynamic-sources`. Gruppe „Divi-Bibliothek“ (`divi-library`) für die drei `lit/library-*`-Tools; „nur lesen“/deaktiviert dieser Gruppe sperrt auch Schreibzugriffe der Divi-Werkzeuge auf Bibliothekseinträge (`ExposurePolicy::groupWritable('divi-library')`). `lit/library-insert` folgt zusätzlich `lit/divi-insert` (Audit M2). Jeder Task mit neuem direktem Tool aktualisiert `docs/guides/overview.md` „Direkt sichtbar:“ im selben Task (Ruling Q2); Texte nennen direkte Tools `lit-<name>`, indirekte `lit/<name>` (ToolNamingTest). In PHP-Texten nie `topic "<x>"` für ein Thema ohne `docs/guides/<x>.md` schreiben (ToolNamingTest).
|
||
- **Sprache und Wortwahl:** Oberfläche, Fehlermeldungen, Hinweise, Guides, Readme und Abnahme auf Deutsch mit echten Umlauten (ä, ö, ü, ß). Neutral formulieren: „KI-Assistent“, „MCP-Client“, „Verbindung“ – keine Chatbot-Marken in UI, Guides, Readme oder Tool-Texten.
|
||
- Tests: Unit-Tests der Abilities über `LIT\MCP\Tests\Unit\TestCase` (Brain Monkey + Mockery); vorbelegte Stubs (`wp_json_encode`, `is_wp_error`, `absint`, `wp_slash`, `wp_unslash`, `sanitize_text_field`) nie mit `Functions\expect()` prüfen; `error_log()` per `ini_set('error_log', …)` umleiten. Reine BlockTree-/Compose-Tests erben von `PHPUnit\Framework\TestCase`. Integrationstests: `cd /home/janniclas/Projekte/WordPress && timeout 900 ddev exec bash wp-content/plugins/WP-LIT-MCP/tests/Integration/<skript>.sh`.
|
||
- `composer test` braucht mehr als 128 MB (Task 1 behebt das); danach laufen `composer test` und `php vendor/bin/phpunit` mit jeder `memory_limit`-Vorgabe.
|
||
- Commits: `git -c user.name="Jan-Niclas Loosen" -c user.email="janniclas@loosen-it.de" commit -m "<Nachricht>" -m "Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>" -m "Claude-Session: https://claude.ai/code/session_01At3V6SjwbMe6eMzVGW3Hs7"` (im Folgenden kurz „Commit wie in den Global Constraints“).
|
||
|
||
## Review Focus
|
||
|
||
1. **Redakteur ohne `unfiltered_html` überträgt gespeicherten Admin-Inhalt in einen anderen Post** (Abschnitt mit eigenem CSS, HTML-Attributen, Code-Modul oder Dynamic-Content-`before`/`after` mit HTML) über `lit/divi-node-copy`, `lit/library-insert` oder `lit/library-save`: Erwartet Ablehnung „nur im Divi-Builder“, nichts gespeichert (E6, Audit M1, R2-Befund 1) → Tests `StoredNodeGuardTest` (Task 11), `DiviNodeCopyAbilityTest::testEditorCannotCarryBuilderOnlyValuesToAnotherPage` (Task 14), `LibraryInsertAbilityTest::testEditorCannotInsertAnItemWithCustomCss` (Task 13), `LibrarySaveAbilityTest::testEditorCannotSaveACodeModule` (Task 12).
|
||
2. **Globaler Eintrag mit Instanzen auf veröffentlichten Seiten wird geändert – auch per `lit-divi-delete`, das ein eigenes `confirm` hat:** Ohne `confirm` nichts gespeichert, Antwort nennt die betroffenen Seiten; mit `confirm` Revision bzw. Sicherung und seitenweite Cache-Leerung → Tests `GlobalEditsTest::testGlobalItemDryRunNamesTheAffectedPagesAndSavesNothing`, `::testDeleteInAGlobalItemNamesTheAffectedPagesBeforeConfirm`, `::testWithoutRevisionsABackupIsMadeFirst` und `DiviSaverTest::testLibraryItemsGetNoDiviFlagsAndGlobalOnesClearEveryPage` (Task 9).
|
||
3. **Bibliothekseintrag verliert seine Form** (Wurzel gelöscht, zweite Wurzel, anderer Wurzeltyp, globales Modul in einem globalen Eintrag): Instanzen auf allen Seiten würden brechen → abgelehnt → Tests `LibraryContentTest::testShapeViolations` (Task 7) und `GlobalEditsTest::testRefusesToEmptyOrDoubleTheRoot` (Task 9).
|
||
4. **Rechte:** Autor ohne Divi-Rolle `divi_library`/`save_library`/`add_library`/`edit_global_library`, fremder Eintrag ohne `edit_post`, Mitarbeiter ohne `publish_posts`, Gruppe „Divi-Bibliothek“ auf „nur lesen“ – alle erhalten `forbidden`, nichts wird geschrieben; ohne eingehängten Bibliothekszugang bleiben Bibliotheks-IDs `not_found` → Tests `LibraryAccessTest` (Task 8), `DiviPageLoaderTest::testLibraryItemsNeedTheLibraryAccess` (Task 8), `LibrarySaveAbilityTest::testNeedsPublishPostsAndTheDiviRole` (Task 12).
|
||
5. **Parallele Änderung:** Quelle oder Ziel wurde seit dem Lesen geändert (`source_tree_rev`/`tree_rev` veraltet), oder der globale Eintrag änderte sich zwischen Probelauf und `confirm` → `rev_mismatch`, nichts geschrieben → Tests `DiviNodeCopyAbilityTest::testStaleSourceOrTargetWritesNothing` (Task 14), `LibrarySaveAbilityTest::testStaleSourceTreeRevCreatesNothing` (Task 12), `GlobalEditsTest::testConfirmWithAStaleTreeRevWritesNothing` (Task 9).
|
||
|
||
---
|
||
|
||
## File Structure
|
||
|
||
```
|
||
phpunit.xml.dist (geändert) memory_limit 512M
|
||
composer.json (geändert) test-Skript mit memory_limit
|
||
wp-lit-mcp.php, src/Plugin.php (geändert) Version 0.4.0; Verdrahtung Bibliothek + Gates
|
||
readme.txt (geändert) Bibliothek, globale Module, Changelog 0.4.0
|
||
docs/guides/
|
||
divi-library.md (neu) Thema „divi-library“
|
||
overview.md, divi-placeholders.md, divi-structure.md, workflows.md, divi-design-system.md (geändert)
|
||
docs/superpowers/specs/2026-09-25-wp-lit-mcp-design.md (geändert) §4.3, §5.2, §5.4, §5.7, §9.2
|
||
docs/superpowers/notes/2026-09-27-etappe-3-entscheidungen-entwurf.md (geändert) Abschnitt 6 „Umsetzung 3a“
|
||
docs/superpowers/notes/2026-09-27-etappe-3a-abnahme.md (neu) manuelle Abnahme
|
||
src/
|
||
Abilities/ExposurePolicy.php (geändert) groupWritable()
|
||
Guides/InstructionsBuilder.php (geändert) Bibliotheks-Regel
|
||
Integrations/Core/EnvironmentProbe.php (geändert) Divi-Kompatibilitätsbefund
|
||
Integrations/Core/GuideAbility.php (geändert) topic = all
|
||
Integrations/WordPress/Render/PageRenderSummaryAbility.php (geändert) Hinweis globale Module
|
||
Integrations/Divi/
|
||
DiviIntegration.php (geändert) Bibliothekszugang, library(), neue Divi-Tools
|
||
DiviCompatibility.php (neu) Live-Prüfung der genutzten Divi-Interna
|
||
BlockTree/
|
||
Block.php (geändert) copyAs()
|
||
Container.php (geändert) replaceChild(), unifyLineBreaks()
|
||
NodeSummary.php (geändert) globalRef()
|
||
Outline.php (geändert) global_id
|
||
GlobalInstance.php (neu) Instanz im Builder-Format, entglobalisieren, effectiveName()
|
||
LibraryContent.php (neu) Rahmen, Wurzeln, Formregeln
|
||
Compose/
|
||
LinkTargets.php (neu) Schnittstelle für {{link:ID}}
|
||
Placeholders.php (geändert) {{link:ID}}
|
||
VariableRef.php (geändert) post_link_url_* nur in URL-Feldern, settingsOf()
|
||
StructureRules.php, TreeEditor.php (geändert) Wurzeltyp globaler Instanzen
|
||
StoredNodeGuard.php (neu) S7/S26 für übertragene gespeicherte Knoten
|
||
Design/DiviDesignSystemAbility.php (geändert) only/module-Filter (S19)
|
||
Pages/
|
||
WpLinkTargets.php (neu)
|
||
SaveScope.php (neu) Seite / Bibliothekseintrag / globaler Eintrag
|
||
DiviSaver.php (geändert) SaveScope: Flags, seitenweiter Cache
|
||
DiviPage.php, DiviPageLoader.php (geändert) Bibliothekseinträge
|
||
DiviWriter.php, DiviWriteAbility.php (geändert) commit(), notice(), precheck()
|
||
DiviSchema.php (geändert) confirm
|
||
DiviComposition.php (geändert) LinkTargets, storedGuard()
|
||
DiviNodeGetAbility.php, DiviOutlineAbility.php (geändert) global
|
||
DynamicContentMap.php (geändert) options()
|
||
DiviNodeCopyAbility.php (neu) lit/divi-node-copy
|
||
DiviDynamicSourcesAbility.php (neu) lit/divi-dynamic-sources
|
||
Library/
|
||
DiviRoles.php (neu) Adapter et_pb_is_allowed
|
||
DiviLibraryStore.php (neu) Adapter et_pb_layout, Terme, Meta
|
||
LibraryAccess.php (neu) Rechte je Objekt, Gruppen-Gate
|
||
LibraryItemSpec.php (neu) Terme/Meta eines neuen Eintrags
|
||
GlobalUsages.php (neu) Seiten mit Instanzen
|
||
GlobalEdits.php (neu) Formregeln, Probelauf, confirm, Sicherung
|
||
LibraryIntegration.php (neu) Gruppe „Divi-Bibliothek“
|
||
LibraryListAbility.php (neu) lit/library-list
|
||
LibrarySaveAbility.php (neu) lit/library-save
|
||
LibraryInsertAbility.php (neu) lit/library-insert
|
||
tests/
|
||
Stubs/EtCorePageResource.php (neu) zeichnet remove_static_resources auf
|
||
bootstrap.php (geändert)
|
||
Support/ComposeFixture.php, DiviWriterFixture.php (geändert) links(), Bibliothek
|
||
Support/LibraryFixtures.php (neu) Posts nach ID, Store/Rollen/Zugang
|
||
Fixtures/divi/stage3/README.md (geändert) Befund 9: CRLF in Bibliothekseinträgen
|
||
Unit/… (neu/geändert je Task)
|
||
Integration/divi-library-smoke.sh (neu) Ende-zu-Ende 3a
|
||
```
|
||
|
||
---
|
||
|
||
### Task 1: Testlauf ohne Speicherfehler
|
||
|
||
`composer test` bricht mit dem PHP-Standard `memory_limit=128M` ab („Allowed memory size of 134217728 bytes exhausted“); der volle Lauf braucht ≈ 177 MB (gemessen: `php -d memory_limit=1G vendor/bin/phpunit` → „Memory: 177.00 MB“). Das ist kein Leck einzelner Tests, sondern die Summe aus 1597 Tests mit Mockery/Brain Monkey und dem 237-KB-Katalog, der je Test dekodiert wird. PHPUnit setzt Werte aus `<php><ini>` zur Laufzeit; das deckt `composer test` und den direkten Aufruf ab.
|
||
|
||
**Files:**
|
||
- Modify: `phpunit.xml.dist`
|
||
- Modify: `composer.json` (`scripts.test`)
|
||
|
||
**Interfaces:**
|
||
- Consumes: nichts.
|
||
- Produces: `composer test` und `php vendor/bin/phpunit` laufen unabhängig von der `memory_limit` der CLI.
|
||
|
||
- [ ] **Step 1: Fehler nachweisen**
|
||
|
||
Run: `php -d memory_limit=128M vendor/bin/phpunit 2>&1 | grep -m1 -o 'Allowed memory size of [0-9]* bytes exhausted'`
|
||
Expected: `Allowed memory size of 134217728 bytes exhausted`
|
||
|
||
- [ ] **Step 2: Grenze in der PHPUnit-Konfiguration setzen**
|
||
|
||
`phpunit.xml.dist` vollständig:
|
||
|
||
```xml
|
||
<?xml version="1.0"?>
|
||
<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
|
||
xsi:noNamespaceSchemaLocation="vendor/phpunit/phpunit/phpunit.xsd"
|
||
bootstrap="tests/bootstrap.php"
|
||
colors="true">
|
||
<php>
|
||
<!-- 1597+ tests with Mockery/Brain Monkey need ~180 MB; the CLI default is 128 MB. -->
|
||
<ini name="memory_limit" value="512M"/>
|
||
</php>
|
||
<testsuites>
|
||
<testsuite name="unit">
|
||
<directory>tests/Unit</directory>
|
||
</testsuite>
|
||
</testsuites>
|
||
</phpunit>
|
||
```
|
||
|
||
- [ ] **Step 3: Composer-Skript absichern (greift schon vor dem Laden der Konfiguration)**
|
||
|
||
In `composer.json` den Block `scripts` ersetzen durch:
|
||
|
||
```json
|
||
"scripts": {
|
||
"test": "@php -d memory_limit=512M vendor/bin/phpunit",
|
||
"lint": "@php vendor/bin/phpcs"
|
||
},
|
||
```
|
||
|
||
- [ ] **Step 4: Prüfen**
|
||
|
||
Run: `php -d memory_limit=128M vendor/bin/phpunit 2>&1 | tail -1`
|
||
Expected: `OK (1597 tests, 7869 assertions)`
|
||
|
||
Run: `composer test 2>&1 | tail -1`
|
||
Expected: `OK (1597 tests, 7869 assertions)`
|
||
|
||
- [ ] **Step 5: Commit**
|
||
|
||
```bash
|
||
git add phpunit.xml.dist composer.json
|
||
git -c user.name="Jan-Niclas Loosen" -c user.email="janniclas@loosen-it.de" commit -m "test: raise memory_limit for the unit suite (512M)" -m "Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>" -m "Claude-Session: https://claude.ai/code/session_01At3V6SjwbMe6eMzVGW3Hs7"
|
||
```
|
||
|
||
---
|
||
|
||
### Task 2: Interner Link `{{link:ID}}` (E13a)
|
||
|
||
Divis natives Dynamic Content `post_link_url_<post_type>` mit `settings.post_id` rendert zur Laufzeit `esc_url(get_permalink($id))` (F27, `DynamicContentOptionCustomPostLinkUrl.php:186-217`) – entwurfssicher und nach dem Veröffentlichen automatisch die schöne URL. Der Name wird nicht fest verdrahtet: `VariableRef` prüft ihn gegen Divis Registry (nur öffentliche Post-Typen, `et_builder_get_public_post_types`), `select_post` prüft `read_post` (S37). Neu: `post_link_url_*` nur in URL-Feldern.
|
||
|
||
**Files:**
|
||
- Create: `src/Integrations/Divi/Compose/LinkTargets.php`
|
||
- Create: `src/Integrations/Divi/Pages/WpLinkTargets.php`
|
||
- Modify: `src/Integrations/Divi/Compose/Placeholders.php`
|
||
- Modify: `src/Integrations/Divi/Compose/VariableRef.php` (`contentSettings()`)
|
||
- Modify: `src/Integrations/Divi/Pages/DiviComposition.php`
|
||
- Modify: `tests/Support/ComposeFixture.php` (`links()`, `placeholders()`)
|
||
- Test: `tests/Unit/Integrations/Divi/Compose/PlaceholdersTest.php`, `tests/Unit/Integrations/Divi/Compose/ShortformWriterTest.php`, `tests/Unit/Integrations/Divi/Pages/WpLinkTargetsTest.php`
|
||
|
||
**Interfaces:**
|
||
- Consumes: `VariableRef::serialize(string $type, string $name, array $settings): string`, `DynamicContentMap::fromOptions(array $options): array`, `DiviFixtures::dynamicContentRegistry()` (enthält `post_link_url_page` mit `post_id` = `select_post`).
|
||
- Produces: `interface LinkTargets { public function postTypeOf(int $id): ?string; }`; `new Placeholders(DesignSystem $design, ?LinkTargets $links = null)`; `WpLinkTargets implements LinkTargets`; `DiviComposition::__construct(…, LinkTargets $links = new WpLinkTargets())` (6. Parameter); `ComposeFixture::links(): LinkTargets` (839 → page, 840 → post, sonst null).
|
||
|
||
- [ ] **Step 1: Failing tests schreiben**
|
||
|
||
In `tests/Support/ComposeFixture.php` ergänzen (Import `use LIT\MCP\Integrations\Divi\Compose\LinkTargets;`) und `placeholders()` ersetzen:
|
||
|
||
```php
|
||
/** Link targets of the tests: 839 is a page, 840 a post; everything else is missing, trashed or unreadable. */
|
||
public static function links(): LinkTargets
|
||
{
|
||
return new class implements LinkTargets {
|
||
public function postTypeOf(int $id): ?string
|
||
{
|
||
return match ($id) {
|
||
839 => 'page',
|
||
840 => 'post',
|
||
default => null,
|
||
};
|
||
}
|
||
};
|
||
}
|
||
|
||
public static function placeholders(): Placeholders
|
||
{
|
||
return new Placeholders(DiviFixtures::designSystem(), self::links());
|
||
}
|
||
```
|
||
|
||
In `PlaceholdersTest::placeholders()` einen Eintrag ergänzen:
|
||
|
||
```php
|
||
'internal link' => [
|
||
'{{link:839}}',
|
||
'$variable({"type":"content","value":{"name":"post_link_url_page","settings":{"post_id":"839"}}})$',
|
||
],
|
||
```
|
||
|
||
Da `testResolvesToDiviVariables` das Ergebnis mit `ComposeFixture::references()` (Standard-Map ohne `post_link_url_page`) prüft, dort die Prüfung auf den Registry-Checker umstellen:
|
||
|
||
```php
|
||
/** @dataProvider placeholders */
|
||
public function testResolvesToDiviVariables(string $input, string $expected): void
|
||
{
|
||
$placeholders = ComposeFixture::placeholders();
|
||
$resolved = $placeholders->resolve($input);
|
||
|
||
self::assertSame($expected, $resolved);
|
||
if ($expected !== $input) {
|
||
// What placeholders produce passes the strict checker unchanged (ruling S1/S25); the live
|
||
// registry map knows post_link_url_page, the URL mode allows it.
|
||
$references = new VariableRef(
|
||
DiviFixtures::designSystem(),
|
||
DynamicContentMap::fromOptions(DiviFixtures::dynamicContentRegistry())
|
||
);
|
||
self::assertSame($resolved, $references->canonical($resolved, ComposeFixture::sanitizer(), true));
|
||
}
|
||
}
|
||
```
|
||
|
||
(Imports: `use LIT\MCP\Integrations\Divi\Compose\VariableRef;`, `use LIT\MCP\Integrations\Divi\Pages\DynamicContentMap;`, `use LIT\MCP\Tests\Support\DiviFixtures;`.) Hinweis: Im URL-Modus sind `before`/`after` nur leer erlaubt – alle bisherigen Zeilen liefern leere `before`/`after`, sie bleiben gültig.
|
||
|
||
In `PlaceholdersTest::invalid()` ergänzen:
|
||
|
||
```php
|
||
'link without id' => ['{{link:start}}', 'Ungültige Beitrags-ID'],
|
||
'link to a missing post' => ['{{link:999}}', 'Eintrag 999'],
|
||
'link without link targets' => ['{{link:0}}', 'Ungültige Beitrags-ID'],
|
||
```
|
||
|
||
und am Ende von `PlaceholdersTest` einen Test ohne `LinkTargets`:
|
||
|
||
```php
|
||
public function testLinksNeedLinkTargets(): void
|
||
{
|
||
$this->expectException(InvalidArgumentException::class);
|
||
$this->expectExceptionMessage('Eintrag 839');
|
||
|
||
(new Placeholders(DiviFixtures::designSystem()))->resolve('{{link:839}}');
|
||
}
|
||
```
|
||
|
||
In `ShortformWriterTest` (Imports `ShortformWriter`, `Placeholders`, `ValueCleaner`, `VariableRef`, `DynamicContentMap`, `DiviFixtures`):
|
||
|
||
```php
|
||
/** E13a: {{link:ID}} becomes Divi's post_link_url_<type> in URL fields – and only there. */
|
||
public function testInternalLinkOnlyInUrlFields(): void
|
||
{
|
||
$design = DiviFixtures::designSystem();
|
||
$cleaner = new ValueCleaner(
|
||
DiviFixtures::catalog(),
|
||
new VariableRef($design, DynamicContentMap::fromOptions(DiviFixtures::dynamicContentRegistry())),
|
||
ComposeFixture::sanitizer()
|
||
);
|
||
$writer = new ShortformWriter(new Placeholders($design, ComposeFixture::links()), ComposeFixture::media(), $cleaner);
|
||
|
||
$button = $writer->apply('button', [], ['text' => 'Kontakt', 'url' => '{{link:839}}'], 'n');
|
||
self::assertSame([], $button['errors']);
|
||
self::assertSame(
|
||
'$variable({"type":"content","value":{"name":"post_link_url_page","settings":{"post_id":"839"}}})$',
|
||
$button['attrs']['button']['innerContent']['desktop']['value']['linkUrl']
|
||
);
|
||
|
||
$text = $writer->apply('button', [], ['text' => '{{link:839}}'], 'n');
|
||
self::assertStringContainsString('nur in Link- und URL-Feldern', $text['errors']['n.text']);
|
||
|
||
// A post type Divi offers no link option for (not public): unknown name.
|
||
$post = $writer->apply('button', [], ['url' => '{{link:840}}'], 'n');
|
||
self::assertStringContainsString('post_link_url_post', $post['errors']['n.url']);
|
||
}
|
||
```
|
||
|
||
`tests/Unit/Integrations/Divi/Pages/WpLinkTargetsTest.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Tests\Unit\Integrations\Divi\Pages;
|
||
|
||
use Brain\Monkey\Functions;
|
||
use LIT\MCP\Integrations\Divi\Pages\WpLinkTargets;
|
||
use LIT\MCP\Tests\Unit\TestCase;
|
||
use WP_Post;
|
||
|
||
final class WpLinkTargetsTest extends TestCase
|
||
{
|
||
public function testOnlyReadableLivingPostsCanBeLinked(): void
|
||
{
|
||
$posts = [
|
||
839 => new WP_Post(['ID' => 839, 'post_type' => 'page', 'post_status' => 'draft']),
|
||
841 => new WP_Post(['ID' => 841, 'post_type' => 'page', 'post_status' => 'trash']),
|
||
842 => new WP_Post(['ID' => 842, 'post_type' => 'page', 'post_status' => 'private']),
|
||
843 => new WP_Post(['ID' => 843, 'post_type' => 'revision', 'post_status' => 'inherit']),
|
||
];
|
||
Functions\when('get_post')->alias(static fn (int $id): ?WP_Post => $posts[$id] ?? null);
|
||
Functions\when('current_user_can')->alias(
|
||
static fn (string $cap, int $id): bool => $cap === 'read_post' && $id !== 842
|
||
);
|
||
|
||
$links = new WpLinkTargets();
|
||
|
||
self::assertSame('page', $links->postTypeOf(839));
|
||
self::assertNull($links->postTypeOf(841), 'trashed');
|
||
self::assertNull($links->postTypeOf(842), 'not readable');
|
||
self::assertNull($links->postTypeOf(843), 'revision');
|
||
self::assertNull($links->postTypeOf(900), 'missing');
|
||
}
|
||
}
|
||
```
|
||
|
||
- [ ] **Step 2: Tests laufen lassen – sie schlagen fehl**
|
||
|
||
Run: `vendor/bin/phpunit --filter 'PlaceholdersTest|ShortformWriterTest|WpLinkTargetsTest'`
|
||
Expected: FAIL (`Class "LIT\MCP\Integrations\Divi\Compose\LinkTargets" not found`)
|
||
|
||
- [ ] **Step 3: Implementieren**
|
||
|
||
`src/Integrations/Divi/Compose/LinkTargets.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Integrations\Divi\Compose;
|
||
|
||
defined('ABSPATH') || exit;
|
||
|
||
/**
|
||
* Entries {{link:<ID>}} may point to (E13a). Pure interface – WpLinkTargets asks WordPress.
|
||
*/
|
||
interface LinkTargets
|
||
{
|
||
/** Post type of entry $id when it may be linked (exists, not trashed, readable); null otherwise. */
|
||
public function postTypeOf(int $id): ?string;
|
||
}
|
||
```
|
||
|
||
`src/Integrations/Divi/Pages/WpLinkTargets.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Integrations\Divi\Pages;
|
||
|
||
use LIT\MCP\Integrations\Divi\Compose\LinkTargets;
|
||
use WP_Post;
|
||
|
||
defined('ABSPATH') || exit;
|
||
|
||
/**
|
||
* {{link:<ID>}} targets from WordPress: the entry exists, lives (no trash, auto-draft or
|
||
* revision) and the current user may read it (read_post, like select_post settings, S37).
|
||
*/
|
||
final class WpLinkTargets implements LinkTargets
|
||
{
|
||
private const DEAD = ['trash', 'auto-draft', 'inherit'];
|
||
|
||
public function postTypeOf(int $id): ?string
|
||
{
|
||
$post = get_post($id);
|
||
if (! $post instanceof WP_Post || in_array((string) $post->post_status, self::DEAD, true)) {
|
||
return null;
|
||
}
|
||
|
||
return current_user_can('read_post', $id) ? (string) $post->post_type : null;
|
||
}
|
||
}
|
||
```
|
||
|
||
`Placeholders.php`: Konstruktor, Muster, Fehlermeldung und neue Methode.
|
||
|
||
```php
|
||
private const PATTERN = '/^\{\{\s*(color|var|font|post|field|link)\s*:\s*([^{}]+?)\s*\}\}$/';
|
||
|
||
public function __construct(private DesignSystem $design, private ?LinkTargets $links = null)
|
||
{
|
||
}
|
||
```
|
||
|
||
In `resolve()` die Meldung zu „(bekannt: color, var, font, post, field, link)“ ändern und das `match` erweitern:
|
||
|
||
```php
|
||
return match ($kind) {
|
||
'color' => $this->color($name),
|
||
'var' => $this->variable($name),
|
||
'font' => $this->font($name),
|
||
'post' => $this->post($name),
|
||
'link' => $this->link($name),
|
||
default => $this->field($name),
|
||
};
|
||
```
|
||
|
||
Neue Methode (Klassen-Docblock um `{{link:<ID>}}` ergänzen):
|
||
|
||
```php
|
||
/**
|
||
* {{link:<ID>}} → Divi's own internal link post_link_url_<type> with settings.post_id (F27):
|
||
* rendered as get_permalink() at view time, so a draft target gets its pretty URL once published.
|
||
* Whether Divi offers that option (public post types only) VariableRef checks against the registry.
|
||
*/
|
||
private function link(string $name): string
|
||
{
|
||
if (preg_match('/^[1-9][0-9]{0,19}$/D', $name) !== 1) {
|
||
throw new InvalidArgumentException(sprintf(
|
||
'Ungültige Beitrags-ID "%s" in {{link:…}} (positive Zahl erwartet, z. B. {{link:42}}).',
|
||
$name
|
||
));
|
||
}
|
||
|
||
$type = $this->links?->postTypeOf((int) $name);
|
||
if ($type === null) {
|
||
throw new InvalidArgumentException(sprintf(
|
||
'Eintrag %s für {{link:…}} gibt es nicht, er liegt im Papierkorb oder ist nicht lesbar.',
|
||
$name
|
||
));
|
||
}
|
||
|
||
return VariableRef::serialize('content', 'post_link_url_' . $type, ['post_id' => $name]);
|
||
}
|
||
```
|
||
|
||
`VariableRef::contentSettings()` – vor der Schleife einfügen:
|
||
|
||
```php
|
||
if (! $url && str_starts_with($name, 'post_link_url_')) {
|
||
throw new InvalidArgumentException(sprintf(
|
||
'"%s" (Link auf einen Eintrag, {{link:…}}) nur in Link- und URL-Feldern.',
|
||
$name
|
||
));
|
||
}
|
||
```
|
||
|
||
`DiviComposition`: Import `use LIT\MCP\Integrations\Divi\Compose\LinkTargets;`, Konstruktor um `private LinkTargets $links = new WpLinkTargets()` als letzten Parameter erweitern und `placeholders()` ändern:
|
||
|
||
```php
|
||
return $this->placeholders ??= new Placeholders($this->design->read(), $this->links);
|
||
```
|
||
|
||
- [ ] **Step 4: Tests laufen lassen**
|
||
|
||
Run: `vendor/bin/phpunit --filter 'PlaceholdersTest|ShortformWriterTest|WpLinkTargetsTest|VariableRefTest|DiviCompositionTest'`
|
||
Expected: PASS
|
||
|
||
Run: `composer test && composer lint`
|
||
Expected: OK / keine Fehler
|
||
|
||
- [ ] **Step 5: Commit**
|
||
|
||
```bash
|
||
git add src/Integrations/Divi/Compose/LinkTargets.php src/Integrations/Divi/Pages/WpLinkTargets.php src/Integrations/Divi/Compose/Placeholders.php src/Integrations/Divi/Compose/VariableRef.php src/Integrations/Divi/Pages/DiviComposition.php tests/Support/ComposeFixture.php tests/Unit/Integrations/Divi/Compose/PlaceholdersTest.php tests/Unit/Integrations/Divi/Compose/ShortformWriterTest.php tests/Unit/Integrations/Divi/Pages/WpLinkTargetsTest.php
|
||
```
|
||
Commit wie in den Global Constraints mit der Nachricht `feat: {{link:ID}} placeholder via Divi's post_link_url dynamic content`.
|
||
|
||
---
|
||
|
||
### Task 3: `lit-guide` mit allen Themen (E13b)
|
||
|
||
Praxistest-Wunsch 7: alle Themen in einem Aufruf. `topic` = `all` liefert zuerst `overview`, dann die übrigen Themen alphabetisch; Obergrenze 100 000 Bytes, nicht aufgenommene Themen werden am Ende genannt.
|
||
|
||
**Files:**
|
||
- Modify: `src/Integrations/Core/GuideAbility.php`
|
||
- Test: `tests/Unit/Integrations/Core/GuideAbilityTest.php`
|
||
|
||
**Interfaces:**
|
||
- Consumes: `GuideRepository::topics(): list<string>`, `GuideRepository::get(string $topic): ?string`.
|
||
- Produces: `lit/guide` mit `topic` = `all` → `{topic: "all", topics: list<string>, content: string}`; Konstante `GuideAbility::ALL_LIMIT = 100000`.
|
||
|
||
- [ ] **Step 1: Failing test schreiben**
|
||
|
||
In `GuideAbilityTest` ergänzen (`$this->ability` liest `tests/Fixtures/guides` mit `overview.md` und `divi-shortform.md`):
|
||
|
||
```php
|
||
public function testAllTopicsInOneCallOverviewFirst(): void
|
||
{
|
||
$result = $this->ability->execute(['topic' => 'all']);
|
||
|
||
self::assertSame('all', $result['topic']);
|
||
self::assertSame(['divi-shortform', 'overview'], $result['topics']);
|
||
$overview = strpos($result['content'], 'Thema `overview`');
|
||
$shortform = strpos($result['content'], 'Thema `divi-shortform`');
|
||
self::assertIsInt($overview);
|
||
self::assertIsInt($shortform);
|
||
self::assertLessThan($shortform, $overview);
|
||
self::assertStringNotContainsString('Nicht enthalten', $result['content']);
|
||
}
|
||
|
||
public function testAllTopicsStopAtTheSizeLimitAndNameTheRest(): void
|
||
{
|
||
$big = str_repeat('x', GuideAbility::ALL_LIMIT);
|
||
// Brain Monkey owns apply_filters(): answer the guide filter through its hooks API.
|
||
Filters\expectApplied('lit_mcp_guides')->andReturn(['gross' => $big]);
|
||
$ability = new GuideAbility(new GuideRepository(dirname(__DIR__, 3) . '/Fixtures/guides'));
|
||
|
||
$content = $ability->execute(['topic' => 'all'])['content'];
|
||
|
||
self::assertLessThanOrEqual(GuideAbility::ALL_LIMIT + 200, strlen($content));
|
||
self::assertStringContainsString('Nicht enthalten (Größenlimit): gross', $content);
|
||
}
|
||
```
|
||
|
||
(Import `use Brain\Monkey\Filters;`.)
|
||
|
||
- [ ] **Step 2: Test laufen lassen – schlägt fehl**
|
||
|
||
Run: `vendor/bin/phpunit --filter GuideAbilityTest`
|
||
Expected: FAIL (`Undefined constant … ALL_LIMIT` bzw. `Unbekanntes Thema`)
|
||
|
||
- [ ] **Step 3: Implementieren**
|
||
|
||
In `GuideAbility`:
|
||
|
||
```php
|
||
private const DEFAULT_TOPIC = 'overview';
|
||
|
||
/** topic = all: every topic in one call (overview first). */
|
||
public const ALL = 'all';
|
||
|
||
/** Upper bound of the combined text of topic = all (bytes). */
|
||
public const ALL_LIMIT = 100000;
|
||
```
|
||
|
||
`description()`:
|
||
|
||
```php
|
||
return 'Liefert Anleitungen zur Bedienung dieses MCP-Servers. Ohne topic: Übersicht und Liste aller Themen; '
|
||
. 'topic = all: alle Themen in einem Aufruf (gut für den Einstieg).';
|
||
```
|
||
|
||
Beschreibung des Schema-Felds `topic`: `'Thema, z. B. "overview" oder "divi-shortform"; "all" = alle Themen.'`
|
||
|
||
In `execute()` direkt nach `$topics = $this->guides->topics();`:
|
||
|
||
```php
|
||
if ($topic === self::ALL) {
|
||
return ['topic' => self::ALL, 'topics' => $topics, 'content' => $this->all($topics)];
|
||
}
|
||
```
|
||
|
||
Neue Methode:
|
||
|
||
```php
|
||
/**
|
||
* Every topic, overview first, separated and labelled; stops before ALL_LIMIT bytes and names
|
||
* the topics left out.
|
||
*
|
||
* @param list<string> $topics
|
||
*/
|
||
private function all(array $topics): string
|
||
{
|
||
$ordered = in_array(self::DEFAULT_TOPIC, $topics, true)
|
||
? array_merge([self::DEFAULT_TOPIC], array_values(array_diff($topics, [self::DEFAULT_TOPIC])))
|
||
: $topics;
|
||
$parts = [];
|
||
$size = 0;
|
||
$left = [];
|
||
foreach ($ordered as $topic) {
|
||
$content = $this->guides->get($topic);
|
||
if ($content === null) {
|
||
continue;
|
||
}
|
||
|
||
$part = sprintf("---\nThema `%s`:\n\n%s", $topic, rtrim($content));
|
||
if ($size + strlen($part) > self::ALL_LIMIT) {
|
||
$left[] = $topic;
|
||
continue;
|
||
}
|
||
|
||
$parts[] = $part;
|
||
$size += strlen($part) + 2;
|
||
}
|
||
|
||
if ($left !== []) {
|
||
$parts[] = sprintf(
|
||
'Nicht enthalten (Größenlimit): %s – einzeln mit topic abrufen.',
|
||
implode(', ', $left)
|
||
);
|
||
}
|
||
|
||
return implode("\n\n", $parts);
|
||
}
|
||
```
|
||
|
||
- [ ] **Step 4: Tests laufen lassen**
|
||
|
||
Run: `vendor/bin/phpunit --filter 'GuideAbilityTest|ToolNamingTest'`
|
||
Expected: PASS
|
||
|
||
- [ ] **Step 5: Commit**
|
||
|
||
```bash
|
||
git add src/Integrations/Core/GuideAbility.php tests/Unit/Integrations/Core/GuideAbilityTest.php
|
||
```
|
||
Commit wie in den Global Constraints mit der Nachricht `feat: lit-guide topic all returns every guide in one call`.
|
||
|
||
---
|
||
|
||
### Task 4: S19 – Designsystem filtern, globale Module in `node-get`/`outline`
|
||
|
||
Ruling S19 (aus 2a F2): `lit-divi-design-system` wird auf großen Websites mit hunderten Presets unhandlich → Filter `only` (colors/variables/presets) und `module` (nur dessen Presets), höchstens 200 Presets je Antwort. `lit-divi-node-get` und `lit-divi-outline` nennen bei globalen Modulen die Bibliotheks-ID und den Wurzeltyp (E2).
|
||
|
||
**Files:**
|
||
- Modify: `src/Integrations/Divi/Design/DiviDesignSystemAbility.php`
|
||
- Modify: `src/Integrations/Divi/BlockTree/NodeSummary.php` (`globalRef()`)
|
||
- Modify: `src/Integrations/Divi/BlockTree/Outline.php` (`global_id`)
|
||
- Modify: `src/Integrations/Divi/Pages/DiviNodeGetAbility.php` (`global`)
|
||
- Modify: `src/Integrations/Divi/Pages/DiviOutlineAbility.php` (Schema, Hinweis)
|
||
- Test: `tests/Unit/Integrations/Divi/Design/DiviDesignSystemAbilityTest.php`, `tests/Unit/Integrations/Divi/BlockTree/OutlineTest.php`, `tests/Unit/Integrations/Divi/Pages/DiviReadAbilitiesTest.php`
|
||
|
||
**Interfaces:**
|
||
- Consumes: `DesignSystem::presets(): list<array{kind: string, module: string, id: string, name: string, default: bool}>`, Fixture `tests/Fixtures/divi/stage3/page--globale-instanzen.html` (g0 = Instanz 1058 `divi/section`, s0.r0.c0.g0 = Instanz 1059 `divi/text`).
|
||
- Produces: `NodeSummary::globalRef(Block $block): ?array{id: string, block_name: string}`; Outline-Zeilen mit `global_id: ?string`; `lit/divi-node-get` mit `global: null|{id, block_name, hint}`; `lit/divi-design-system` mit `only`, `module`.
|
||
|
||
- [ ] **Step 1: Failing tests schreiben**
|
||
|
||
`OutlineTest::testRowsAndTextOfAPage`: im erwarteten Array `'truncated' => false]` durch `'truncated' => false, 'global_id' => null]` ersetzen. Neuer Test in `OutlineTest`:
|
||
|
||
```php
|
||
public function testGlobalInstancesShowTheirLibraryIdAndRootType(): void
|
||
{
|
||
$content = DiviFixtures::markup('stage3/page--globale-instanzen.html');
|
||
$outline = new Outline();
|
||
$rows = $outline->rows(NodeIndex::build((new Parser())->parse($content)));
|
||
|
||
$byId = array_column($rows, null, 'id');
|
||
self::assertSame('1058', $byId['g0']['global_id']);
|
||
self::assertSame('section', $byId['g0']['type']);
|
||
self::assertFalse($byId['g0']['editable']);
|
||
self::assertSame('1059', $byId['s0.r0.c0.g0']['global_id']);
|
||
self::assertSame('text', $byId['s0.r0.c0.g0']['type']);
|
||
self::assertNull($byId['s0']['global_id']);
|
||
self::assertStringContainsString('g0 section "Global Abschnitt" [global 1058]', $outline->text($rows));
|
||
}
|
||
```
|
||
|
||
(Import `use LIT\MCP\Tests\Support\DiviFixtures;` – `DiviFixtures::markup()` ist reines PHP und liest `tests/Fixtures/divi/<name>`.)
|
||
|
||
In `DiviReadAbilitiesTest`:
|
||
|
||
```php
|
||
public function testNodeGetNamesTheLibraryEntryOfAGlobalModule(): void
|
||
{
|
||
DiviFixtures::givenPost(DiviFixtures::markup('stage3/page--globale-instanzen.html'));
|
||
$ability = new DiviNodeGetAbility(new DiviPageLoader(DiviFixtures::schema()), $this->design());
|
||
|
||
$global = $ability->execute(['post_id' => 7, 'id' => 'g0']);
|
||
$plain = $ability->execute(['post_id' => 7, 'id' => 's0']);
|
||
|
||
self::assertSame('1058', $global['global']['id']);
|
||
self::assertSame('divi/section', $global['global']['block_name']);
|
||
self::assertStringContainsString('post_id 1058', $global['global']['hint']);
|
||
self::assertFalse($global['editable']);
|
||
self::assertNull($plain['global']);
|
||
}
|
||
```
|
||
|
||
In `DiviDesignSystemAbilityTest` (Muster der vorhandenen Tests: Reader-Mock mit `DiviFixtures::designSystem()`):
|
||
|
||
```php
|
||
public function testFiltersPartsAndPresetsOfOneModule(): void
|
||
{
|
||
Functions\when('current_user_can')->justReturn(true);
|
||
$reader = Mockery::mock(DesignSystemReader::class);
|
||
$reader->allows('read')->andReturn(DiviFixtures::designSystem());
|
||
$ability = new DiviDesignSystemAbility($reader);
|
||
|
||
$result = $ability->execute(['only' => ['presets'], 'module' => 'button']);
|
||
|
||
self::assertSame([], $result['colors']);
|
||
self::assertSame([], $result['variables']);
|
||
self::assertSame(['p-1', 'p-2'], array_column($result['presets'], 'id'));
|
||
self::assertSame(['divi/button'], array_values(array_unique(array_column($result['presets'], 'module'))));
|
||
self::assertNotEmpty($result['fonts']['heading']);
|
||
self::assertContains('Nicht angefordert: colors, variables.', $result['notes']);
|
||
}
|
||
|
||
public function testCapsThePresetList(): void
|
||
{
|
||
Functions\when('current_user_can')->justReturn(true);
|
||
$items = [];
|
||
for ($i = 0; $i < 250; ++$i) {
|
||
$items['p' . $i] = ['id' => 'p' . $i, 'name' => 'Preset ' . $i, 'moduleName' => 'divi/text'];
|
||
}
|
||
$design = DesignSystem::fromDivi([], [], ['module' => ['divi/text' => ['default' => '', 'items' => $items]]], []);
|
||
$reader = Mockery::mock(DesignSystemReader::class);
|
||
$reader->allows('read')->andReturn($design);
|
||
|
||
$result = (new DiviDesignSystemAbility($reader))->execute([]);
|
||
|
||
self::assertCount(DiviDesignSystemAbility::PRESET_LIMIT, $result['presets']);
|
||
self::assertContains('200 von 250 Presets gezeigt; mit module auf ein Modul eingrenzen.', $result['notes']);
|
||
}
|
||
```
|
||
|
||
(Imports: `DesignSystem`, `DesignSystemReader`, `DiviFixtures`, `Mockery`, `Functions`.)
|
||
|
||
- [ ] **Step 2: Tests laufen lassen – schlagen fehl**
|
||
|
||
Run: `vendor/bin/phpunit --filter 'OutlineTest|DiviReadAbilitiesTest|DiviDesignSystemAbilityTest'`
|
||
Expected: FAIL (`global_id`, `global`, `PRESET_LIMIT` fehlen)
|
||
|
||
- [ ] **Step 3: Implementieren**
|
||
|
||
`NodeSummary`:
|
||
|
||
```php
|
||
/**
|
||
* Library entry of a global module: a divi/global-layout instance (its root type in blockName)
|
||
* or a block that carries globalModule itself (Divi 4 conversions). Null for every other block.
|
||
*
|
||
* @return array{id: string, block_name: string}|null
|
||
*/
|
||
public static function globalRef(Block $block): ?array
|
||
{
|
||
if (! $block->isGlobal()) {
|
||
return null;
|
||
}
|
||
|
||
$attrs = $block->attrs();
|
||
$id = $attrs['globalModule'] ?? null;
|
||
if (! is_string($id) && ! is_int($id)) {
|
||
return null;
|
||
}
|
||
|
||
$name = $block->name() === 'divi/global-layout' ? ($attrs['blockName'] ?? '') : $block->name();
|
||
|
||
return ['id' => (string) $id, 'block_name' => is_string($name) ? $name : ''];
|
||
}
|
||
```
|
||
|
||
`Outline::row()` – Typ und `global_id` (Docblock-Rückgabetyp um `global_id: ?string` ergänzen):
|
||
|
||
```php
|
||
private function row(Block $block, string $id, int $depth): array
|
||
{
|
||
$editable = $block->isDivi() && ! $block->isOpaque();
|
||
$global = NodeSummary::globalRef($block);
|
||
$type = $block->isDivi() ? $block->shortName() : $block->name();
|
||
if ($global !== null && $global['block_name'] !== '') {
|
||
$type = str_starts_with($global['block_name'], 'divi/') ? substr($global['block_name'], 5) : $global['block_name'];
|
||
}
|
||
|
||
return [
|
||
'id' => $id,
|
||
'type' => $type,
|
||
'label' => NodeSummary::label($block),
|
||
'excerpt' => NodeSummary::excerpt($block),
|
||
'info' => $editable ? NodeSummary::info($block) : '',
|
||
'presets' => array_map(
|
||
fn (string $presetId): string => $this->presetNames[$presetId] ?? $presetId,
|
||
NodeSummary::presetIds($block)
|
||
),
|
||
'children' => $editable ? count($block->children()) : 0,
|
||
'editable' => $editable,
|
||
'depth' => $depth,
|
||
'truncated' => false,
|
||
'global_id' => $global['id'] ?? null,
|
||
];
|
||
}
|
||
```
|
||
|
||
`NodeSummary::label()` liest `module.meta.adminLabel` aus den Attributen; bei `divi/global-layout` steht das Label in `localAttrs`. In `NodeSummary::label()` die erste Zeile ersetzen durch:
|
||
|
||
```php
|
||
$attrs = $block->name() === 'divi/global-layout' && is_array($block->attrs()['localAttrs'] ?? null)
|
||
? $block->attrs()['localAttrs']
|
||
: $block->attrs();
|
||
$label = AttrMap::desktop($attrs, 'module.meta.adminLabel');
|
||
```
|
||
|
||
`Outline::text()` – nach der Label-Zeile:
|
||
|
||
```php
|
||
$line .= ($row['global_id'] ?? null) !== null ? ' [global ' . $row['global_id'] . ']' : '';
|
||
```
|
||
|
||
`DiviOutlineAbility::outputSchema()` – in den Zeilen-`properties` `'global_id' => ['type' => ['string', 'null'], 'description' => 'Bibliotheks-ID eines globalen Moduls.']` ergänzen und `'global_id'` in `required` aufnehmen. In `hints()` den Text für nur lesbare Knoten ersetzen:
|
||
|
||
```php
|
||
$hints[] = 'Knoten mit "nur lesbar" (globale Module, fremde Blöcke) lassen sich nur als Ganzes '
|
||
. 'verschieben, duplizieren oder löschen. Globale Module [global <ID>] im Bibliothekseintrag '
|
||
. 'bearbeiten: lit-divi-outline mit post_id <ID> – die Änderung wirkt auf alle Seiten.';
|
||
```
|
||
|
||
`DiviNodeGetAbility`: im `outputSchema` `'global' => ['type' => ['object', 'null']]` ergänzen (nicht in `required`); in `execute()` vor dem `return`:
|
||
|
||
```php
|
||
$global = NodeSummary::globalRef($block);
|
||
if ($global !== null) {
|
||
$global['hint'] = sprintf(
|
||
'Globales Modul: Inhalt im Bibliothekseintrag %s bearbeiten (lit-divi-outline mit post_id %s); '
|
||
. 'jede Änderung dort wirkt auf alle Seiten mit diesem Modul.',
|
||
$global['id'],
|
||
$global['id']
|
||
);
|
||
}
|
||
```
|
||
|
||
und `'global' => $global,` ins Ergebnis-Array.
|
||
|
||
`DiviDesignSystemAbility`:
|
||
|
||
```php
|
||
/** Presets per answer (ruling S19); narrow with "module". */
|
||
public const PRESET_LIMIT = 200;
|
||
|
||
private const PARTS = ['colors', 'variables', 'presets'];
|
||
```
|
||
|
||
`description()` um „Filter: only (colors/variables/presets) und module (Presets eines Moduls).“ ergänzen. `inputSchema()`:
|
||
|
||
```php
|
||
return [
|
||
'type' => 'object',
|
||
'properties' => [
|
||
'only' => [
|
||
'type' => 'array',
|
||
'items' => ['type' => 'string', 'enum' => self::PARTS],
|
||
'description' => 'Nur diese Teile liefern (Standard: alle). Schriften und Größen sind immer dabei.',
|
||
],
|
||
'module' => [
|
||
'type' => 'string',
|
||
'description' => 'Nur Presets dieses Moduls, z. B. "button" oder "divi/button".',
|
||
],
|
||
],
|
||
'additionalProperties' => false,
|
||
];
|
||
```
|
||
|
||
`execute()` vollständig:
|
||
|
||
```php
|
||
public function execute(array $input): mixed
|
||
{
|
||
$design = $this->reader->read();
|
||
$only = is_array($input['only'] ?? null) && $input['only'] !== []
|
||
? array_values(array_intersect(self::PARTS, $input['only']))
|
||
: self::PARTS;
|
||
$notes = [
|
||
'Schriften: {{font:heading}} bzw. {{font:body}}; Presets in der Kurzform über "preset": "<Name>".',
|
||
'Feste Farben oder Schriften nur verwenden, wenn der Nutzer es ausdrücklich möchte.',
|
||
];
|
||
$skipped = array_values(array_diff(self::PARTS, $only));
|
||
if ($skipped !== []) {
|
||
$notes[] = 'Nicht angefordert: ' . implode(', ', $skipped) . '.';
|
||
}
|
||
|
||
$presets = $design->presets();
|
||
$module = is_string($input['module'] ?? null) ? trim($input['module']) : '';
|
||
if ($module !== '') {
|
||
$name = str_contains($module, '/') ? $module : 'divi/' . $module;
|
||
$presets = array_values(array_filter(
|
||
$presets,
|
||
static fn (array $preset): bool => $preset['module'] === $name
|
||
));
|
||
}
|
||
if (count($presets) > self::PRESET_LIMIT) {
|
||
$notes[] = sprintf(
|
||
'%d von %d Presets gezeigt; mit module auf ein Modul eingrenzen.',
|
||
self::PRESET_LIMIT,
|
||
count($presets)
|
||
);
|
||
$presets = array_slice($presets, 0, self::PRESET_LIMIT);
|
||
}
|
||
|
||
return [
|
||
'colors' => in_array('colors', $only, true) ? array_map(
|
||
static fn (array $color): array => $color + [
|
||
'placeholder' => DesignSystem::colorPlaceholder($color['id'], $color['label']),
|
||
],
|
||
$design->colors()
|
||
) : [],
|
||
'variables' => in_array('variables', $only, true) ? array_map(
|
||
static fn (array $variable): array => $variable
|
||
+ ['placeholder' => '{{var:' . $variable['label'] . '}}'],
|
||
$design->variables()
|
||
) : [],
|
||
'fonts' => $design->fonts(),
|
||
'sizes' => $design->sizes(),
|
||
'presets' => in_array('presets', $only, true) ? $presets : [],
|
||
'notes' => $notes,
|
||
];
|
||
}
|
||
```
|
||
|
||
- [ ] **Step 4: Tests laufen lassen**
|
||
|
||
Run: `vendor/bin/phpunit --filter 'OutlineTest|DiviReadAbilitiesTest|DiviDesignSystemAbilityTest|DiviWriterTest'`
|
||
Expected: PASS
|
||
|
||
Run: `composer test && composer lint`
|
||
Expected: OK
|
||
|
||
- [ ] **Step 5: Commit**
|
||
|
||
```bash
|
||
git add src/Integrations/Divi/Design/DiviDesignSystemAbility.php src/Integrations/Divi/BlockTree/NodeSummary.php src/Integrations/Divi/BlockTree/Outline.php src/Integrations/Divi/Pages/DiviNodeGetAbility.php src/Integrations/Divi/Pages/DiviOutlineAbility.php tests/Unit/Integrations/Divi
|
||
```
|
||
Commit wie in den Global Constraints mit der Nachricht `feat: design-system filters and global module ids in node-get/outline (S19)`.
|
||
|
||
---
|
||
|
||
### Task 5: `lit-page-render-summary` meldet globale Module (E13d, F8)
|
||
|
||
Divis `BlockParser` expandiert `divi/global-layout` nicht bei REST-POST-Anfragen (F8, `BlockParser.php:827-831`) – unsere MCP-Aufrufe sind REST-POST, der Auszug enthält globale Module also nicht. Statt einen Divi-internen Schalter zu umgehen, meldet der Auszug jede Instanz (Divis eigene Erkennung per Zeichenkettensuche, F10). Bibliotheks-IDs bleiben für das Tool `not_found` (`ContentSchema::EXCLUDED`).
|
||
|
||
**Files:**
|
||
- Modify: `src/Integrations/WordPress/Render/PageRenderSummaryAbility.php`
|
||
- Test: `tests/Unit/Integrations/WordPress/Render/PageRenderSummaryAbilityTest.php`
|
||
|
||
**Interfaces:**
|
||
- Consumes: `PageRenderer::render(WP_Post): string`, `RenderSummary::fromHtml()`.
|
||
- Produces: `notes` enthält je globaler Instanz `Globales Modul <ID> ist im Auszug nicht enthalten …` (höchstens 20).
|
||
|
||
- [ ] **Step 1: Failing test schreiben**
|
||
|
||
Im vorhandenen Test das Muster zum Stubben von `get_post`, `current_user_can`, `get_permalink` und des `PageRenderer`-Mocks übernehmen (siehe bestehende Tests der Datei):
|
||
|
||
```php
|
||
public function testNotesEveryGlobalModuleTheSummaryCannotShow(): void
|
||
{
|
||
$content = DiviFixtures::markup('stage3/page--globale-instanzen.html');
|
||
$post = new WP_Post(['ID' => 7, 'post_type' => 'page', 'post_status' => 'draft', 'post_content' => $content]);
|
||
Functions\when('get_post')->justReturn($post);
|
||
Functions\when('current_user_can')->justReturn(true);
|
||
Functions\when('get_permalink')->justReturn('https://kunde.test/?page_id=7');
|
||
$renderer = Mockery::mock(PageRenderer::class);
|
||
$renderer->allows('render')->andReturn('<p>Text</p>');
|
||
$ability = new PageRenderSummaryAbility(SchemaFixture::managed(), $renderer);
|
||
|
||
$notes = $ability->execute(['post_id' => 7])['notes'];
|
||
|
||
$globals = array_values(array_filter($notes, static fn (string $note): bool => str_starts_with($note, 'Globales Modul')));
|
||
self::assertCount(2, $globals);
|
||
self::assertStringContainsString('Globales Modul 1058 ist im Auszug nicht enthalten', $globals[0]);
|
||
self::assertStringContainsString('lit-divi-outline mit post_id 1059', $globals[1]);
|
||
}
|
||
|
||
public function testLibraryEntriesAreNoManagedContent(): void
|
||
{
|
||
Functions\when('get_post')->justReturn(new WP_Post(['ID' => 1058, 'post_type' => 'et_pb_layout']));
|
||
$schema = Mockery::mock(ContentSchema::class);
|
||
$schema->allows('isManaged')->with('et_pb_layout')->andReturn(false);
|
||
$ability = new PageRenderSummaryAbility($schema, Mockery::mock(PageRenderer::class));
|
||
|
||
self::assertToolError($ability->permission(['post_id' => 1058]), 'not_found');
|
||
}
|
||
```
|
||
|
||
(Imports: `ContentSchema`, `SchemaFixture`, `DiviFixtures`, `PageRenderer`, `Mockery`, `WP_Post`, `Functions`.)
|
||
|
||
- [ ] **Step 2: Test laufen lassen – schlägt fehl**
|
||
|
||
Run: `vendor/bin/phpunit --filter PageRenderSummaryAbilityTest`
|
||
Expected: FAIL (`assertCount(2, …)`: 0)
|
||
|
||
- [ ] **Step 3: Implementieren**
|
||
|
||
In `PageRenderSummaryAbility`:
|
||
|
||
```php
|
||
/** At most this many global-module notes per summary. */
|
||
private const GLOBAL_NOTES = 20;
|
||
```
|
||
|
||
In `execute()` nach dem Passwort-Hinweis:
|
||
|
||
```php
|
||
foreach (array_slice(self::globalModuleIds((string) $post->post_content), 0, self::GLOBAL_NOTES) as $id) {
|
||
$notes[] = sprintf(
|
||
'Globales Modul %s ist im Auszug nicht enthalten (beim Aufruf über die Schnittstelle rendert Divi '
|
||
. 'globale Module nicht); Inhalt mit lit-divi-outline mit post_id %s lesen.',
|
||
$id,
|
||
$id
|
||
);
|
||
}
|
||
```
|
||
|
||
Neue Methode:
|
||
|
||
```php
|
||
/**
|
||
* IDs of the global modules in $content, found the way Divi finds them (a string scan for
|
||
* "globalModule", BlockParserStore::get_global_layout_content – parse_blocks() is unreliable there).
|
||
*
|
||
* @return list<string>
|
||
*/
|
||
private static function globalModuleIds(string $content): array
|
||
{
|
||
preg_match_all('/"globalModule":"?(\d+)"?/', $content, $matches);
|
||
|
||
return array_values(array_unique($matches[1]));
|
||
}
|
||
```
|
||
|
||
`description()` um den Satz „Globale Module (Divi-Bibliothek) fehlen im Auszug und werden unter notes genannt.“ ergänzen.
|
||
|
||
- [ ] **Step 4: Tests laufen lassen**
|
||
|
||
Run: `vendor/bin/phpunit --filter 'PageRenderSummaryAbilityTest|ToolNamingTest'`
|
||
Expected: PASS
|
||
|
||
- [ ] **Step 5: Commit**
|
||
|
||
```bash
|
||
git add src/Integrations/WordPress/Render/PageRenderSummaryAbility.php tests/Unit/Integrations/WordPress/Render/PageRenderSummaryAbilityTest.php
|
||
```
|
||
Commit wie in den Global Constraints mit der Nachricht `feat: render summary notes global modules it cannot show (F8)`.
|
||
|
||
---
|
||
|
||
### Task 6: Divi-Adapter mit Kompatibilitätsprüfung – `DiviRoles`, `DiviLibraryStore` (lesen), `DiviCompatibility`
|
||
|
||
Schnittstellen-Einordnung (Entscheidungen §5, E15): Divis Rollen-Editor (`et_pb_is_allowed`, Stufe c), der Bibliotheks-Post-Typ mit Termen/Meta (c/d) und `GlobalLayout::is_global_layout_template` (c) werden nur über Adapter angesprochen. Fehlt eine Funktion/Klasse nach einem Divi-Update, liefern die Adapter „nicht erlaubt“ bzw. den Rückfall, nie einen Fatal; `lit-site-status` zeigt den Befund. Die Builder-Routen `divi/v1/divi-library/*` werden nicht benutzt (Nonce, keine Rechte je Eintrag, F9/F11).
|
||
|
||
**Files:**
|
||
- Create: `src/Integrations/Divi/Library/DiviRoles.php`
|
||
- Create: `src/Integrations/Divi/Library/DiviLibraryStore.php`
|
||
- Create: `src/Integrations/Divi/DiviCompatibility.php`
|
||
- Modify: `src/Integrations/Divi/Pages/DynamicContentMap.php` (`REGISTRY` öffentlich)
|
||
- Modify: `src/Integrations/Core/EnvironmentProbe.php`
|
||
- Test: `tests/Unit/Integrations/Divi/Library/DiviRolesTest.php`, `tests/Unit/Integrations/Divi/Library/DiviLibraryStoreTest.php`, `tests/Unit/Integrations/Divi/DiviCompatibilityTest.php`, `tests/Unit/Integrations/Core/EnvironmentProbeTest.php`
|
||
|
||
**Interfaces:**
|
||
- Consumes: `Errors::forbidden()`, `DiviModules::isAvailable()`, `WP_Term`-Stub.
|
||
- Produces:
|
||
- `class DiviRoles { __construct(?Closure $check = null); allows(string $capability): bool; refusal(string $capability): ?WP_Error }`
|
||
- `class DiviLibraryStore { const POST_TYPE = 'et_pb_layout'; const GLOBAL_LAYOUT = 'ET\Builder\Packages\GlobalLayout\GlobalLayout'; const LAYOUT_TYPES = ['layout','section','row','module']; const TAXONOMIES = ['scope','layout_type','module_width']; isGlobal(int $id): bool; layoutType(int $id): ?string; termSlugs(int $id, string $taxonomy): list<string>; termNames(int $id, string $taxonomy): list<string>; find(array $filters, int $limit, int $offset): list<WP_Post>; describe(WP_Post $post): array; missingTaxonomies(): list<string> }` (nicht final, mockbar; `create()`/`delete()` folgen in Task 12)
|
||
- `final class DiviCompatibility { __construct(?array $checks = null); problems(): list<string>; static defaults(): array<string, callable(): bool> }`
|
||
- `EnvironmentProbe::__construct(?DiviCompatibility $divi = null)`; jede Komponente hat zusätzlich `problems: list<string>`.
|
||
|
||
- [ ] **Step 1: Failing tests schreiben**
|
||
|
||
`tests/Unit/Integrations/Divi/Library/DiviRolesTest.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Tests\Unit\Integrations\Divi\Library;
|
||
|
||
use LIT\MCP\Integrations\Divi\Library\DiviRoles;
|
||
use LIT\MCP\Tests\Unit\TestCase;
|
||
|
||
final class DiviRolesTest extends TestCase
|
||
{
|
||
public function testAsksTheCheckAndExplainsARefusal(): void
|
||
{
|
||
$roles = new DiviRoles(static fn (string $cap): bool => $cap !== 'edit_global_library');
|
||
|
||
self::assertTrue($roles->allows('divi_library'));
|
||
self::assertNull($roles->refusal('divi_library'));
|
||
$refusal = $roles->refusal('edit_global_library');
|
||
self::assertToolError($refusal, 'forbidden');
|
||
self::assertStringContainsString('Globale Bibliothekselemente bearbeiten', $refusal->get_error_message());
|
||
self::assertStringContainsString('Rollen-Editor', $refusal->get_error_message());
|
||
}
|
||
|
||
public function testWithoutDiviNothingIsAllowed(): void
|
||
{
|
||
// Unit tests have no et_pb_is_allowed(): a missing Divi function never means "allowed".
|
||
self::assertFalse((new DiviRoles())->allows('divi_library'));
|
||
}
|
||
}
|
||
```
|
||
|
||
`tests/Unit/Integrations/Divi/Library/DiviLibraryStoreTest.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Tests\Unit\Integrations\Divi\Library;
|
||
|
||
use Brain\Monkey\Functions;
|
||
use LIT\MCP\Integrations\Divi\Library\DiviLibraryStore;
|
||
use LIT\MCP\Tests\Unit\TestCase;
|
||
use WP_Post;
|
||
use WP_Term;
|
||
|
||
final class DiviLibraryStoreTest extends TestCase
|
||
{
|
||
protected function setUp(): void
|
||
{
|
||
parent::setUp();
|
||
$terms = [
|
||
1058 => [
|
||
'scope' => [new WP_Term(['slug' => 'global', 'name' => 'global'])],
|
||
'layout_type' => [new WP_Term(['slug' => 'section', 'name' => 'section'])],
|
||
'layout_category' => [new WP_Term(['slug' => 'kopf', 'name' => 'Kopfbereiche'])],
|
||
],
|
||
1055 => [
|
||
'scope' => [new WP_Term(['slug' => 'non_global', 'name' => 'non_global'])],
|
||
'layout_type' => [new WP_Term(['slug' => 'section', 'name' => 'section'])],
|
||
],
|
||
1057 => [],
|
||
];
|
||
Functions\when('get_the_terms')->alias(
|
||
static fn (int $id, string $taxonomy): array|false => $terms[$id][$taxonomy] ?? false
|
||
);
|
||
Functions\when('get_post_meta')->alias(
|
||
static fn (int $id, string $key): string => $id === 1057 && $key === '_et_pb_module_type' ? 'divi/blurb' : ''
|
||
);
|
||
}
|
||
|
||
public function testGlobalScopeAndLayoutTypeFromTheTerms(): void
|
||
{
|
||
$store = new DiviLibraryStore();
|
||
|
||
self::assertTrue($store->isGlobal(1058));
|
||
self::assertFalse($store->isGlobal(1055));
|
||
self::assertSame('section', $store->layoutType(1058));
|
||
self::assertNull($store->layoutType(1057));
|
||
self::assertSame(['Kopfbereiche'], $store->termNames(1058, 'layout_category'));
|
||
}
|
||
|
||
public function testDescribesAnEntry(): void
|
||
{
|
||
$post = new WP_Post([
|
||
'ID' => 1057, 'post_type' => 'et_pb_layout', 'post_title' => '[Fixture] Library-Modul',
|
||
'post_modified_gmt' => '2026-09-26 20:56:29',
|
||
]);
|
||
|
||
self::assertSame(
|
||
[
|
||
'id' => 1057, 'title' => '[Fixture] Library-Modul', 'layout_type' => null, 'scope' => 'normal',
|
||
'module_type' => 'divi/blurb', 'categories' => [], 'tags' => [], 'modified' => '2026-09-26 20:56:29',
|
||
],
|
||
(new DiviLibraryStore())->describe($post)
|
||
);
|
||
}
|
||
|
||
public function testFindQueriesPublishedEntriesWithFilters(): void
|
||
{
|
||
$captured = [];
|
||
Functions\when('get_posts')->alias(static function (array $args) use (&$captured): array {
|
||
$captured = $args;
|
||
|
||
return [];
|
||
});
|
||
|
||
(new DiviLibraryStore())->find(
|
||
['layout_type' => 'section', 'scope' => 'normal', 'search' => 'Kopf', 'category' => 'Kopfbereiche'],
|
||
20,
|
||
40
|
||
);
|
||
|
||
self::assertSame('et_pb_layout', $captured['post_type']);
|
||
self::assertSame('publish', $captured['post_status']);
|
||
self::assertSame(21, $captured['posts_per_page']);
|
||
self::assertSame(40, $captured['offset']);
|
||
self::assertSame('Kopf', $captured['s']);
|
||
self::assertSame(
|
||
[
|
||
'relation' => 'AND',
|
||
['taxonomy' => 'layout_type', 'field' => 'slug', 'terms' => ['section']],
|
||
['taxonomy' => 'scope', 'field' => 'slug', 'terms' => ['global'], 'operator' => 'NOT IN'],
|
||
['taxonomy' => 'layout_category', 'field' => 'name', 'terms' => ['Kopfbereiche']],
|
||
],
|
||
$captured['tax_query']
|
||
);
|
||
}
|
||
|
||
public function testReportsMissingTaxonomies(): void
|
||
{
|
||
Functions\when('taxonomy_exists')->alias(static fn (string $taxonomy): bool => $taxonomy !== 'scope');
|
||
|
||
self::assertSame(['scope'], (new DiviLibraryStore())->missingTaxonomies());
|
||
}
|
||
}
|
||
```
|
||
|
||
`tests/Unit/Integrations/Divi/DiviCompatibilityTest.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Tests\Unit\Integrations\Divi;
|
||
|
||
use LIT\MCP\Integrations\Divi\DiviCompatibility;
|
||
use PHPUnit\Framework\TestCase;
|
||
use RuntimeException;
|
||
|
||
final class DiviCompatibilityTest extends TestCase
|
||
{
|
||
public function testListsFailedAndThrowingChecks(): void
|
||
{
|
||
$compatibility = new DiviCompatibility([
|
||
'A' => static fn (): bool => true,
|
||
'B' => static fn (): bool => false,
|
||
'C' => static function (): bool {
|
||
throw new RuntimeException('Divi changed');
|
||
},
|
||
]);
|
||
|
||
self::assertSame(['B', 'C'], $compatibility->problems());
|
||
}
|
||
|
||
public function testDefaultsCoverTheDiviInternalsInUse(): void
|
||
{
|
||
self::assertSame(
|
||
[
|
||
'ModuleRegistration (Modul-Katalog)',
|
||
'DynamicContentOptions (Dynamic Content)',
|
||
'et_pb_is_allowed (Divi-Rollen)',
|
||
'Post-Typ et_pb_layout (Bibliothek)',
|
||
'Taxonomien scope, layout_type, module_width (Bibliothek)',
|
||
'GlobalLayout::is_global_layout_template (globale Module)',
|
||
'ET_Core_PageResource (CSS-Cache)',
|
||
],
|
||
array_keys(DiviCompatibility::defaults())
|
||
);
|
||
}
|
||
}
|
||
```
|
||
|
||
`tests/Unit/Integrations/Core/EnvironmentProbeTest.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Tests\Unit\Integrations\Core;
|
||
|
||
use Brain\Monkey\Functions;
|
||
use LIT\MCP\Integrations\Core\EnvironmentProbe;
|
||
use LIT\MCP\Integrations\Divi\DiviCompatibility;
|
||
use LIT\MCP\Tests\Unit\TestCase;
|
||
use Mockery;
|
||
|
||
final class EnvironmentProbeTest extends TestCase
|
||
{
|
||
public function testDiviComponentCarriesTheCompatibilityFindings(): void
|
||
{
|
||
$theme = Mockery::mock();
|
||
$theme->allows('get_template')->andReturn('Divi');
|
||
$theme->allows('parent')->andReturn(false);
|
||
$theme->allows('get')->with('Version')->andReturn('5.2.1');
|
||
Functions\when('wp_get_theme')->justReturn($theme);
|
||
|
||
$probe = new EnvironmentProbe(new DiviCompatibility(['GlobalLayout' => static fn (): bool => false]));
|
||
$components = array_column($probe->components(), null, 'id');
|
||
|
||
self::assertSame(['GlobalLayout'], $components['divi']['problems']);
|
||
self::assertSame([], $components['pods']['problems']);
|
||
}
|
||
}
|
||
```
|
||
|
||
- [ ] **Step 2: Tests laufen lassen – schlagen fehl**
|
||
|
||
Run: `vendor/bin/phpunit --filter 'DiviRolesTest|DiviLibraryStoreTest|DiviCompatibilityTest|EnvironmentProbeTest'`
|
||
Expected: FAIL (Klassen fehlen)
|
||
|
||
- [ ] **Step 3: Implementieren**
|
||
|
||
`src/Integrations/Divi/Library/DiviRoles.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Integrations\Divi\Library;
|
||
|
||
use Closure;
|
||
use LIT\MCP\Abilities\Errors;
|
||
use WP_Error;
|
||
|
||
defined('ABSPATH') || exit;
|
||
|
||
/**
|
||
* Adapter for Divi's role editor (E3, E15): et_pb_is_allowed() (Divi 5.2.1 builder/core.php:1128)
|
||
* answers for the current user's role, "dangerous" options (theme_builder,
|
||
* read_dynamic_content_custom_fields) default to off for every role but administrator. When
|
||
* Divi no longer has the function, nothing is allowed – DiviCompatibility reports it.
|
||
* Not final so tests can pass a check.
|
||
*/
|
||
class DiviRoles
|
||
{
|
||
private const LABELS = [
|
||
'divi_library' => 'Divi-Bibliothek',
|
||
'save_library' => 'In der Bibliothek speichern',
|
||
'add_library' => 'Aus der Bibliothek hinzufügen',
|
||
'edit_global_library' => 'Globale Bibliothekselemente bearbeiten',
|
||
'read_dynamic_content_custom_fields' => 'Dynamic Content: benutzerdefinierte Felder lesen',
|
||
];
|
||
|
||
/** @param (Closure(string): bool)|null $check Test seam; null = Divi's et_pb_is_allowed(). */
|
||
public function __construct(private ?Closure $check = null)
|
||
{
|
||
}
|
||
|
||
public function allows(string $capability): bool
|
||
{
|
||
if ($this->check !== null) {
|
||
return ($this->check)($capability);
|
||
}
|
||
|
||
return function_exists('et_pb_is_allowed') && (bool) et_pb_is_allowed($capability);
|
||
}
|
||
|
||
/** Null when the role allows $capability, else a forbidden error naming the option. */
|
||
public function refusal(string $capability): ?WP_Error
|
||
{
|
||
if ($this->allows($capability)) {
|
||
return null;
|
||
}
|
||
|
||
return Errors::forbidden(
|
||
sprintf('Die Divi-Rolle dieses Kontos erlaubt „%s“ nicht.', self::LABELS[$capability] ?? $capability),
|
||
'Einen Administrator bitten, das Recht unter Divi → Rollen-Editor freizugeben.'
|
||
);
|
||
}
|
||
}
|
||
```
|
||
|
||
`src/Integrations/Divi/Library/DiviLibraryStore.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Integrations\Divi\Library;
|
||
|
||
use WP_Post;
|
||
use WP_Term;
|
||
|
||
defined('ABSPATH') || exit;
|
||
|
||
/**
|
||
* Adapter for the Divi Library (E4, E15): post type et_pb_layout, the taxonomies scope,
|
||
* layout_type, module_width, layout_category, layout_tag and the meta Divi's et_pb_submit_layout()
|
||
* writes (F1, F2, fixtures stage3). "Global" is Divi's own definition
|
||
* GlobalLayout::is_global_layout_template() (F5) with the scope term as fallback when the class is
|
||
* gone. Library entries are always "publish" (F2). Not final so abilities can be tested with a mock.
|
||
*/
|
||
class DiviLibraryStore
|
||
{
|
||
public const POST_TYPE = 'et_pb_layout';
|
||
|
||
public const GLOBAL_LAYOUT = 'ET\Builder\Packages\GlobalLayout\GlobalLayout';
|
||
|
||
public const LAYOUT_TYPES = ['layout', 'section', 'row', 'module'];
|
||
|
||
/** Taxonomies every new entry needs (et_pb_submit_layout). */
|
||
public const TAXONOMIES = ['scope', 'layout_type', 'module_width'];
|
||
|
||
public function isGlobal(int $id): bool
|
||
{
|
||
if (method_exists(self::GLOBAL_LAYOUT, 'is_global_layout_template')) {
|
||
return (bool) call_user_func([self::GLOBAL_LAYOUT, 'is_global_layout_template'], $id);
|
||
}
|
||
|
||
return in_array('global', $this->termSlugs($id, 'scope'), true);
|
||
}
|
||
|
||
/** "layout", "section", "row" or "module"; null when the entry has no known type. */
|
||
public function layoutType(int $id): ?string
|
||
{
|
||
foreach ($this->termSlugs($id, 'layout_type') as $slug) {
|
||
if (in_array($slug, self::LAYOUT_TYPES, true)) {
|
||
return $slug;
|
||
}
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
/** @return list<string> */
|
||
public function termSlugs(int $id, string $taxonomy): array
|
||
{
|
||
return array_map(static fn (WP_Term $term): string => (string) $term->slug, $this->terms($id, $taxonomy));
|
||
}
|
||
|
||
/** @return list<string> */
|
||
public function termNames(int $id, string $taxonomy): array
|
||
{
|
||
return array_map(static fn (WP_Term $term): string => (string) $term->name, $this->terms($id, $taxonomy));
|
||
}
|
||
|
||
/**
|
||
* Published entries, $limit + 1 of them (Cursor::page() tells whether there are more).
|
||
*
|
||
* @param array{layout_type?: string, scope?: string, search?: string, category?: string} $filters
|
||
* scope: "global" or "normal"; category: name of a layout_category term.
|
||
* @return list<WP_Post>
|
||
*/
|
||
public function find(array $filters, int $limit, int $offset): array
|
||
{
|
||
$taxQuery = [];
|
||
if (in_array($filters['layout_type'] ?? '', self::LAYOUT_TYPES, true)) {
|
||
$taxQuery[] = ['taxonomy' => 'layout_type', 'field' => 'slug', 'terms' => [$filters['layout_type']]];
|
||
}
|
||
if (($filters['scope'] ?? '') === 'global') {
|
||
$taxQuery[] = ['taxonomy' => 'scope', 'field' => 'slug', 'terms' => ['global']];
|
||
} elseif (($filters['scope'] ?? '') === 'normal') {
|
||
$taxQuery[] = ['taxonomy' => 'scope', 'field' => 'slug', 'terms' => ['global'], 'operator' => 'NOT IN'];
|
||
}
|
||
if (($filters['category'] ?? '') !== '') {
|
||
$taxQuery[] = ['taxonomy' => 'layout_category', 'field' => 'name', 'terms' => [$filters['category']]];
|
||
}
|
||
|
||
$args = [
|
||
'post_type' => self::POST_TYPE,
|
||
'post_status' => 'publish',
|
||
'posts_per_page' => $limit + 1,
|
||
'offset' => $offset,
|
||
'orderby' => 'title',
|
||
'order' => 'ASC',
|
||
'no_found_rows' => true,
|
||
'suppress_filters' => false,
|
||
];
|
||
if (($filters['search'] ?? '') !== '') {
|
||
$args['s'] = $filters['search'];
|
||
}
|
||
if ($taxQuery !== []) {
|
||
// phpcs:ignore WordPress.DB.SlowDBQuery.slow_db_query_tax_query -- the library is small.
|
||
$args['tax_query'] = array_merge(['relation' => 'AND'], $taxQuery);
|
||
}
|
||
|
||
return array_values(array_filter(get_posts($args), static fn (mixed $post): bool => $post instanceof WP_Post));
|
||
}
|
||
|
||
/**
|
||
* @return array{id: int, title: string, layout_type: ?string, scope: string, module_type: ?string,
|
||
* categories: list<string>, tags: list<string>, modified: string}
|
||
*/
|
||
public function describe(WP_Post $post): array
|
||
{
|
||
$id = (int) $post->ID;
|
||
$moduleType = (string) get_post_meta($id, '_et_pb_module_type', true);
|
||
|
||
return [
|
||
'id' => $id,
|
||
'title' => (string) $post->post_title,
|
||
'layout_type' => $this->layoutType($id),
|
||
'scope' => $this->isGlobal($id) ? 'global' : 'normal',
|
||
'module_type' => $moduleType === '' ? null : $moduleType,
|
||
'categories' => $this->termNames($id, 'layout_category'),
|
||
'tags' => $this->termNames($id, 'layout_tag'),
|
||
'modified' => (string) $post->post_modified_gmt,
|
||
];
|
||
}
|
||
|
||
/**
|
||
* Library taxonomies not registered in this request (F2: Divi registers them in
|
||
* ET_Builder_Library; fixture finding 6: not in every context).
|
||
*
|
||
* @return list<string>
|
||
*/
|
||
public function missingTaxonomies(): array
|
||
{
|
||
return array_values(array_filter(
|
||
self::TAXONOMIES,
|
||
static fn (string $taxonomy): bool => ! taxonomy_exists($taxonomy)
|
||
));
|
||
}
|
||
|
||
/** @return list<WP_Term> */
|
||
private function terms(int $id, string $taxonomy): array
|
||
{
|
||
$terms = get_the_terms($id, $taxonomy);
|
||
|
||
return is_array($terms)
|
||
? array_values(array_filter($terms, static fn (mixed $term): bool => $term instanceof WP_Term))
|
||
: [];
|
||
}
|
||
}
|
||
```
|
||
|
||
`DynamicContentMap`: `private const REGISTRY` → `public const REGISTRY` (Docblock: „also checked by DiviCompatibility“).
|
||
|
||
`src/Integrations/Divi/DiviCompatibility.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Integrations\Divi;
|
||
|
||
use LIT\MCP\Integrations\Divi\Library\DiviLibraryStore;
|
||
use LIT\MCP\Integrations\Divi\Pages\DynamicContentMap;
|
||
use LIT\MCP\Integrations\Divi\Schema\DiviModules;
|
||
use Throwable;
|
||
|
||
defined('ABSPATH') || exit;
|
||
|
||
/**
|
||
* Live check of the Divi internals LIT MCP relies on (decisions note §5, E15): classes,
|
||
* functions, the library post type and taxonomies. lit-site-status shows the failed checks, so a
|
||
* Divi update that moves one of them is visible before a tool reports "unsupported".
|
||
*/
|
||
final class DiviCompatibility
|
||
{
|
||
/** @param array<string, callable(): bool>|null $checks Label => check; null = defaults(). */
|
||
public function __construct(private ?array $checks = null)
|
||
{
|
||
}
|
||
|
||
/** @return list<string> Labels of the checks that failed or threw. */
|
||
public function problems(): array
|
||
{
|
||
$problems = [];
|
||
foreach ($this->checks ?? self::defaults() as $label => $check) {
|
||
try {
|
||
$ok = (bool) $check();
|
||
} catch (Throwable) {
|
||
$ok = false;
|
||
}
|
||
if (! $ok) {
|
||
$problems[] = (string) $label;
|
||
}
|
||
}
|
||
|
||
return $problems;
|
||
}
|
||
|
||
/** @return array<string, callable(): bool> */
|
||
public static function defaults(): array
|
||
{
|
||
return [
|
||
'ModuleRegistration (Modul-Katalog)' => static fn (): bool => DiviModules::isAvailable(),
|
||
'DynamicContentOptions (Dynamic Content)' => static fn (): bool => class_exists(DynamicContentMap::REGISTRY),
|
||
'et_pb_is_allowed (Divi-Rollen)' => static fn (): bool => function_exists('et_pb_is_allowed'),
|
||
'Post-Typ et_pb_layout (Bibliothek)' => static fn (): bool => post_type_exists(DiviLibraryStore::POST_TYPE),
|
||
'Taxonomien scope, layout_type, module_width (Bibliothek)' =>
|
||
static fn (): bool => (new DiviLibraryStore())->missingTaxonomies() === [],
|
||
'GlobalLayout::is_global_layout_template (globale Module)' =>
|
||
static fn (): bool => method_exists(DiviLibraryStore::GLOBAL_LAYOUT, 'is_global_layout_template'),
|
||
'ET_Core_PageResource (CSS-Cache)' => static fn (): bool => class_exists('ET_Core_PageResource'),
|
||
];
|
||
}
|
||
}
|
||
```
|
||
|
||
`EnvironmentProbe::components()` vollständig ersetzen (Konstruktor ergänzen, Import `use LIT\MCP\Integrations\Divi\DiviCompatibility;`):
|
||
|
||
```php
|
||
public function __construct(private ?DiviCompatibility $divi = null)
|
||
{
|
||
}
|
||
|
||
/** @return list<array{id: string, active: bool, version: ?string, problems: list<string>}> */
|
||
public function components(): array
|
||
{
|
||
$theme = wp_get_theme();
|
||
$isDivi = $theme->get_template() === 'Divi';
|
||
$parent = $theme->parent();
|
||
$diviVersion = $isDivi ? (string) ($parent ? $parent->get('Version') : $theme->get('Version')) : null;
|
||
|
||
$tecActive = class_exists('Tribe__Events__Main');
|
||
|
||
return [
|
||
[
|
||
'id' => 'divi',
|
||
'active' => $isDivi,
|
||
'version' => $diviVersion,
|
||
'problems' => $isDivi ? ($this->divi ?? new DiviCompatibility())->problems() : [],
|
||
],
|
||
[
|
||
'id' => 'pods',
|
||
'active' => defined('PODS_VERSION'),
|
||
'version' => defined('PODS_VERSION') ? (string) PODS_VERSION : null,
|
||
'problems' => [],
|
||
],
|
||
[
|
||
'id' => 'the-events-calendar',
|
||
'active' => $tecActive,
|
||
'version' => $tecActive ? (string) constant('Tribe__Events__Main::VERSION') : null,
|
||
'problems' => [],
|
||
],
|
||
];
|
||
}
|
||
```
|
||
|
||
In `SiteStatusAbility::description()` den Satz „Bei Divi nennt problems Divi-Funktionen, die nach einem Update fehlen.“ ergänzen.
|
||
|
||
- [ ] **Step 4: Tests laufen lassen**
|
||
|
||
Run: `vendor/bin/phpunit --filter 'DiviRolesTest|DiviLibraryStoreTest|DiviCompatibilityTest|EnvironmentProbeTest|SiteStatusAbilityTest'`
|
||
Expected: PASS
|
||
|
||
Run: `composer test && composer lint`
|
||
Expected: OK
|
||
|
||
- [ ] **Step 5: Commit**
|
||
|
||
```bash
|
||
git add src/Integrations/Divi/Library/DiviRoles.php src/Integrations/Divi/Library/DiviLibraryStore.php src/Integrations/Divi/DiviCompatibility.php src/Integrations/Divi/Pages/DynamicContentMap.php src/Integrations/Core/EnvironmentProbe.php src/Integrations/Core/SiteStatusAbility.php tests/Unit/Integrations/Divi/Library tests/Unit/Integrations/Divi/DiviCompatibilityTest.php tests/Unit/Integrations/Core/EnvironmentProbeTest.php
|
||
```
|
||
Commit wie in den Global Constraints mit der Nachricht `feat: Divi adapters for roles and library with a live compatibility check`.
|
||
|
||
---
|
||
|
||
### Task 7: Bausteine globaler Module im BlockTree – `copyAs`, `GlobalInstance`, `LibraryContent`
|
||
|
||
Rein PHP, gegen die echten Builder-Fixtures. Befunde aus `tests/Fixtures/divi/stage3/`: (a) eine globale Instanz ist `divi/global-layout` mit `globalModule`, `blockName`, `localAttrs` (vollständiger Schnappschuss der Wurzel-Attribute, oberste Schlüssel sortiert – im Fixture `builderVersion, content, module` gegenüber `module, content, builderVersion` im Bibliothekseintrag), die Kinder mit ihren echten Blocknamen und `"globalParent":"<id>"` am Ende; eine Instanz ohne Kinder ist selbstschließend. (b) **Neu:** Bibliothekseinträge, die über Divis Dialog „Zur Bibliothek hinzufügen“ gespeichert wurden, haben zwischen den Blöcken `\r\n` (Formular-Übertragung des Browsers), Seiten `\n`; der Builder schreibt Instanzen mit `\n`. Deshalb normalisiert `LibraryContent::load()` Zeilenumbrüche im reinen Leerraum zwischen Blöcken. Mit beidem entsteht die Instanz byte-genau wie im Fixture (vorab per Skript geprüft).
|
||
|
||
**Files:**
|
||
- Modify: `src/Integrations/Divi/BlockTree/Block.php` (`copyAs()`)
|
||
- Modify: `src/Integrations/Divi/BlockTree/Container.php` (`replaceChild()`, `unifyLineBreaks()`)
|
||
- Create: `src/Integrations/Divi/BlockTree/GlobalInstance.php`
|
||
- Create: `src/Integrations/Divi/BlockTree/LibraryContent.php`
|
||
- Modify: `src/Integrations/Divi/Compose/TreeEditor.php` (Wurzeltyp globaler Instanzen)
|
||
- Modify: `tests/Fixtures/divi/stage3/README.md` (Befund 9)
|
||
- Test: `tests/Unit/Integrations/Divi/BlockTree/BlockTest.php`, `…/ContainerTest.php`, `…/GlobalInstanceTest.php`, `…/LibraryContentTest.php`, `tests/Unit/Integrations/Divi/Compose/TreeEditorTest.php`
|
||
|
||
**Interfaces:**
|
||
- Consumes: `Parser::parse()`, `Serializer::block()`, `NodeIndex::build()`, `DiviFixtures::markup()`.
|
||
- Produces:
|
||
- `Block::copyAs(string $name, array $attrs): Block`
|
||
- `Container::replaceChild(Block $old, Block $new): void`, `Container::unifyLineBreaks(): void`
|
||
- `GlobalInstance::BLOCK = 'divi/global-layout'`, `GlobalInstance::effectiveName(Block): string`, `GlobalInstance::of(Block $root, int $libraryId): Block`, `GlobalInstance::deglobalize(Block $block): Block`
|
||
- `LibraryContent::load(Parser $parser, string $content): Document` (wirft `MalformedMarkup`), `LibraryContent::wrap(Block $node): string`, `LibraryContent::roots(Document $document): list<Block>`, `LibraryContent::containsGlobal(Block $block): bool`, `LibraryContent::shapeViolation(list<Block> $before, list<Block> $after, ?string $layoutType, bool $global): ?string`
|
||
|
||
- [ ] **Step 1: Failing tests schreiben**
|
||
|
||
In `BlockTest`:
|
||
|
||
```php
|
||
public function testCopyAsRegeneratesTheDelimitersAndKeepsChildrenAndText(): void
|
||
{
|
||
$document = (new Parser())->parse("<!-- wp:divi/row {\"a\":1} -->\n<!-- wp:divi/column /-->\n<!-- /wp:divi/row -->");
|
||
$row = $document->children()[0];
|
||
|
||
$copy = $row->copyAs('divi/global-layout', ['globalModule' => '5', 'blockName' => 'divi/row']);
|
||
|
||
self::assertSame(
|
||
"<!-- wp:divi/global-layout {\"globalModule\":\"5\",\"blockName\":\"divi/row\"} -->\n<!-- wp:divi/column /-->\n"
|
||
. '<!-- /wp:divi/global-layout -->',
|
||
Serializer::block($copy)
|
||
);
|
||
self::assertTrue($copy->isOpaque());
|
||
self::assertSame("<!-- wp:divi/row {\"a\":1} -->\n<!-- wp:divi/column /-->\n<!-- /wp:divi/row -->", Serializer::block($row));
|
||
self::assertFalse($row->copyAs('divi/row', [])->isOpaque());
|
||
}
|
||
|
||
public function testCopyAsRefusesInvalidNames(): void
|
||
{
|
||
$this->expectException(InvalidArgumentException::class);
|
||
|
||
Block::create('divi/text')->copyAs('Divi Text', []);
|
||
}
|
||
```
|
||
|
||
In `ContainerTest`:
|
||
|
||
```php
|
||
public function testReplaceChildKeepsTheTextAround(): void
|
||
{
|
||
$document = (new Parser())->parse("A<!-- wp:divi/text /-->B");
|
||
$new = Block::create('divi/button');
|
||
|
||
$document->replaceChild($document->children()[0], $new);
|
||
|
||
self::assertSame('A<!-- wp:divi/button --><!-- /wp:divi/button -->B', Serializer::document($document));
|
||
}
|
||
|
||
public function testUnifyLineBreaksOnlyTouchesWhitespaceBetweenBlocks(): void
|
||
{
|
||
$document = (new Parser())->parse(
|
||
"<!-- wp:divi/section -->\r\n<!-- wp:divi/row -->\r\n<!-- /wp:divi/row -->\r\n<!-- /wp:divi/section -->x\r\ny"
|
||
);
|
||
|
||
$document->unifyLineBreaks();
|
||
|
||
self::assertSame(
|
||
"<!-- wp:divi/section -->\n<!-- wp:divi/row -->\n<!-- /wp:divi/row -->\n<!-- /wp:divi/section -->x\r\ny",
|
||
Serializer::document($document)
|
||
);
|
||
}
|
||
```
|
||
|
||
(Imports `Block`, `Parser`, `Serializer`, `InvalidArgumentException` je nach Datei ergänzen.)
|
||
|
||
`tests/Unit/Integrations/Divi/BlockTree/GlobalInstanceTest.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Tests\Unit\Integrations\Divi\BlockTree;
|
||
|
||
use LIT\MCP\Integrations\Divi\BlockTree\Block;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\GlobalInstance;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\LibraryContent;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\NodeIndex;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\Parser;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\Serializer;
|
||
use LIT\MCP\Tests\Support\DiviFixtures;
|
||
use PHPUnit\Framework\TestCase;
|
||
|
||
final class GlobalInstanceTest extends TestCase
|
||
{
|
||
private static function libraryRoot(string $file): Block
|
||
{
|
||
return LibraryContent::roots(LibraryContent::load(new Parser(), DiviFixtures::markup('stage3/' . $file)))[0];
|
||
}
|
||
|
||
private static function pageIndex(): NodeIndex
|
||
{
|
||
return NodeIndex::build((new Parser())->parse(DiviFixtures::markup('stage3/page--globale-instanzen.html')));
|
||
}
|
||
|
||
/** @return array<string, array{string, int, string}> */
|
||
public static function instances(): array
|
||
{
|
||
return [
|
||
'global section' => ['library-global--globaler-abschnitt.html', 1058, '<!-- /wp:divi/global-layout -->'],
|
||
'global module (void)' => ['library-global--globales-modul.html', 1059, '/-->'],
|
||
];
|
||
}
|
||
|
||
/** @dataProvider instances */
|
||
public function testInstanceMatchesTheVisualBuilderByteForByte(string $file, int $id, string $end): void
|
||
{
|
||
$page = DiviFixtures::markup('stage3/page--globale-instanzen.html');
|
||
$start = (int) strpos($page, '<!-- wp:divi/global-layout {"globalModule":"' . $id . '"');
|
||
$expected = substr($page, $start, (int) strpos($page, $end, $start) + strlen($end) - $start);
|
||
|
||
$instance = GlobalInstance::of(self::libraryRoot($file), $id);
|
||
|
||
self::assertSame($expected, Serializer::block($instance));
|
||
self::assertTrue($instance->isOpaque());
|
||
self::assertTrue($instance->isGlobal());
|
||
}
|
||
|
||
public function testEffectiveNameOfAnInstanceIsItsRootType(): void
|
||
{
|
||
$index = self::pageIndex();
|
||
|
||
self::assertSame('divi/section', GlobalInstance::effectiveName($index->find('g0')));
|
||
self::assertSame('divi/text', GlobalInstance::effectiveName($index->find('s0.r0.c0.g0')));
|
||
self::assertSame('divi/section', GlobalInstance::effectiveName($index->find('s0')));
|
||
}
|
||
|
||
public function testDeglobalizeRestoresTheLibraryRoot(): void
|
||
{
|
||
$root = self::libraryRoot('library-global--globaler-abschnitt.html');
|
||
|
||
$plain = GlobalInstance::deglobalize(self::pageIndex()->find('g0')->copy());
|
||
|
||
self::assertSame('divi/section', $plain->name());
|
||
self::assertFalse($plain->isOpaque());
|
||
self::assertEquals($root->attrs(), $plain->attrs());
|
||
self::assertSame(
|
||
array_map([Serializer::class, 'block'], $root->children()),
|
||
array_map([Serializer::class, 'block'], $plain->children())
|
||
);
|
||
self::assertStringNotContainsString('globalParent', Serializer::block($plain));
|
||
}
|
||
|
||
public function testDeglobalizeReachesNestedInstances(): void
|
||
{
|
||
$section = GlobalInstance::deglobalize(self::pageIndex()->find('s0')->copy());
|
||
|
||
$markup = Serializer::block($section);
|
||
self::assertStringNotContainsString('global-layout', $markup);
|
||
self::assertStringContainsString('<!-- wp:divi/text {"builderVersion":"5.2.1","content":', $markup);
|
||
}
|
||
}
|
||
```
|
||
|
||
`tests/Unit/Integrations/Divi/BlockTree/LibraryContentTest.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Tests\Unit\Integrations\Divi\BlockTree;
|
||
|
||
use LIT\MCP\Integrations\Divi\BlockTree\Block;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\GlobalInstance;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\LibraryContent;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\NodeIndex;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\Parser;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\Serializer;
|
||
use LIT\MCP\Tests\Support\DiviFixtures;
|
||
use PHPUnit\Framework\TestCase;
|
||
|
||
final class LibraryContentTest extends TestCase
|
||
{
|
||
/** @return array<string, array{string, string}> */
|
||
public static function savedNodes(): array
|
||
{
|
||
return [
|
||
'section' => ['s1', 'library--library-abschnitt.html'],
|
||
'row' => ['s1.r0', 'library--library-zeile.html'],
|
||
'module' => ['s1.r0.c0.m0', 'library--library-modul.html'],
|
||
];
|
||
}
|
||
|
||
/**
|
||
* The builder's "add to library" wraps the node in divi/placeholder (F4); the fixtures only
|
||
* differ by the CRLF of the form upload (finding 9).
|
||
*
|
||
* @dataProvider savedNodes
|
||
*/
|
||
public function testWrapMatchesTheBuilderEntry(string $id, string $file): void
|
||
{
|
||
$index = NodeIndex::build((new Parser())->parse(DiviFixtures::markup('stage3/page--globale-instanzen.html')));
|
||
|
||
self::assertSame(
|
||
str_replace("\r\n", "\n", DiviFixtures::markup('stage3/' . $file)),
|
||
LibraryContent::wrap($index->find($id))
|
||
);
|
||
}
|
||
|
||
public function testLoadUnifiesLineBreaksAndRootsSkipThePlaceholder(): void
|
||
{
|
||
$document = LibraryContent::load(new Parser(), DiviFixtures::markup('stage3/library--layout-ganze-seite.html'));
|
||
|
||
self::assertStringNotContainsString("\r", Serializer::document($document));
|
||
self::assertSame(
|
||
['divi/section', 'divi/section', 'divi/section'],
|
||
array_map(static fn (Block $block): string => $block->name(), LibraryContent::roots($document))
|
||
);
|
||
self::assertSame(
|
||
['divi/text'],
|
||
array_map(
|
||
static fn (Block $block): string => $block->name(),
|
||
LibraryContent::roots((new Parser())->parse('<!-- wp:divi/text /-->'))
|
||
)
|
||
);
|
||
}
|
||
|
||
public function testContainsGlobal(): void
|
||
{
|
||
$index = NodeIndex::build((new Parser())->parse(DiviFixtures::markup('stage3/page--globale-instanzen.html')));
|
||
|
||
self::assertTrue(LibraryContent::containsGlobal($index->find('s0')));
|
||
self::assertFalse(LibraryContent::containsGlobal($index->find('s1')));
|
||
}
|
||
|
||
public function testShapeViolations(): void
|
||
{
|
||
$section = Block::create('divi/section');
|
||
$row = Block::create('divi/row');
|
||
$instance = GlobalInstance::of(Block::create('divi/text'), 9);
|
||
$withInstance = Block::create('divi/section', [], [Block::create('divi/row', [], [
|
||
Block::create('divi/column', [], [$instance]),
|
||
])]);
|
||
|
||
self::assertNull(LibraryContent::shapeViolation([$section], [$section], 'section', false));
|
||
self::assertStringContainsString('nicht leer', (string) LibraryContent::shapeViolation([$section], [], 'section', false));
|
||
self::assertStringContainsString(
|
||
'genau ein divi/section',
|
||
(string) LibraryContent::shapeViolation([$section], [$section, $section], 'section', false)
|
||
);
|
||
self::assertStringContainsString(
|
||
'genau ein divi/section',
|
||
(string) LibraryContent::shapeViolation([$section], [$row], null, false)
|
||
);
|
||
self::assertNull(LibraryContent::shapeViolation([$section, $section], [$section], 'layout', false));
|
||
self::assertStringContainsString(
|
||
'nur Abschnitte',
|
||
(string) LibraryContent::shapeViolation([$section, $section], [$section, $row], 'layout', false)
|
||
);
|
||
self::assertNull(LibraryContent::shapeViolation([$section], [$withInstance], 'section', false));
|
||
self::assertStringContainsString(
|
||
'keine globalen Module',
|
||
(string) LibraryContent::shapeViolation([$section], [$withInstance], 'section', true)
|
||
);
|
||
}
|
||
}
|
||
```
|
||
|
||
In `TreeEditorTest`:
|
||
|
||
```php
|
||
/** A global instance counts as its root type: a section instance at the top, a module instance in a column. */
|
||
public function testGlobalInstancesFollowTheRulesOfTheirRootType(): void
|
||
{
|
||
$document = $this->document('stage3/page--globale-instanzen.html');
|
||
$index = NodeIndex::build($document);
|
||
$editor = new TreeEditor(ComposeFixture::rules());
|
||
|
||
self::assertNull($editor->move($index, $index->find('g0'), $editor->position($index, ['after' => 's1'])));
|
||
|
||
$index = NodeIndex::build($document);
|
||
$module = GlobalInstance::of(Block::create('divi/text'), 1059);
|
||
self::assertNull($editor->insert($editor->position($index, ['parent' => 's1.r0.c0']), [$module]));
|
||
self::assertSame(
|
||
'auf oberster Ebene sind nur Abschnitte (section) erlaubt',
|
||
$editor->insert($editor->position($index, []), [GlobalInstance::of(Block::create('divi/text'), 1059)])
|
||
);
|
||
}
|
||
```
|
||
|
||
(Import `use LIT\MCP\Integrations\Divi\BlockTree\GlobalInstance;`.)
|
||
|
||
- [ ] **Step 2: Tests laufen lassen – schlagen fehl**
|
||
|
||
Run: `vendor/bin/phpunit --filter 'BlockTest|ContainerTest|GlobalInstanceTest|LibraryContentTest|TreeEditorTest'`
|
||
Expected: FAIL (Methoden/Klassen fehlen)
|
||
|
||
- [ ] **Step 3: Implementieren**
|
||
|
||
`Block.php` – neue Methode nach `copy()`:
|
||
|
||
```php
|
||
/**
|
||
* A deep copy of this block under another name and attributes: opener and closer are
|
||
* regenerated, children and the text between them are kept, the void flag too. Opaque exactly
|
||
* when the Parser would make it so. GlobalInstance uses it to turn a library root into an
|
||
* instance and back.
|
||
*
|
||
* @param array<string, mixed> $attrs
|
||
*/
|
||
public function copyAs(string $name, array $attrs): self
|
||
{
|
||
if (preg_match(self::NAME_PATTERN, $name) !== 1) {
|
||
throw new InvalidArgumentException(sprintf('"%s" is not a valid block name.', $name));
|
||
}
|
||
|
||
$copy = clone $this;
|
||
$copy->name = $name;
|
||
$copy->attrs = self::deepCloneAttrs($attrs);
|
||
$copy->rawOpen = null;
|
||
$copy->rawClose = null;
|
||
$copy->opaque = $name === 'divi/global-layout' || array_key_exists('globalModule', $attrs);
|
||
|
||
return $copy;
|
||
}
|
||
```
|
||
|
||
`Container.php` – neue Methoden nach `removeChild()`:
|
||
|
||
```php
|
||
/** Puts $new where the child $old is; the text around it stays. */
|
||
public function replaceChild(Block $old, Block $new): void
|
||
{
|
||
$this->guardMutable();
|
||
$this->parts[$this->partPosition($old)] = $new;
|
||
$this->touched();
|
||
}
|
||
|
||
/**
|
||
* "\r\n" → "\n" in whitespace-only text between blocks, at every depth. Library entries saved
|
||
* through Divi's "add to library" form carry CRLF (browsers normalise form fields, fixture
|
||
* finding 9); the Visual Builder writes "\n". Text inside blocks' own content stays untouched.
|
||
*/
|
||
public function unifyLineBreaks(): void
|
||
{
|
||
foreach ($this->parts as $position => $part) {
|
||
if ($part instanceof Block) {
|
||
$part->unifyLineBreaks();
|
||
} elseif (trim($part) === '' && str_contains($part, "\r\n")) {
|
||
$this->parts[$position] = str_replace("\r\n", "\n", $part);
|
||
}
|
||
}
|
||
}
|
||
```
|
||
|
||
`src/Integrations/Divi/BlockTree/GlobalInstance.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Integrations\Divi\BlockTree;
|
||
|
||
defined('ABSPATH') || exit;
|
||
|
||
/**
|
||
* Global modules the way Divi 5 stores them (F6, F10, fixtures stage3): an instance on a page is a
|
||
* divi/global-layout block whose content Divi takes from the library entry at render time (F7).
|
||
* Pure PHP.
|
||
*/
|
||
final class GlobalInstance
|
||
{
|
||
public const BLOCK = 'divi/global-layout';
|
||
|
||
/** Block name the node counts as for structure rules: an instance counts as its root type. */
|
||
public static function effectiveName(Block $block): string
|
||
{
|
||
if ($block->name() !== self::BLOCK) {
|
||
return $block->name();
|
||
}
|
||
|
||
$name = $block->attrs()['blockName'] ?? '';
|
||
|
||
return is_string($name) ? $name : '';
|
||
}
|
||
|
||
/**
|
||
* The instance the Visual Builder writes for library entry $libraryId whose content root is
|
||
* $root (serialized-post.js, filter divi.serializedPost.parseFlatModuleObjectIntoBlockArray.nested;
|
||
* fixture page--globale-instanzen.html): divi/global-layout with globalModule, blockName and
|
||
* localAttrs – the root's attributes, top-level keys sorted like the builder's store, left out
|
||
* when empty –, the root's children as snapshot with "globalParent": "<id>" appended to every
|
||
* block below. A void root gives a void instance. $root is not changed.
|
||
*/
|
||
public static function of(Block $root, int $libraryId): Block
|
||
{
|
||
$id = (string) $libraryId;
|
||
$local = $root->attrs();
|
||
ksort($local);
|
||
$attrs = ['globalModule' => $id, 'blockName' => $root->name()];
|
||
if ($local !== []) {
|
||
$attrs['localAttrs'] = $local;
|
||
}
|
||
|
||
$instance = $root->copyAs(self::BLOCK, $attrs);
|
||
foreach ($instance->children() as $child) {
|
||
self::markParent($child, $id);
|
||
}
|
||
|
||
return $instance;
|
||
}
|
||
|
||
/**
|
||
* Divi's PortabilityPost::maybe_deglobalize_nested_global_modules() on a tree (Divi 5.2.1
|
||
* PortabilityPost.php:3518, used by DiviLibraryController::load for global entries): every
|
||
* divi/global-layout at or below $block becomes its blockName with localAttrs as attributes,
|
||
* and globalParent disappears from every block. Other opaque blocks stay. Changes $block in
|
||
* place (pass a copy) and returns the result – a new block when $block itself was an instance.
|
||
*/
|
||
public static function deglobalize(Block $block): Block
|
||
{
|
||
if ($block->name() === self::BLOCK) {
|
||
$name = self::effectiveName($block);
|
||
if ($name === '') {
|
||
return $block;
|
||
}
|
||
$local = $block->attrs()['localAttrs'] ?? [];
|
||
$block = $block->copyAs($name, is_array($local) ? $local : []);
|
||
}
|
||
|
||
if ($block->isOpaque()) {
|
||
return $block;
|
||
}
|
||
|
||
if (array_key_exists('globalParent', $block->attrs())) {
|
||
$attrs = $block->attrs();
|
||
unset($attrs['globalParent']);
|
||
$block->setAttrs($attrs);
|
||
}
|
||
|
||
foreach ($block->children() as $child) {
|
||
$plain = self::deglobalize($child);
|
||
if ($plain !== $child) {
|
||
$block->replaceChild($child, $plain);
|
||
}
|
||
}
|
||
|
||
return $block;
|
||
}
|
||
|
||
private static function markParent(Block $block, string $id): void
|
||
{
|
||
if ($block->isOpaque()) {
|
||
return;
|
||
}
|
||
|
||
$attrs = $block->attrs();
|
||
unset($attrs['globalParent']);
|
||
$attrs['globalParent'] = $id;
|
||
$block->setAttrs($attrs);
|
||
foreach ($block->children() as $child) {
|
||
self::markParent($child, $id);
|
||
}
|
||
}
|
||
}
|
||
```
|
||
|
||
`src/Integrations/Divi/BlockTree/LibraryContent.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Integrations\Divi\BlockTree;
|
||
|
||
defined('ABSPATH') || exit;
|
||
|
||
/**
|
||
* post_content of Divi Library entries (F4, fixtures stage3): the nodes sit in a divi/placeholder
|
||
* frame; a section/row/module entry has exactly one root, a layout entry sections. Pure PHP.
|
||
*/
|
||
final class LibraryContent
|
||
{
|
||
public const WRAPPER = 'divi/placeholder';
|
||
|
||
/**
|
||
* Parses library content for copying and unifies its line breaks (Container::unifyLineBreaks()).
|
||
* Never used for the content a tool edits in place – that keeps its bytes.
|
||
*
|
||
* @throws MalformedMarkup
|
||
*/
|
||
public static function load(Parser $parser, string $content): Document
|
||
{
|
||
$document = $parser->parse($content);
|
||
$document->unifyLineBreaks();
|
||
|
||
return $document;
|
||
}
|
||
|
||
/** post_content of a library entry holding $node, framed like the builder's "add to library". */
|
||
public static function wrap(Block $node): string
|
||
{
|
||
return '<!-- wp:' . self::WRAPPER . ' -->' . Serializer::block($node) . '<!-- /wp:' . self::WRAPPER . ' -->';
|
||
}
|
||
|
||
/** @return list<Block> Top-level nodes: the children of the first divi/placeholder, else of the document. */
|
||
public static function roots(Document $document): array
|
||
{
|
||
foreach ($document->children() as $block) {
|
||
if ($block->isPlaceholder()) {
|
||
return $block->children();
|
||
}
|
||
}
|
||
|
||
return $document->children();
|
||
}
|
||
|
||
/** Whether $block is or contains a global module. */
|
||
public static function containsGlobal(Block $block): bool
|
||
{
|
||
if ($block->isGlobal()) {
|
||
return true;
|
||
}
|
||
|
||
foreach ($block->children() as $child) {
|
||
if (self::containsGlobal($child)) {
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* Why the roots $after may not replace $before, or null. Instances on pages expect their
|
||
* entry's root type (blockName), so a section/row/module entry keeps exactly one root of the
|
||
* same type; a layout entry (or one with several roots) holds sections only. A global entry
|
||
* contains no global modules (F10: Divi forbids nesting).
|
||
*
|
||
* @param list<Block> $before
|
||
* @param list<Block> $after
|
||
*/
|
||
public static function shapeViolation(array $before, array $after, ?string $layoutType, bool $global): ?string
|
||
{
|
||
if ($after === []) {
|
||
return 'Der Bibliothekseintrag darf nicht leer werden.';
|
||
}
|
||
|
||
if ($layoutType === 'layout' || count($before) !== 1) {
|
||
foreach ($after as $root) {
|
||
if (GlobalInstance::effectiveName($root) !== 'divi/section') {
|
||
return 'Ein Layout-Eintrag der Bibliothek enthält nur Abschnitte.';
|
||
}
|
||
}
|
||
} else {
|
||
$expected = GlobalInstance::effectiveName($before[0]);
|
||
if (count($after) !== 1 || GlobalInstance::effectiveName($after[0]) !== $expected) {
|
||
return sprintf(
|
||
'Der Bibliothekseintrag muss genau ein %s bleiben (Instanzen auf den Seiten erwarten diesen Typ).',
|
||
$expected
|
||
);
|
||
}
|
||
}
|
||
|
||
if ($global) {
|
||
foreach ($after as $root) {
|
||
if (self::containsGlobal($root)) {
|
||
return 'Ein globaler Bibliothekseintrag darf keine globalen Module enthalten (Divi erlaubt keine '
|
||
. 'Verschachtelung).';
|
||
}
|
||
}
|
||
}
|
||
|
||
return null;
|
||
}
|
||
}
|
||
```
|
||
|
||
`TreeEditor.php` – Import `use LIT\MCP\Integrations\Divi\BlockTree\GlobalInstance;`; in `insert()`:
|
||
|
||
```php
|
||
$violation = $this->rules->violation($position['parent'], GlobalInstance::effectiveName($block));
|
||
```
|
||
|
||
und in `move()`:
|
||
|
||
```php
|
||
$violation = $this->rules->violation($position['parent'], GlobalInstance::effectiveName($node));
|
||
```
|
||
|
||
Klassen-Docblock von `TreeEditor` um „globale Instanzen gelten als ihr Wurzeltyp (blockName)“ ergänzen.
|
||
|
||
`tests/Fixtures/divi/stage3/README.md` – unter „Format-Befunde“ als Punkt 9 anfügen:
|
||
|
||
```markdown
|
||
9. **Zeilenumbrüche in Bibliothekseinträgen:** Einträge aus dem Dialog „Zur Bibliothek hinzufügen“ haben zwischen den Blöcken `\r\n` (1054–1056, 1058; der Browser normalisiert Formularfelder beim Senden an `divi-library/create-item`), Seiten und TB-Layouts `\n`. Der Builder schreibt globale Instanzen mit `\n`. `LibraryContent::load()` vereinheitlicht deshalb Zeilenumbrüche im Leerraum zwischen Blöcken, bevor Inhalte aus der Bibliothek übernommen werden; damit entstehen Instanzen byte-genau wie in `page--globale-instanzen.html`.
|
||
```
|
||
|
||
- [ ] **Step 4: Tests laufen lassen**
|
||
|
||
Run: `vendor/bin/phpunit --filter 'BlockTest|ContainerTest|GlobalInstanceTest|LibraryContentTest|TreeEditorTest|ParserTest|SerializerTest'`
|
||
Expected: PASS
|
||
|
||
Run: `composer test && composer lint`
|
||
Expected: OK
|
||
|
||
- [ ] **Step 5: Commit**
|
||
|
||
```bash
|
||
git add src/Integrations/Divi/BlockTree src/Integrations/Divi/Compose/TreeEditor.php tests/Unit/Integrations/Divi/BlockTree tests/Unit/Integrations/Divi/Compose/TreeEditorTest.php tests/Fixtures/divi/stage3/README.md
|
||
```
|
||
Commit wie in den Global Constraints mit der Nachricht `feat: global instance in the builder's format, deglobalize, library content rules`.
|
||
|
||
---
|
||
|
||
### Task 8: Bibliothekseinträge mit den Divi-Werkzeugen lesen – `LibraryAccess`, `DiviPageLoader`
|
||
|
||
E1/E3: `lit-divi-outline` und `lit-divi-node-get` nehmen die ID eines Bibliothekseintrags an. `LibraryAccess::item()` prüft zuerst, ob die ID ein `et_pb_layout` ist; sonst geht es unverändert über `PostGuard` weiter (Seiten bleiben wie bisher, `ContentSchema::EXCLUDED` bleibt). Schreiben folgt in Task 9 – bis dahin laufen Schreibzugriffe auf Bibliotheks-IDs weiter über `PostGuard` und enden in `not_found`.
|
||
|
||
**Files:**
|
||
- Create: `src/Integrations/Divi/Library/LibraryAccess.php`
|
||
- Modify: `src/Integrations/Divi/Pages/DiviPage.php`
|
||
- Modify: `src/Integrations/Divi/Pages/DiviPageLoader.php`
|
||
- Modify: `src/Integrations/Divi/DiviIntegration.php`
|
||
- Create: `tests/Support/LibraryFixtures.php`
|
||
- Test: `tests/Unit/Integrations/Divi/Library/LibraryAccessTest.php`, `tests/Unit/Integrations/Divi/Pages/DiviPageLoaderTest.php`, `tests/Unit/Integrations/Divi/Pages/DiviReadAbilitiesTest.php`
|
||
|
||
**Interfaces:**
|
||
- Consumes: `DiviLibraryStore`, `DiviRoles` (Task 6), `PostGuard::id()`, `Errors`.
|
||
- Produces:
|
||
- `class LibraryAccess { __construct(DiviLibraryStore $store, DiviRoles $roles, ?Closure $writable = null); store(): DiviLibraryStore; roles(): DiviRoles; item(mixed $postId, bool $forWrite): WP_Post|WP_Error|null; canList(): ?WP_Error; canRead(WP_Post $item): ?WP_Error; isGlobal(WP_Post $item): bool }` (nicht final; `canEdit`, `canSave`, `canInsert` folgen in Task 9/12/13)
|
||
- `DiviPage::__construct(WP_Post $post, Document $document, NodeIndex $index, bool $libraryItem = false)`, `DiviPage::isLibraryItem(): bool`; `editUrl()` liefert für Bibliothekseinträge `get_edit_post_link($id, 'raw')`.
|
||
- `DiviPageLoader::__construct(ContentSchema $schema, Parser $parser = new Parser(), ?LibraryAccess $library = null)`, `DiviPageLoader::library(): ?LibraryAccess`.
|
||
- `LibraryFixtures` (Tests): `ITEMS`, `item(int $id, array $fields = []): WP_Post`, `page(string $content, array $fields = []): WP_Post`, `given(array $posts, array $denied = []): void`, `store(): DiviLibraryStore`, `roles(array $deniedRoles = []): DiviRoles`, `access(array $deniedRoles = [], bool $writable = true, ?DiviLibraryStore $store = null): LibraryAccess`, `loader(?LibraryAccess $access = null): DiviPageLoader`.
|
||
|
||
- [ ] **Step 1: Test-Helfer und failing tests schreiben**
|
||
|
||
`tests/Support/LibraryFixtures.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Tests\Support;
|
||
|
||
use Brain\Monkey\Functions;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\Parser;
|
||
use LIT\MCP\Integrations\Divi\Library\DiviLibraryStore;
|
||
use LIT\MCP\Integrations\Divi\Library\DiviRoles;
|
||
use LIT\MCP\Integrations\Divi\Library\LibraryAccess;
|
||
use LIT\MCP\Integrations\Divi\Pages\DiviPageLoader;
|
||
use Mockery;
|
||
use WP_Post;
|
||
|
||
/**
|
||
* The Divi Library of the tests: the real builder entries of tests/Fixtures/divi/stage3 by their
|
||
* IDs, a page (post 7), WordPress stubs by post ID, a store answering from ITEMS, Divi roles and
|
||
* the library access built from them.
|
||
*/
|
||
final class LibraryFixtures
|
||
{
|
||
public const PAGE = 7;
|
||
|
||
/** @var array<int, array{string, string, bool}> ID => [fixture file, layout type, global]. */
|
||
public const ITEMS = [
|
||
1054 => ['library--layout-ganze-seite.html', 'layout', false],
|
||
1055 => ['library--library-abschnitt.html', 'section', false],
|
||
1056 => ['library--library-zeile.html', 'row', false],
|
||
1057 => ['library--library-modul.html', 'module', false],
|
||
1058 => ['library-global--globaler-abschnitt.html', 'section', true],
|
||
1059 => ['library-global--globales-modul.html', 'module', true],
|
||
];
|
||
|
||
/** @param array<string, mixed> $fields */
|
||
public static function item(int $id, array $fields = []): WP_Post
|
||
{
|
||
return new WP_Post(array_merge([
|
||
'ID' => $id,
|
||
'post_type' => DiviLibraryStore::POST_TYPE,
|
||
'post_status' => 'publish',
|
||
'post_title' => '[Fixture] ' . $id,
|
||
'post_content' => DiviFixtures::markup('stage3/' . self::ITEMS[$id][0]),
|
||
], $fields));
|
||
}
|
||
|
||
/** @param array<string, mixed> $fields */
|
||
public static function page(string $content, array $fields = []): WP_Post
|
||
{
|
||
return new WP_Post(array_merge([
|
||
'ID' => self::PAGE,
|
||
'post_type' => 'page',
|
||
'post_status' => 'draft',
|
||
'post_title' => 'Start',
|
||
'post_content' => $content,
|
||
], $fields));
|
||
}
|
||
|
||
/**
|
||
* WordPress stubs for $posts (get_post by ID) and a user with every capability but $denied.
|
||
*
|
||
* @param list<WP_Post> $posts
|
||
* @param list<string> $denied
|
||
*/
|
||
public static function given(array $posts, array $denied = []): void
|
||
{
|
||
$byId = [];
|
||
foreach ($posts as $post) {
|
||
$byId[(int) $post->ID] = $post;
|
||
}
|
||
Functions\when('get_post')->alias(
|
||
static fn (mixed $id): ?WP_Post => $byId[(int) ($id instanceof WP_Post ? $id->ID : $id)] ?? null
|
||
);
|
||
Functions\when('current_user_can')->alias(
|
||
static fn (string $cap, mixed ...$args): bool => ! in_array($cap, $denied, true)
|
||
);
|
||
Functions\when('get_post_type_object')->justReturn(null);
|
||
Functions\when('get_permalink')->justReturn('https://kunde.test/?page_id=7');
|
||
Functions\when('get_edit_post_link')->alias(static fn (mixed $post): string => sprintf(
|
||
'https://kunde.test/wp-admin/post.php?post=%d&action=edit',
|
||
$post instanceof WP_Post ? $post->ID : (int) $post
|
||
));
|
||
Functions\when('add_query_arg')->alias(
|
||
static fn (string $key, string $value, string $url): string => $url . '&' . $key . '=' . $value
|
||
);
|
||
Functions\when('get_preview_post_link')->justReturn('https://kunde.test/?page_id=7&preview=true');
|
||
}
|
||
|
||
/** A store that answers isGlobal()/layoutType() from ITEMS (no database). */
|
||
public static function store(): DiviLibraryStore
|
||
{
|
||
$store = Mockery::mock(DiviLibraryStore::class)->makePartial();
|
||
$store->allows('isGlobal')->andReturnUsing(static fn (int $id): bool => self::ITEMS[$id][2] ?? false);
|
||
$store->allows('layoutType')->andReturnUsing(static fn (int $id): ?string => self::ITEMS[$id][1] ?? null);
|
||
|
||
return $store;
|
||
}
|
||
|
||
/** @param list<string> $deniedRoles Divi role options the user lacks. */
|
||
public static function roles(array $deniedRoles = []): DiviRoles
|
||
{
|
||
return new DiviRoles(static fn (string $cap): bool => ! in_array($cap, $deniedRoles, true));
|
||
}
|
||
|
||
/** @param list<string> $deniedRoles */
|
||
public static function access(
|
||
array $deniedRoles = [],
|
||
bool $writable = true,
|
||
?DiviLibraryStore $store = null
|
||
): LibraryAccess {
|
||
return new LibraryAccess($store ?? self::store(), self::roles($deniedRoles), static fn (): bool => $writable);
|
||
}
|
||
|
||
public static function loader(?LibraryAccess $access = null): DiviPageLoader
|
||
{
|
||
return new DiviPageLoader(DiviFixtures::schema(), new Parser(), $access ?? self::access());
|
||
}
|
||
}
|
||
```
|
||
|
||
`tests/Unit/Integrations/Divi/Library/LibraryAccessTest.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Tests\Unit\Integrations\Divi\Library;
|
||
|
||
use LIT\MCP\Tests\Support\LibraryFixtures;
|
||
use LIT\MCP\Tests\Unit\TestCase;
|
||
use WP_Post;
|
||
|
||
final class LibraryAccessTest extends TestCase
|
||
{
|
||
public function testReadsLibraryItemsAndLeavesOtherIdsToPostGuard(): void
|
||
{
|
||
$item = LibraryFixtures::item(1055);
|
||
LibraryFixtures::given([$item, LibraryFixtures::page('')]);
|
||
$access = LibraryFixtures::access();
|
||
|
||
self::assertSame($item, $access->item(1055, false));
|
||
self::assertNull($access->item(LibraryFixtures::PAGE, false), 'a page is PostGuard\'s business');
|
||
self::assertNull($access->item(9999, false));
|
||
self::assertNull($access->item('abc', false));
|
||
self::assertNull($access->canList());
|
||
}
|
||
|
||
public function testReadingNeedsEditPostsTheDiviLibraryRoleAndEditPost(): void
|
||
{
|
||
$item = LibraryFixtures::item(1055);
|
||
|
||
LibraryFixtures::given([$item], ['edit_posts']);
|
||
self::assertToolError(LibraryFixtures::access()->item(1055, false), 'forbidden');
|
||
|
||
LibraryFixtures::given([$item]);
|
||
self::assertToolError(LibraryFixtures::access(['divi_library'])->item(1055, false), 'forbidden');
|
||
|
||
LibraryFixtures::given([$item], ['edit_post']);
|
||
$refusal = LibraryFixtures::access()->item(1055, false);
|
||
self::assertToolError($refusal, 'forbidden');
|
||
self::assertStringContainsString('Bibliothekseintrag 1055', $refusal->get_error_message());
|
||
}
|
||
|
||
public function testTrashedItemsCanBeRead(): void
|
||
{
|
||
$item = LibraryFixtures::item(1055, ['post_status' => 'trash']);
|
||
LibraryFixtures::given([$item]);
|
||
|
||
self::assertInstanceOf(WP_Post::class, LibraryFixtures::access()->item(1055, false));
|
||
}
|
||
|
||
public function testGlobalFromTheStore(): void
|
||
{
|
||
$access = LibraryFixtures::access();
|
||
|
||
self::assertTrue($access->isGlobal(LibraryFixtures::item(1058)));
|
||
self::assertFalse($access->isGlobal(LibraryFixtures::item(1055)));
|
||
}
|
||
}
|
||
```
|
||
|
||
In `DiviPageLoaderTest`:
|
||
|
||
```php
|
||
public function testLoadsALibraryItemForReading(): void
|
||
{
|
||
LibraryFixtures::given([LibraryFixtures::item(1058)]);
|
||
|
||
$page = LibraryFixtures::loader()->load(1058, false);
|
||
|
||
self::assertInstanceOf(DiviPage::class, $page);
|
||
self::assertTrue($page->isLibraryItem());
|
||
self::assertSame('divi/section', $page->index->find('s0')?->name());
|
||
self::assertSame('https://kunde.test/wp-admin/post.php?post=1058&action=edit', $page->editUrl());
|
||
}
|
||
|
||
public function testLibraryItemsNeedTheLibraryAccess(): void
|
||
{
|
||
LibraryFixtures::given([LibraryFixtures::item(1058)]);
|
||
$schema = Mockery::mock(ContentSchema::class);
|
||
$schema->allows('isManaged')->with('et_pb_layout')->andReturn(false);
|
||
|
||
self::assertToolError((new DiviPageLoader($schema))->load(1058, false), 'not_found');
|
||
self::assertToolError(
|
||
(new DiviPageLoader($schema, new Parser(), LibraryFixtures::access(['divi_library'])))->load(1058, false),
|
||
'forbidden'
|
||
);
|
||
}
|
||
```
|
||
|
||
(Imports: `LibraryFixtures`, `ContentSchema`, `Parser`, `Mockery`.)
|
||
|
||
In `DiviReadAbilitiesTest`:
|
||
|
||
```php
|
||
public function testOutlineOfALibraryItem(): void
|
||
{
|
||
LibraryFixtures::given([LibraryFixtures::item(1059)]);
|
||
$ability = new DiviOutlineAbility(LibraryFixtures::loader(), $this->design());
|
||
|
||
$result = $ability->execute(['post_id' => 1059]);
|
||
|
||
self::assertSame(['m0'], array_column($result['nodes'], 'id'));
|
||
self::assertStringStartsWith('m0 text "Globales Modul Öffnungszeiten"', $result['outline']);
|
||
self::assertSame('https://kunde.test/wp-admin/post.php?post=1059&action=edit', $result['edit_url']);
|
||
}
|
||
```
|
||
|
||
- [ ] **Step 2: Tests laufen lassen – schlagen fehl**
|
||
|
||
Run: `vendor/bin/phpunit --filter 'LibraryAccessTest|DiviPageLoaderTest|DiviReadAbilitiesTest'`
|
||
Expected: FAIL (`LibraryAccess` fehlt)
|
||
|
||
- [ ] **Step 3: Implementieren**
|
||
|
||
`src/Integrations/Divi/Library/LibraryAccess.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Integrations\Divi\Library;
|
||
|
||
use Closure;
|
||
use LIT\MCP\Abilities\Errors;
|
||
use LIT\MCP\Integrations\WordPress\PostGuard;
|
||
use WP_Error;
|
||
use WP_Post;
|
||
|
||
defined('ABSPATH') || exit;
|
||
|
||
/**
|
||
* Rights on Divi Library entries (spec §4.5, E3 – never laxer than Divi): the library at all needs
|
||
* edit_posts and the Divi role option divi_library; one entry additionally edit_post on it (Divi's
|
||
* builder routes do not check that, F9). The Divi tools reach library entries only through
|
||
* item(); every other ID goes on to PostGuard unchanged.
|
||
* Not final so abilities can be tested with a mock.
|
||
*/
|
||
class LibraryAccess
|
||
{
|
||
/**
|
||
* @param (Closure(): bool)|null $writable Whether the Tools tab lets this connection write to the
|
||
* library (group "Divi-Bibliothek" not read-only or disabled); null = always.
|
||
*/
|
||
public function __construct(
|
||
private DiviLibraryStore $store,
|
||
private DiviRoles $roles,
|
||
private ?Closure $writable = null
|
||
) {
|
||
}
|
||
|
||
public function store(): DiviLibraryStore
|
||
{
|
||
return $this->store;
|
||
}
|
||
|
||
public function roles(): DiviRoles
|
||
{
|
||
return $this->roles;
|
||
}
|
||
|
||
/**
|
||
* The library entry $postId after the checks for reading, or their refusal; null when $postId
|
||
* names no library entry (the caller goes on with PostGuard).
|
||
*/
|
||
public function item(mixed $postId, bool $forWrite): WP_Post|WP_Error|null
|
||
{
|
||
$id = PostGuard::id($postId);
|
||
$post = $id === null ? null : get_post($id);
|
||
if (! $post instanceof WP_Post || $post->post_type !== DiviLibraryStore::POST_TYPE) {
|
||
return null;
|
||
}
|
||
|
||
return $this->canRead($post) ?? $post;
|
||
}
|
||
|
||
/** Listing the library: edit_posts and the Divi role option divi_library. */
|
||
public function canList(): ?WP_Error
|
||
{
|
||
if (! current_user_can('edit_posts')) {
|
||
return Errors::forbidden('Keine Berechtigung, die Divi-Bibliothek zu nutzen.');
|
||
}
|
||
|
||
return $this->roles->refusal('divi_library');
|
||
}
|
||
|
||
/** Reading one entry: canList() and edit_post on the entry. */
|
||
public function canRead(WP_Post $item): ?WP_Error
|
||
{
|
||
$refusal = $this->canList();
|
||
if ($refusal !== null) {
|
||
return $refusal;
|
||
}
|
||
|
||
return current_user_can('edit_post', (int) $item->ID)
|
||
? null
|
||
: Errors::forbidden(sprintf('Keine Berechtigung, Bibliothekseintrag %d zu bearbeiten.', (int) $item->ID));
|
||
}
|
||
|
||
public function isGlobal(WP_Post $item): bool
|
||
{
|
||
return $this->store->isGlobal((int) $item->ID);
|
||
}
|
||
}
|
||
```
|
||
|
||
(`$forWrite` wird in Task 9 ausgewertet; bis dahin ruft `DiviPageLoader` `item()` nur zum Lesen auf.)
|
||
|
||
`DiviPage.php` – Konstruktor und `editUrl()`:
|
||
|
||
```php
|
||
public function __construct(
|
||
public readonly WP_Post $post,
|
||
public readonly Document $document,
|
||
public readonly NodeIndex $index,
|
||
private bool $libraryItem = false
|
||
) {
|
||
}
|
||
|
||
/** Whether the entry is a Divi Library entry (et_pb_layout), loaded through LibraryAccess. */
|
||
public function isLibraryItem(): bool
|
||
{
|
||
return $this->libraryItem;
|
||
}
|
||
|
||
public function editUrl(): string
|
||
{
|
||
// A library entry has no public permalink (public: false); Divi's library list opens it here.
|
||
return $this->libraryItem
|
||
? (string) get_edit_post_link($this->post, 'raw')
|
||
: self::builderUrl($this->post);
|
||
}
|
||
```
|
||
|
||
`DiviPageLoader.php` – Konstruktor, `library()` und Anfang von `load()` (Import `use LIT\MCP\Integrations\Divi\Library\LibraryAccess;`, `use WP_Post;`):
|
||
|
||
```php
|
||
public function __construct(
|
||
private ContentSchema $schema,
|
||
private Parser $parser = new Parser(),
|
||
private ?LibraryAccess $library = null
|
||
) {
|
||
}
|
||
|
||
/** The library access the Divi tools use, null when library entries are not reachable. */
|
||
public function library(): ?LibraryAccess
|
||
{
|
||
return $this->library;
|
||
}
|
||
|
||
/** Readers pass $forWrite = false (trashed entries may be read, like lit-content-get). */
|
||
public function load(mixed $postId, bool $forWrite): DiviPage|WP_Error
|
||
{
|
||
// Library entries (E1): only for reading so far, and only with a library access.
|
||
$item = $forWrite ? null : $this->library?->item($postId, false);
|
||
$post = $item ?? PostGuard::editable($postId, $this->schema, 'post_id', ! $forWrite);
|
||
if ($post instanceof WP_Error) {
|
||
return $post;
|
||
}
|
||
```
|
||
|
||
und am Ende von `load()`:
|
||
|
||
```php
|
||
return new DiviPage($post, $document, NodeIndex::build($document), $item instanceof WP_Post);
|
||
```
|
||
|
||
`DiviIntegration.php` – Bibliothekszugang als Feld (Imports `DiviLibraryStore`, `DiviRoles`, `LibraryAccess`, `Parser`):
|
||
|
||
```php
|
||
private LibraryAccess $access;
|
||
|
||
public function __construct(private ContentSchema $schema, private ChangeLog $log)
|
||
{
|
||
$this->modules = new DiviModules();
|
||
$this->design = new DesignSystemReader();
|
||
$this->access = new LibraryAccess(new DiviLibraryStore(), new DiviRoles());
|
||
}
|
||
```
|
||
|
||
und in `abilities()`:
|
||
|
||
```php
|
||
$loader = new DiviPageLoader($this->schema, new Parser(), $this->access);
|
||
```
|
||
|
||
- [ ] **Step 4: Tests laufen lassen**
|
||
|
||
Run: `vendor/bin/phpunit --filter 'LibraryAccessTest|DiviPageLoaderTest|DiviReadAbilitiesTest|DiviIntegrationTest'`
|
||
Expected: PASS
|
||
|
||
Run: `composer test && composer lint`
|
||
Expected: OK
|
||
|
||
- [ ] **Step 5: Commit**
|
||
|
||
```bash
|
||
git add src/Integrations/Divi/Library/LibraryAccess.php src/Integrations/Divi/Pages/DiviPage.php src/Integrations/Divi/Pages/DiviPageLoader.php src/Integrations/Divi/DiviIntegration.php tests/Support/LibraryFixtures.php tests/Unit/Integrations/Divi/Library/LibraryAccessTest.php tests/Unit/Integrations/Divi/Pages/DiviPageLoaderTest.php tests/Unit/Integrations/Divi/Pages/DiviReadAbilitiesTest.php
|
||
```
|
||
Commit wie in den Global Constraints mit der Nachricht `feat: Divi read tools accept library entries (library access, E1/E3)`.
|
||
|
||
---
|
||
|
||
### Task 9: Bibliothekseinträge schreiben – Formregeln, globale Einträge mit Probelauf, `confirm` und Sicherung
|
||
|
||
E2 und Antwort F2: Die Divi-Schreibwerkzeuge (`lit-divi-insert`, `-update`, `-move`, `-delete`, `lit/divi-duplicate-node`) ändern Bibliothekseinträge wie Seiten. Zusätzlich (`GlobalEdits`, aufgerufen aus `DiviWriter::commit()` nach der vollständig validierten Änderung): Der Eintrag behält seine Form (`LibraryContent::shapeViolation`); ist er global, wird ohne `confirm: true` nichts gespeichert und die Antwort nennt die betroffenen Seiten (Probelauf, `GlobalUsages` sucht `"globalModule":"<id>"` wie Divi); mit `confirm: true` sichert `DiviSaver` wie immer eine Revision im kses-Fenster, bei abgeschalteten Revisionen legt `GlobalEdits` vorher eine Sicherung an (`PostCloner::backup`), danach leert `DiviSaver` seitenweit den CSS- und Theme-Builder-Cache (`SaveScope::GlobalItem`). Bibliothekseinträge bekommen keine Divi-Flags (Fixture-Befund 4). Das Gruppen-Gate: ist „Divi-Bibliothek“ auf „nur lesen“ oder deaktiviert, sind Bibliothekseinträge für alle Divi-Werkzeuge nur lesbar.
|
||
|
||
**Files:**
|
||
- Modify: `src/Integrations/Divi/Library/LibraryAccess.php` (`item()` für Schreiben, `canEdit()`, `writableGate()`, `GROUP`)
|
||
- Modify: `src/Integrations/Divi/Pages/DiviPageLoader.php` (Schreiben, `writable()`)
|
||
- Create: `src/Integrations/Divi/Pages/SaveScope.php`
|
||
- Modify: `src/Integrations/Divi/Pages/DiviSaver.php`
|
||
- Create: `src/Integrations/Divi/Library/GlobalUsages.php`
|
||
- Create: `src/Integrations/Divi/Library/GlobalEdits.php`
|
||
- Modify: `src/Integrations/Divi/Pages/DiviWriter.php` (`save()`-Scope, `commit()`, `notice()`)
|
||
- Modify: `src/Integrations/Divi/Pages/DiviWriteAbility.php` (`precheck()`, `commit`, `notice`)
|
||
- Modify: `src/Integrations/Divi/Pages/DiviSchema.php` (`confirm`)
|
||
- Modify: `src/Abilities/ExposurePolicy.php` (`groupWritable()`)
|
||
- Modify: `src/Integrations/Divi/DiviIntegration.php`, `src/Plugin.php`
|
||
- Create: `tests/Stubs/EtCorePageResource.php`; Modify: `tests/bootstrap.php`, `tests/Support/DiviWriterFixture.php`
|
||
- Test: `tests/Unit/Integrations/Divi/Library/LibraryAccessTest.php`, `…/Library/GlobalUsagesTest.php`, `…/Library/GlobalEditsTest.php`, `tests/Unit/Integrations/Divi/Pages/DiviPageLoaderTest.php`, `…/Pages/DiviSaverTest.php`, `tests/Unit/Abilities/ExposurePolicyTest.php`
|
||
|
||
**Interfaces:**
|
||
- Consumes: `LibraryContent::load/roots/shapeViolation` (Task 7), `LibraryAccess`, `LibraryFixtures` (Task 8), `PostCloner::backup(WP_Post): int`, `Errors::confirmRequired/clientMessage/codeOf/unsupported/invalidInput`.
|
||
- Produces:
|
||
- `LibraryAccess::GROUP = 'divi-library'`, `LibraryAccess::canEdit(WP_Post $item): ?WP_Error`, `LibraryAccess::writableGate(): ?WP_Error`; `item($id, true)` prüft `canEdit()`.
|
||
- `enum SaveScope { Page, LibraryItem, GlobalItem; setsFlags(): bool; clearsSiteCss(): bool }`
|
||
- `DiviSaver::save(WP_Post $post, string $content, SaveScope $scope = SaveScope::Page): array`, `DiviSaver::saveNew(int $postId, string $content, SaveScope $scope = SaveScope::Page): list<string>`
|
||
- `class GlobalUsages { const LIMIT = 50; __construct(?\wpdb $db = null); of(int $libraryId): array{items: list<array{post_id: int, title: string, status: string, type: string}>, count: int} }` (nicht final)
|
||
- `final class GlobalEdits { __construct(LibraryAccess $access, GlobalUsages $usages, ?Closure $backup = null, Parser $parser = new Parser()); prepare(DiviPage $page, array $input): array{scope: SaveScope, details: array<string, mixed>}|WP_Error; notice(DiviPage $page, WP_Error $error): WP_Error }`
|
||
- `DiviWriter::__construct(…, DiviComposition $composition, ?GlobalEdits $globals = null)`, `DiviWriter::save(…, SaveScope $scope = SaveScope::Page)`, `DiviWriter::commit(string $ability, DiviPage $page, DiviChange $change, array $input): array|WP_Error`, `DiviWriter::notice(DiviPage $page, WP_Error $error): WP_Error`
|
||
- `DiviWriteAbility::precheck(array $input): ?WP_Error` (protected, Standard `null`)
|
||
- `ExposurePolicy::groupWritable(string $group): bool`
|
||
- `DiviIntegration::__construct(ContentSchema $schema, ChangeLog $log, ?Closure $libraryWritable = null)`
|
||
- `DiviWriterFixture::writer(array &$saved, array &$failures = [], bool $unfiltered = false, ?DiviPageLoader $loader = null, ?GlobalEdits $globals = null)`
|
||
|
||
- [ ] **Step 1: Stub und failing tests schreiben**
|
||
|
||
`tests/Stubs/EtCorePageResource.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
if (! class_exists('ET_Core_PageResource')) {
|
||
/**
|
||
* Divi's static CSS cache for the saver tests: records every remove_static_resources() call.
|
||
*/
|
||
class ET_Core_PageResource
|
||
{
|
||
/** @var list<array{0: int|string, 1: string, 2: bool}> */
|
||
public static array $removed = [];
|
||
|
||
public static function remove_static_resources($postId, $owner, $force = false): void
|
||
{
|
||
self::$removed[] = [$postId, $owner, (bool) $force];
|
||
}
|
||
}
|
||
}
|
||
```
|
||
|
||
In `tests/bootstrap.php` nach `RequestsException.php` ergänzen: `require_once __DIR__ . '/Stubs/EtCorePageResource.php';`
|
||
|
||
`DiviWriterFixture::writer()` um den Parameter `?GlobalEdits $globals = null` (letzter Parameter, Import `LIT\MCP\Integrations\Divi\Library\GlobalEdits`) erweitern und an `new DiviWriter(…, self::composition($design, $unfiltered), $globals)` durchreichen.
|
||
|
||
In `DiviSaverTest`:
|
||
|
||
```php
|
||
public function testLibraryItemsGetNoDiviFlagsAndGlobalOnesClearEveryPage(): void
|
||
{
|
||
\ET_Core_PageResource::$removed = [];
|
||
Functions\when('current_user_can')->justReturn(true);
|
||
Functions\when('wp_update_post')->justReturn(7);
|
||
Functions\when('get_post')->justReturn(new WP_Post(['ID' => 7, 'post_content' => 'NEU']));
|
||
$cleared = [];
|
||
Functions\when('et_theme_builder_clear_wp_cache')->alias(static function (string $what) use (&$cleared): void {
|
||
$cleared[] = $what;
|
||
});
|
||
|
||
(new DiviSaver())->save($this->post, 'NEU', SaveScope::LibraryItem);
|
||
self::assertSame([], array_filter($this->calls, static fn (string $call): bool => str_starts_with($call, 'meta:')));
|
||
self::assertSame([[7, 'all', true]], \ET_Core_PageResource::$removed);
|
||
self::assertSame([], $cleared);
|
||
|
||
\ET_Core_PageResource::$removed = [];
|
||
(new DiviSaver())->save($this->post, 'NEU', SaveScope::GlobalItem);
|
||
self::assertSame([[7, 'all', true], ['all', 'all', true]], \ET_Core_PageResource::$removed);
|
||
self::assertSame(['all'], $cleared);
|
||
}
|
||
|
||
public function testSaveNewOfALibraryItemSetsNoFlags(): void
|
||
{
|
||
Functions\when('current_user_can')->justReturn(true);
|
||
Functions\when('wp_update_post')->justReturn(42);
|
||
Functions\when('get_post')->justReturn(new WP_Post(['ID' => 42, 'post_content' => 'NEU']));
|
||
|
||
self::assertSame([], (new DiviSaver())->saveNew(42, 'NEU', SaveScope::LibraryItem));
|
||
self::assertSame([], array_filter($this->calls, static fn (string $call): bool => str_starts_with($call, 'meta:')));
|
||
}
|
||
```
|
||
|
||
(Import `use LIT\MCP\Integrations\Divi\Pages\SaveScope;`.)
|
||
|
||
In `LibraryAccessTest`:
|
||
|
||
```php
|
||
public function testEditingNeedsSaveLibraryAPublishedItemAWritableGroupAndForGlobalsEditGlobalLibrary(): void
|
||
{
|
||
LibraryFixtures::given([
|
||
LibraryFixtures::item(1057),
|
||
LibraryFixtures::item(1059),
|
||
LibraryFixtures::item(1055, ['post_status' => 'trash']),
|
||
]);
|
||
|
||
self::assertInstanceOf(WP_Post::class, LibraryFixtures::access()->item(1057, true));
|
||
self::assertToolError(LibraryFixtures::access(['save_library'])->item(1057, true), 'forbidden');
|
||
$readonly = LibraryFixtures::access([], false)->item(1057, true);
|
||
self::assertToolError($readonly, 'forbidden');
|
||
self::assertStringContainsString('Divi-Bibliothek', $readonly->get_error_message());
|
||
self::assertToolError(LibraryFixtures::access()->item(1055, true), 'validation_failed');
|
||
self::assertInstanceOf(WP_Post::class, LibraryFixtures::access()->item(1059, true));
|
||
self::assertToolError(LibraryFixtures::access(['edit_global_library'])->item(1059, true), 'forbidden');
|
||
self::assertInstanceOf(WP_Post::class, LibraryFixtures::access(['edit_global_library'])->item(1057, true));
|
||
}
|
||
```
|
||
|
||
In `DiviPageLoaderTest`:
|
||
|
||
```php
|
||
public function testLibraryItemsAreWritableWhateverTheBuilderSettingOfTheirType(): void
|
||
{
|
||
LibraryFixtures::given([LibraryFixtures::item(1057)]);
|
||
$loader = new DiviPageLoader(DiviFixtures::schema(false), new Parser(), LibraryFixtures::access());
|
||
|
||
$page = $loader->loadWritable(1057);
|
||
|
||
self::assertInstanceOf(DiviPage::class, $page);
|
||
self::assertTrue($page->isLibraryItem());
|
||
}
|
||
```
|
||
|
||
In `ExposurePolicyTest`:
|
||
|
||
```php
|
||
public function testGroupWritable(): void
|
||
{
|
||
self::assertTrue((new ExposurePolicy([]))->groupWritable('divi-library'));
|
||
self::assertFalse((new ExposurePolicy(['@readonly:divi-library' => true]))->groupWritable('divi-library'));
|
||
self::assertFalse((new ExposurePolicy(['@group:divi-library' => 'disabled']))->groupWritable('divi-library'));
|
||
self::assertTrue((new ExposurePolicy(['@group:divi-library' => 'indirect']))->groupWritable('divi-library'));
|
||
}
|
||
```
|
||
|
||
`tests/Unit/Integrations/Divi/Library/GlobalUsagesTest.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Tests\Unit\Integrations\Divi\Library;
|
||
|
||
use Brain\Monkey\Functions;
|
||
use LIT\MCP\Integrations\Divi\Library\GlobalUsages;
|
||
use LIT\MCP\Tests\Unit\TestCase;
|
||
use Mockery;
|
||
|
||
final class GlobalUsagesTest extends TestCase
|
||
{
|
||
public function testFindsInstancesLikeDiviAndHidesUnreadableTitles(): void
|
||
{
|
||
$db = Mockery::mock(\wpdb::class)->makePartial();
|
||
$queries = [];
|
||
$db->allows('get_var')->andReturnUsing(static function (string $sql) use (&$queries): string {
|
||
$queries[] = $sql;
|
||
|
||
return '3';
|
||
});
|
||
$db->allows('get_results')->andReturnUsing(static function (string $sql) use (&$queries): array {
|
||
$queries[] = $sql;
|
||
|
||
return [
|
||
['ID' => '1053', 'post_title' => 'Globale Instanzen', 'post_status' => 'draft', 'post_type' => 'page'],
|
||
['ID' => '1061', 'post_title' => 'Geheim', 'post_status' => 'private', 'post_type' => 'et_header_layout'],
|
||
];
|
||
});
|
||
Functions\when('current_user_can')->alias(static fn (string $cap, int $id): bool => $id !== 1061);
|
||
|
||
$usages = (new GlobalUsages($db))->of(1058);
|
||
|
||
self::assertSame(3, $usages['count']);
|
||
self::assertSame(
|
||
[
|
||
['post_id' => 1053, 'title' => 'Globale Instanzen', 'status' => 'draft', 'type' => 'page'],
|
||
['post_id' => 1061, 'title' => '(nicht lesbar)', 'status' => 'private', 'type' => 'et_header_layout'],
|
||
],
|
||
$usages['items']
|
||
);
|
||
self::assertStringContainsString("LIKE '%\"globalModule\":\"1058\"%'", $queries[0]);
|
||
self::assertStringContainsString("post_status NOT IN ('trash', 'auto-draft', 'inherit')", $queries[1]);
|
||
self::assertStringContainsString('LIMIT 50', $queries[1]);
|
||
}
|
||
}
|
||
```
|
||
|
||
`tests/Unit/Integrations/Divi/Library/GlobalEditsTest.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Tests\Unit\Integrations\Divi\Library;
|
||
|
||
use Brain\Monkey\Functions;
|
||
use LIT\MCP\Abilities\Rev;
|
||
use LIT\MCP\Integrations\Divi\Library\GlobalEdits;
|
||
use LIT\MCP\Integrations\Divi\Library\GlobalUsages;
|
||
use LIT\MCP\Integrations\Divi\Pages\DiviDeleteAbility;
|
||
use LIT\MCP\Integrations\Divi\Pages\DiviDuplicateNodeAbility;
|
||
use LIT\MCP\Integrations\Divi\Pages\DiviSaver;
|
||
use LIT\MCP\Integrations\Divi\Pages\DiviUpdateAbility;
|
||
use LIT\MCP\Integrations\Divi\Pages\DiviWriter;
|
||
use LIT\MCP\Integrations\Divi\Pages\SaveScope;
|
||
use LIT\MCP\Tests\Support\DiviWriterFixture;
|
||
use LIT\MCP\Tests\Support\LibraryFixtures;
|
||
use LIT\MCP\Tests\Unit\TestCase;
|
||
use Mockery;
|
||
use WP_Post;
|
||
|
||
/** The Divi write tools on library entries (E2, answer F2). */
|
||
final class GlobalEditsTest extends TestCase
|
||
{
|
||
/** @var list<array{string, SaveScope}> Content and scope handed to the saver. */
|
||
private array $saved = [];
|
||
|
||
private int $backups = 0;
|
||
|
||
protected function setUp(): void
|
||
{
|
||
parent::setUp();
|
||
Functions\when('wp_revisions_enabled')->justReturn(true);
|
||
}
|
||
|
||
private function usages(): GlobalUsages
|
||
{
|
||
$usages = Mockery::mock(GlobalUsages::class);
|
||
$usages->allows('of')->andReturn([
|
||
'items' => [
|
||
['post_id' => 1053, 'title' => 'Globale Instanzen', 'status' => 'publish', 'type' => 'page'],
|
||
['post_id' => 1070, 'title' => '(nicht lesbar)', 'status' => 'draft', 'type' => 'page'],
|
||
],
|
||
'count' => 2,
|
||
]);
|
||
|
||
return $usages;
|
||
}
|
||
|
||
/** @param list<string> $deniedRoles */
|
||
private function writer(bool $writable = true, array $deniedRoles = []): DiviWriter
|
||
{
|
||
$saver = Mockery::mock(DiviSaver::class);
|
||
$saver->allows('save')->andReturnUsing(function (WP_Post $post, string $content, SaveScope $scope): array {
|
||
$this->saved[] = [$content, $scope];
|
||
$post->post_content = $content;
|
||
|
||
return ['revision_id' => 811, 'warnings' => []];
|
||
});
|
||
$access = LibraryFixtures::access($deniedRoles, $writable);
|
||
$design = DiviWriterFixture::designReader();
|
||
$globals = new GlobalEdits($access, $this->usages(), function (WP_Post $item): int {
|
||
++$this->backups;
|
||
|
||
return 1071;
|
||
});
|
||
|
||
return new DiviWriter(
|
||
LibraryFixtures::loader($access),
|
||
$saver,
|
||
DiviWriterFixture::log(),
|
||
$design,
|
||
DiviWriterFixture::composition($design),
|
||
$globals
|
||
);
|
||
}
|
||
|
||
private static function rev(int $id): string
|
||
{
|
||
return Rev::of((string) LibraryFixtures::item($id)->post_content);
|
||
}
|
||
|
||
/** @return array<string, mixed> */
|
||
private static function relabel(int $id, bool $confirm = false): array
|
||
{
|
||
return array_merge(
|
||
['post_id' => $id, 'tree_rev' => self::rev($id), 'changes' => [['id' => 'm0', 'label' => 'Neu']]],
|
||
$confirm ? ['confirm' => true] : []
|
||
);
|
||
}
|
||
|
||
public function testPlainLibraryItemIsSavedWithoutConfirmAndWithoutDiviFlags(): void
|
||
{
|
||
LibraryFixtures::given([LibraryFixtures::item(1057)]);
|
||
|
||
$result = (new DiviUpdateAbility($this->writer()))->execute(self::relabel(1057));
|
||
|
||
self::assertTrue($result['ok']);
|
||
self::assertSame(SaveScope::LibraryItem, $this->saved[0][1]);
|
||
self::assertStringStartsWith('<!-- wp:divi/placeholder --><!-- wp:divi/blurb ', $this->saved[0][0]);
|
||
self::assertArrayNotHasKey('affected', $result);
|
||
}
|
||
|
||
public function testGlobalItemDryRunNamesTheAffectedPagesAndSavesNothing(): void
|
||
{
|
||
LibraryFixtures::given([LibraryFixtures::item(1059)]);
|
||
|
||
$result = (new DiviUpdateAbility($this->writer()))->execute(self::relabel(1059));
|
||
|
||
self::assertToolError($result, 'confirm_required');
|
||
self::assertStringContainsString('wirkt sofort auf 2 Seiten', $result->get_error_message());
|
||
self::assertSame(1053, $result->get_error_data()['affected'][0]['post_id']);
|
||
self::assertSame(2, $result->get_error_data()['affected_count']);
|
||
self::assertSame([], $this->saved);
|
||
}
|
||
|
||
public function testConfirmedGlobalEditClearsEveryPageAndKeepsARevision(): void
|
||
{
|
||
LibraryFixtures::given([LibraryFixtures::item(1059)]);
|
||
|
||
$result = (new DiviUpdateAbility($this->writer()))->execute(self::relabel(1059, true));
|
||
|
||
self::assertTrue($result['ok']);
|
||
self::assertSame(SaveScope::GlobalItem, $this->saved[0][1]);
|
||
self::assertSame(811, $result['revision_id']);
|
||
self::assertSame(2, $result['affected_count']);
|
||
self::assertArrayNotHasKey('backup_id', $result);
|
||
self::assertSame(0, $this->backups);
|
||
}
|
||
|
||
public function testWithoutRevisionsABackupIsMadeFirst(): void
|
||
{
|
||
Functions\when('wp_revisions_enabled')->justReturn(false);
|
||
LibraryFixtures::given([LibraryFixtures::item(1059)]);
|
||
|
||
$result = (new DiviUpdateAbility($this->writer()))->execute(self::relabel(1059, true));
|
||
|
||
self::assertSame(1071, $result['backup_id']);
|
||
self::assertSame(1, $this->backups);
|
||
}
|
||
|
||
public function testRefusesToEmptyOrDoubleTheRoot(): void
|
||
{
|
||
LibraryFixtures::given([LibraryFixtures::item(1058)]);
|
||
|
||
$emptied = (new DiviDeleteAbility($this->writer()))->execute(
|
||
['post_id' => 1058, 'tree_rev' => self::rev(1058), 'ids' => ['s0'], 'confirm' => true]
|
||
);
|
||
$doubled = (new DiviDuplicateNodeAbility($this->writer()))->execute(
|
||
['post_id' => 1058, 'tree_rev' => self::rev(1058), 'id' => 's0', 'confirm' => true]
|
||
);
|
||
|
||
self::assertToolError($emptied, 'validation_failed');
|
||
self::assertStringContainsString('nicht leer', $emptied->get_error_message());
|
||
self::assertToolError($doubled, 'validation_failed');
|
||
self::assertStringContainsString('genau ein divi/section', $doubled->get_error_message());
|
||
self::assertSame([], $this->saved);
|
||
}
|
||
|
||
public function testDeleteInAGlobalItemNamesTheAffectedPagesBeforeConfirm(): void
|
||
{
|
||
LibraryFixtures::given([LibraryFixtures::item(1058)]);
|
||
|
||
$result = (new DiviDeleteAbility($this->writer()))->execute(
|
||
['post_id' => 1058, 'tree_rev' => self::rev(1058), 'ids' => ['s0.r0.c0.m1']]
|
||
);
|
||
|
||
self::assertToolError($result, 'confirm_required');
|
||
self::assertStringContainsString('Globaler Bibliothekseintrag: wirkt auf 2 Seiten', $result->get_error_message());
|
||
self::assertSame(['s0.r0.c0.m1'], $result->get_error_data()['nodes']);
|
||
self::assertCount(2, $result->get_error_data()['affected']);
|
||
}
|
||
|
||
public function testConfirmWithAStaleTreeRevWritesNothing(): void
|
||
{
|
||
LibraryFixtures::given([LibraryFixtures::item(1059)]);
|
||
|
||
$result = (new DiviUpdateAbility($this->writer()))->execute(
|
||
['tree_rev' => 'abcdef012345'] + self::relabel(1059, true)
|
||
);
|
||
|
||
self::assertToolError($result, 'rev_mismatch');
|
||
self::assertSame([], $this->saved);
|
||
}
|
||
|
||
public function testGlobalItemsNeedEditGlobalLibraryAndAWritableGroup(): void
|
||
{
|
||
LibraryFixtures::given([LibraryFixtures::item(1059), LibraryFixtures::item(1057)]);
|
||
|
||
self::assertToolError(
|
||
(new DiviUpdateAbility($this->writer(true, ['edit_global_library'])))->permission(self::relabel(1059)),
|
||
'forbidden'
|
||
);
|
||
self::assertToolError((new DiviUpdateAbility($this->writer(false)))->permission(self::relabel(1057)), 'forbidden');
|
||
self::assertTrue(
|
||
(new DiviUpdateAbility($this->writer(true, ['edit_global_library'])))->permission(self::relabel(1057))
|
||
);
|
||
}
|
||
}
|
||
```
|
||
|
||
- [ ] **Step 2: Tests laufen lassen – schlagen fehl**
|
||
|
||
Run: `vendor/bin/phpunit --filter 'DiviSaverTest|LibraryAccessTest|DiviPageLoaderTest|ExposurePolicyTest|GlobalUsagesTest|GlobalEditsTest'`
|
||
Expected: FAIL (`SaveScope`, `GlobalEdits`, `GlobalUsages`, `groupWritable` fehlen)
|
||
|
||
- [ ] **Step 3: Implementieren**
|
||
|
||
`src/Integrations/Divi/Pages/SaveScope.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Integrations\Divi\Pages;
|
||
|
||
defined('ABSPATH') || exit;
|
||
|
||
/** What DiviSaver writes to – it decides the Divi flags and how much static CSS is cleared. */
|
||
enum SaveScope
|
||
{
|
||
/** A page or post: Divi flags, its own static CSS. */
|
||
case Page;
|
||
|
||
/** A library entry: no Divi flags (Divi sets none there, fixture finding 4), its own CSS. */
|
||
case LibraryItem;
|
||
|
||
/** A global library entry: like LibraryItem, plus the CSS of every page and the Theme Builder cache (spec §5.6). */
|
||
case GlobalItem;
|
||
|
||
public function setsFlags(): bool
|
||
{
|
||
return $this === self::Page;
|
||
}
|
||
|
||
public function clearsSiteCss(): bool
|
||
{
|
||
return $this === self::GlobalItem;
|
||
}
|
||
}
|
||
```
|
||
|
||
`DiviSaver::save()` – Signatur `public function save(WP_Post $post, string $content, SaveScope $scope = SaveScope::Page): array`; die beiden `FollowUp::run`-Aufrufe nach dem Speichern ersetzen durch:
|
||
|
||
```php
|
||
$warnings = [];
|
||
if ($scope->setsFlags()) {
|
||
FollowUp::run(
|
||
static fn () => DiviFlags::set($postId),
|
||
'divi builder flags',
|
||
'Die Divi-Kennzeichen der Seite konnten nicht gesetzt werden; der Inhalt ist gespeichert – die Seite '
|
||
. 'einmal im Divi-Builder öffnen und speichern.',
|
||
$warnings
|
||
);
|
||
}
|
||
FollowUp::run(
|
||
static function () use ($postId, $scope): void {
|
||
if (! class_exists('ET_Core_PageResource')) {
|
||
return;
|
||
}
|
||
\ET_Core_PageResource::remove_static_resources($postId, 'all', true);
|
||
// A global library entry is part of every page that shows it (spec §5.6 step 5).
|
||
if ($scope->clearsSiteCss()) {
|
||
\ET_Core_PageResource::remove_static_resources('all', 'all', true);
|
||
if (function_exists('et_theme_builder_clear_wp_cache')) {
|
||
et_theme_builder_clear_wp_cache('all');
|
||
}
|
||
}
|
||
},
|
||
'divi static css',
|
||
'Der CSS-Cache von Divi konnte nicht geleert werden; die Änderung ist gespeichert, erscheint aber evtl. '
|
||
. 'erst nach „Statische CSS-Dateien leeren“ (Divi → Theme-Optionen → Builder).',
|
||
$warnings
|
||
);
|
||
```
|
||
|
||
`DiviSaver::saveNew()` – Signatur `public function saveNew(int $postId, string $content, SaveScope $scope = SaveScope::Page): array`, statt `DiviFlags::set($postId);`:
|
||
|
||
```php
|
||
if ($scope->setsFlags()) {
|
||
DiviFlags::set($postId);
|
||
}
|
||
```
|
||
|
||
Klassen-Docblock von `DiviSaver` um einen Absatz ergänzen: „SaveScope: Bibliothekseinträge bekommen keine Divi-Flags; ein globaler Eintrag leert zusätzlich den CSS-Cache aller Seiten und den Theme-Builder-Cache.“
|
||
|
||
`LibraryAccess` – Konstante, `item()`, `canEdit()`, `writableGate()`:
|
||
|
||
```php
|
||
/** Group (integration id) of the library tools in the Tools tab. */
|
||
public const GROUP = 'divi-library';
|
||
```
|
||
|
||
In `item()` die letzte Zeile ersetzen:
|
||
|
||
```php
|
||
return ($forWrite ? $this->canEdit($post) : $this->canRead($post)) ?? $post;
|
||
```
|
||
|
||
Neue Methoden:
|
||
|
||
```php
|
||
/**
|
||
* Changing one entry: canRead(), the role option save_library, the Tools-tab gate and a live
|
||
* entry; a global entry additionally needs edit_global_library (E3 – Divi's builder route
|
||
* does not check edit_post on the entry, F9; LIT MCP does).
|
||
*/
|
||
public function canEdit(WP_Post $item): ?WP_Error
|
||
{
|
||
$refusal = $this->canRead($item) ?? $this->roles->refusal('save_library') ?? $this->writableGate();
|
||
if ($refusal !== null) {
|
||
return $refusal;
|
||
}
|
||
|
||
if ((string) $item->post_status !== 'publish') {
|
||
return Errors::invalidInput(
|
||
sprintf(
|
||
'Bibliothekseintrag %d ist nicht aktiv (Status „%s“); nichts wurde gespeichert.',
|
||
(int) $item->ID,
|
||
(string) $item->post_status
|
||
),
|
||
['post_id' => 'nur aktive Bibliothekseinträge'],
|
||
'Den Eintrag zuerst in der Divi-Bibliothek wiederherstellen.'
|
||
);
|
||
}
|
||
|
||
return $this->isGlobal($item) ? $this->roles->refusal('edit_global_library') : null;
|
||
}
|
||
|
||
/** Refusal while the Tools tab keeps this connection from writing to the library. */
|
||
public function writableGate(): ?WP_Error
|
||
{
|
||
if ($this->writable === null || ($this->writable)()) {
|
||
return null;
|
||
}
|
||
|
||
return Errors::forbidden(
|
||
'Schreiben in die Divi-Bibliothek ist für diese Verbindung abgeschaltet (Gruppe „Divi-Bibliothek“ auf '
|
||
. '„nur lesen“ oder deaktiviert).',
|
||
'Einen Administrator fragen: Einstellungen → LIT MCP → Tools.'
|
||
);
|
||
}
|
||
```
|
||
|
||
`DiviPageLoader::load()` – die Bibliothekszeile ersetzen durch:
|
||
|
||
```php
|
||
// Library entries (E1): with a library access, for reading and writing.
|
||
$item = $this->library?->item($postId, $forWrite);
|
||
```
|
||
|
||
`DiviPageLoader::writable()` – die Builder-Prüfung auf Nicht-Bibliothekseinträge beschränken:
|
||
|
||
```php
|
||
if (! $page->isLibraryItem() && ! $this->schema->diviEnabled((string) $post->post_type)) {
|
||
```
|
||
|
||
`src/Integrations/Divi/Library/GlobalUsages.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Integrations\Divi\Library;
|
||
|
||
defined('ABSPATH') || exit;
|
||
|
||
/**
|
||
* Pages (and Theme Builder layouts) that show global library entry $id: every living post whose
|
||
* content has "globalModule":"<id>" – Divi's own way to find instances (string scan,
|
||
* BlockParserStore, F10). Titles only for posts the user may read. Not final so tests can mock it.
|
||
*/
|
||
class GlobalUsages
|
||
{
|
||
public const LIMIT = 50;
|
||
|
||
private const WHERE = "post_content LIKE %s AND post_type <> 'revision' "
|
||
. "AND post_status NOT IN ('trash', 'auto-draft', 'inherit')";
|
||
|
||
public function __construct(private ?\wpdb $db = null)
|
||
{
|
||
}
|
||
|
||
/** @return array{items: list<array{post_id: int, title: string, status: string, type: string}>, count: int} */
|
||
public function of(int $libraryId): array
|
||
{
|
||
$db = $this->db ?? $GLOBALS['wpdb'];
|
||
$like = '%' . $db->esc_like('"globalModule":"' . $libraryId . '"') . '%';
|
||
// phpcs:disable WordPress.DB.PreparedSQL.InterpolatedNotPrepared, WordPress.DB.DirectDatabaseQuery
|
||
$count = (int) $db->get_var($db->prepare('SELECT COUNT(*) FROM ' . $db->posts . ' WHERE ' . self::WHERE, $like));
|
||
$rows = $db->get_results(
|
||
$db->prepare(
|
||
'SELECT ID, post_title, post_status, post_type FROM ' . $db->posts . ' WHERE ' . self::WHERE
|
||
. ' ORDER BY ID ASC LIMIT %d',
|
||
$like,
|
||
self::LIMIT
|
||
),
|
||
'ARRAY_A'
|
||
);
|
||
// phpcs:enable
|
||
|
||
$items = [];
|
||
foreach (is_array($rows) ? $rows : [] as $row) {
|
||
$id = (int) $row['ID'];
|
||
$items[] = [
|
||
'post_id' => $id,
|
||
'title' => current_user_can('read_post', $id) ? (string) $row['post_title'] : '(nicht lesbar)',
|
||
'status' => (string) $row['post_status'],
|
||
'type' => (string) $row['post_type'],
|
||
];
|
||
}
|
||
|
||
return ['items' => $items, 'count' => max($count, count($items))];
|
||
}
|
||
}
|
||
```
|
||
|
||
`src/Integrations/Divi/Library/GlobalEdits.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Integrations\Divi\Library;
|
||
|
||
use Closure;
|
||
use LIT\MCP\Abilities\Errors;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\LibraryContent;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\MalformedMarkup;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\Parser;
|
||
use LIT\MCP\Integrations\Divi\Pages\DiviPage;
|
||
use LIT\MCP\Integrations\Divi\Pages\SaveScope;
|
||
use LIT\MCP\Integrations\WordPress\Status\PostCloner;
|
||
use WP_Error;
|
||
use WP_Post;
|
||
|
||
defined('ABSPATH') || exit;
|
||
|
||
/**
|
||
* The extra rules of a Divi write to a library entry (E2, answer F2), checked after the whole
|
||
* change validated and before anything is saved:
|
||
* - every entry keeps its shape (LibraryContent::shapeViolation) – instances expect their root type;
|
||
* - a global entry changes every page that shows it at once (F7): without confirm: true nothing is
|
||
* saved and the answer lists those pages (a dry run of the fully validated change); with it the
|
||
* save scope is GlobalItem (site-wide cache) and, when revisions are off for the entry, a backup
|
||
* copy is made first – the revision itself is DiviSaver's restore point, as for every page.
|
||
*/
|
||
final class GlobalEdits
|
||
{
|
||
/** @var Closure(WP_Post): int */
|
||
private Closure $backup;
|
||
|
||
/** @param (Closure(WP_Post): int)|null $backup Backup copy of the entry; null = PostCloner::backup(). */
|
||
public function __construct(
|
||
private LibraryAccess $access,
|
||
private GlobalUsages $usages,
|
||
?Closure $backup = null,
|
||
private Parser $parser = new Parser()
|
||
) {
|
||
$this->backup = $backup ?? static fn (WP_Post $item): int => (new PostCloner())->backup($item);
|
||
}
|
||
|
||
/**
|
||
* @param array<string, mixed> $input
|
||
* @return array{scope: SaveScope, details: array<string, mixed>}|WP_Error
|
||
*/
|
||
public function prepare(DiviPage $page, array $input): array|WP_Error
|
||
{
|
||
$item = $page->post;
|
||
$id = (int) $item->ID;
|
||
$global = $this->access->isGlobal($item);
|
||
try {
|
||
$before = LibraryContent::roots(LibraryContent::load($this->parser, (string) $item->post_content));
|
||
} catch (MalformedMarkup) {
|
||
$before = [];
|
||
}
|
||
|
||
$violation = LibraryContent::shapeViolation(
|
||
$before,
|
||
LibraryContent::roots($page->document),
|
||
$this->access->store()->layoutType($id),
|
||
$global
|
||
);
|
||
if ($violation !== null) {
|
||
return Errors::invalidInput($violation . ' Nichts wurde gespeichert.', ['post_id' => $violation]);
|
||
}
|
||
|
||
if (! $global) {
|
||
return ['scope' => SaveScope::LibraryItem, 'details' => []];
|
||
}
|
||
|
||
$usages = $this->usages->of($id);
|
||
$details = ['affected' => $usages['items'], 'affected_count' => $usages['count']];
|
||
if (($input['confirm'] ?? false) !== true) {
|
||
return Errors::confirmRequired(
|
||
sprintf(
|
||
'Globaler Bibliothekseintrag %d: die Änderung wirkt sofort auf %d %s (siehe affected), auch '
|
||
. 'veröffentlichte. Nichts wurde gespeichert (Probelauf).',
|
||
$id,
|
||
$usages['count'],
|
||
$usages['count'] === 1 ? 'Seite' : 'Seiten'
|
||
),
|
||
$details
|
||
);
|
||
}
|
||
|
||
if (! wp_revisions_enabled($item)) {
|
||
$details['backup_id'] = ($this->backup)($item);
|
||
}
|
||
|
||
return ['scope' => SaveScope::GlobalItem, 'details' => $details];
|
||
}
|
||
|
||
/**
|
||
* A tool's own confirm_required (lit-divi-delete) on a global entry, extended by the affected
|
||
* pages – so the one confirm the client sends covers both questions.
|
||
*/
|
||
public function notice(DiviPage $page, WP_Error $error): WP_Error
|
||
{
|
||
if (Errors::codeOf($error) !== 'confirm_required' || ! $this->access->isGlobal($page->post)) {
|
||
return $error;
|
||
}
|
||
|
||
$usages = $this->usages->of((int) $page->post->ID);
|
||
$data = $error->get_error_data();
|
||
$details = is_array($data) ? array_diff_key($data, ['status' => true, 'hint' => true]) : [];
|
||
|
||
return Errors::confirmRequired(
|
||
Errors::clientMessage($error)
|
||
. sprintf(' Globaler Bibliothekseintrag: wirkt auf %d Seiten (siehe affected).', $usages['count']),
|
||
array_merge($details, ['affected' => $usages['items'], 'affected_count' => $usages['count']])
|
||
);
|
||
}
|
||
}
|
||
```
|
||
|
||
`DiviWriter.php` – Konstruktor um `private ?GlobalEdits $globals = null` als letzten Parameter erweitern (Imports `GlobalEdits`, `Errors` ist vorhanden, `WP_Error` vorhanden). `save()` bekommt `SaveScope $scope = SaveScope::Page` als letzten Parameter und reicht ihn weiter: `$saved = $this->saver->save($post, $content, $scope);`. Neue Methoden:
|
||
|
||
```php
|
||
/**
|
||
* save() for the Divi tools (E2): pages as before; a library entry keeps its shape, a global one
|
||
* needs confirm (dry run first), gets a backup when revisions are off and clears every page's
|
||
* cache; the result then names the affected pages.
|
||
*
|
||
* @param array<string, mixed> $input
|
||
* @return array<string, mixed>|WP_Error
|
||
* @throws WriteFailed
|
||
*/
|
||
public function commit(string $ability, DiviPage $page, DiviChange $change, array $input): array|WP_Error
|
||
{
|
||
if (! $page->isLibraryItem()) {
|
||
return $this->save($ability, $page, $change, $input);
|
||
}
|
||
|
||
if ($this->globals === null) {
|
||
return Errors::unsupported(
|
||
'Bibliothekseinträge lassen sich über diese Verbindung nicht ändern.',
|
||
'Den Eintrag im Divi-Builder bearbeiten.'
|
||
);
|
||
}
|
||
|
||
if (Serializer::document($page->document) === (string) $page->post->post_content) {
|
||
return $this->save($ability, $page, $change, $input, SaveScope::LibraryItem);
|
||
}
|
||
|
||
$prepared = $this->globals->prepare($page, $input);
|
||
if ($prepared instanceof WP_Error) {
|
||
return $prepared;
|
||
}
|
||
|
||
return array_merge($this->save($ability, $page, $change, $input, $prepared['scope']), $prepared['details']);
|
||
}
|
||
|
||
/** A tool's confirm_required on a global library entry, extended by the affected pages. */
|
||
public function notice(DiviPage $page, WP_Error $error): WP_Error
|
||
{
|
||
return $page->isLibraryItem() && $this->globals !== null ? $this->globals->notice($page, $error) : $error;
|
||
}
|
||
```
|
||
|
||
`DiviWriteAbility.php` – `permission()`/`execute()` ersetzen und `precheck()` ergänzen:
|
||
|
||
```php
|
||
final public function permission(array $input): bool|WP_Error
|
||
{
|
||
$refusal = $this->precheck($input);
|
||
if ($refusal !== null) {
|
||
return $refusal;
|
||
}
|
||
|
||
$page = $this->writer->page($input);
|
||
|
||
return $page instanceof WP_Error ? $page : true;
|
||
}
|
||
|
||
final public function execute(array $input): mixed
|
||
{
|
||
$refusal = $this->precheck($input);
|
||
if ($refusal !== null) {
|
||
return $refusal;
|
||
}
|
||
|
||
$page = $this->writer->page($input);
|
||
if ($page instanceof WP_Error) {
|
||
return $page;
|
||
}
|
||
|
||
$change = $this->change($page, $input, $this->writer->composition($page));
|
||
if ($change instanceof WP_Error) {
|
||
return $this->writer->notice($page, $change);
|
||
}
|
||
|
||
return $this->writer->commit($this->name(), $page, $change, $input);
|
||
}
|
||
|
||
/**
|
||
* Checks of a tool beyond the page (rights and Tools-tab gates of another group) – run in
|
||
* permission() and again in execute(). Null = none.
|
||
*
|
||
* @param array<string, mixed> $input
|
||
*/
|
||
protected function precheck(array $input): ?WP_Error
|
||
{
|
||
return null;
|
||
}
|
||
```
|
||
|
||
Klassen-Docblock von `DiviWriteAbility`: „… `DiviWriter::commit()` stores it (library entries: `GlobalEdits`) and builds the result.“
|
||
|
||
`DiviSchema::write()`:
|
||
|
||
```php
|
||
public static function write(): array
|
||
{
|
||
return [
|
||
'post_id' => ['type' => 'integer', 'minimum' => 1],
|
||
'tree_rev' => [
|
||
'type' => 'string',
|
||
'description' => 'tree_rev aus lit-divi-outline bzw. der letzten Divi-Änderung (Pflicht).',
|
||
],
|
||
'confirm' => [
|
||
'type' => 'boolean',
|
||
'description' => 'Bei globalen Bibliothekseinträgen (und beim Löschen): true erst, nachdem der Nutzer '
|
||
. 'den Probelauf (confirm_required mit den betroffenen Seiten) bestätigt hat.',
|
||
],
|
||
];
|
||
}
|
||
```
|
||
|
||
`ExposurePolicy` – nach `isReadonly()`:
|
||
|
||
```php
|
||
/** Whether abilities of $group may write: the group is neither "nur lesen" nor disabled as a whole. */
|
||
public function groupWritable(string $group): bool
|
||
{
|
||
return ! $this->isReadonly($group) && $this->groupMode($group) !== self::DISABLED;
|
||
}
|
||
```
|
||
|
||
`DiviIntegration.php` – Konstruktor und Writer (Imports `Closure`, `GlobalEdits`, `GlobalUsages`):
|
||
|
||
```php
|
||
/**
|
||
* @param (Closure(): bool)|null $libraryWritable Tools-tab gate for writes to library entries
|
||
* (group "Divi-Bibliothek" writable); null = always.
|
||
*/
|
||
public function __construct(private ContentSchema $schema, private ChangeLog $log, ?Closure $libraryWritable = null)
|
||
{
|
||
$this->modules = new DiviModules();
|
||
$this->design = new DesignSystemReader();
|
||
$this->access = new LibraryAccess(new DiviLibraryStore(), new DiviRoles(), $libraryWritable);
|
||
}
|
||
```
|
||
|
||
In `abilities()`:
|
||
|
||
```php
|
||
$loader = new DiviPageLoader($this->schema, new Parser(), $this->access);
|
||
$composition = new DiviComposition($this->modules, $this->design);
|
||
$writer = new DiviWriter(
|
||
$loader,
|
||
new DiviSaver(),
|
||
$this->log,
|
||
$this->design,
|
||
$composition,
|
||
new GlobalEdits($this->access, new GlobalUsages())
|
||
);
|
||
```
|
||
|
||
`Plugin::boot()` (Import `use LIT\MCP\Integrations\Divi\Library\LibraryAccess;`): die Zeile `$divi = new DiviIntegration($schema, $changeLog);` entfällt an ihrer bisherigen Stelle; der Block ab `$schema = self::contentSchema();` bis vor `$registry = new IntegrationRegistry(` lautet danach:
|
||
|
||
```php
|
||
$schema = self::contentSchema();
|
||
$registry = null;
|
||
$policy = null;
|
||
// Security M2: content-create's divi input follows lit/divi-insert (asked at execute time,
|
||
// when registry and policy exist), so the Divi group's switches stop every Divi layout write.
|
||
$diviWritable = static function () use (&$registry, &$policy): bool {
|
||
return $registry instanceof IntegrationRegistry
|
||
&& $policy instanceof ExposurePolicy
|
||
&& $policy->allows('lit/divi-insert', $registry->abilities());
|
||
};
|
||
// The Divi tools write to library entries only while the group "Divi-Bibliothek" may write (E9).
|
||
$libraryWritable = static function () use (&$policy): bool {
|
||
return $policy instanceof ExposurePolicy && $policy->groupWritable(LibraryAccess::GROUP);
|
||
};
|
||
$divi = new DiviIntegration($schema, $changeLog, $libraryWritable);
|
||
```
|
||
|
||
(Beide Closures fragen erst bei der Ausführung; `$policy` wird weiter unten gesetzt.)
|
||
|
||
- [ ] **Step 4: Tests laufen lassen**
|
||
|
||
Run: `vendor/bin/phpunit --filter 'DiviSaverTest|LibraryAccessTest|DiviPageLoaderTest|ExposurePolicyTest|GlobalUsagesTest|GlobalEditsTest|DiviWriterTest|DiviWriteAbilityTest|DiviDeleteAbilityTest|DiviReplaceTextAbilityTest'`
|
||
Expected: PASS
|
||
|
||
Run: `composer test && composer lint`
|
||
Expected: OK
|
||
|
||
- [ ] **Step 5: Commit**
|
||
|
||
```bash
|
||
git add src/Integrations/Divi/Library src/Integrations/Divi/Pages/SaveScope.php src/Integrations/Divi/Pages/DiviSaver.php src/Integrations/Divi/Pages/DiviPageLoader.php src/Integrations/Divi/Pages/DiviWriter.php src/Integrations/Divi/Pages/DiviWriteAbility.php src/Integrations/Divi/Pages/DiviSchema.php src/Abilities/ExposurePolicy.php src/Integrations/Divi/DiviIntegration.php src/Plugin.php tests/Stubs/EtCorePageResource.php tests/bootstrap.php tests/Support/DiviWriterFixture.php tests/Unit
|
||
```
|
||
Commit wie in den Global Constraints mit der Nachricht `feat: Divi tools write library entries; global ones with dry run, confirm and backup (E2, F2)`.
|
||
|
||
---
|
||
|
||
### Task 10: Gruppe „Divi-Bibliothek“ und `lit/library-list` (mit `id` als Detail)
|
||
|
||
E9: `lit/library-list` ersetzt `lit/library-get` (Spec §5.7 wird in Task 16 angepasst). Ohne `id` eine Seite der Liste mit Filtern und `cursor`, mit `id` ein Eintrag mit Knoten-Übersicht, `tree_rev`, `rev` und – bei globalen Einträgen – den Seiten, die ihn zeigen. Die drei `lit/library-*`-Tools bilden eine eigene Integration (= Gruppe im Tools-Tab).
|
||
|
||
**Files:**
|
||
- Create: `src/Integrations/Divi/Library/LibraryIntegration.php`
|
||
- Create: `src/Integrations/Divi/Library/LibraryListAbility.php`
|
||
- Modify: `src/Integrations/Divi/DiviIntegration.php` (`library()`, `loader()`)
|
||
- Modify: `src/Plugin.php` (Registrierung)
|
||
- Modify: `docs/guides/overview.md` (indirekte Tools, Gruppenliste)
|
||
- Test: `tests/Unit/Integrations/Divi/Library/LibraryListAbilityTest.php`, `tests/Unit/Integrations/Divi/DiviIntegrationTest.php`
|
||
|
||
**Interfaces:**
|
||
- Consumes: `LibraryAccess::canList()`, `DiviPageLoader::load()`, `DiviLibraryStore::find/describe`, `GlobalUsages::of()`, `Outline`, `Cursor`, `Rev`.
|
||
- Produces:
|
||
- `final class LibraryIntegration implements Integration { __construct(LibraryAccess $access, DiviPageLoader $loader, DesignSystemReader $design); id() = LibraryAccess::GROUP; label() = 'Divi-Bibliothek' }` (Task 12/13 erweitern den Konstruktor)
|
||
- `final class LibraryListAbility implements Ability { __construct(LibraryAccess $access, DiviPageLoader $loader, DesignSystemReader $design, GlobalUsages $usages) }` – Name `lit/library-list`, indirekt, nur lesend; Ausgabe `{items, next_cursor}` bzw. mit `id` zusätzlich `outline`, `tree_rev`, `rev`, `edit_url`, bei globalen `affected`, `affected_count`.
|
||
- `DiviIntegration::library(): LibraryIntegration`
|
||
|
||
- [ ] **Step 1: Failing tests schreiben**
|
||
|
||
`tests/Unit/Integrations/Divi/Library/LibraryListAbilityTest.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Tests\Unit\Integrations\Divi\Library;
|
||
|
||
use Brain\Monkey\Functions;
|
||
use LIT\MCP\Abilities\Cursor;
|
||
use LIT\MCP\Integrations\Divi\Library\GlobalUsages;
|
||
use LIT\MCP\Integrations\Divi\Library\LibraryListAbility;
|
||
use LIT\MCP\Tests\Support\DiviWriterFixture;
|
||
use LIT\MCP\Tests\Support\LibraryFixtures;
|
||
use LIT\MCP\Tests\Unit\TestCase;
|
||
use Mockery;
|
||
|
||
final class LibraryListAbilityTest extends TestCase
|
||
{
|
||
protected function setUp(): void
|
||
{
|
||
parent::setUp();
|
||
Functions\when('get_the_terms')->justReturn(false);
|
||
Functions\when('get_post_meta')->justReturn('');
|
||
}
|
||
|
||
private function ability(array $deniedRoles = []): LibraryListAbility
|
||
{
|
||
$store = LibraryFixtures::store();
|
||
$store->allows('find')->andReturnUsing(static fn (array $filters, int $limit, int $offset): array => array_slice(
|
||
[LibraryFixtures::item(1055), LibraryFixtures::item(1058), LibraryFixtures::item(1059)],
|
||
$offset,
|
||
$limit + 1
|
||
));
|
||
$access = LibraryFixtures::access($deniedRoles, true, $store);
|
||
$usages = Mockery::mock(GlobalUsages::class);
|
||
$usages->allows('of')->with(1058)->andReturn([
|
||
'items' => [['post_id' => 1053, 'title' => 'Globale Instanzen', 'status' => 'draft', 'type' => 'page']],
|
||
'count' => 1,
|
||
]);
|
||
|
||
return new LibraryListAbility($access, LibraryFixtures::loader($access), DiviWriterFixture::designReader(), $usages);
|
||
}
|
||
|
||
public function testListsAPageWithCursor(): void
|
||
{
|
||
LibraryFixtures::given([]);
|
||
|
||
$first = $this->ability()->execute(['limit' => 2]);
|
||
$second = $this->ability()->execute(['limit' => 2, 'cursor' => $first['next_cursor']]);
|
||
|
||
self::assertSame([1055, 1058], array_column($first['items'], 'id'));
|
||
self::assertSame(['normal', 'global'], array_column($first['items'], 'scope'));
|
||
self::assertSame('section', $first['items'][0]['layout_type']);
|
||
self::assertSame(Cursor::encode(2), $first['next_cursor']);
|
||
self::assertSame([1059], array_column($second['items'], 'id'));
|
||
self::assertNull($second['next_cursor']);
|
||
}
|
||
|
||
public function testPassesTheFilters(): void
|
||
{
|
||
LibraryFixtures::given([]);
|
||
$store = LibraryFixtures::store();
|
||
$store->expects('find')->with(['layout_type' => 'module', 'scope' => 'global', 'search' => 'Zeiten'], 20, 0)
|
||
->andReturn([]);
|
||
$access = LibraryFixtures::access([], true, $store);
|
||
$ability = new LibraryListAbility(
|
||
$access,
|
||
LibraryFixtures::loader($access),
|
||
DiviWriterFixture::designReader(),
|
||
Mockery::mock(GlobalUsages::class)
|
||
);
|
||
|
||
$result = $ability->execute(['layout_type' => 'module', 'scope' => 'global', 'search' => 'Zeiten', 'category' => '']);
|
||
|
||
self::assertSame(['items' => [], 'next_cursor' => null], $result);
|
||
}
|
||
|
||
public function testDetailOfAGlobalEntryWithOutlineAndAffectedPages(): void
|
||
{
|
||
LibraryFixtures::given([LibraryFixtures::item(1058)]);
|
||
|
||
$result = $this->ability()->execute(['id' => 1058]);
|
||
|
||
self::assertSame(1058, $result['items'][0]['id']);
|
||
self::assertNull($result['next_cursor']);
|
||
self::assertStringStartsWith('s0 section "Global Abschnitt"', $result['outline']);
|
||
self::assertSame(12, strlen($result['tree_rev']));
|
||
self::assertSame(1, $result['affected_count']);
|
||
self::assertSame('https://kunde.test/wp-admin/post.php?post=1058&action=edit', $result['edit_url']);
|
||
}
|
||
|
||
public function testDetailOfSomethingElseIsNotFoundAndTheRoleIsNeeded(): void
|
||
{
|
||
LibraryFixtures::given([LibraryFixtures::page('')]);
|
||
|
||
self::assertToolError($this->ability()->execute(['id' => LibraryFixtures::PAGE]), 'not_found');
|
||
self::assertToolError($this->ability(['divi_library'])->permission([]), 'forbidden');
|
||
self::assertToolError($this->ability()->execute(['cursor' => '!!']), 'validation_failed');
|
||
self::assertTrue($this->ability()->annotations()['readonly']);
|
||
self::assertFalse($this->ability()->isDirect());
|
||
}
|
||
}
|
||
```
|
||
|
||
(`LibraryFixtures::given([])` stubbt die Rechte ohne Posts; `Cursor::invalid()` liefert `validation_failed`.)
|
||
|
||
In `DiviIntegrationTest`:
|
||
|
||
```php
|
||
public function testProvidesTheLibraryGroup(): void
|
||
{
|
||
$library = (new DiviIntegration(Mockery::mock(ContentSchema::class), FakeChangeLog::forbidden()))->library();
|
||
|
||
self::assertSame('divi-library', $library->id());
|
||
self::assertFalse($library->isAvailable(), 'no Divi classes in unit tests');
|
||
self::assertSame(
|
||
['lit/library-list'],
|
||
array_map(static fn (Ability $ability): string => $ability->name(), $library->abilities())
|
||
);
|
||
foreach ($library->abilities() as $ability) {
|
||
self::assertFalse($ability->inputSchema()['additionalProperties'], $ability->name());
|
||
self::assertNotNull($ability->outputSchema(), $ability->name());
|
||
}
|
||
}
|
||
```
|
||
|
||
- [ ] **Step 2: Tests laufen lassen – schlagen fehl**
|
||
|
||
Run: `vendor/bin/phpunit --filter 'LibraryListAbilityTest|DiviIntegrationTest'`
|
||
Expected: FAIL (Klassen fehlen)
|
||
|
||
- [ ] **Step 3: Implementieren**
|
||
|
||
`src/Integrations/Divi/Library/LibraryListAbility.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Integrations\Divi\Library;
|
||
|
||
use LIT\MCP\Abilities\Ability;
|
||
use LIT\MCP\Abilities\Annotations;
|
||
use LIT\MCP\Abilities\Cursor;
|
||
use LIT\MCP\Abilities\Errors;
|
||
use LIT\MCP\Abilities\Rev;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\Outline;
|
||
use LIT\MCP\Integrations\Divi\Design\DesignSystemReader;
|
||
use LIT\MCP\Integrations\Divi\Pages\DiviPageLoader;
|
||
use WP_Error;
|
||
use WP_Post;
|
||
|
||
defined('ABSPATH') || exit;
|
||
|
||
/**
|
||
* lit/library-list: the Divi Library (spec §5.7, E9 – replaces lit/library-get). Without id a page
|
||
* of published entries (filters, cursor); with id one entry with its node outline, tree_rev and,
|
||
* for a global entry, the pages that show it. Rights: LibraryAccess (edit_posts + divi_library;
|
||
* one entry also edit_post).
|
||
*/
|
||
final class LibraryListAbility implements Ability
|
||
{
|
||
public function __construct(
|
||
private LibraryAccess $access,
|
||
private DiviPageLoader $loader,
|
||
private DesignSystemReader $design,
|
||
private GlobalUsages $usages
|
||
) {
|
||
}
|
||
|
||
public function name(): string
|
||
{
|
||
return 'lit/library-list';
|
||
}
|
||
|
||
public function label(): string
|
||
{
|
||
return 'Divi-Bibliothek auflisten';
|
||
}
|
||
|
||
public function description(): string
|
||
{
|
||
return 'Listet Einträge der Divi-Bibliothek (Layouts, Abschnitte, Zeilen, Module; normal oder global), '
|
||
. 'filterbar nach layout_type, scope, search und category, blätterbar mit cursor. Mit id: ein Eintrag '
|
||
. 'im Detail – Knoten-Übersicht, tree_rev und bei globalen Einträgen die Seiten, die ihn zeigen '
|
||
. '(affected). Einfügen mit lit-library-insert; bearbeiten mit den Divi-Werkzeugen und der ID als post_id.';
|
||
}
|
||
|
||
public function inputSchema(): array
|
||
{
|
||
return [
|
||
'type' => 'object',
|
||
'properties' => array_merge([
|
||
'id' => ['type' => 'integer', 'minimum' => 1, 'description' => 'Ein Eintrag im Detail.'],
|
||
'layout_type' => ['type' => 'string', 'enum' => DiviLibraryStore::LAYOUT_TYPES],
|
||
'scope' => ['type' => 'string', 'enum' => ['normal', 'global']],
|
||
'search' => ['type' => 'string', 'maxLength' => 100, 'description' => 'Suche im Titel.'],
|
||
'category' => ['type' => 'string', 'maxLength' => 100, 'description' => 'Name einer Kategorie.'],
|
||
], Cursor::inputProperties()),
|
||
'additionalProperties' => false,
|
||
];
|
||
}
|
||
|
||
public function outputSchema(): ?array
|
||
{
|
||
return [
|
||
'type' => 'object',
|
||
'properties' => [
|
||
'items' => [
|
||
'type' => 'array',
|
||
'items' => [
|
||
'type' => 'object',
|
||
'properties' => [
|
||
'id' => ['type' => 'integer'],
|
||
'title' => ['type' => 'string'],
|
||
'layout_type' => ['type' => ['string', 'null']],
|
||
'scope' => ['type' => 'string'],
|
||
'module_type' => ['type' => ['string', 'null']],
|
||
'categories' => ['type' => 'array', 'items' => ['type' => 'string']],
|
||
'tags' => ['type' => 'array', 'items' => ['type' => 'string']],
|
||
'modified' => ['type' => 'string'],
|
||
],
|
||
'required' => ['id', 'title', 'layout_type', 'scope', 'module_type', 'categories', 'tags', 'modified'],
|
||
],
|
||
],
|
||
'next_cursor' => ['type' => ['string', 'null']],
|
||
'outline' => ['type' => 'string'],
|
||
'tree_rev' => ['type' => 'string'],
|
||
'rev' => ['type' => 'string'],
|
||
'edit_url' => ['type' => 'string'],
|
||
'affected' => ['type' => 'array', 'items' => ['type' => 'object']],
|
||
'affected_count' => ['type' => 'integer'],
|
||
],
|
||
'required' => ['items', 'next_cursor'],
|
||
];
|
||
}
|
||
|
||
public function annotations(): array
|
||
{
|
||
return Annotations::read();
|
||
}
|
||
|
||
public function isDirect(): bool
|
||
{
|
||
return false;
|
||
}
|
||
|
||
public function permission(array $input): bool|WP_Error
|
||
{
|
||
$refusal = $this->access->canList();
|
||
if ($refusal !== null) {
|
||
return $refusal;
|
||
}
|
||
|
||
if (! isset($input['id'])) {
|
||
return true;
|
||
}
|
||
|
||
$page = $this->loader->load($input['id'], false);
|
||
|
||
return $page instanceof WP_Error ? $page : true;
|
||
}
|
||
|
||
public function execute(array $input): mixed
|
||
{
|
||
$refusal = $this->access->canList();
|
||
if ($refusal !== null) {
|
||
return $refusal;
|
||
}
|
||
|
||
if (isset($input['id'])) {
|
||
return $this->detail($input['id']);
|
||
}
|
||
|
||
$offset = Cursor::decode(is_string($input['cursor'] ?? null) ? $input['cursor'] : null);
|
||
if ($offset === null) {
|
||
return Cursor::invalid();
|
||
}
|
||
|
||
$limit = Cursor::limit($input['limit'] ?? null);
|
||
$filters = array_filter(
|
||
[
|
||
'layout_type' => $input['layout_type'] ?? null,
|
||
'scope' => $input['scope'] ?? null,
|
||
'search' => $input['search'] ?? null,
|
||
'category' => $input['category'] ?? null,
|
||
],
|
||
static fn (mixed $value): bool => is_string($value) && $value !== ''
|
||
);
|
||
$store = $this->access->store();
|
||
$page = Cursor::page(
|
||
array_map(static fn (WP_Post $post): array => $store->describe($post), $store->find($filters, $limit, $offset)),
|
||
$limit,
|
||
$offset
|
||
);
|
||
|
||
return ['items' => $page['items'], 'next_cursor' => $page['next_cursor']];
|
||
}
|
||
|
||
/** @return array<string, mixed>|WP_Error */
|
||
private function detail(mixed $id): array|WP_Error
|
||
{
|
||
$page = $this->loader->load($id, false);
|
||
if ($page instanceof WP_Error) {
|
||
return $page;
|
||
}
|
||
|
||
if (! $page->isLibraryItem()) {
|
||
return Errors::notFound(
|
||
sprintf('Eintrag %d ist kein Eintrag der Divi-Bibliothek.', (int) $page->post->ID),
|
||
'Einträge mit lit/library-list (ohne id) auflisten.'
|
||
);
|
||
}
|
||
|
||
$item = $this->access->store()->describe($page->post);
|
||
$outline = new Outline($this->design->read()->presetNames());
|
||
$result = [
|
||
'items' => [$item],
|
||
'next_cursor' => null,
|
||
'outline' => $outline->text($outline->rows($page->index)),
|
||
'tree_rev' => $page->treeRev(),
|
||
'rev' => Rev::ofPost($page->post),
|
||
'edit_url' => $page->editUrl(),
|
||
];
|
||
if ($item['scope'] === 'global') {
|
||
$usages = $this->usages->of((int) $page->post->ID);
|
||
$result['affected'] = $usages['items'];
|
||
$result['affected_count'] = $usages['count'];
|
||
}
|
||
|
||
return $result;
|
||
}
|
||
}
|
||
```
|
||
|
||
`src/Integrations/Divi/Library/LibraryIntegration.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Integrations\Divi\Library;
|
||
|
||
use LIT\MCP\Integrations\Divi\Design\DesignSystemReader;
|
||
use LIT\MCP\Integrations\Divi\Pages\DiviPageLoader;
|
||
use LIT\MCP\Integrations\Divi\Schema\DiviModules;
|
||
use LIT\MCP\Integrations\Integration;
|
||
|
||
defined('ABSPATH') || exit;
|
||
|
||
/**
|
||
* The group "Divi-Bibliothek" (E9): lit/library-list, lit/library-save, lit/library-insert. Built by
|
||
* DiviIntegration::library() so it shares the library access (rights, Tools-tab gate). Available
|
||
* with the Divi 5 builder, like the Divi group.
|
||
*/
|
||
final class LibraryIntegration implements Integration
|
||
{
|
||
public function __construct(
|
||
private LibraryAccess $access,
|
||
private DiviPageLoader $loader,
|
||
private DesignSystemReader $design
|
||
) {
|
||
}
|
||
|
||
public function id(): string
|
||
{
|
||
return LibraryAccess::GROUP;
|
||
}
|
||
|
||
public function label(): string
|
||
{
|
||
return __('Divi-Bibliothek', 'wp-lit-mcp');
|
||
}
|
||
|
||
public function isAvailable(): bool
|
||
{
|
||
return DiviModules::isAvailable();
|
||
}
|
||
|
||
public function abilities(): array
|
||
{
|
||
return [
|
||
new LibraryListAbility($this->access, $this->loader, $this->design, new GlobalUsages()),
|
||
];
|
||
}
|
||
}
|
||
```
|
||
|
||
`DiviIntegration.php` (Import `LibraryIntegration`):
|
||
|
||
```php
|
||
/** The group "Divi-Bibliothek" (lit/library-*), sharing this integration's library access. */
|
||
public function library(): LibraryIntegration
|
||
{
|
||
return new LibraryIntegration($this->access, $this->loader(), $this->design);
|
||
}
|
||
|
||
private function loader(): DiviPageLoader
|
||
{
|
||
return new DiviPageLoader($this->schema, new Parser(), $this->access);
|
||
}
|
||
```
|
||
|
||
und in `abilities()` `$loader = $this->loader();`.
|
||
|
||
`Plugin::boot()` – die Registry um die Gruppe erweitern:
|
||
|
||
```php
|
||
$registry = new IntegrationRegistry(
|
||
new CoreIntegration(self::pluginDir() . '/docs/guides'),
|
||
new WordPressIntegration($schema, $changeLog, $divi->contentComposer($diviWritable)),
|
||
new MediaIntegration($schema, $changeLog, $limits),
|
||
$divi,
|
||
$divi->library()
|
||
);
|
||
```
|
||
|
||
`docs/guides/overview.md`: in „Die Tools sind nach Integration gruppiert (Grundlagen, WordPress, Medien, Divi)“ → „(Grundlagen, WordPress, Medien, Divi, Divi-Bibliothek)“; am Ende der indirekten Liste „Divi (`lit/divi-duplicate-node`, `lit/divi-replace-text`).“ → „Divi (`lit/divi-duplicate-node`, `lit/divi-replace-text`), Divi-Bibliothek (`lit/library-list`).“
|
||
|
||
- [ ] **Step 4: Tests laufen lassen**
|
||
|
||
Run: `vendor/bin/phpunit --filter 'LibraryListAbilityTest|DiviIntegrationTest|ToolNamingTest|ToolsTabTest'`
|
||
Expected: PASS
|
||
|
||
Run: `composer test && composer lint`
|
||
Expected: OK
|
||
|
||
- [ ] **Step 5: Commit**
|
||
|
||
```bash
|
||
git add src/Integrations/Divi/Library/LibraryIntegration.php src/Integrations/Divi/Library/LibraryListAbility.php src/Integrations/Divi/DiviIntegration.php src/Plugin.php docs/guides/overview.md tests/Unit/Integrations/Divi/Library/LibraryListAbilityTest.php tests/Unit/Integrations/Divi/DiviIntegrationTest.php
|
||
```
|
||
Commit wie in den Global Constraints mit der Nachricht `feat: group Divi-Bibliothek with lit/library-list`.
|
||
|
||
---
|
||
|
||
### Task 11: `StoredNodeGuard` – gespeicherte Knoten, die den Post wechseln (E6)
|
||
|
||
Audit M1 und R2-Befund 1: Wer einen gespeicherten Knoten über eine andere Post-ID überträgt, darf die S7/S26-Sperre nicht umgehen, und Divi filtert Dynamic-Content-`before`/`after` nach dem **Autor des Ziel-Posts**. Für Benutzer ohne `unfiltered_html` wird deshalb abgelehnt (nicht bereinigt): Builder-only-Pfade (`ValueCleaner::guardPath()`), Code-Modul, `$variable`-Verweise, die `VariableRef::canonical()` für das Ziel ablehnt oder deren Einstellungen es verändern würde. Alles andere bleibt byte-identisch. Auch `localAttrs` globaler Instanzen werden geprüft (Divi nutzt sie für entkoppelte Attribute, F7).
|
||
|
||
**Files:**
|
||
- Create: `src/Integrations/Divi/Compose/StoredNodeGuard.php`
|
||
- Modify: `src/Integrations/Divi/Compose/VariableRef.php` (`settingsOf()`)
|
||
- Modify: `src/Integrations/Divi/Pages/DiviComposition.php` (`storedGuard()`)
|
||
- Test: `tests/Unit/Integrations/Divi/Compose/StoredNodeGuardTest.php`, `tests/Unit/Integrations/Divi/Pages/DiviCompositionTest.php`
|
||
|
||
**Interfaces:**
|
||
- Consumes: `ValueCleaner::guardPath()/kindOf()`, `VariableRef::canonical()`, `AttrMap::flatten()`, `GlobalInstance::effectiveName()/BLOCK`.
|
||
- Produces: `final class StoredNodeGuard { const CODE_MODULES = ['divi/code', 'divi/fullwidth-code']; __construct(ValueCleaner $cleaner, VariableRef $references, ValueSanitizer $sanitizer); problems(Block $root): list<string> }`; `VariableRef::settingsOf(string $value): array`; `DiviComposition::storedGuard(): StoredNodeGuard`.
|
||
|
||
- [ ] **Step 1: Failing tests schreiben**
|
||
|
||
`tests/Unit/Integrations/Divi/Compose/StoredNodeGuardTest.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Tests\Unit\Integrations\Divi\Compose;
|
||
|
||
use LIT\MCP\Integrations\Divi\BlockTree\Block;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\NodeIndex;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\Parser;
|
||
use LIT\MCP\Integrations\Divi\Compose\StoredNodeGuard;
|
||
use LIT\MCP\Integrations\Divi\Compose\ValueCleaner;
|
||
use LIT\MCP\Integrations\Divi\Compose\VariableRef;
|
||
use LIT\MCP\Integrations\Divi\Pages\DynamicContentMap;
|
||
use LIT\MCP\Tests\Support\ComposeFixture;
|
||
use LIT\MCP\Tests\Support\DiviFixtures;
|
||
use PHPUnit\Framework\TestCase;
|
||
|
||
final class StoredNodeGuardTest extends TestCase
|
||
{
|
||
private static function guard(bool $unfiltered = false): StoredNodeGuard
|
||
{
|
||
$references = new VariableRef(
|
||
DiviFixtures::designSystem(),
|
||
DynamicContentMap::fromOptions(DiviFixtures::dynamicContentRegistry())
|
||
);
|
||
$sanitizer = ComposeFixture::sanitizer($unfiltered);
|
||
|
||
return new StoredNodeGuard(new ValueCleaner(DiviFixtures::catalog(), $references, $sanitizer), $references, $sanitizer);
|
||
}
|
||
|
||
private static function block(string $markup): Block
|
||
{
|
||
return (new Parser())->parse($markup)->children()[0];
|
||
}
|
||
|
||
public function testBuilderContentWithInstancesAndLinksPasses(): void
|
||
{
|
||
$index = NodeIndex::build((new Parser())->parse(DiviFixtures::markup('stage3/page--globale-instanzen.html')));
|
||
$link = '<!-- wp:divi/button {"button":{"innerContent":{"desktop":{"value":{"text":"Kontakt","linkUrl":'
|
||
. '"$variable({"type":"content","value":{"name":'
|
||
. '"post_link_url_page","settings":{"post_id":"839"}}})$"}}}}} /-->';
|
||
|
||
self::assertSame([], self::guard()->problems($index->find('s0')));
|
||
self::assertSame([], self::guard()->problems($index->find('g0')));
|
||
self::assertSame([], self::guard()->problems(self::block($link)));
|
||
}
|
||
|
||
/** @return array<string, array{string, string}> */
|
||
public static function refused(): array
|
||
{
|
||
$ref = static fn (string $name, string $settings): string => '"$variable({"type":"content",'
|
||
. '"value":{"name":"' . $name . '","settings":' . $settings . '}})$"';
|
||
|
||
return [
|
||
'custom css' => [
|
||
'<!-- wp:divi/text {"css":{"desktop":{"value":{"freeForm":"body{display:none}"}}}} /-->',
|
||
'"css"',
|
||
],
|
||
'html attributes' => [
|
||
'<!-- wp:divi/text {"module":{"decoration":{"attributes":{"desktop":{"value":{"attributes":'
|
||
. '[{"name":"data-x","value":"1"}]}}}}}} /-->',
|
||
'module.decoration.attributes',
|
||
],
|
||
'code module' => ['<!-- wp:divi/code {"content":{"innerContent":{"desktop":{"value":"x"}}}} /-->', 'Code-Modul'],
|
||
'script in before' => [
|
||
'<!-- wp:divi/text {"content":{"innerContent":{"desktop":{"value":' . $ref(
|
||
'post_title',
|
||
'{"before":"<script>x</script>","after":""}'
|
||
) . '}}}} /-->',
|
||
'nicht schreiben darf',
|
||
],
|
||
'protected meta' => [
|
||
'<!-- wp:divi/text {"content":{"innerContent":{"desktop":{"value":' . $ref('custom_meta__edit_lock', '{}')
|
||
. '}}}} /-->',
|
||
'custom_meta__edit_lock',
|
||
],
|
||
'css in the local attributes of an instance' => [
|
||
'<!-- wp:divi/global-layout {"globalModule":"5","blockName":"divi/text","localAttrs":{"css":{"desktop":'
|
||
. '{"value":{"freeForm":"a{}"}}}}} /-->',
|
||
'"css"',
|
||
],
|
||
'code module deep inside a section' => [
|
||
'<!-- wp:divi/section --><!-- wp:divi/row --><!-- wp:divi/column --><!-- wp:divi/code /-->'
|
||
. '<!-- /wp:divi/column --><!-- /wp:divi/row --><!-- /wp:divi/section -->',
|
||
'Code-Modul',
|
||
],
|
||
];
|
||
}
|
||
|
||
/** @dataProvider refused */
|
||
public function testRefusesBuilderOnlyValuesForUsersWithoutUnfilteredHtml(string $markup, string $problem): void
|
||
{
|
||
$problems = self::guard()->problems(self::block($markup));
|
||
|
||
self::assertNotSame([], $problems);
|
||
self::assertStringContainsString($problem, implode(' | ', $problems));
|
||
self::assertSame([], self::guard(true)->problems(self::block($markup)), 'unfiltered_html may carry it');
|
||
}
|
||
}
|
||
```
|
||
|
||
In `DiviCompositionTest` ergänzen:
|
||
|
||
```php
|
||
public function testStoredGuardSharesTheCleanerAndReferences(): void
|
||
{
|
||
$composition = DiviWriterFixture::composition(DiviWriterFixture::designReader())->forPost(7);
|
||
|
||
self::assertInstanceOf(StoredNodeGuard::class, $composition->storedGuard());
|
||
self::assertSame(
|
||
[],
|
||
$composition->storedGuard()->problems(Block::create('divi/text', ['builderVersion' => '5.2.1']))
|
||
);
|
||
}
|
||
```
|
||
|
||
(Imports `StoredNodeGuard`, `Block`, `DiviWriterFixture`.)
|
||
|
||
- [ ] **Step 2: Tests laufen lassen – schlagen fehl**
|
||
|
||
Run: `vendor/bin/phpunit --filter 'StoredNodeGuardTest|DiviCompositionTest'`
|
||
Expected: FAIL (`StoredNodeGuard` fehlt)
|
||
|
||
- [ ] **Step 3: Implementieren**
|
||
|
||
`VariableRef.php` – nach `typeOf()`:
|
||
|
||
```php
|
||
/**
|
||
* The settings of $value when it is exactly one reference ([] otherwise). StoredNodeGuard compares
|
||
* a stored reference with canonical(): different settings mean cleaning would change them.
|
||
*
|
||
* @return array<array-key, mixed>
|
||
*/
|
||
public static function settingsOf(string $value): array
|
||
{
|
||
try {
|
||
$payload = self::payloadOf($value);
|
||
} catch (InvalidArgumentException) {
|
||
return [];
|
||
}
|
||
|
||
$settings = $payload['value']['settings'] ?? [];
|
||
|
||
return is_array($settings) ? $settings : [];
|
||
}
|
||
```
|
||
|
||
`src/Integrations/Divi/Compose/StoredNodeGuard.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Integrations\Divi\Compose;
|
||
|
||
use InvalidArgumentException;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\AttrMap;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\Block;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\GlobalInstance;
|
||
|
||
defined('ABSPATH') || exit;
|
||
|
||
/**
|
||
* E6 (security audit M1, R2 finding 1): a stored node that moves to another post – page → page
|
||
* (lit/divi-node-copy), library → page (lit/library-insert), page → library (lit/library-save) – keeps
|
||
* its bytes, but the builder-only gate must hold across post IDs, and Divi filters dynamic content
|
||
* before/after by the author of the TARGET post. For users without unfiltered_html the node is
|
||
* refused when anything in it (localAttrs of instances included) is
|
||
* - a builder-only path (ValueCleaner::guardPath(): own HTML, HTML attributes, custom CSS – S7/S26),
|
||
* - a code module,
|
||
* - a $variable(…)$ reference VariableRef::canonical() refuses for the target post, or whose
|
||
* settings canonical() would clean (e.g. before/after with markup such a user may not write).
|
||
* Nothing is cleaned or rewritten – a refused node stays a job for the Divi builder. Pure PHP.
|
||
*/
|
||
final class StoredNodeGuard
|
||
{
|
||
public const CODE_MODULES = ['divi/code', 'divi/fullwidth-code'];
|
||
|
||
/** Keys of a breakpoint map that are no sub-field names. */
|
||
private const STATE_KEYS = ['value', 'hover', 'sticky'];
|
||
|
||
public function __construct(
|
||
private ValueCleaner $cleaner,
|
||
private VariableRef $references,
|
||
private ValueSanitizer $sanitizer
|
||
) {
|
||
}
|
||
|
||
/** @return list<string> German problems; [] when $root may move to the target post. */
|
||
public function problems(Block $root): array
|
||
{
|
||
if ($this->sanitizer->allowsUnfilteredHtml()) {
|
||
return [];
|
||
}
|
||
|
||
$problems = [];
|
||
$this->walk($root, $problems);
|
||
|
||
return array_values(array_unique($problems));
|
||
}
|
||
|
||
/** @param list<string> $problems */
|
||
private function walk(Block $block, array &$problems): void
|
||
{
|
||
$module = GlobalInstance::effectiveName($block);
|
||
if (in_array($module, self::CODE_MODULES, true)) {
|
||
$problems[] = sprintf(
|
||
'%s: Code-Modul – nur im Divi-Builder übertragbar (oder mit dem Recht unfiltered_html).',
|
||
$module
|
||
);
|
||
}
|
||
|
||
$attrs = $block->attrs();
|
||
if ($block->name() === GlobalInstance::BLOCK) {
|
||
$attrs = is_array($attrs['localAttrs'] ?? null) ? $attrs['localAttrs'] : [];
|
||
}
|
||
|
||
foreach (AttrMap::flatten($attrs) as $path => $value) {
|
||
try {
|
||
$this->cleaner->guardPath((string) $path);
|
||
} catch (InvalidArgumentException $e) {
|
||
$problems[] = $e->getMessage();
|
||
continue;
|
||
}
|
||
$this->references($module, (string) $path, $value, null, $problems);
|
||
}
|
||
|
||
foreach ($block->children() as $child) {
|
||
$this->walk($child, $problems);
|
||
}
|
||
}
|
||
|
||
/** @param list<string> $problems */
|
||
private function references(string $module, string $path, mixed $value, ?string $key, array &$problems): void
|
||
{
|
||
if (is_array($value)) {
|
||
foreach ($value as $childKey => $item) {
|
||
$isField = is_string($childKey)
|
||
&& ! in_array($childKey, AttrMap::BREAKPOINTS, true)
|
||
&& ! in_array($childKey, self::STATE_KEYS, true);
|
||
$this->references($module, $path, $item, $isField ? $childKey : $key, $problems);
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
if (! is_string($value) || ! VariableRef::contains($value)) {
|
||
return;
|
||
}
|
||
|
||
try {
|
||
$url = $this->cleaner->kindOf($module, $path, $key) === ValueKind::Url;
|
||
$canonical = $this->references->canonical($value, $this->sanitizer, $url);
|
||
} catch (InvalidArgumentException $e) {
|
||
$problems[] = sprintf('%s: %s', $path, $e->getMessage());
|
||
|
||
return;
|
||
}
|
||
|
||
if (self::normalized(VariableRef::settingsOf($canonical)) !== self::normalized(VariableRef::settingsOf($value))) {
|
||
$problems[] = sprintf(
|
||
'%s: Divi-Verweis mit Einstellungen, die dieses Konto nicht schreiben darf – nur im Divi-Builder '
|
||
. 'übertragbar.',
|
||
$path
|
||
);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @param array<array-key, mixed> $settings
|
||
* @return array<array-key, mixed> Keys sorted, scalars as strings (post_id 839 = "839").
|
||
*/
|
||
private static function normalized(array $settings): array
|
||
{
|
||
ksort($settings);
|
||
|
||
return array_map(static fn (mixed $value): mixed => is_scalar($value) ? (string) $value : $value, $settings);
|
||
}
|
||
}
|
||
```
|
||
|
||
`DiviComposition` (Import `StoredNodeGuard`):
|
||
|
||
```php
|
||
/** E6: the check for stored nodes that move into this composition's entry. */
|
||
public function storedGuard(): StoredNodeGuard
|
||
{
|
||
return new StoredNodeGuard($this->cleaner(), $this->references(), $this->sanitizer);
|
||
}
|
||
```
|
||
|
||
- [ ] **Step 4: Tests laufen lassen**
|
||
|
||
Run: `vendor/bin/phpunit --filter 'StoredNodeGuardTest|DiviCompositionTest|VariableRefTest'`
|
||
Expected: PASS
|
||
|
||
Run: `composer test && composer lint`
|
||
Expected: OK
|
||
|
||
- [ ] **Step 5: Commit**
|
||
|
||
```bash
|
||
git add src/Integrations/Divi/Compose/StoredNodeGuard.php src/Integrations/Divi/Compose/VariableRef.php src/Integrations/Divi/Pages/DiviComposition.php tests/Unit/Integrations/Divi/Compose/StoredNodeGuardTest.php tests/Unit/Integrations/Divi/Pages/DiviCompositionTest.php
|
||
```
|
||
Commit wie in den Global Constraints mit der Nachricht `feat: StoredNodeGuard keeps S7/S26 for nodes moving between posts (E6)`.
|
||
|
||
---
|
||
|
||
### Task 12: `lit/library-save` – Knoten als Bibliothekseintrag (E4)
|
||
|
||
E4: Das Plugin legt Einträge selbst an – kein `et_pb_submit_layout` (im REST-Kontext nicht geladen, speichert mit kses, F2), keine Builder-Route (Nonce, Preset-Import, F3). `wp_insert_post` mit leerem Inhalt und Status `publish` (Divi kennt keine Bibliotheksentwürfe), Terme und Meta wie `et_pb_submit_layout` (verglichen mit den echten Builder-Einträgen der Fixtures; `_et_pb_row_layout` wird nicht geschrieben – Divi selbst speichert dort `"[object Object]"`, Befund 5), danach der Inhalt über `DiviSaver::saveNew` (`SaveScope::LibraryItem`, ohne Divi-Flags, Befund 4) als `divi/placeholder`-Rahmen um die unveränderten Bytes des Knotens. Alles oder nichts: jeder Fehler löscht den neuen Eintrag endgültig. Der Knoten auf der Seite bleibt unverändert (das Verknüpfen ist `lit/library-make-global`, Etappe 3b).
|
||
|
||
**Files:**
|
||
- Create: `src/Integrations/Divi/Library/LibraryItemSpec.php`
|
||
- Modify: `src/Integrations/Divi/Library/DiviLibraryStore.php` (`create()`, `delete()`)
|
||
- Modify: `src/Integrations/Divi/Library/LibraryAccess.php` (`canSave()`)
|
||
- Create: `src/Integrations/Divi/Library/LibrarySaveAbility.php`
|
||
- Modify: `src/Integrations/Divi/Library/LibraryIntegration.php`, `src/Integrations/Divi/DiviIntegration.php`
|
||
- Modify: `docs/guides/overview.md` (indirekte Tools)
|
||
- Test: `tests/Unit/Integrations/Divi/Library/LibraryItemSpecTest.php`, `…/DiviLibraryStoreTest.php`, `…/LibraryAccessTest.php`, `…/LibrarySaveAbilityTest.php`, `tests/Unit/Integrations/Divi/DiviIntegrationTest.php`
|
||
|
||
**Interfaces:**
|
||
- Consumes: `LibraryContent::wrap/containsGlobal`, `NodeSummary::globalRef`, `ModuleCatalog::has/category`, `DiviSaver::saveNew(…, SaveScope::LibraryItem)`, `StoredNodeGuard` über `DiviWriter::composition($page)->storedGuard()`, `PostSaveFollowUp`, `Errors::writeFailed/partialWrite/revMismatch`.
|
||
- Produces:
|
||
- `final class LibraryItemSpec { __construct(string $title, string $layoutType, bool $global, string $moduleWidth, ?string $moduleType, string $builtFor, array $categories = [], array $tags = []); static forNode(Block $node, ModuleCatalog $catalog, string $title, bool $global, string $builtFor): self|string; withTerms(array $categories, array $tags): self; terms(): array<string, list<int|string>>; meta(): array<string, string> }`
|
||
- `DiviLibraryStore::create(LibraryItemSpec $spec): int` (wirft `RuntimeException`, löscht bei Teilfehlern), `DiviLibraryStore::delete(int $id): bool`
|
||
- `LibraryAccess::canSave(): ?WP_Error`
|
||
- `final class LibrarySaveAbility implements Ability { __construct(LibraryAccess $access, DiviPageLoader $loader, DiviWriter $writer, DiviSaver $saver, ChangeLog $log, DiviModules $modules) }` – `lit/library-save`, indirekt, schreibend (nicht idempotent); Ergebnis `ToolResult` + `library_id`, `tree_rev`.
|
||
- `LibraryIntegration::__construct(LibraryAccess $access, DiviPageLoader $loader, DesignSystemReader $design, DiviWriter $writer, DiviSaver $saver, ChangeLog $log, DiviModules $modules)`
|
||
|
||
- [ ] **Step 1: Failing tests schreiben**
|
||
|
||
`tests/Unit/Integrations/Divi/Library/LibraryItemSpecTest.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Tests\Unit\Integrations\Divi\Library;
|
||
|
||
use LIT\MCP\Integrations\Divi\BlockTree\Block;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\LibraryContent;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\NodeIndex;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\Parser;
|
||
use LIT\MCP\Integrations\Divi\Library\LibraryItemSpec;
|
||
use LIT\MCP\Tests\Support\DiviFixtures;
|
||
use PHPUnit\Framework\TestCase;
|
||
|
||
final class LibraryItemSpecTest extends TestCase
|
||
{
|
||
private static function pageNode(string $id): Block
|
||
{
|
||
return NodeIndex::build((new Parser())->parse(DiviFixtures::markup('stage3/page--globale-instanzen.html')))
|
||
->find($id);
|
||
}
|
||
|
||
private static function libraryRoot(string $file): Block
|
||
{
|
||
return LibraryContent::roots(LibraryContent::load(new Parser(), DiviFixtures::markup('stage3/' . $file)))[0];
|
||
}
|
||
|
||
/** @return array<string, array{string, bool}> Fixture role => [node source, global]. */
|
||
public static function builderEntries(): array
|
||
{
|
||
return [
|
||
'library--library-abschnitt' => ['page:s1', false],
|
||
'library--library-zeile' => ['page:s1.r0', false],
|
||
'library--library-modul' => ['page:s1.r0.c0.m0', false],
|
||
'library-global--globaler-abschnitt' => ['library:library-global--globaler-abschnitt.html', true],
|
||
'library-global--globales-modul' => ['library:library-global--globales-modul.html', true],
|
||
];
|
||
}
|
||
|
||
/**
|
||
* Terms and meta as Divi's own "add to library" wrote them (fixtures stage3, JSON of each entry),
|
||
* without Divi's broken _et_pb_row_layout ("[object Object]", finding 5).
|
||
*
|
||
* @dataProvider builderEntries
|
||
*/
|
||
public function testTermsAndMetaMatchTheBuilderEntries(string $source, bool $global): void
|
||
{
|
||
[$kind, $ref] = explode(':', $source, 2);
|
||
$node = $kind === 'page' ? self::pageNode($ref) : self::libraryRoot($ref);
|
||
$role = (string) $this->dataName();
|
||
$json = json_decode(DiviFixtures::markup('stage3/' . $role . '.json'), true);
|
||
|
||
$spec = LibraryItemSpec::forNode($node, DiviFixtures::catalog(), 'Titel', $global, 'page');
|
||
|
||
self::assertInstanceOf(LibraryItemSpec::class, $spec);
|
||
$expectedTerms = [];
|
||
foreach (['scope', 'layout_type', 'module_width'] as $taxonomy) {
|
||
$expectedTerms[$taxonomy] = array_column($json['terms'][$taxonomy], 'slug');
|
||
}
|
||
self::assertEquals($expectedTerms, $spec->terms());
|
||
$expectedMeta = array_map(static fn (array $values): string => $values[0], $json['meta']);
|
||
unset($expectedMeta['_et_pb_row_layout']);
|
||
self::assertEquals($expectedMeta, $spec->meta());
|
||
}
|
||
|
||
public function testRefusesInstancesColumnsAndGlobalsInsideGlobals(): void
|
||
{
|
||
$catalog = DiviFixtures::catalog();
|
||
|
||
self::assertStringContainsString(
|
||
'bereits ein globales Modul (Bibliothekseintrag 1058)',
|
||
(string) LibraryItemSpec::forNode(self::pageNode('g0'), $catalog, 'T', false, 'page')
|
||
);
|
||
self::assertStringContainsString(
|
||
'nur Abschnitte, Zeilen und Module',
|
||
(string) LibraryItemSpec::forNode(self::pageNode('s1.r0.c0'), $catalog, 'T', false, 'page')
|
||
);
|
||
self::assertStringContainsString(
|
||
'keine globalen Module',
|
||
(string) LibraryItemSpec::forNode(self::pageNode('s0'), $catalog, 'T', true, 'page')
|
||
);
|
||
self::assertInstanceOf(LibraryItemSpec::class, LibraryItemSpec::forNode(self::pageNode('s0'), $catalog, 'T', false, 'page'));
|
||
}
|
||
|
||
public function testFullwidthAndTerms(): void
|
||
{
|
||
$section = Block::create('divi/section', ['module' => ['advanced' => ['type' => ['desktop' => ['value' => 'fullwidth']]]]]);
|
||
|
||
$spec = LibraryItemSpec::forNode($section, DiviFixtures::catalog(), 'Kopf', false, 'page');
|
||
|
||
self::assertSame(['fullwidth'], $spec->terms()['module_width']);
|
||
self::assertSame([26], $spec->withTerms([26], [])->terms()['layout_category']);
|
||
self::assertArrayNotHasKey('layout_tag', $spec->withTerms([26], [])->terms());
|
||
}
|
||
}
|
||
```
|
||
|
||
In `DiviLibraryStoreTest`:
|
||
|
||
```php
|
||
public function testCreatesAPublishedEntryWithTermsAndMeta(): void
|
||
{
|
||
Functions\when('taxonomy_exists')->justReturn(true);
|
||
$inserted = [];
|
||
Functions\when('wp_insert_post')->alias(static function (array $data) use (&$inserted): int {
|
||
$inserted = $data;
|
||
|
||
return 2001;
|
||
});
|
||
$terms = [];
|
||
Functions\when('wp_set_object_terms')->alias(static function (int $id, array $values, string $taxonomy) use (&$terms): array {
|
||
$terms[$taxonomy] = $values;
|
||
|
||
return [1];
|
||
});
|
||
$meta = [];
|
||
Functions\when('update_post_meta')->alias(static function (int $id, string $key, string $value) use (&$meta): bool {
|
||
$meta[$key] = $value;
|
||
|
||
return true;
|
||
});
|
||
Functions\when('get_post_meta')->alias(static fn (int $id, string $key): string => $meta[$key] ?? '');
|
||
$spec = new LibraryItemSpec('Öffnungszeiten', 'module', true, 'regular', 'divi/text', 'page');
|
||
|
||
self::assertSame(2001, (new DiviLibraryStore())->create($spec));
|
||
self::assertSame(
|
||
['post_type' => 'et_pb_layout', 'post_status' => 'publish', 'post_title' => 'Öffnungszeiten', 'post_content' => ''],
|
||
$inserted
|
||
);
|
||
self::assertSame(['scope' => ['global'], 'layout_type' => ['module'], 'module_width' => ['regular']], $terms);
|
||
self::assertSame('[]', $meta['_et_pb_excluded_global_options']);
|
||
}
|
||
|
||
public function testAFailedStepDeletesTheNewEntry(): void
|
||
{
|
||
Functions\when('taxonomy_exists')->justReturn(true);
|
||
Functions\when('wp_insert_post')->justReturn(2001);
|
||
Functions\when('wp_set_object_terms')->justReturn(new \WP_Error('invalid_taxonomy', 'Ungültige Taxonomie.'));
|
||
Functions\expect('wp_delete_post')->once()->with(2001, true)->andReturn(new WP_Post(['ID' => 2001]));
|
||
|
||
$this->expectException(\RuntimeException::class);
|
||
(new DiviLibraryStore())->create(new LibraryItemSpec('X', 'section', false, 'regular', null, 'page'));
|
||
}
|
||
|
||
public function testRefusesWhenTheLibraryTaxonomiesAreMissing(): void
|
||
{
|
||
Functions\when('taxonomy_exists')->justReturn(false);
|
||
Functions\expect('wp_insert_post')->never();
|
||
|
||
$this->expectException(\RuntimeException::class);
|
||
(new DiviLibraryStore())->create(new LibraryItemSpec('X', 'section', false, 'regular', null, 'page'));
|
||
}
|
||
```
|
||
|
||
(Import `LibraryItemSpec`. Die Stubs aus `setUp()` für `get_post_meta` werden im ersten Test per `Functions\when` überschrieben.)
|
||
|
||
In `LibraryAccessTest`:
|
||
|
||
```php
|
||
public function testSavingNeedsPublishPostsSaveLibraryAndAWritableGroup(): void
|
||
{
|
||
LibraryFixtures::given([]);
|
||
self::assertNull(LibraryFixtures::access()->canSave());
|
||
|
||
LibraryFixtures::given([], ['publish_posts']);
|
||
self::assertToolError(LibraryFixtures::access()->canSave(), 'forbidden');
|
||
|
||
LibraryFixtures::given([]);
|
||
self::assertToolError(LibraryFixtures::access(['save_library'])->canSave(), 'forbidden');
|
||
self::assertToolError(LibraryFixtures::access([], false)->canSave(), 'forbidden');
|
||
}
|
||
```
|
||
|
||
`tests/Unit/Integrations/Divi/Library/LibrarySaveAbilityTest.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Tests\Unit\Integrations\Divi\Library;
|
||
|
||
use Brain\Monkey\Functions;
|
||
use LIT\MCP\Abilities\Rev;
|
||
use LIT\MCP\Integrations\Divi\Library\LibraryItemSpec;
|
||
use LIT\MCP\Integrations\Divi\Library\LibrarySaveAbility;
|
||
use LIT\MCP\Integrations\Divi\Pages\DiviSaver;
|
||
use LIT\MCP\Integrations\Divi\Pages\SaveScope;
|
||
use LIT\MCP\Tests\Support\DiviFixtures;
|
||
use LIT\MCP\Tests\Support\DiviWriterFixture;
|
||
use LIT\MCP\Tests\Support\FakeChangeLog;
|
||
use LIT\MCP\Tests\Support\LibraryFixtures;
|
||
use LIT\MCP\Tests\Unit\TestCase;
|
||
use Mockery;
|
||
use RuntimeException;
|
||
use WP_Post;
|
||
use WP_Term;
|
||
|
||
final class LibrarySaveAbilityTest extends TestCase
|
||
{
|
||
private WP_Post $page;
|
||
|
||
/** @var list<LibraryItemSpec> */
|
||
private array $specs = [];
|
||
|
||
/** @var list<array{int, string, SaveScope}> */
|
||
private array $contents = [];
|
||
|
||
private int $deleted = 0;
|
||
|
||
private FakeChangeLog $log;
|
||
|
||
protected function setUp(): void
|
||
{
|
||
parent::setUp();
|
||
$this->page = LibraryFixtures::page(DiviFixtures::markup('stage3/page--globale-instanzen.html'));
|
||
LibraryFixtures::given([$this->page]);
|
||
Functions\when('get_term_by')->alias(static fn (string $field, string $name, string $taxonomy): WP_Term|false => $name === 'Fixture'
|
||
? new WP_Term(['term_id' => 26, 'name' => 'Fixture', 'taxonomy' => $taxonomy])
|
||
: false);
|
||
$this->log = new FakeChangeLog(4711);
|
||
}
|
||
|
||
/** @param list<string> $deniedRoles */
|
||
private function ability(array $deniedRoles = [], bool $writable = true, ?\Throwable $layoutFailure = null): LibrarySaveAbility
|
||
{
|
||
$store = LibraryFixtures::store();
|
||
$store->allows('create')->andReturnUsing(function (LibraryItemSpec $spec): int {
|
||
$this->specs[] = $spec;
|
||
|
||
return 2001;
|
||
});
|
||
$store->allows('delete')->andReturnUsing(function (int $id): bool {
|
||
++$this->deleted;
|
||
|
||
return true;
|
||
});
|
||
$saver = Mockery::mock(DiviSaver::class);
|
||
$saver->allows('saveNew')->andReturnUsing(function (int $id, string $content, SaveScope $scope) use ($layoutFailure): array {
|
||
if ($layoutFailure !== null) {
|
||
throw $layoutFailure;
|
||
}
|
||
$this->contents[] = [$id, $content, $scope];
|
||
LibraryFixtures::given([$this->page, LibraryFixtures::item(1055, ['ID' => 2001, 'post_content' => $content])]);
|
||
|
||
return [];
|
||
});
|
||
$access = LibraryFixtures::access($deniedRoles, $writable, $store);
|
||
$saved = [];
|
||
$failures = [];
|
||
|
||
return new LibrarySaveAbility(
|
||
$access,
|
||
LibraryFixtures::loader($access),
|
||
DiviWriterFixture::writer($saved, $failures, false, LibraryFixtures::loader($access)),
|
||
$saver,
|
||
$this->log,
|
||
DiviWriterFixture::modules()
|
||
);
|
||
}
|
||
|
||
/** @return array<string, mixed> */
|
||
private function input(array $extra = []): array
|
||
{
|
||
return array_merge(
|
||
['post_id' => 7, 'tree_rev' => Rev::of((string) $this->page->post_content), 'id' => 's1', 'title' => 'Leistungen'],
|
||
$extra
|
||
);
|
||
}
|
||
|
||
public function testSavesASectionLikeTheBuilder(): void
|
||
{
|
||
$result = $this->ability()->execute($this->input(['categories' => ['Fixture']]));
|
||
|
||
self::assertTrue($result['ok']);
|
||
self::assertSame(2001, $result['library_id']);
|
||
self::assertSame('section', $this->specs[0]->layoutType);
|
||
self::assertSame([26], $this->specs[0]->terms()['layout_category']);
|
||
self::assertSame(
|
||
str_replace("\r\n", "\n", DiviFixtures::markup('stage3/library--library-abschnitt.html')),
|
||
$this->contents[0][1]
|
||
);
|
||
self::assertSame(SaveScope::LibraryItem, $this->contents[0][2]);
|
||
self::assertSame(Rev::of($this->contents[0][1]), $result['tree_rev']);
|
||
self::assertSame('et_pb_layout', $this->log->records[0]['object_type']);
|
||
self::assertSame('2001', $this->log->records[0]['object_id']);
|
||
}
|
||
|
||
public function testSavesAGlobalModule(): void
|
||
{
|
||
$result = $this->ability()->execute($this->input(['id' => 's0.r0.c0.m0', 'title' => 'Kontakt-Button', 'scope' => 'global']));
|
||
|
||
self::assertTrue($result['ok']);
|
||
self::assertTrue($this->specs[0]->global);
|
||
self::assertSame('divi/button', $this->specs[0]->meta()['_et_pb_module_type']);
|
||
self::assertSame('[]', $this->specs[0]->meta()['_et_pb_excluded_global_options']);
|
||
}
|
||
|
||
public function testRefusesAGlobalInstanceAndColumnsAndCreatesNothing(): void
|
||
{
|
||
self::assertToolError($this->ability()->execute($this->input(['id' => 'g0'])), 'validation_failed');
|
||
self::assertToolError($this->ability()->execute($this->input(['id' => 's1.r0.c0'])), 'validation_failed');
|
||
self::assertSame([], $this->specs);
|
||
}
|
||
|
||
public function testStaleSourceTreeRevCreatesNothing(): void
|
||
{
|
||
self::assertToolError($this->ability()->execute($this->input(['tree_rev' => 'abcdef012345'])), 'rev_mismatch');
|
||
self::assertSame([], $this->specs);
|
||
}
|
||
|
||
public function testNeedsPublishPostsAndTheDiviRole(): void
|
||
{
|
||
self::assertToolError($this->ability(['save_library'])->permission($this->input()), 'forbidden');
|
||
self::assertToolError($this->ability([], false)->permission($this->input()), 'forbidden');
|
||
LibraryFixtures::given([$this->page], ['publish_posts']);
|
||
self::assertToolError($this->ability()->permission($this->input()), 'forbidden');
|
||
self::assertSame([], $this->specs);
|
||
}
|
||
|
||
public function testEditorCannotSaveACodeModule(): void
|
||
{
|
||
$this->page = LibraryFixtures::page(
|
||
'<!-- wp:divi/placeholder --><!-- wp:divi/section --><!-- wp:divi/row --><!-- wp:divi/column -->'
|
||
. '<!-- wp:divi/code {"content":{"innerContent":{"desktop":{"value":"<b>x</b>"}}}} /-->'
|
||
. '<!-- /wp:divi/column --><!-- /wp:divi/row --><!-- /wp:divi/section --><!-- /wp:divi/placeholder -->'
|
||
);
|
||
LibraryFixtures::given([$this->page]);
|
||
|
||
$result = $this->ability()->execute($this->input(['id' => 's0']));
|
||
|
||
self::assertToolError($result, 'validation_failed');
|
||
self::assertStringContainsString('Code-Modul', implode(' ', \LIT\MCP\Abilities\Errors::fieldsOf($result)));
|
||
self::assertSame([], $this->specs);
|
||
}
|
||
|
||
public function testUnknownCategoryCreatesNothing(): void
|
||
{
|
||
$result = $this->ability()->execute($this->input(['categories' => ['Gibt es nicht']]));
|
||
|
||
self::assertToolError($result, 'validation_failed');
|
||
self::assertSame([], $this->specs);
|
||
}
|
||
|
||
public function testFailedLayoutWriteDeletesTheEntry(): void
|
||
{
|
||
$log = (string) tempnam(sys_get_temp_dir(), 'lit-log');
|
||
$previous = ini_set('error_log', $log);
|
||
try {
|
||
$result = $this->ability([], true, new RuntimeException('hook failed'))->execute($this->input());
|
||
} finally {
|
||
ini_set('error_log', (string) $previous);
|
||
@unlink($log);
|
||
}
|
||
|
||
self::assertToolError($result, 'write_failed');
|
||
self::assertSame(1, $this->deleted);
|
||
}
|
||
}
|
||
```
|
||
|
||
In `DiviIntegrationTest::testProvidesTheLibraryGroup` die erwartete Liste auf `['lit/library-list', 'lit/library-save']` erweitern.
|
||
|
||
- [ ] **Step 2: Tests laufen lassen – schlagen fehl**
|
||
|
||
Run: `vendor/bin/phpunit --filter 'LibraryItemSpecTest|DiviLibraryStoreTest|LibraryAccessTest|LibrarySaveAbilityTest|DiviIntegrationTest'`
|
||
Expected: FAIL (`LibraryItemSpec`, `create`, `canSave`, `LibrarySaveAbility` fehlen)
|
||
|
||
- [ ] **Step 3: Implementieren**
|
||
|
||
`src/Integrations/Divi/Library/LibraryItemSpec.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Integrations\Divi\Library;
|
||
|
||
use LIT\MCP\Integrations\Divi\BlockTree\AttrMap;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\Block;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\LibraryContent;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\NodeSummary;
|
||
use LIT\MCP\Integrations\Divi\Schema\ModuleCatalog;
|
||
|
||
defined('ABSPATH') || exit;
|
||
|
||
/**
|
||
* Title, terms and meta of a new library entry, like Divi's et_pb_submit_layout() writes them
|
||
* (builder/shortcode-core.php:654-734; compared with the real builder entries, fixtures stage3):
|
||
* terms scope (global / non_global), layout_type, module_width, optional layout_category/layout_tag;
|
||
* meta _et_pb_module_type (modules), _et_pb_excluded_global_options = "[]" (global modules),
|
||
* _et_pb_built_for_post_type, _et_pb_template_type. _et_pb_row_layout is left out – Divi 5.2.1 stores
|
||
* "[object Object]" there (finding 5). Pure PHP.
|
||
*/
|
||
final class LibraryItemSpec
|
||
{
|
||
private const MODULE_CATEGORIES = ['module', 'fullwidth-module'];
|
||
|
||
/**
|
||
* @param list<int> $categories layout_category term IDs.
|
||
* @param list<int> $tags layout_tag term IDs.
|
||
*/
|
||
public function __construct(
|
||
public readonly string $title,
|
||
public readonly string $layoutType,
|
||
public readonly bool $global,
|
||
public readonly string $moduleWidth,
|
||
public readonly ?string $moduleType,
|
||
public readonly string $builtFor,
|
||
public readonly array $categories = [],
|
||
public readonly array $tags = []
|
||
) {
|
||
}
|
||
|
||
/**
|
||
* The entry that holds $node, or the German reason it cannot be saved: sections, rows and
|
||
* modules only (Divi's "add to library"); a global module is already an entry; a global entry
|
||
* holds no global module (F10).
|
||
*/
|
||
public static function forNode(
|
||
Block $node,
|
||
ModuleCatalog $catalog,
|
||
string $title,
|
||
bool $global,
|
||
string $builtFor
|
||
): self|string {
|
||
$ref = NodeSummary::globalRef($node);
|
||
if ($ref !== null) {
|
||
return sprintf(
|
||
'Dieser Knoten ist bereits ein globales Modul (Bibliothekseintrag %s); ihn mit lit-library-insert '
|
||
. 'einfügen statt erneut speichern.',
|
||
$ref['id']
|
||
);
|
||
}
|
||
|
||
$name = $node->name();
|
||
if ($name === 'divi/section') {
|
||
$type = 'section';
|
||
$width = AttrMap::desktop($node->attrs(), 'module.advanced.type') === 'fullwidth' ? 'fullwidth' : 'regular';
|
||
} elseif ($name === 'divi/row') {
|
||
$type = 'row';
|
||
$width = 'regular';
|
||
} elseif ($catalog->has($name) && in_array($catalog->category($name), self::MODULE_CATEGORIES, true)) {
|
||
$type = 'module';
|
||
$width = $catalog->category($name) === 'fullwidth-module' ? 'fullwidth' : 'regular';
|
||
} else {
|
||
return sprintf(
|
||
'%s lässt sich nicht einzeln in der Bibliothek speichern (nur Abschnitte, Zeilen und Module).',
|
||
$name
|
||
);
|
||
}
|
||
|
||
if ($global && LibraryContent::containsGlobal($node)) {
|
||
return 'Ein globaler Bibliothekseintrag darf keine globalen Module enthalten (Divi erlaubt keine '
|
||
. 'Verschachtelung); als normalen Eintrag speichern.';
|
||
}
|
||
|
||
return new self($title, $type, $global, $width, $type === 'module' ? $name : null, $builtFor);
|
||
}
|
||
|
||
/**
|
||
* @param list<int> $categories
|
||
* @param list<int> $tags
|
||
*/
|
||
public function withTerms(array $categories, array $tags): self
|
||
{
|
||
return new self(
|
||
$this->title,
|
||
$this->layoutType,
|
||
$this->global,
|
||
$this->moduleWidth,
|
||
$this->moduleType,
|
||
$this->builtFor,
|
||
$categories,
|
||
$tags
|
||
);
|
||
}
|
||
|
||
/** @return array<string, list<int|string>> Taxonomy => slugs (system terms) or term IDs. */
|
||
public function terms(): array
|
||
{
|
||
$terms = [
|
||
'scope' => [$this->global ? 'global' : 'non_global'],
|
||
'layout_type' => [$this->layoutType],
|
||
'module_width' => [$this->moduleWidth],
|
||
];
|
||
if ($this->categories !== []) {
|
||
$terms['layout_category'] = $this->categories;
|
||
}
|
||
if ($this->tags !== []) {
|
||
$terms['layout_tag'] = $this->tags;
|
||
}
|
||
|
||
return $terms;
|
||
}
|
||
|
||
/** @return array<string, string> */
|
||
public function meta(): array
|
||
{
|
||
$meta = [];
|
||
if ($this->moduleType !== null) {
|
||
$meta['_et_pb_module_type'] = $this->moduleType;
|
||
}
|
||
if ($this->global && $this->layoutType === 'module') {
|
||
$meta['_et_pb_excluded_global_options'] = '[]';
|
||
}
|
||
$meta['_et_pb_built_for_post_type'] = $this->builtFor;
|
||
$meta['_et_pb_template_type'] = $this->layoutType;
|
||
|
||
return $meta;
|
||
}
|
||
}
|
||
```
|
||
|
||
`DiviLibraryStore` – neue Methoden (Imports `RuntimeException`, `WP_Error`):
|
||
|
||
```php
|
||
/**
|
||
* A published entry with the terms and meta of $spec and empty content (E4; the layout follows
|
||
* through DiviSaver::saveNew()). All or nothing: when a term or meta write fails, the entry is
|
||
* deleted again before the exception leaves.
|
||
*
|
||
* @throws RuntimeException
|
||
*/
|
||
public function create(LibraryItemSpec $spec): int
|
||
{
|
||
$missing = $this->missingTaxonomies();
|
||
if ($missing !== []) {
|
||
throw new RuntimeException('Divi Library taxonomies not registered: ' . implode(', ', $missing));
|
||
}
|
||
|
||
$id = wp_insert_post(wp_slash([
|
||
'post_type' => self::POST_TYPE,
|
||
'post_status' => 'publish',
|
||
'post_title' => $spec->title,
|
||
'post_content' => '',
|
||
]), true);
|
||
if ($id instanceof WP_Error || (int) $id <= 0) {
|
||
throw new RuntimeException(
|
||
'wp_insert_post refused the library entry: ' . ($id instanceof WP_Error ? $id->get_error_message() : '0')
|
||
);
|
||
}
|
||
|
||
$id = (int) $id;
|
||
try {
|
||
foreach ($spec->terms() as $taxonomy => $terms) {
|
||
$result = wp_set_object_terms($id, $terms, $taxonomy);
|
||
if ($result instanceof WP_Error) {
|
||
throw new RuntimeException(sprintf('terms %s: %s', $taxonomy, $result->get_error_message()));
|
||
}
|
||
}
|
||
foreach ($spec->meta() as $key => $value) {
|
||
update_post_meta($id, $key, $value);
|
||
if ((string) get_post_meta($id, $key, true) !== $value) {
|
||
throw new RuntimeException(sprintf('meta %s of library entry %d not stored', $key, $id));
|
||
}
|
||
}
|
||
} catch (RuntimeException $e) {
|
||
$this->delete($id);
|
||
throw $e;
|
||
}
|
||
|
||
return $id;
|
||
}
|
||
|
||
/** Deletes an entry for good (only this plugin's own, just created entries). */
|
||
public function delete(int $id): bool
|
||
{
|
||
return (bool) wp_delete_post($id, true);
|
||
}
|
||
```
|
||
|
||
`LibraryAccess::canSave()`:
|
||
|
||
```php
|
||
/**
|
||
* Creating an entry: canList(), publish_posts of et_pb_layout (library entries are always
|
||
* published, F2), the role option save_library and the Tools-tab gate.
|
||
*/
|
||
public function canSave(): ?WP_Error
|
||
{
|
||
$refusal = $this->canList();
|
||
if ($refusal !== null) {
|
||
return $refusal;
|
||
}
|
||
|
||
$type = get_post_type_object(DiviLibraryStore::POST_TYPE);
|
||
$publish = is_object($type) && isset($type->cap->publish_posts) ? (string) $type->cap->publish_posts : 'publish_posts';
|
||
if (! current_user_can($publish)) {
|
||
return Errors::forbidden('Keine Berechtigung, Einträge der Divi-Bibliothek anzulegen (publish_posts).');
|
||
}
|
||
|
||
return $this->roles->refusal('save_library') ?? $this->writableGate();
|
||
}
|
||
```
|
||
|
||
`src/Integrations/Divi/Library/LibrarySaveAbility.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Integrations\Divi\Library;
|
||
|
||
use LIT\MCP\Abilities\Ability;
|
||
use LIT\MCP\Abilities\Annotations;
|
||
use LIT\MCP\Abilities\Errors;
|
||
use LIT\MCP\Abilities\Rev;
|
||
use LIT\MCP\Abilities\ToolResult;
|
||
use LIT\MCP\ChangeLog\ChangeLog;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\LibraryContent;
|
||
use LIT\MCP\Integrations\Divi\Pages\DiviErrors;
|
||
use LIT\MCP\Integrations\Divi\Pages\DiviPage;
|
||
use LIT\MCP\Integrations\Divi\Pages\DiviPageLoader;
|
||
use LIT\MCP\Integrations\Divi\Pages\DiviSaver;
|
||
use LIT\MCP\Integrations\Divi\Pages\DiviWriter;
|
||
use LIT\MCP\Integrations\Divi\Pages\SaveScope;
|
||
use LIT\MCP\Integrations\Divi\Schema\DiviModules;
|
||
use LIT\MCP\Integrations\WordPress\PostSaveFollowUp;
|
||
use LIT\MCP\Log;
|
||
use RuntimeException;
|
||
use Throwable;
|
||
use WP_Error;
|
||
use WP_Term;
|
||
|
||
defined('ABSPATH') || exit;
|
||
|
||
/**
|
||
* lit/library-save: a node of a Divi page (or library entry) becomes a new Divi Library entry,
|
||
* normal or global (spec §5.7, E4). The entry gets the unchanged bytes of the node in the
|
||
* divi/placeholder frame (LibraryContent::wrap), saved through DiviSaver::saveNew (the one content
|
||
* write, D7); the stored node is checked by StoredNodeGuard (E6) because it moves to another post.
|
||
* The source stays as it is. All or nothing: any failure deletes the new entry.
|
||
*/
|
||
final class LibrarySaveAbility implements Ability
|
||
{
|
||
private const TYPE_LABELS = ['section' => 'Abschnitt', 'row' => 'Zeile', 'module' => 'Modul'];
|
||
|
||
public function __construct(
|
||
private LibraryAccess $access,
|
||
private DiviPageLoader $loader,
|
||
private DiviWriter $writer,
|
||
private DiviSaver $saver,
|
||
private ChangeLog $log,
|
||
private DiviModules $modules
|
||
) {
|
||
}
|
||
|
||
public function name(): string
|
||
{
|
||
return 'lit/library-save';
|
||
}
|
||
|
||
public function label(): string
|
||
{
|
||
return 'In der Divi-Bibliothek speichern';
|
||
}
|
||
|
||
public function description(): string
|
||
{
|
||
return 'Speichert einen Divi-Knoten (Abschnitt, Zeile oder Modul) als neuen Eintrag der Divi-Bibliothek – '
|
||
. 'normal oder global (scope). Der Knoten auf der Seite bleibt unverändert. post_id, tree_rev und die '
|
||
. 'Pfad-ID aus lit-divi-outline; Kategorien und Schlagwörter nur vorhandene. Globale Einträge mit '
|
||
. 'lit-library-insert (mode "global") auf Seiten einfügen.';
|
||
}
|
||
|
||
public function inputSchema(): array
|
||
{
|
||
return [
|
||
'type' => 'object',
|
||
'properties' => [
|
||
'post_id' => ['type' => 'integer', 'minimum' => 1, 'description' => 'Seite (oder Eintrag) mit dem Knoten.'],
|
||
'tree_rev' => ['type' => 'string', 'description' => 'tree_rev aus lit-divi-outline dieser Seite.'],
|
||
'id' => ['type' => 'string', 'description' => 'Pfad-ID des Knotens, z. B. "s1".'],
|
||
'title' => ['type' => 'string', 'minLength' => 1, 'maxLength' => 200],
|
||
'scope' => ['type' => 'string', 'enum' => ['normal', 'global'], 'description' => 'Standard: normal.'],
|
||
'categories' => ['type' => 'array', 'maxItems' => 10, 'items' => ['type' => 'string']],
|
||
'tags' => ['type' => 'array', 'maxItems' => 10, 'items' => ['type' => 'string']],
|
||
],
|
||
'required' => ['post_id', 'tree_rev', 'id', 'title'],
|
||
'additionalProperties' => false,
|
||
];
|
||
}
|
||
|
||
public function outputSchema(): ?array
|
||
{
|
||
return ToolResult::schema(
|
||
['library_id' => ['type' => 'integer'], 'tree_rev' => ['type' => 'string']],
|
||
['library_id', 'tree_rev']
|
||
);
|
||
}
|
||
|
||
public function annotations(): array
|
||
{
|
||
return Annotations::write(false);
|
||
}
|
||
|
||
public function isDirect(): bool
|
||
{
|
||
return false;
|
||
}
|
||
|
||
public function permission(array $input): bool|WP_Error
|
||
{
|
||
$refusal = $this->access->canSave();
|
||
if ($refusal !== null) {
|
||
return $refusal;
|
||
}
|
||
|
||
$page = $this->loader->load($input['post_id'] ?? null, false);
|
||
|
||
return $page instanceof WP_Error ? $page : true;
|
||
}
|
||
|
||
public function execute(array $input): mixed
|
||
{
|
||
$refusal = $this->access->canSave();
|
||
if ($refusal !== null) {
|
||
return $refusal;
|
||
}
|
||
|
||
$page = $this->loader->load($input['post_id'] ?? null, false);
|
||
if ($page instanceof WP_Error) {
|
||
return $page;
|
||
}
|
||
|
||
if (! is_string($input['tree_rev'] ?? null) || $input['tree_rev'] !== $page->treeRev()) {
|
||
return Errors::revMismatch(
|
||
'Die Seite wurde seit dem letzten Lesen geändert (tree_rev passt nicht); nichts wurde angelegt.',
|
||
DiviPageLoader::OUTLINE_HINT
|
||
);
|
||
}
|
||
|
||
$id = is_string($input['id'] ?? null) ? $input['id'] : '';
|
||
$node = $page->index->find($id);
|
||
if ($node === null) {
|
||
return DiviErrors::unknownNode($id, $page->post);
|
||
}
|
||
|
||
$title = sanitize_text_field(is_string($input['title'] ?? null) ? $input['title'] : '');
|
||
if ($title === '') {
|
||
return Errors::invalidInput('Titel fehlt; nichts wurde angelegt.', ['title' => 'nicht leer']);
|
||
}
|
||
|
||
$spec = LibraryItemSpec::forNode(
|
||
$node,
|
||
$this->modules->catalog(),
|
||
$title,
|
||
($input['scope'] ?? 'normal') === 'global',
|
||
(string) $page->post->post_type
|
||
);
|
||
if (is_string($spec)) {
|
||
return Errors::invalidInput($spec . ' Nichts wurde angelegt.', ['id' => $spec]);
|
||
}
|
||
|
||
$problems = $this->writer->composition($page)->storedGuard()->problems($node);
|
||
if ($problems !== []) {
|
||
return Errors::invalidInput(
|
||
'Der Knoten enthält Einstellungen, die nur im Divi-Builder übertragen werden dürfen; nichts wurde angelegt.',
|
||
['id' => implode('; ', $problems)]
|
||
);
|
||
}
|
||
|
||
$categories = $this->termIds('layout_category', $input['categories'] ?? []);
|
||
$tags = $this->termIds('layout_tag', $input['tags'] ?? []);
|
||
foreach (['categories' => $categories, 'tags' => $tags] as $field => $ids) {
|
||
if (is_string($ids)) {
|
||
return Errors::invalidInput('Unbekannte Kategorie oder unbekanntes Schlagwort; nichts wurde angelegt.', [
|
||
$field => $ids,
|
||
]);
|
||
}
|
||
}
|
||
|
||
return $this->create($page, $spec->withTerms($categories, $tags), LibraryContent::wrap($node), $input);
|
||
}
|
||
|
||
/**
|
||
* @param array<string, mixed> $input
|
||
* @return array<string, mixed>|WP_Error
|
||
*/
|
||
private function create(DiviPage $page, LibraryItemSpec $spec, string $content, array $input): array|WP_Error
|
||
{
|
||
try {
|
||
$libraryId = $this->access->store()->create($spec);
|
||
} catch (RuntimeException $e) {
|
||
Log::failure('lit/library-save create', $e);
|
||
|
||
return Errors::writeFailed('Der Bibliothekseintrag konnte nicht angelegt werden.');
|
||
}
|
||
|
||
try {
|
||
$warnings = $this->saver->saveNew($libraryId, $content, SaveScope::LibraryItem);
|
||
} catch (Throwable $e) {
|
||
Log::failure('lit/library-save layout', $e);
|
||
if (! $this->access->store()->delete($libraryId)) {
|
||
return Errors::partialWrite('Der Inhalt des Bibliothekseintrags konnte nicht gespeichert werden.', $libraryId);
|
||
}
|
||
|
||
return Errors::writeFailed('Der Inhalt des Bibliothekseintrags konnte nicht gespeichert werden.');
|
||
}
|
||
|
||
$followUp = (new PostSaveFollowUp($this->name(), $this->log, $libraryId, 'der Bibliothekseintrag', $warnings))
|
||
->afterSave($input);
|
||
$created = $followUp->reread();
|
||
$kind = (self::TYPE_LABELS[$spec->layoutType] ?? $spec->layoutType) . ($spec->global ? ', global' : '');
|
||
$followUp->log(
|
||
DiviLibraryStore::POST_TYPE,
|
||
sprintf('Bibliothek: „%s“ angelegt (%s) aus Eintrag %d', $spec->title, $kind, (int) $page->post->ID)
|
||
);
|
||
|
||
$result = $followUp->result(sprintf('Bibliothekseintrag „%s“ angelegt (%s).', $spec->title, $kind), $created)
|
||
->with('library_id', $libraryId)
|
||
->with('tree_rev', Rev::of($created !== null ? (string) $created->post_content : $content))
|
||
->urls(null, (string) get_edit_post_link($libraryId, 'raw'));
|
||
if ($spec->global) {
|
||
$result->warning(
|
||
'Der Knoten auf der Seite bleibt eine eigenständige Kopie; verknüpfte Instanzen mit lit-library-insert '
|
||
. '(mode "global") einfügen.'
|
||
);
|
||
}
|
||
|
||
return $result->toArray();
|
||
}
|
||
|
||
/** @return list<int>|string Term IDs of existing terms by name, or the problem. */
|
||
private function termIds(string $taxonomy, mixed $names): array|string
|
||
{
|
||
$ids = [];
|
||
foreach (is_array($names) ? $names : [] as $name) {
|
||
$term = is_string($name) ? get_term_by('name', $name, $taxonomy) : false;
|
||
if (! $term instanceof WP_Term) {
|
||
return sprintf(
|
||
'„%s“ gibt es nicht; nur vorhandene Begriffe (neue in der Divi-Bibliothek anlegen).',
|
||
is_string($name) ? $name : '?'
|
||
);
|
||
}
|
||
$ids[] = (int) $term->term_id;
|
||
}
|
||
|
||
return $ids;
|
||
}
|
||
}
|
||
```
|
||
|
||
`LibraryIntegration` – Konstruktor und `abilities()` (Imports `ChangeLog`, `DiviSaver`, `DiviWriter`):
|
||
|
||
```php
|
||
public function __construct(
|
||
private LibraryAccess $access,
|
||
private DiviPageLoader $loader,
|
||
private DesignSystemReader $design,
|
||
private DiviWriter $writer,
|
||
private DiviSaver $saver,
|
||
private ChangeLog $log,
|
||
private DiviModules $modules
|
||
) {
|
||
}
|
||
|
||
public function abilities(): array
|
||
{
|
||
return [
|
||
new LibraryListAbility($this->access, $this->loader, $this->design, new GlobalUsages()),
|
||
new LibrarySaveAbility($this->access, $this->loader, $this->writer, $this->saver, $this->log, $this->modules),
|
||
];
|
||
}
|
||
```
|
||
|
||
`DiviIntegration` – Writer-Fabrik teilen und `library()` anpassen:
|
||
|
||
```php
|
||
public function library(): LibraryIntegration
|
||
{
|
||
$loader = $this->loader();
|
||
|
||
return new LibraryIntegration(
|
||
$this->access,
|
||
$loader,
|
||
$this->design,
|
||
$this->writer($loader),
|
||
new DiviSaver(),
|
||
$this->log,
|
||
$this->modules
|
||
);
|
||
}
|
||
|
||
private function writer(DiviPageLoader $loader): DiviWriter
|
||
{
|
||
return new DiviWriter(
|
||
$loader,
|
||
new DiviSaver(),
|
||
$this->log,
|
||
$this->design,
|
||
new DiviComposition($this->modules, $this->design),
|
||
new GlobalEdits($this->access, new GlobalUsages())
|
||
);
|
||
}
|
||
```
|
||
|
||
In `abilities()` `$writer = $this->writer($loader);` statt des bisherigen `new DiviWriter(…)`.
|
||
|
||
`docs/guides/overview.md`: „Divi-Bibliothek (`lit/library-list`)“ → „Divi-Bibliothek (`lit/library-list`, `lit/library-save`)“.
|
||
|
||
- [ ] **Step 4: Tests laufen lassen**
|
||
|
||
Run: `vendor/bin/phpunit --filter 'LibraryItemSpecTest|DiviLibraryStoreTest|LibraryAccessTest|LibrarySaveAbilityTest|DiviIntegrationTest|ToolNamingTest'`
|
||
Expected: PASS
|
||
|
||
Run: `composer test && composer lint`
|
||
Expected: OK
|
||
|
||
- [ ] **Step 5: Commit**
|
||
|
||
```bash
|
||
git add src/Integrations/Divi/Library src/Integrations/Divi/DiviIntegration.php docs/guides/overview.md tests/Unit/Integrations/Divi
|
||
```
|
||
Commit wie in den Global Constraints mit der Nachricht `feat: lit/library-save creates library entries like Divi (E4)`.
|
||
|
||
---
|
||
|
||
### Task 13: `lit/library-insert` – Kopie oder globale Instanz im Builder-Format (E5, direkt)
|
||
|
||
Das einzige neue direkte Tool (22 direkte Tools). `mode` = `global` (Standard für globale Einträge) fügt die Instanz genau so ein, wie der Visual Builder sie schreibt (`GlobalInstance::of`, byte-gleich zum Fixture) – den Inhalt liefert Divi beim Rendern aus der Bibliothek (F7). `mode` = `copy` (Standard sonst) fügt die Wurzeln des Eintrags ohne `divi/placeholder` ein; bei globalen Einträgen vorher entglobalisiert wie Divis `/load` (`GlobalInstance::deglobalize`, F10). Rechte: Ziel wie `lit-divi-insert` (gleiche Sperre, alles oder nichts), dazu `add_library` (E3) und – Audit M2 – nur solange `lit/divi-insert` nicht gesperrt ist. Übernommene Knoten laufen durch `StoredNodeGuard`.
|
||
|
||
**Files:**
|
||
- Create: `src/Integrations/Divi/Library/LibraryInsertAbility.php`
|
||
- Modify: `src/Integrations/Divi/Library/LibraryAccess.php` (`canInsert()`)
|
||
- Modify: `src/Integrations/Divi/Library/LibraryIntegration.php`, `src/Integrations/Divi/DiviIntegration.php`, `src/Plugin.php`
|
||
- Modify: `docs/guides/overview.md` („Direkt sichtbar:“, Ruling Q2)
|
||
- Test: `tests/Unit/Integrations/Divi/Library/LibraryInsertAbilityTest.php`, `…/LibraryAccessTest.php`, `tests/Unit/Integrations/Divi/DiviIntegrationTest.php`
|
||
|
||
**Interfaces:**
|
||
- Consumes: `DiviWriteAbility` (Task 9: `precheck`, `commit`), `GlobalInstance::of/deglobalize`, `LibraryContent::load/roots`, `DiviComposition::storedGuard/editor`, `TreeEditor::position/insert`, `DiviSchema::write/position`.
|
||
- Produces: `LibraryAccess::canInsert(): ?WP_Error`; `final class LibraryInsertAbility extends DiviWriteAbility { __construct(DiviWriter $writer, LibraryAccess $access, ?Closure $diviWritable = null, Parser $parser = new Parser()) }` – `lit/library-insert`, direkt; `LibraryIntegration::__construct(…, DiviModules $modules, ?Closure $diviWritable = null)`; `DiviIntegration::library(?Closure $diviWritable = null)`.
|
||
|
||
- [ ] **Step 1: Failing tests schreiben**
|
||
|
||
In `LibraryAccessTest`:
|
||
|
||
```php
|
||
public function testInsertingNeedsAddLibrary(): void
|
||
{
|
||
LibraryFixtures::given([]);
|
||
|
||
self::assertNull(LibraryFixtures::access()->canInsert());
|
||
self::assertToolError(LibraryFixtures::access(['add_library'])->canInsert(), 'forbidden');
|
||
}
|
||
```
|
||
|
||
`tests/Unit/Integrations/Divi/Library/LibraryInsertAbilityTest.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Tests\Unit\Integrations\Divi\Library;
|
||
|
||
use LIT\MCP\Abilities\Rev;
|
||
use LIT\MCP\Integrations\Divi\Library\LibraryInsertAbility;
|
||
use LIT\MCP\Tests\Support\DiviFixtures;
|
||
use LIT\MCP\Tests\Support\DiviWriterFixture;
|
||
use LIT\MCP\Tests\Support\LibraryFixtures;
|
||
use LIT\MCP\Tests\Unit\TestCase;
|
||
use WP_Post;
|
||
|
||
final class LibraryInsertAbilityTest extends TestCase
|
||
{
|
||
private WP_Post $page;
|
||
|
||
/** @var list<string> */
|
||
private array $saved = [];
|
||
|
||
protected function setUp(): void
|
||
{
|
||
parent::setUp();
|
||
$this->page = LibraryFixtures::page(DiviFixtures::markup('synthetic-basic.html'));
|
||
LibraryFixtures::given(array_merge(
|
||
[$this->page],
|
||
array_map(static fn (int $id): WP_Post => LibraryFixtures::item($id), array_keys(LibraryFixtures::ITEMS))
|
||
));
|
||
}
|
||
|
||
/** @param list<string> $deniedRoles */
|
||
private function ability(array $deniedRoles = [], bool $diviWritable = true): LibraryInsertAbility
|
||
{
|
||
$access = LibraryFixtures::access($deniedRoles);
|
||
$failures = [];
|
||
|
||
return new LibraryInsertAbility(
|
||
DiviWriterFixture::writer($this->saved, $failures, false, LibraryFixtures::loader($access)),
|
||
$access,
|
||
static fn (): bool => $diviWritable
|
||
);
|
||
}
|
||
|
||
/** @return array<string, mixed> */
|
||
private function input(array $extra): array
|
||
{
|
||
return array_merge(['post_id' => 7, 'tree_rev' => Rev::of((string) $this->page->post_content)], $extra);
|
||
}
|
||
|
||
private static function fixtureInstance(int $id, string $end): string
|
||
{
|
||
$page = DiviFixtures::markup('stage3/page--globale-instanzen.html');
|
||
$start = (int) strpos($page, '<!-- wp:divi/global-layout {"globalModule":"' . $id . '"');
|
||
|
||
return substr($page, $start, (int) strpos($page, $end, $start) + strlen($end) - $start);
|
||
}
|
||
|
||
public function testInsertsAGlobalSectionExactlyLikeTheBuilder(): void
|
||
{
|
||
$result = $this->ability()->execute($this->input(['library_id' => 1058, 'after' => 's0']));
|
||
|
||
self::assertTrue($result['ok']);
|
||
self::assertStringContainsString(self::fixtureInstance(1058, '<!-- /wp:divi/global-layout -->'), $this->saved[0]);
|
||
self::assertSame('g0', $result['changed'][0]['id']);
|
||
self::assertStringContainsString('Bibliothekseintrag 1058', implode(' ', $result['warnings']));
|
||
}
|
||
|
||
public function testInsertsAGlobalModuleIntoAColumn(): void
|
||
{
|
||
$result = $this->ability()->execute($this->input(['library_id' => 1059, 'parent' => 's0.r0.c1']));
|
||
|
||
self::assertTrue($result['ok']);
|
||
self::assertStringContainsString(self::fixtureInstance(1059, '/-->'), $this->saved[0]);
|
||
}
|
||
|
||
public function testCopyInsertsTheRootsWithoutFrameAndCrlf(): void
|
||
{
|
||
$result = $this->ability()->execute($this->input(['library_id' => 1055]));
|
||
|
||
$section = str_replace(
|
||
['<!-- wp:divi/placeholder -->', '<!-- /wp:divi/placeholder -->', "\r\n"],
|
||
['', '', "\n"],
|
||
DiviFixtures::markup('stage3/library--library-abschnitt.html')
|
||
);
|
||
self::assertTrue($result['ok']);
|
||
self::assertStringContainsString($section, $this->saved[0]);
|
||
self::assertStringNotContainsString("\r", $this->saved[0]);
|
||
}
|
||
|
||
public function testLayoutCopyInsertsEverySection(): void
|
||
{
|
||
$result = $this->ability()->execute($this->input(['library_id' => 1054, 'mode' => 'copy']));
|
||
|
||
self::assertCount(3, $result['changed']);
|
||
self::assertStringContainsString('Library-Blurb', $this->saved[0]);
|
||
}
|
||
|
||
public function testGlobalModeNeedsAGlobalEntryAndUnknownEntriesAreNotFound(): void
|
||
{
|
||
self::assertToolError($this->ability()->execute($this->input(['library_id' => 1055, 'mode' => 'global'])), 'validation_failed');
|
||
self::assertToolError($this->ability()->execute($this->input(['library_id' => 9999])), 'not_found');
|
||
self::assertToolError($this->ability()->execute($this->input(['library_id' => 7])), 'not_found');
|
||
self::assertSame([], $this->saved);
|
||
}
|
||
|
||
public function testNeedsAddLibraryAndAWritableDiviGroup(): void
|
||
{
|
||
self::assertToolError($this->ability(['add_library'])->permission($this->input(['library_id' => 1058])), 'forbidden');
|
||
self::assertToolError($this->ability([], false)->permission($this->input(['library_id' => 1058])), 'unsupported');
|
||
self::assertTrue($this->ability()->isDirect());
|
||
}
|
||
|
||
public function testEditorCannotInsertAnItemWithCustomCss(): void
|
||
{
|
||
$custom = LibraryFixtures::item(1055, [
|
||
'ID' => 1080,
|
||
'post_content' => '<!-- wp:divi/placeholder --><!-- wp:divi/section {"css":{"desktop":{"value":'
|
||
. '{"freeForm":"body{display:none}"}}}} --><!-- /wp:divi/section --><!-- /wp:divi/placeholder -->',
|
||
]);
|
||
LibraryFixtures::given([$this->page, $custom]);
|
||
|
||
$result = $this->ability()->execute($this->input(['library_id' => 1080]));
|
||
|
||
self::assertToolError($result, 'validation_failed');
|
||
self::assertSame([], $this->saved);
|
||
}
|
||
}
|
||
```
|
||
|
||
In `DiviIntegrationTest::testProvidesTheLibraryGroup` die Liste auf `['lit/library-list', 'lit/library-save', 'lit/library-insert']` erweitern.
|
||
|
||
- [ ] **Step 2: Tests laufen lassen – schlagen fehl**
|
||
|
||
Run: `vendor/bin/phpunit --filter 'LibraryAccessTest|LibraryInsertAbilityTest|DiviIntegrationTest|ToolNamingTest'`
|
||
Expected: FAIL (`canInsert`, `LibraryInsertAbility` fehlen; ToolNamingTest bleibt grün, bis das Tool existiert)
|
||
|
||
- [ ] **Step 3: Implementieren**
|
||
|
||
`LibraryAccess::canInsert()`:
|
||
|
||
```php
|
||
/** Inserting from the library: canList() and the role option add_library (E3). */
|
||
public function canInsert(): ?WP_Error
|
||
{
|
||
return $this->canList() ?? $this->roles->refusal('add_library');
|
||
}
|
||
```
|
||
|
||
`src/Integrations/Divi/Library/LibraryInsertAbility.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Integrations\Divi\Library;
|
||
|
||
use Closure;
|
||
use LIT\MCP\Abilities\Annotations;
|
||
use LIT\MCP\Abilities\Errors;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\Block;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\GlobalInstance;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\LibraryContent;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\MalformedMarkup;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\Parser;
|
||
use LIT\MCP\Integrations\Divi\Pages\DiviChange;
|
||
use LIT\MCP\Integrations\Divi\Pages\DiviComposition;
|
||
use LIT\MCP\Integrations\Divi\Pages\DiviErrors;
|
||
use LIT\MCP\Integrations\Divi\Pages\DiviPage;
|
||
use LIT\MCP\Integrations\Divi\Pages\DiviSchema;
|
||
use LIT\MCP\Integrations\Divi\Pages\DiviWriteAbility;
|
||
use LIT\MCP\Integrations\Divi\Pages\DiviWriter;
|
||
use LIT\MCP\Integrations\WordPress\PostGuard;
|
||
use WP_Error;
|
||
use WP_Post;
|
||
|
||
defined('ABSPATH') || exit;
|
||
|
||
/**
|
||
* lit/library-insert (spec §5.7, E5): a Divi Library entry into a Divi page – as the global instance
|
||
* the Visual Builder writes (GlobalInstance::of; Divi renders the entry's current content, F7) or
|
||
* as an independent copy of its roots (a global entry deglobalized like Divi's /load, F10). The
|
||
* target works like lit-divi-insert (tree_rev lock, StructureRules, all or nothing, DiviWriter);
|
||
* stored nodes from the entry pass StoredNodeGuard (E6). Needs add_library (E3) and follows
|
||
* lit-divi-insert's Tools-tab state (audit M2).
|
||
*/
|
||
final class LibraryInsertAbility extends DiviWriteAbility
|
||
{
|
||
/** @param (Closure(): bool)|null $diviWritable Whether lit/divi-insert is enabled; null = always. */
|
||
public function __construct(
|
||
DiviWriter $writer,
|
||
private LibraryAccess $access,
|
||
private ?Closure $diviWritable = null,
|
||
private Parser $parser = new Parser()
|
||
) {
|
||
parent::__construct($writer);
|
||
}
|
||
|
||
public function name(): string
|
||
{
|
||
return 'lit/library-insert';
|
||
}
|
||
|
||
public function label(): string
|
||
{
|
||
return 'Aus der Divi-Bibliothek einfügen';
|
||
}
|
||
|
||
public function description(): string
|
||
{
|
||
return 'Fügt einen Eintrag der Divi-Bibliothek in eine Divi-Seite ein: mode "global" als verknüpfte Instanz '
|
||
. '(der Inhalt kommt immer aus der Bibliothek; Änderungen dort wirken auf allen Seiten) oder mode "copy" '
|
||
. 'als unabhängige Kopie. Standard: global für globale Einträge, sonst copy. Einträge über lit/library-list; '
|
||
. 'Position über parent, before oder after (Pfad-IDs aus lit-divi-outline), sonst ans Seitenende. '
|
||
. 'tree_rev ist Pflicht; alles oder nichts.';
|
||
}
|
||
|
||
public function inputSchema(): array
|
||
{
|
||
return [
|
||
'type' => 'object',
|
||
'properties' => array_merge(DiviSchema::write(), [
|
||
'library_id' => ['type' => 'integer', 'minimum' => 1, 'description' => 'ID aus lit/library-list.'],
|
||
'mode' => ['type' => 'string', 'enum' => ['copy', 'global']],
|
||
], DiviSchema::position()),
|
||
'required' => ['post_id', 'tree_rev', 'library_id'],
|
||
'additionalProperties' => false,
|
||
];
|
||
}
|
||
|
||
public function annotations(): array
|
||
{
|
||
return Annotations::write(false);
|
||
}
|
||
|
||
protected function precheck(array $input): ?WP_Error
|
||
{
|
||
$refusal = $this->access->canInsert();
|
||
if ($refusal !== null) {
|
||
return $refusal;
|
||
}
|
||
|
||
if ($this->diviWritable !== null && ! ($this->diviWritable)()) {
|
||
return Errors::unsupported(
|
||
'Divi-Änderungen sind für diese Verbindung abgeschaltet (Gruppe „Divi“ auf „nur lesen“ oder '
|
||
. 'lit-divi-insert deaktiviert).',
|
||
'Einen Administrator fragen: Einstellungen → LIT MCP → Tools.'
|
||
);
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
protected function change(DiviPage $page, array $input, DiviComposition $composition): DiviChange|WP_Error
|
||
{
|
||
$item = $this->item($input['library_id'] ?? null);
|
||
if ($item instanceof WP_Error) {
|
||
return $item;
|
||
}
|
||
|
||
$id = (int) $item->ID;
|
||
$global = $this->access->isGlobal($item);
|
||
$mode = is_string($input['mode'] ?? null) ? $input['mode'] : ($global ? 'global' : 'copy');
|
||
if ($mode === 'global' && ! $global) {
|
||
return Errors::invalidInput(
|
||
'Nur globale Bibliothekseinträge lassen sich als Instanz einfügen; nichts wurde gespeichert.',
|
||
['mode' => 'der Eintrag ist nicht global – mode "copy" verwenden']
|
||
);
|
||
}
|
||
|
||
$blocks = $this->blocks($item, $mode, $global);
|
||
if ($blocks instanceof WP_Error) {
|
||
return $blocks;
|
||
}
|
||
|
||
$guard = $composition->storedGuard();
|
||
foreach ($blocks as $block) {
|
||
$problems = $guard->problems($block);
|
||
if ($problems !== []) {
|
||
return Errors::invalidInput(
|
||
'Der Bibliothekseintrag enthält Einstellungen, die nur im Divi-Builder übertragen werden dürfen; '
|
||
. 'nichts wurde gespeichert.',
|
||
['library_id' => implode('; ', $problems)]
|
||
);
|
||
}
|
||
}
|
||
|
||
$editor = $composition->editor();
|
||
$position = $editor->position($page->index, $input);
|
||
if (is_string($position)) {
|
||
return DiviErrors::position($position);
|
||
}
|
||
|
||
$violation = $editor->insert($position, $blocks);
|
||
if ($violation !== null) {
|
||
return Errors::invalidInput(
|
||
'Der Bibliothekseintrag passt nicht an diese Stelle; nichts wurde gespeichert.',
|
||
['library_id' => $violation]
|
||
);
|
||
}
|
||
|
||
$change = new DiviChange(sprintf(
|
||
'Bibliothekseintrag „%s“ %s eingefügt',
|
||
(string) $item->post_title,
|
||
$mode === 'global' ? 'als globale Instanz' : 'als Kopie'
|
||
));
|
||
foreach ($blocks as $block) {
|
||
$change->record($block, 'inserted');
|
||
}
|
||
if ($mode === 'global') {
|
||
$change->warning(sprintf(
|
||
'Globale Instanz: den Inhalt liefert Bibliothekseintrag %d; Änderungen dort wirken auf alle Seiten mit '
|
||
. 'diesem Modul (lit-divi-outline mit post_id %d).',
|
||
$id,
|
||
$id
|
||
));
|
||
}
|
||
|
||
return $change;
|
||
}
|
||
|
||
/** The active library entry $libraryId the user may read, or the error. */
|
||
private function item(mixed $libraryId): WP_Post|WP_Error
|
||
{
|
||
$id = PostGuard::id($libraryId);
|
||
$item = $id === null ? null : get_post($id);
|
||
if (
|
||
! $item instanceof WP_Post
|
||
|| $item->post_type !== DiviLibraryStore::POST_TYPE
|
||
|| $item->post_status !== 'publish'
|
||
) {
|
||
return Errors::notFound(
|
||
sprintf('Bibliothekseintrag %s gibt es nicht (oder er ist nicht aktiv).', (string) ($id ?? '?')),
|
||
'Einträge mit lit/library-list auflisten.'
|
||
);
|
||
}
|
||
|
||
return current_user_can('read_post', (int) $item->ID)
|
||
? $item
|
||
: Errors::forbidden(sprintf('Keine Berechtigung, Bibliothekseintrag %d zu lesen.', (int) $item->ID));
|
||
}
|
||
|
||
/** @return list<Block>|WP_Error The blocks to insert. */
|
||
private function blocks(WP_Post $item, string $mode, bool $global): array|WP_Error
|
||
{
|
||
$id = (int) $item->ID;
|
||
try {
|
||
$roots = LibraryContent::roots(LibraryContent::load($this->parser, (string) $item->post_content));
|
||
} catch (MalformedMarkup) {
|
||
return Errors::unsupported(
|
||
sprintf('Bibliothekseintrag %d ist kein gültiges Block-Markup; nichts wurde gespeichert.', $id),
|
||
'Den Eintrag im Divi-Builder öffnen und speichern.'
|
||
);
|
||
}
|
||
|
||
if ($roots === []) {
|
||
return Errors::invalidInput(
|
||
sprintf('Bibliothekseintrag %d ist leer; nichts wurde gespeichert.', $id),
|
||
['library_id' => 'leer']
|
||
);
|
||
}
|
||
|
||
if ($mode === 'global') {
|
||
if (count($roots) !== 1) {
|
||
return Errors::invalidInput(
|
||
'Dieser globale Eintrag hat mehrere Wurzeln und lässt sich nur als Kopie einfügen; nichts wurde '
|
||
. 'gespeichert.',
|
||
['mode' => 'mode "copy" verwenden']
|
||
);
|
||
}
|
||
|
||
return [GlobalInstance::of($roots[0], $id)];
|
||
}
|
||
|
||
return array_map(
|
||
static fn (Block $root): Block => $global ? GlobalInstance::deglobalize($root->copy()) : $root->copy(),
|
||
$roots
|
||
);
|
||
}
|
||
}
|
||
```
|
||
|
||
`LibraryIntegration` – Konstruktor um `private ?Closure $diviWritable = null` (letzter Parameter, Import `Closure`) erweitern und in `abilities()` ergänzen:
|
||
|
||
```php
|
||
new LibraryInsertAbility($this->writer, $this->access, $this->diviWritable),
|
||
```
|
||
|
||
`DiviIntegration::library(?Closure $diviWritable = null)` reicht `$diviWritable` als letzten Parameter an `LibraryIntegration` weiter. `Plugin::boot()`: `$divi->library($diviWritable)`.
|
||
|
||
`docs/guides/overview.md` – „Direkt sichtbar:“ um `lit-library-insert` ergänzen (nach `lit-divi-delete`, Reihenfolge wie bisher, der Absatz endet mit einer Leerzeile – der ToolNamingTest liest bis dahin):
|
||
|
||
```markdown
|
||
Direkt sichtbar: `lit-guide`, `lit-site-status`, `lit-content-types`, `lit-content-query`,
|
||
`lit-content-get`, `lit-content-create`, `lit-content-update`, `lit-post-publish`, `lit-media-search`,
|
||
`lit-media-preview`, `lit-media-download`, `lit-media-upload-from-url`, `lit-page-render-summary`,
|
||
`lit-divi-outline`, `lit-divi-node-get`, `lit-divi-catalog`, `lit-divi-design-system`, `lit-divi-insert`,
|
||
`lit-divi-update`, `lit-divi-move`, `lit-divi-delete`, `lit-library-insert`.
|
||
```
|
||
|
||
- [ ] **Step 4: Tests laufen lassen**
|
||
|
||
Run: `vendor/bin/phpunit --filter 'LibraryAccessTest|LibraryInsertAbilityTest|DiviIntegrationTest|ToolNamingTest'`
|
||
Expected: PASS
|
||
|
||
Run: `composer test && composer lint`
|
||
Expected: OK
|
||
|
||
- [ ] **Step 5: Commit**
|
||
|
||
```bash
|
||
git add src/Integrations/Divi/Library src/Integrations/Divi/DiviIntegration.php src/Plugin.php docs/guides/overview.md tests/Unit/Integrations/Divi
|
||
```
|
||
Commit wie in den Global Constraints mit der Nachricht `feat: lit-library-insert as copy or global instance in the builder's format (E5)`.
|
||
|
||
---
|
||
|
||
### Task 14: `lit/divi-node-copy` – Knoten zwischen Seiten kopieren (E6)
|
||
|
||
Kopiert einen gespeicherten Knoten byte-gleich an eine Position eines anderen Posts (Seite oder Bibliothekseintrag). Quelle: Leserechte wie `lit-divi-outline` (auch Bibliothekseinträge) und die `source_tree_rev` (Pfad-IDs gelten nur für ihren Stand); Ziel: wie `lit-divi-insert` (`tree_rev`, StructureRules, alles oder nichts, bei Bibliothekszielen `GlobalEdits`). Globale Instanzen bleiben verknüpft. Die Kopie läuft durch `StoredNodeGuard` des Ziels. Gruppe „Divi“, indirekt.
|
||
|
||
**Files:**
|
||
- Create: `src/Integrations/Divi/Pages/DiviNodeCopyAbility.php`
|
||
- Modify: `src/Integrations/Divi/DiviIntegration.php`
|
||
- Modify: `docs/guides/overview.md` (indirekte Tools)
|
||
- Test: `tests/Unit/Integrations/Divi/Pages/DiviNodeCopyAbilityTest.php`, `tests/Unit/Integrations/Divi/DiviIntegrationTest.php`
|
||
|
||
**Interfaces:**
|
||
- Consumes: `DiviWriteAbility` (`precheck`, `change`, `commit`), `DiviPageLoader::load()`, `DiviComposition::storedGuard/editor`, `GlobalEdits`, `LibraryFixtures`.
|
||
- Produces: `final class DiviNodeCopyAbility extends DiviWriteAbility { __construct(DiviWriter $writer, DiviPageLoader $loader) }` – `lit/divi-node-copy`, indirekt, Eingabe `post_id`, `tree_rev`, `source_post_id`, `source_id`, `source_tree_rev`, Position.
|
||
|
||
- [ ] **Step 1: Failing tests schreiben**
|
||
|
||
`tests/Unit/Integrations/Divi/Pages/DiviNodeCopyAbilityTest.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Tests\Unit\Integrations\Divi\Pages;
|
||
|
||
use Brain\Monkey\Functions;
|
||
use LIT\MCP\Abilities\Rev;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\NodeIndex;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\Parser;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\Serializer;
|
||
use LIT\MCP\Integrations\Divi\Library\GlobalEdits;
|
||
use LIT\MCP\Integrations\Divi\Library\GlobalUsages;
|
||
use LIT\MCP\Integrations\Divi\Pages\DiviNodeCopyAbility;
|
||
use LIT\MCP\Tests\Support\DiviFixtures;
|
||
use LIT\MCP\Tests\Support\DiviWriterFixture;
|
||
use LIT\MCP\Tests\Support\LibraryFixtures;
|
||
use LIT\MCP\Tests\Unit\TestCase;
|
||
use Mockery;
|
||
use WP_Post;
|
||
|
||
final class DiviNodeCopyAbilityTest extends TestCase
|
||
{
|
||
private WP_Post $target;
|
||
private WP_Post $source;
|
||
|
||
/** @var list<string> */
|
||
private array $saved = [];
|
||
|
||
protected function setUp(): void
|
||
{
|
||
parent::setUp();
|
||
$this->target = LibraryFixtures::page(DiviFixtures::markup('synthetic-basic.html'));
|
||
$this->source = LibraryFixtures::page(
|
||
DiviFixtures::markup('stage3/page--globale-instanzen.html'),
|
||
['ID' => 8, 'post_title' => 'Quelle']
|
||
);
|
||
LibraryFixtures::given([$this->target, $this->source, LibraryFixtures::item(1055)]);
|
||
}
|
||
|
||
private function ability(): DiviNodeCopyAbility
|
||
{
|
||
$access = LibraryFixtures::access();
|
||
$loader = LibraryFixtures::loader($access);
|
||
$failures = [];
|
||
$globals = new GlobalEdits($access, Mockery::mock(GlobalUsages::class));
|
||
|
||
return new DiviNodeCopyAbility(
|
||
DiviWriterFixture::writer($this->saved, $failures, false, $loader, $globals),
|
||
$loader
|
||
);
|
||
}
|
||
|
||
/** @return array<string, mixed> */
|
||
private function input(array $extra = []): array
|
||
{
|
||
return array_merge([
|
||
'post_id' => 7,
|
||
'tree_rev' => Rev::of((string) $this->target->post_content),
|
||
'source_post_id' => 8,
|
||
'source_tree_rev' => Rev::of((string) $this->source->post_content),
|
||
'source_id' => 's1',
|
||
'after' => 's0',
|
||
], $extra);
|
||
}
|
||
|
||
public function testCopiesANodeByteForByteBetweenPages(): void
|
||
{
|
||
$bytes = Serializer::block(
|
||
NodeIndex::build((new Parser())->parse((string) $this->source->post_content))->find('s1')
|
||
);
|
||
|
||
$result = $this->ability()->execute($this->input());
|
||
|
||
self::assertTrue($result['ok']);
|
||
self::assertCount(1, $this->saved, 'only the target is written');
|
||
self::assertStringContainsString($bytes, $this->saved[0]);
|
||
self::assertSame('s1', $result['changed'][0]['id']);
|
||
self::assertFalse($this->ability()->isDirect());
|
||
}
|
||
|
||
public function testGlobalInstancesStayLinked(): void
|
||
{
|
||
$result = $this->ability()->execute($this->input(['source_id' => 'g0']));
|
||
|
||
self::assertTrue($result['ok']);
|
||
self::assertStringContainsString('<!-- wp:divi/global-layout {"globalModule":"1058"', $this->saved[0]);
|
||
}
|
||
|
||
public function testStaleSourceOrTargetWritesNothing(): void
|
||
{
|
||
self::assertToolError($this->ability()->execute($this->input(['source_tree_rev' => 'abcdef012345'])), 'rev_mismatch');
|
||
self::assertToolError($this->ability()->execute($this->input(['tree_rev' => 'abcdef012345'])), 'rev_mismatch');
|
||
self::assertToolError($this->ability()->execute($this->input(['source_id' => 's9'])), 'not_found');
|
||
self::assertSame([], $this->saved);
|
||
}
|
||
|
||
public function testEditorCannotCarryBuilderOnlyValuesToAnotherPage(): void
|
||
{
|
||
$this->source = LibraryFixtures::page(
|
||
'<!-- wp:divi/placeholder --><!-- wp:divi/section {"css":{"desktop":{"value":{"freeForm":"body{display:none}"}}}} -->'
|
||
. '<!-- /wp:divi/section --><!-- /wp:divi/placeholder -->',
|
||
['ID' => 8]
|
||
);
|
||
LibraryFixtures::given([$this->target, $this->source]);
|
||
|
||
$result = $this->ability()->execute($this->input(['source_id' => 's0']));
|
||
|
||
self::assertToolError($result, 'validation_failed');
|
||
self::assertSame([], $this->saved);
|
||
}
|
||
|
||
public function testTheSourceNeedsItsOwnRights(): void
|
||
{
|
||
Functions\when('current_user_can')->alias(
|
||
static fn (string $cap, mixed ...$args): bool => ! ($cap === 'edit_post' && ($args[0] ?? 0) === 8)
|
||
);
|
||
|
||
self::assertToolError($this->ability()->permission($this->input()), 'forbidden');
|
||
}
|
||
|
||
public function testCopiesIntoALibraryEntry(): void
|
||
{
|
||
$item = LibraryFixtures::item(1055);
|
||
|
||
$result = $this->ability()->execute($this->input([
|
||
'post_id' => 1055,
|
||
'tree_rev' => Rev::of((string) $item->post_content),
|
||
'source_id' => 's0.r0.c0.m0',
|
||
'after' => null,
|
||
'parent' => 's0.r0.c0',
|
||
]));
|
||
|
||
self::assertTrue($result['ok']);
|
||
self::assertStringContainsString('Kontakt aufnehmen', $this->saved[0]);
|
||
}
|
||
}
|
||
```
|
||
|
||
In `DiviIntegrationTest::EXPECTED` am Ende `'lit/divi-node-copy'` ergänzen.
|
||
|
||
- [ ] **Step 2: Tests laufen lassen – schlagen fehl**
|
||
|
||
Run: `vendor/bin/phpunit --filter 'DiviNodeCopyAbilityTest|DiviIntegrationTest'`
|
||
Expected: FAIL (`DiviNodeCopyAbility` fehlt)
|
||
|
||
- [ ] **Step 3: Implementieren**
|
||
|
||
`src/Integrations/Divi/Pages/DiviNodeCopyAbility.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Integrations\Divi\Pages;
|
||
|
||
use LIT\MCP\Abilities\Annotations;
|
||
use LIT\MCP\Abilities\Errors;
|
||
use WP_Error;
|
||
|
||
defined('ABSPATH') || exit;
|
||
|
||
/**
|
||
* lit/divi-node-copy (spec §5.7): a node with everything inside from one Divi entry (page or library
|
||
* entry) to a position in another. The copy keeps its bytes – global instances stay linked – and
|
||
* passes StoredNodeGuard of the target (E6: builder-only values never move to another post for users
|
||
* without unfiltered_html). Source: read rights (DiviPageLoader) and its own tree_rev, because path
|
||
* IDs are only valid for the state they were read in. Target: like lit-divi-insert.
|
||
*/
|
||
final class DiviNodeCopyAbility extends DiviWriteAbility
|
||
{
|
||
public function __construct(DiviWriter $writer, private DiviPageLoader $loader)
|
||
{
|
||
parent::__construct($writer);
|
||
}
|
||
|
||
public function name(): string
|
||
{
|
||
return 'lit/divi-node-copy';
|
||
}
|
||
|
||
public function label(): string
|
||
{
|
||
return 'Divi-Knoten kopieren';
|
||
}
|
||
|
||
public function description(): string
|
||
{
|
||
return 'Kopiert einen Divi-Knoten samt Inhalt von einem Eintrag (source_post_id, source_id und '
|
||
. 'source_tree_rev aus lit-divi-outline der Quelle) an eine Position eines anderen Eintrags (post_id, '
|
||
. 'tree_rev, parent/before/after). Die Kopie ist byte-gleich; globale Module bleiben verknüpft. Quelle '
|
||
. 'und Ziel dürfen auch Bibliothekseinträge sein. Alles oder nichts.';
|
||
}
|
||
|
||
public function inputSchema(): array
|
||
{
|
||
return [
|
||
'type' => 'object',
|
||
'properties' => array_merge(DiviSchema::write(), [
|
||
'source_post_id' => ['type' => 'integer', 'minimum' => 1],
|
||
'source_id' => ['type' => 'string', 'description' => 'Pfad-ID des Knotens in der Quelle.'],
|
||
'source_tree_rev' => ['type' => 'string', 'description' => 'tree_rev der Quelle (lit-divi-outline).'],
|
||
], DiviSchema::position()),
|
||
'required' => ['post_id', 'tree_rev', 'source_post_id', 'source_id', 'source_tree_rev'],
|
||
'additionalProperties' => false,
|
||
];
|
||
}
|
||
|
||
public function annotations(): array
|
||
{
|
||
return Annotations::write(false);
|
||
}
|
||
|
||
public function isDirect(): bool
|
||
{
|
||
return false;
|
||
}
|
||
|
||
/** The source needs its own read rights – checked in permission() too. */
|
||
protected function precheck(array $input): ?WP_Error
|
||
{
|
||
$source = $this->loader->load($input['source_post_id'] ?? null, false);
|
||
|
||
return $source instanceof WP_Error ? $source : null;
|
||
}
|
||
|
||
protected function change(DiviPage $page, array $input, DiviComposition $composition): DiviChange|WP_Error
|
||
{
|
||
$source = $this->loader->load($input['source_post_id'] ?? null, false);
|
||
if ($source instanceof WP_Error) {
|
||
return $source;
|
||
}
|
||
|
||
if (! is_string($input['source_tree_rev'] ?? null) || $input['source_tree_rev'] !== $source->treeRev()) {
|
||
return Errors::revMismatch(
|
||
'Die Quelle wurde seit dem letzten Lesen geändert (source_tree_rev passt nicht); nichts wurde gespeichert.',
|
||
'Die Quelle mit lit-divi-outline neu lesen und source_tree_rev sowie die Pfad-ID übernehmen.'
|
||
);
|
||
}
|
||
|
||
$id = is_string($input['source_id'] ?? null) ? $input['source_id'] : '';
|
||
$node = $source->index->find($id);
|
||
if ($node === null) {
|
||
return DiviErrors::unknownNode($id, $source->post);
|
||
}
|
||
|
||
$copy = $node->copy();
|
||
$problems = $composition->storedGuard()->problems($copy);
|
||
if ($problems !== []) {
|
||
return Errors::invalidInput(
|
||
'Der Knoten enthält Einstellungen, die nur im Divi-Builder übertragen werden dürfen; nichts wurde '
|
||
. 'gespeichert.',
|
||
['source_id' => implode('; ', $problems)]
|
||
);
|
||
}
|
||
|
||
$editor = $composition->editor();
|
||
$position = $editor->position($page->index, $input);
|
||
if (is_string($position)) {
|
||
return DiviErrors::position($position);
|
||
}
|
||
|
||
$violation = $editor->insert($position, [$copy]);
|
||
if ($violation !== null) {
|
||
return Errors::invalidInput(
|
||
'Der Knoten passt nicht an diese Stelle; nichts wurde gespeichert.',
|
||
['source_id' => $violation]
|
||
);
|
||
}
|
||
|
||
return (new DiviChange(sprintf('Knoten %s aus Eintrag %d kopiert', $id, (int) $source->post->ID)))
|
||
->record($copy, 'inserted');
|
||
}
|
||
}
|
||
```
|
||
|
||
`DiviIntegration::abilities()` – nach `DiviReplaceTextAbility` ergänzen: `new DiviNodeCopyAbility($writer, $loader),`.
|
||
|
||
`docs/guides/overview.md`: „Divi (`lit/divi-duplicate-node`, `lit/divi-replace-text`)“ → „Divi (`lit/divi-duplicate-node`, `lit/divi-replace-text`, `lit/divi-node-copy`)“.
|
||
|
||
- [ ] **Step 4: Tests laufen lassen**
|
||
|
||
Run: `vendor/bin/phpunit --filter 'DiviNodeCopyAbilityTest|DiviIntegrationTest|ToolNamingTest'`
|
||
Expected: PASS
|
||
|
||
Run: `composer test && composer lint`
|
||
Expected: OK
|
||
|
||
- [ ] **Step 5: Commit**
|
||
|
||
```bash
|
||
git add src/Integrations/Divi/Pages/DiviNodeCopyAbility.php src/Integrations/Divi/DiviIntegration.php docs/guides/overview.md tests/Unit/Integrations/Divi/Pages/DiviNodeCopyAbilityTest.php tests/Unit/Integrations/Divi/DiviIntegrationTest.php
|
||
```
|
||
Commit wie in den Global Constraints mit der Nachricht `feat: lit/divi-node-copy between pages and library entries`.
|
||
|
||
---
|
||
|
||
### Task 15: `lit/divi-dynamic-sources` (E12, Antwort F4)
|
||
|
||
E14 ordnet das Tool 3a zu. Es liefert Divis Dynamic-Content-Optionen (`DynamicContentOptions::get_options` für einen Beispiel-Eintrag des Typs, sonst 0; über `DynamicContentMap`, ohne `loop_*`, S36) mit dem passenden Platzhalter (`{{post:…}}`, `{{link:<ID>}}`) bzw. dem Namen für die Vollform, und die Felder des Typs aus `ContentSchema` (Pods, registriertes und gefundenes Meta). Antwort F4 (verbindlich): nur textartige Felder als Quelle anbieten, andere mit Grund auslassen (Beziehung/Datei zeigt Divi nur als IDs, F26; Pods mit Tabellen-Speicherung liest Divi nicht; geschützte Schlüssel mit `_` nie, S12). Die Feldliste nur mit der Divi-Rolle `read_dynamic_content_custom_fields` (E3, F25). Gruppe „Divi“, indirekt, nur lesend.
|
||
|
||
**Files:**
|
||
- Modify: `src/Integrations/Divi/Pages/DynamicContentMap.php` (`options()`)
|
||
- Create: `src/Integrations/Divi/Pages/DiviDynamicSourcesAbility.php`
|
||
- Modify: `src/Integrations/Divi/DiviIntegration.php`
|
||
- Modify: `docs/guides/overview.md` (indirekte Tools)
|
||
- Test: `tests/Unit/Integrations/Divi/Pages/DynamicContentMapTest.php`, `tests/Unit/Integrations/Divi/Pages/DiviDynamicSourcesAbilityTest.php`, `tests/Unit/Integrations/Divi/DiviIntegrationTest.php`
|
||
|
||
**Interfaces:**
|
||
- Consumes: `DynamicContentMap::fromOptions()`, `DynamicContentRules::DEFAULT_DYNAMIC_CONTENT/isMetaKey()`, `Placeholders::POST`, `ContentSchema::fields()`, `FieldDefinition`, `PostGuard::postType()`, `JsonMap::of()`, `DiviRoles`.
|
||
- Produces: `DynamicContentMap::options(int $postId): ?array<string, array{label: string, group: string, settings: array<string, string>}>`; `final class DiviDynamicSourcesAbility implements Ability { __construct(ContentSchema $schema, DynamicContentMap $map, DiviRoles $roles, ?Closure $samplePost = null, ?Closure $podStorage = null) }` – `lit/divi-dynamic-sources`.
|
||
|
||
- [ ] **Step 1: Failing tests schreiben**
|
||
|
||
In `DynamicContentMapTest`:
|
||
|
||
```php
|
||
public function testOptionsCarryLabelGroupAndSettingTypesWithoutLoops(): void
|
||
{
|
||
$map = new DynamicContentMap(static fn (int $id): array => DiviFixtures::dynamicContentRegistry());
|
||
|
||
$options = $map->options(831);
|
||
|
||
self::assertSame(['post_id' => 'select_post'], $options['post_link_url_page']['settings']);
|
||
self::assertSame('post_meta_key', $options['post_meta_key']['label']);
|
||
self::assertSame('Standard', $options['post_meta_key']['group']);
|
||
self::assertArrayNotHasKey('loop_post_title', $options);
|
||
self::assertNull((new DynamicContentMap(static fn (int $id): array => []))->options(831));
|
||
}
|
||
```
|
||
|
||
`tests/Unit/Integrations/Divi/Pages/DiviDynamicSourcesAbilityTest.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Tests\Unit\Integrations\Divi\Pages;
|
||
|
||
use Brain\Monkey\Functions;
|
||
use LIT\MCP\Integrations\Divi\Pages\DiviDynamicSourcesAbility;
|
||
use LIT\MCP\Integrations\Divi\Pages\DynamicContentMap;
|
||
use LIT\MCP\Integrations\WordPress\Schema\ContentSchema;
|
||
use LIT\MCP\Integrations\WordPress\Schema\FieldDefinition;
|
||
use LIT\MCP\Tests\Support\DiviFixtures;
|
||
use LIT\MCP\Tests\Support\LibraryFixtures;
|
||
use LIT\MCP\Tests\Unit\TestCase;
|
||
use Mockery;
|
||
|
||
final class DiviDynamicSourcesAbilityTest extends TestCase
|
||
{
|
||
protected function setUp(): void
|
||
{
|
||
parent::setUp();
|
||
Functions\when('get_post_type_object')->justReturn(
|
||
(object) ['name' => 'page', 'cap' => (object) ['edit_posts' => 'edit_pages']]
|
||
);
|
||
Functions\when('current_user_can')->justReturn(true);
|
||
}
|
||
|
||
private function schema(): ContentSchema
|
||
{
|
||
$schema = Mockery::mock(ContentSchema::class);
|
||
$schema->allows('isManaged')->andReturn(true);
|
||
$schema->allows('fields')->with('page')->andReturn([
|
||
'telefon' => new FieldDefinition('telefon', 'Telefon', 'string', 'meta', FieldDefinition::WRITABLE),
|
||
'notiz' => new FieldDefinition('notiz', 'Notiz', 'text', 'pods', FieldDefinition::WRITABLE),
|
||
'foto' => new FieldDefinition('foto', 'Foto', 'file', 'pods', FieldDefinition::WRITABLE),
|
||
'projekte' => new FieldDefinition('projekte', 'Projekte', 'relation', 'pods', FieldDefinition::WRITABLE),
|
||
'_intern' => new FieldDefinition('_intern', '_intern', 'string', 'meta', FieldDefinition::WRITABLE),
|
||
'geheim' => new FieldDefinition('geheim', 'Geheim', 'string', 'pods', FieldDefinition::HIDDEN),
|
||
]);
|
||
|
||
return $schema;
|
||
}
|
||
|
||
/** @param list<string> $deniedRoles */
|
||
private function ability(array $deniedRoles = [], ?string $storage = 'meta', ?array $registry = null): DiviDynamicSourcesAbility
|
||
{
|
||
$registry ??= DiviFixtures::dynamicContentRegistry();
|
||
|
||
return new DiviDynamicSourcesAbility(
|
||
$this->schema(),
|
||
new DynamicContentMap(static fn (int $id): array => $registry),
|
||
LibraryFixtures::roles($deniedRoles),
|
||
static fn (string $postType): int => 831,
|
||
static fn (string $postType): ?string => $storage
|
||
);
|
||
}
|
||
|
||
public function testListsDiviSourcesWithTheirPlaceholders(): void
|
||
{
|
||
$result = $this->ability()->execute(['post_type' => 'page']);
|
||
|
||
$sources = array_column($result['sources'], null, 'name');
|
||
self::assertSame(831, $result['sample_post_id']);
|
||
self::assertSame('{{post:title}}', $sources['post_title']['placeholder']);
|
||
self::assertSame('{{link:<ID>}}', $sources['post_link_url_page']['placeholder']);
|
||
self::assertNull($sources['site_title']['placeholder']);
|
||
self::assertArrayNotHasKey('loop_post_title', $sources);
|
||
self::assertEquals(['post_id' => 'select_post'], (array) $sources['post_link_url_page']['settings']);
|
||
self::assertFalse($this->ability()->isDirect());
|
||
self::assertTrue($this->ability()->annotations()['readonly']);
|
||
}
|
||
|
||
public function testOffersTextLikeFieldsAndNamesTheOthers(): void
|
||
{
|
||
$result = $this->ability()->execute(['post_type' => 'page']);
|
||
|
||
self::assertSame(['telefon', 'notiz'], array_column($result['fields'], 'key'));
|
||
self::assertSame('{{field:notiz}}', $result['fields'][1]['placeholder']);
|
||
$omitted = array_column($result['omitted'], 'reason', 'key');
|
||
self::assertSame(['foto', 'projekte', '_intern'], array_keys($omitted));
|
||
self::assertStringContainsString('nur IDs', $omitted['foto']);
|
||
self::assertStringContainsString('„_“', $omitted['_intern']);
|
||
}
|
||
|
||
public function testPodsTableStorageIsNotReadableByDivi(): void
|
||
{
|
||
$result = $this->ability([], 'table')->execute(['post_type' => 'page']);
|
||
|
||
self::assertSame(['telefon'], array_column($result['fields'], 'key'));
|
||
self::assertStringContainsString('Tabellen', array_column($result['omitted'], 'reason', 'key')['notiz']);
|
||
}
|
||
|
||
public function testFieldListNeedsTheDiviRole(): void
|
||
{
|
||
$result = $this->ability(['read_dynamic_content_custom_fields'])->execute(['post_type' => 'page']);
|
||
|
||
self::assertSame([], $result['fields']);
|
||
self::assertSame([], $result['omitted']);
|
||
self::assertStringContainsString('Rollen-Editor', implode(' ', $result['notes']));
|
||
}
|
||
|
||
public function testWithoutDivisRegistryThePlaceholderSourcesAreShown(): void
|
||
{
|
||
$result = $this->ability([], 'meta', [])->execute(['post_type' => 'page']);
|
||
|
||
self::assertContains('post_title', array_column($result['sources'], 'name'));
|
||
self::assertStringContainsString('nicht verfügbar', implode(' ', $result['notes']));
|
||
}
|
||
|
||
public function testUnknownPostTypeIsNotFound(): void
|
||
{
|
||
Functions\when('get_post_type_object')->justReturn(null);
|
||
|
||
self::assertToolError($this->ability()->permission(['post_type' => 'nix']), 'not_found');
|
||
}
|
||
}
|
||
```
|
||
|
||
In `DiviIntegrationTest::EXPECTED` am Ende `'lit/divi-dynamic-sources'` ergänzen.
|
||
|
||
- [ ] **Step 2: Tests laufen lassen – schlagen fehl**
|
||
|
||
Run: `vendor/bin/phpunit --filter 'DynamicContentMapTest|DiviDynamicSourcesAbilityTest|DiviIntegrationTest'`
|
||
Expected: FAIL
|
||
|
||
- [ ] **Step 3: Implementieren**
|
||
|
||
`DynamicContentMap` – `forPost()` auf eine gemeinsame Rohabfrage umstellen und `options()` ergänzen:
|
||
|
||
```php
|
||
/** @return array<string, array<string, string>>|null Null = use DynamicContentRules' default map. */
|
||
public function forPost(int $postId): ?array
|
||
{
|
||
$raw = $this->raw($postId);
|
||
|
||
return $raw === null ? null : self::fromOptions($raw);
|
||
}
|
||
|
||
/**
|
||
* The options for lit/divi-dynamic-sources: name => label, group and setting types (the same
|
||
* names and types as forPost(), loop_* left out). Null when Divi's registry is unavailable.
|
||
*
|
||
* @return array<string, array{label: string, group: string, settings: array<string, string>}>|null
|
||
*/
|
||
public function options(int $postId): ?array
|
||
{
|
||
$raw = $this->raw($postId);
|
||
if ($raw === null) {
|
||
return null;
|
||
}
|
||
|
||
$options = [];
|
||
foreach (self::fromOptions($raw) as $name => $settings) {
|
||
$option = is_array($raw[$name] ?? null) ? $raw[$name] : [];
|
||
$options[$name] = [
|
||
'label' => is_string($option['label'] ?? null) ? $option['label'] : $name,
|
||
'group' => is_string($option['group'] ?? null) ? $option['group'] : '',
|
||
'settings' => $settings,
|
||
];
|
||
}
|
||
|
||
return $options;
|
||
}
|
||
|
||
/** @return array<array-key, mixed>|null */
|
||
private function raw(int $postId): ?array
|
||
{
|
||
try {
|
||
$options = $this->registry !== null ? ($this->registry)($postId) : self::divi($postId);
|
||
} catch (Throwable $e) {
|
||
Log::failure(sprintf('divi dynamic content options of post %d', $postId), $e->getMessage());
|
||
|
||
return null;
|
||
}
|
||
|
||
return is_array($options) && $options !== [] ? $options : null;
|
||
}
|
||
```
|
||
|
||
`src/Integrations/Divi/Pages/DiviDynamicSourcesAbility.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Integrations\Divi\Pages;
|
||
|
||
use Closure;
|
||
use LIT\MCP\Abilities\Ability;
|
||
use LIT\MCP\Abilities\Annotations;
|
||
use LIT\MCP\Abilities\JsonMap;
|
||
use LIT\MCP\Integrations\Divi\Compose\DynamicContentRules;
|
||
use LIT\MCP\Integrations\Divi\Compose\Placeholders;
|
||
use LIT\MCP\Integrations\Divi\Library\DiviRoles;
|
||
use LIT\MCP\Integrations\WordPress\PostGuard;
|
||
use LIT\MCP\Integrations\WordPress\Schema\ContentSchema;
|
||
use LIT\MCP\Integrations\WordPress\Schema\FieldDefinition;
|
||
use Throwable;
|
||
use WP_Error;
|
||
|
||
defined('ABSPATH') || exit;
|
||
|
||
/**
|
||
* lit/divi-dynamic-sources (spec §5.7, E12): Divi's dynamic content options for a post type
|
||
* (DynamicContentOptions::get_options with a sample entry of the type, else 0; no loop_* – S36) with
|
||
* the placeholder that writes each, and the fields of the type usable as {{field:<key>}} (answer
|
||
* F4: text-like fields only; relation/file fields show IDs in Divi (F26), Pods table storage is not
|
||
* post meta, protected keys never (S12) – each left out with its reason). The field list needs the
|
||
* Divi role option read_dynamic_content_custom_fields (E3, F25).
|
||
*/
|
||
final class DiviDynamicSourcesAbility implements Ability
|
||
{
|
||
/** Field types Divi can show as text (arrays of strings are joined with ", ", F26). */
|
||
private const TEXT_TYPES = ['string', 'text', 'number', 'integer', 'date', 'datetime', 'time', 'choice', 'unknown'];
|
||
|
||
private const ID_TYPES = ['relation', 'file'];
|
||
|
||
/** @var Closure(string): int */
|
||
private Closure $samplePost;
|
||
|
||
/** @var Closure(string): ?string */
|
||
private Closure $podStorage;
|
||
|
||
/**
|
||
* @param (Closure(string): int)|null $samplePost Post type → an entry to ask Divi with (0 = none).
|
||
* @param (Closure(string): ?string)|null $podStorage Post type → Pods storage ("meta", "table"), null without a pod.
|
||
*/
|
||
public function __construct(
|
||
private ContentSchema $schema,
|
||
private DynamicContentMap $map,
|
||
private DiviRoles $roles,
|
||
?Closure $samplePost = null,
|
||
?Closure $podStorage = null
|
||
) {
|
||
$this->samplePost = $samplePost ?? static function (string $postType): int {
|
||
$ids = get_posts([
|
||
'post_type' => $postType,
|
||
'post_status' => ['publish', 'draft', 'pending', 'private', 'future'],
|
||
'posts_per_page' => 1,
|
||
'orderby' => 'modified',
|
||
'order' => 'DESC',
|
||
'fields' => 'ids',
|
||
'no_found_rows' => true,
|
||
]);
|
||
|
||
return is_array($ids) && isset($ids[0]) ? (int) $ids[0] : 0;
|
||
};
|
||
$this->podStorage = $podStorage ?? static function (string $postType): ?string {
|
||
if (! function_exists('pods_api')) {
|
||
return null;
|
||
}
|
||
try {
|
||
$pod = pods_api()->load_pod(['name' => $postType]);
|
||
} catch (Throwable) {
|
||
return null;
|
||
}
|
||
|
||
return is_object($pod) && method_exists($pod, 'get_storage') ? (string) $pod->get_storage() : null;
|
||
};
|
||
}
|
||
|
||
public function name(): string
|
||
{
|
||
return 'lit/divi-dynamic-sources';
|
||
}
|
||
|
||
public function label(): string
|
||
{
|
||
return 'Dynamic-Content-Quellen';
|
||
}
|
||
|
||
public function description(): string
|
||
{
|
||
return 'Listet die Dynamic-Content-Quellen, die Divi für einen Inhaltstyp anbietet (Beitragsdaten, Links, '
|
||
. 'Website-Daten …) mit dem Platzhalter dazu ({{post:…}}, {{link:<ID>}}) bzw. dem Namen für die Vollform, '
|
||
. 'und die Felder des Typs, die sich als {{field:<Schlüssel>}} eignen. Nur textartige Felder; Beziehungs-, '
|
||
. 'Datei- und Tabellenfelder stehen mit Grund unter omitted.';
|
||
}
|
||
|
||
public function inputSchema(): array
|
||
{
|
||
return [
|
||
'type' => 'object',
|
||
'properties' => ['post_type' => ['type' => 'string', 'description' => 'z. B. "page" oder "person".']],
|
||
'required' => ['post_type'],
|
||
'additionalProperties' => false,
|
||
];
|
||
}
|
||
|
||
public function outputSchema(): ?array
|
||
{
|
||
return [
|
||
'type' => 'object',
|
||
'properties' => [
|
||
'post_type' => ['type' => 'string'],
|
||
'sample_post_id' => ['type' => 'integer'],
|
||
'sources' => [
|
||
'type' => 'array',
|
||
'items' => [
|
||
'type' => 'object',
|
||
'properties' => [
|
||
'name' => ['type' => 'string'],
|
||
'label' => ['type' => 'string'],
|
||
'group' => ['type' => 'string'],
|
||
'placeholder' => ['type' => ['string', 'null']],
|
||
'settings' => ['type' => 'object'],
|
||
],
|
||
'required' => ['name', 'label', 'group', 'placeholder', 'settings'],
|
||
],
|
||
],
|
||
'fields' => ['type' => 'array', 'items' => ['type' => 'object']],
|
||
'omitted' => ['type' => 'array', 'items' => ['type' => 'object']],
|
||
'notes' => ['type' => 'array', 'items' => ['type' => 'string']],
|
||
],
|
||
'required' => ['post_type', 'sample_post_id', 'sources', 'fields', 'omitted', 'notes'],
|
||
];
|
||
}
|
||
|
||
public function annotations(): array
|
||
{
|
||
return Annotations::read();
|
||
}
|
||
|
||
public function isDirect(): bool
|
||
{
|
||
return false;
|
||
}
|
||
|
||
public function permission(array $input): bool|WP_Error
|
||
{
|
||
$type = PostGuard::postType($input['post_type'] ?? null, $this->schema, 'edit_posts');
|
||
|
||
return $type instanceof WP_Error ? $type : true;
|
||
}
|
||
|
||
public function execute(array $input): mixed
|
||
{
|
||
$type = PostGuard::postType($input['post_type'] ?? null, $this->schema, 'edit_posts');
|
||
if ($type instanceof WP_Error) {
|
||
return $type;
|
||
}
|
||
|
||
$postType = (string) $input['post_type'];
|
||
$sample = ($this->samplePost)($postType);
|
||
$notes = [
|
||
'Quellen ohne Platzhalter in der Vollform als $variable({"type":"content","value":{"name":"<name>",'
|
||
. '"settings":{…}}})$ mit den genannten Einstellungen schreiben.',
|
||
];
|
||
$options = $this->map->options($sample);
|
||
if ($options === null) {
|
||
$notes[] = 'Divis Quellenliste ist nicht verfügbar; gezeigt werden die Quellen der Platzhalter {{post:…}}.';
|
||
$options = [];
|
||
foreach (DynamicContentRules::DEFAULT_DYNAMIC_CONTENT as $name => $settings) {
|
||
$options[$name] = ['label' => $name, 'group' => '', 'settings' => $settings];
|
||
}
|
||
}
|
||
|
||
$sources = [];
|
||
foreach ($options as $name => $option) {
|
||
$sources[] = [
|
||
'name' => (string) $name,
|
||
'label' => $option['label'],
|
||
'group' => $option['group'],
|
||
'placeholder' => self::placeholder((string) $name),
|
||
'settings' => JsonMap::of($option['settings']),
|
||
];
|
||
}
|
||
|
||
$fields = [];
|
||
$omitted = [];
|
||
if ($this->roles->allows('read_dynamic_content_custom_fields')) {
|
||
[$fields, $omitted] = $this->fields($postType);
|
||
} else {
|
||
$notes[] = 'Felder werden nicht gelistet: die Divi-Rolle erlaubt „Dynamic Content: benutzerdefinierte '
|
||
. 'Felder lesen“ nicht (Divi → Rollen-Editor).';
|
||
}
|
||
|
||
return [
|
||
'post_type' => $postType,
|
||
'sample_post_id' => $sample,
|
||
'sources' => $sources,
|
||
'fields' => $fields,
|
||
'omitted' => $omitted,
|
||
'notes' => $notes,
|
||
];
|
||
}
|
||
|
||
private static function placeholder(string $name): ?string
|
||
{
|
||
$post = array_search($name, Placeholders::POST, true);
|
||
if ($post !== false) {
|
||
return '{{post:' . $post . '}}';
|
||
}
|
||
|
||
return str_starts_with($name, 'post_link_url_') ? '{{link:<ID>}}' : null;
|
||
}
|
||
|
||
/**
|
||
* @return array{0: list<array<string, string>>, 1: list<array<string, string>>} Offered and omitted fields.
|
||
*/
|
||
private function fields(string $postType): array
|
||
{
|
||
$storage = ($this->podStorage)($postType);
|
||
$fields = [];
|
||
$omitted = [];
|
||
foreach ($this->schema->fields($postType) as $field) {
|
||
if ($field->status === FieldDefinition::HIDDEN) {
|
||
continue;
|
||
}
|
||
|
||
$entry = ['key' => $field->key, 'label' => $field->label];
|
||
$reason = match (true) {
|
||
! DynamicContentRules::isMetaKey($field->key) => 'geschütztes oder ungültiges Meta-Feld (beginnt mit „_“)',
|
||
$field->source === 'pods' && $storage === 'table' => 'Pods mit Tabellen-Speicherung – Divi liest nur Post-Meta',
|
||
in_array($field->type, self::ID_TYPES, true) => 'Beziehungs- oder Dateifeld – Divi zeigt davon nur IDs',
|
||
! in_array($field->type, self::TEXT_TYPES, true) => sprintf('Feldtyp „%s“ ist nicht textartig', $field->type),
|
||
default => null,
|
||
};
|
||
if ($reason !== null) {
|
||
$omitted[] = $entry + ['reason' => $reason];
|
||
continue;
|
||
}
|
||
|
||
$fields[] = $entry + [
|
||
'type' => $field->type,
|
||
'source' => $field->source,
|
||
'placeholder' => '{{field:' . $field->key . '}}',
|
||
];
|
||
}
|
||
|
||
return [$fields, $omitted];
|
||
}
|
||
}
|
||
```
|
||
|
||
`DiviIntegration::abilities()` – nach `DiviNodeCopyAbility` (Import `DynamicContentMap`, `DiviDynamicSourcesAbility`):
|
||
|
||
```php
|
||
new DiviDynamicSourcesAbility($this->schema, new DynamicContentMap(), $this->access->roles()),
|
||
```
|
||
|
||
`docs/guides/overview.md`: „…, `lit/divi-node-copy`)“ → „…, `lit/divi-node-copy`, `lit/divi-dynamic-sources`)“.
|
||
|
||
- [ ] **Step 4: Tests laufen lassen**
|
||
|
||
Run: `vendor/bin/phpunit --filter 'DynamicContentMapTest|DiviDynamicSourcesAbilityTest|DiviIntegrationTest|ToolNamingTest'`
|
||
Expected: PASS
|
||
|
||
Run: `composer test && composer lint`
|
||
Expected: OK
|
||
|
||
- [ ] **Step 5: Commit**
|
||
|
||
```bash
|
||
git add src/Integrations/Divi/Pages/DynamicContentMap.php src/Integrations/Divi/Pages/DiviDynamicSourcesAbility.php src/Integrations/Divi/DiviIntegration.php docs/guides/overview.md tests/Unit/Integrations/Divi
|
||
```
|
||
Commit wie in den Global Constraints mit der Nachricht `feat: lit/divi-dynamic-sources with text-like fields only (E12, F4)`.
|
||
|
||
---
|
||
|
||
### Task 16: Guides, Server-Instructions, Readme, Version 0.4.0, Spec- und Entscheidungs-Nachträge
|
||
|
||
Dokumentation zu allem aus 3a, deutsch mit Umlauten, neutral formuliert (keine Chatbot-Marke; der Readme-Satz „z. B. Claude oder ein anderer MCP-fähiger Client“ wird dabei neutralisiert). Neues Guide-Thema `divi-library` mit dem Ablauf „Globale Module vorschlagen“ (E14; MCP-Prompts gibt es im Plugin noch nicht, siehe offene Punkte). Server-Instructions bekommen eine Zeile zur Bibliothek, wenn die Gruppe aktiv ist.
|
||
|
||
**Files:**
|
||
- Create: `docs/guides/divi-library.md`
|
||
- Modify: `docs/guides/overview.md`, `docs/guides/divi-placeholders.md`, `docs/guides/divi-structure.md`, `docs/guides/divi-design-system.md`, `docs/guides/workflows.md`
|
||
- Modify: `src/Guides/InstructionsBuilder.php`
|
||
- Modify: `readme.txt`, `wp-lit-mcp.php`, `src/Plugin.php`
|
||
- Modify: `docs/superpowers/specs/2026-09-25-wp-lit-mcp-design.md`, `docs/superpowers/notes/2026-09-27-etappe-3-entscheidungen-entwurf.md`
|
||
- Test: `tests/Unit/Guides/InstructionsBuilderTest.php`, `tests/Unit/Guides/ToolNamingTest.php` (unverändert, muss grün bleiben)
|
||
|
||
**Interfaces:**
|
||
- Consumes: alle Tools aus Task 2–15.
|
||
- Produces: Guide-Thema `divi-library`; `Plugin::VERSION = '0.4.0'`; Instructions-Zeile „Divi-Bibliothek: …“.
|
||
|
||
- [ ] **Step 1: Failing test schreiben**
|
||
|
||
In `InstructionsBuilderTest`:
|
||
|
||
```php
|
||
public function testAddsTheLibraryRuleOnlyWhenTheLibraryGroupIsActive(): void
|
||
{
|
||
$library = Mockery::mock(Integration::class);
|
||
$library->allows('id')->andReturn('divi-library');
|
||
$library->allows('isAvailable')->andReturn(true);
|
||
$library->allows('abilities')->andReturn([$this->ability('lit/library-insert', true)]);
|
||
$core = $this->coreWith($this->ability('lit/guide', true));
|
||
|
||
$with = (new InstructionsBuilder(new IntegrationRegistry($core, $library)))->build();
|
||
$without = (new InstructionsBuilder(new IntegrationRegistry($core)))->build();
|
||
|
||
self::assertStringContainsString('Divi-Bibliothek: globale Module', $with);
|
||
self::assertStringContainsString('confirm: true', $with);
|
||
self::assertStringNotContainsString('Divi-Bibliothek:', $without);
|
||
self::assertLessThan(2000, strlen($with));
|
||
}
|
||
```
|
||
|
||
- [ ] **Step 2: Test laufen lassen – schlägt fehl**
|
||
|
||
Run: `vendor/bin/phpunit --filter InstructionsBuilderTest`
|
||
Expected: FAIL
|
||
|
||
- [ ] **Step 3: Guide `divi-library` anlegen**
|
||
|
||
`docs/guides/divi-library.md`:
|
||
|
||
```markdown
|
||
# Divi-Bibliothek und globale Module
|
||
|
||
Die Divi-Bibliothek speichert Layouts, Abschnitte, Zeilen und Module zur Wiederverwendung.
|
||
|
||
- **Normale Einträge** werden beim Einfügen kopiert; die Kopie ist danach unabhängig.
|
||
- **Globale Einträge** werden als Instanz eingefügt. Divi zeigt überall den aktuellen Inhalt des
|
||
Bibliothekseintrags: eine Änderung dort wirkt sofort auf allen Seiten mit diesem Modul – auch auf
|
||
veröffentlichten.
|
||
|
||
## Werkzeuge
|
||
|
||
- `lit/library-list` (über `mcp-adapter-execute-ability`): Einträge auflisten, Filter `layout_type`
|
||
(`layout`, `section`, `row`, `module`), `scope` (`normal`, `global`), `search`, `category`, weiterblättern
|
||
mit `cursor`. Mit `id`: ein Eintrag im Detail – Knoten-Übersicht (`outline`), `tree_rev` und bei globalen
|
||
Einträgen die Seiten, die ihn zeigen (`affected`, `affected_count`).
|
||
- `lit-library-insert`: einen Eintrag in eine Divi-Seite einfügen. `mode: "global"` (Standard bei globalen
|
||
Einträgen) fügt eine verknüpfte Instanz ein, `mode: "copy"` (Standard sonst) eine unabhängige Kopie.
|
||
Position wie bei `lit-divi-insert` (`parent`, `before`, `after`, ohne Angabe ans Seitenende); `tree_rev`
|
||
der Zielseite ist Pflicht.
|
||
- `lit/library-save`: einen Abschnitt, eine Zeile oder ein Modul als neuen Eintrag speichern (`title`,
|
||
`scope: "normal"` oder `"global"`, vorhandene `categories`/`tags`). Der Knoten auf der Seite bleibt eine
|
||
eigenständige Kopie – um ihn zu verknüpfen, ihn durch eine Instanz ersetzen (siehe Ablauf unten).
|
||
- `lit/divi-node-copy`: einen Knoten von einem Eintrag an eine Position eines anderen kopieren
|
||
(`source_post_id`, `source_id`, `source_tree_rev` aus `lit-divi-outline` der Quelle; Ziel mit `post_id`,
|
||
`tree_rev`, Position). Die Kopie ist byte-gleich; globale Module bleiben verknüpft.
|
||
- Die Divi-Werkzeuge arbeiten auch auf Bibliothekseinträgen: `lit-divi-outline`, `lit-divi-node-get`,
|
||
`lit-divi-insert`, `lit-divi-update`, `lit-divi-move`, `lit-divi-delete` und `lit/divi-duplicate-node`
|
||
mit der ID des Eintrags als `post_id`.
|
||
|
||
## Globale Module erkennen und ändern
|
||
|
||
1. In `lit-divi-outline` einer Seite erscheinen Instanzen als z. B. `g0 section "Kontakt" [global 1058]
|
||
(nur lesbar)`; `lit-divi-node-get` nennt unter `global` die ID des Bibliothekseintrags. Auf der Seite
|
||
lassen sie sich nur als Ganzes verschieben, duplizieren oder löschen.
|
||
2. `lit-divi-outline` mit `post_id` = ID des Eintrags lesen und die Änderung wie auf einer Seite senden.
|
||
3. Ohne `confirm` ist das ein Probelauf: Antwort `confirm_required` mit `affected` (betroffene Seiten, Titel
|
||
nicht lesbarer Seiten als „(nicht lesbar)“) und `affected_count`; gespeichert wird nichts.
|
||
4. Dem Nutzer die betroffenen Seiten nennen und fragen. Erst nach Zustimmung dieselbe Änderung mit
|
||
`confirm: true` wiederholen (bei `lit-divi-delete` gilt dasselbe `confirm`).
|
||
5. Vorher entsteht eine Revision des Eintrags (`revision_id`); sind Revisionen abgeschaltet, eine
|
||
Sicherungskopie (`backup_id`). Divis CSS-Cache wird für alle Seiten geleert.
|
||
|
||
Regeln für Bibliothekseinträge: ein Abschnitts-, Zeilen- oder Modul-Eintrag behält genau einen Knoten dieses
|
||
Typs (die Instanzen auf den Seiten erwarten ihn); ein Layout-Eintrag enthält nur Abschnitte; ein globaler
|
||
Eintrag enthält keine globalen Module.
|
||
|
||
`lit-page-render-summary` zeigt globale Module nicht (über die Schnittstelle rendert Divi sie nicht) und nennt
|
||
sie in `notes`; ihren Inhalt mit `lit-divi-outline` und der ID lesen.
|
||
|
||
## Rechte
|
||
|
||
- WordPress: die Bibliothek nutzen = Beiträge bearbeiten dürfen; einen Eintrag lesen oder ändern = diesen
|
||
Eintrag bearbeiten dürfen; neue Einträge anlegen = Beiträge veröffentlichen dürfen (Bibliothekseinträge
|
||
sind immer aktiv).
|
||
- Divi → Rollen-Editor: „Divi-Bibliothek“, „In der Bibliothek speichern“, „Aus der Bibliothek hinzufügen“,
|
||
„Globale Bibliothekselemente bearbeiten“. Fehlt eines, antwortet das Werkzeug mit `forbidden` und diesem
|
||
Hinweis.
|
||
- Einstellungen → LIT MCP → Tools: Gruppe „Divi-Bibliothek“ auf „nur lesen“ sperrt jeden Schreibzugriff auf
|
||
Bibliothekseinträge, auch über die Divi-Werkzeuge; `lit-library-insert` ist außerdem gesperrt, wenn
|
||
`lit-divi-insert` gesperrt ist.
|
||
- Ohne das Recht `unfiltered_html` lassen sich Knoten mit eigenem CSS, eigenen HTML-Attributen, dem
|
||
Code-Modul oder dynamischem Inhalt mit HTML davor/danach nicht in einen anderen Eintrag übertragen
|
||
(Kopieren, Einfügen, Speichern) – „nur im Divi-Builder“.
|
||
|
||
## Ablauf: globale Module vorschlagen
|
||
|
||
1. Die Seiten lesen (`lit-divi-outline`) und wiederkehrende Abschnitte suchen (gleiche Admin-Labels oder
|
||
Texte, z. B. Kontakt, Öffnungszeiten, Call-to-Action).
|
||
2. Dem Nutzer vorschlagen, welche davon globale Module werden sollen, und erklären: eine Änderung wirkt
|
||
danach auf allen Seiten.
|
||
3. Nach Zustimmung den Abschnitt einer Seite mit `lit/library-save` und `scope: "global"` speichern.
|
||
4. Auf jeder Seite (auch der ersten) die Instanz mit `lit-library-insert` direkt vor dem bisherigen Abschnitt
|
||
einfügen und den bisherigen Abschnitt nach Rückfrage mit `lit-divi-delete` entfernen.
|
||
5. Den Nutzer bitten, das Ergebnis im Divi-Builder anzusehen.
|
||
|
||
Unterscheiden sich die Abschnitte in Details, vorher mit dem Nutzer klären, welche Fassung gilt.
|
||
```
|
||
|
||
- [ ] **Step 4: Übrige Guides anpassen**
|
||
|
||
`docs/guides/overview.md`:
|
||
- In „Weitere Themen:“ `divi-library` ergänzen:
|
||
|
||
```markdown
|
||
Weitere Themen: `lit-guide` mit `topic` = `content-types`, `workflows`, `media`, `divi-structure`,
|
||
`divi-shortform`, `divi-attrs`, `divi-placeholders`, `divi-design-system` oder `divi-library`.
|
||
```
|
||
|
||
- Direkt darunter einen eigenen Absatz (nach einer Leerzeile, damit der Themen-Test ihn nicht mitliest):
|
||
|
||
```markdown
|
||
Für den Einstieg liefert `lit-guide` mit dem Thema „all“ alle Themen in einem Aufruf.
|
||
```
|
||
|
||
- Nach „Die `lit-divi-…`-Werkzeuge gibt es nur, wenn der Divi-5-Builder aktiv ist.“ ergänzen: „Sie arbeiten
|
||
auch auf Einträgen der Divi-Bibliothek (ID als `post_id`); globale Module: `lit-guide` topic `divi-library`.“
|
||
|
||
`docs/guides/divi-placeholders.md` – Tabellenzeile nach `{{field:<meta_key>}}` einfügen:
|
||
|
||
```markdown
|
||
| `{{link:<ID>}}` | Link auf einen anderen Eintrag (Seite, Beitrag …), z. B. `{{link:42}}` – nur in Link-Feldern; Divi setzt beim Anzeigen die aktuelle Adresse ein, also auch für Entwürfe, die erst später veröffentlicht werden |
|
||
```
|
||
|
||
Den Absatz „In Link-Feldern (`url`, `button_url` …) …“ ersetzen durch:
|
||
|
||
```markdown
|
||
In Link-Feldern (`url`, `button_url` …) für interne Links immer `{{link:<ID>}}` verwenden statt fester
|
||
Adressen wie `/?page_id=…`. Der Eintrag muss existieren, lesbar sein und darf nicht im Papierkorb liegen;
|
||
`{{link:…}}` außerhalb von Link-Feldern lehnt das Werkzeug ab. Sonst nimmt ein Link-Feld jeden dynamischen
|
||
Inhalt an; sinnvoll sind nur Werte, die eine Adresse ergeben (`{{post:url}}`, ein Feld mit einer URL, eine
|
||
Link-Variable).
|
||
|
||
Welche dynamischen Quellen und Felder es für einen Inhaltstyp gibt, liefert `lit/divi-dynamic-sources`
|
||
(über `mcp-adapter-execute-ability`): Divis Quellen mit Platzhalter und die Felder, die sich als
|
||
`{{field:…}}` eignen (nur textartige; Beziehungs- und Dateifelder zeigt Divi nur als IDs).
|
||
```
|
||
|
||
`docs/guides/divi-structure.md` – den ersten Punkt unter „Was nicht bearbeitet wird“ ersetzen durch:
|
||
|
||
```markdown
|
||
- Knoten mit „nur lesbar“ (globale Module `g…`, fremde Blöcke `x…`) lassen sich nur als Ganzes verschieben,
|
||
duplizieren oder löschen. Globale Module zeigt die Übersicht mit `[global <ID>]`: ihren Inhalt im
|
||
Bibliothekseintrag ändern (`lit-divi-outline` mit `post_id` = ID; Ablauf mit Probelauf und `confirm` siehe
|
||
`lit-guide` topic `divi-library`). `lit/divi-replace-text` ändert sie nicht, sondern nennt sie in
|
||
`skipped_nodes`.
|
||
```
|
||
|
||
`docs/guides/divi-design-system.md` – vor „Regeln:“ einfügen:
|
||
|
||
```markdown
|
||
Auf großen Websites eingrenzen: `only` (Liste aus `colors`, `variables`, `presets`) liefert nur diese Teile,
|
||
`module` (z. B. `"button"`) nur die Presets dieses Moduls; höchstens 200 Presets je Antwort.
|
||
```
|
||
|
||
`docs/guides/workflows.md` – nach „Divi-Seite bauen“ einfügen:
|
||
|
||
```markdown
|
||
## Bibliothek und globale Module
|
||
|
||
Vorhandene Abschnitte aus der Divi-Bibliothek zuerst suchen (`lit/library-list`) und mit `lit-library-insert`
|
||
einfügen, statt sie neu zu bauen. Einen gelungenen Abschnitt für später speichern: `lit/library-save`.
|
||
Abschnitte zwischen Seiten kopieren: `lit/divi-node-copy`. Globale Module ändern und neue vorschlagen:
|
||
`lit-guide` topic `divi-library`.
|
||
```
|
||
|
||
Im Abschnitt „Text auf vielen Seiten ersetzen“ den letzten Satz ersetzen durch: „Globale Module werden nicht
|
||
geändert, sondern in `skipped_nodes` genannt – sie im Bibliothekseintrag ändern (`lit-guide` topic
|
||
`divi-library`).“
|
||
|
||
- [ ] **Step 5: Server-Instructions**
|
||
|
||
`InstructionsBuilder::build()` – nach dem `$divi`-Block:
|
||
|
||
```php
|
||
$library = str_contains(', ' . $active . ',', ', divi-library,')
|
||
? [
|
||
'- Divi-Bibliothek: globale Module (lit-divi-outline zeigt [global <ID>]) im Bibliothekseintrag ändern; '
|
||
. 'das wirkt auf alle Seiten und braucht nach dem Probelauf confirm: true (lit-guide topic '
|
||
. '"divi-library").',
|
||
]
|
||
: [];
|
||
```
|
||
|
||
und im `implode` `array_merge([...], $divi, $library)`.
|
||
|
||
- [ ] **Step 6: Readme und Version**
|
||
|
||
`wp-lit-mcp.php`: `* Version: 0.4.0`. `src/Plugin.php`: `public const VERSION = '0.4.0';`. `readme.txt`: `Stable tag: 0.4.0`.
|
||
|
||
`readme.txt` – im ersten Satz der Beschreibung „(z. B. Claude oder ein anderer MCP-fähiger Client mit OAuth)“ durch „(ein MCP-fähiger Client mit OAuth)“ ersetzen und die Aufzählung um „Divi-Seiten und die Divi-Bibliothek (auch globale Module)“ ergänzen.
|
||
|
||
Unter „Auswirkungen auf die gesamte Website“ anfügen:
|
||
|
||
```text
|
||
* Divi-Bibliothek: LIT MCP legt Bibliothekseinträge selbst an (Post-Typ et_pb_layout, Status publish, mit
|
||
Divis Begriffen scope, layout_type, module_width und dessen Meta-Feldern) und benutzt keine Builder-Routen.
|
||
Eine Änderung an einem globalen Bibliothekseintrag wirkt sofort auf allen Seiten, die ihn zeigen; LIT MCP
|
||
verlangt dafür einen Probelauf mit Liste der betroffenen Seiten und confirm, legt vorher eine Revision (bei
|
||
abgeschalteten Revisionen eine Sicherungskopie im Papierkorb) an und leert danach Divis CSS-Cache aller Seiten
|
||
und den Theme-Builder-Cache.
|
||
* Divis Rollen-Editor gilt zusätzlich zu den WordPress-Rechten: ohne „Divi-Bibliothek“, „In der Bibliothek
|
||
speichern“, „Aus der Bibliothek hinzufügen“ bzw. „Globale Bibliothekselemente bearbeiten“ lehnt LIT MCP ab.
|
||
* Interne Links über {{link:<ID>}} nutzen Divis eigenen dynamischen Inhalt „<Typ> Link“: die Adresse wird beim
|
||
Anzeigen ermittelt.
|
||
```
|
||
|
||
Unter „Rückgängig machen“ nach dem Punkt „Divi-Seiten“ einfügen:
|
||
|
||
```text
|
||
* Bibliothekseinträge: jede Änderung legt vorher eine Revision an (revision_id), bei abgeschalteten Revisionen
|
||
eine Sicherungskopie im Papierkorb (backup_id); zurück über WordPress (Eintrag der Divi-Bibliothek
|
||
bearbeiten → Revisionen). Neu angelegte Einträge (lit/library-save) in der Divi-Bibliothek löschen.
|
||
```
|
||
|
||
Unter „Frequently Asked Questions“ anfügen:
|
||
|
||
```text
|
||
= Was passiert, wenn der Assistent ein globales Modul ändert? =
|
||
|
||
Die Änderung wirkt auf allen Seiten mit diesem Modul. LIT MCP speichert erst nach einem Probelauf, der die
|
||
betroffenen Seiten nennt, und einer ausdrücklichen Bestätigung (confirm); vorher entsteht eine Revision des
|
||
Bibliothekseintrags.
|
||
```
|
||
|
||
Changelog oben:
|
||
|
||
```text
|
||
= 0.4.0 =
|
||
* Divi-Bibliothek: Einträge auflisten und lesen (lit/library-list), Knoten als normalen oder globalen Eintrag
|
||
speichern (lit/library-save), als Kopie oder globale Instanz einfügen (lit-library-insert, direkt).
|
||
* Globale Module: Bibliothekseinträge mit den Divi-Werkzeugen bearbeiten; bei globalen Einträgen Probelauf
|
||
mit betroffenen Seiten, confirm, Revision bzw. Sicherung und seitenweite Cache-Leerung.
|
||
* Knoten zwischen Seiten und Bibliothekseinträgen kopieren (lit/divi-node-copy).
|
||
* Interne Links mit {{link:<ID>}}; lit/divi-dynamic-sources listet Divis dynamische Quellen und geeignete Felder.
|
||
* lit-guide mit dem Thema „all“; lit-divi-design-system mit Filtern (only, module); lit-divi-node-get und
|
||
lit-divi-outline nennen die Bibliotheks-ID globaler Module; lit-page-render-summary weist auf globale Module
|
||
hin; lit-site-status prüft die genutzten Divi-Funktionen.
|
||
* Tools-Gruppe „Divi-Bibliothek“; „nur lesen“ sperrt auch Schreibzugriffe der Divi-Werkzeuge auf die Bibliothek.
|
||
```
|
||
|
||
- [ ] **Step 7: Spec und Entscheidungen nachtragen**
|
||
|
||
In `docs/superpowers/specs/2026-09-25-wp-lit-mcp-design.md`:
|
||
|
||
- §4.3, zweiter Punkt, anfügen: „**Stand nach Etappe 3a:** 22 direkte Tools (dazu `lit/library-insert`); indirekt neu `lit/library-list`, `lit/library-save`, `lit/divi-node-copy`, `lit/divi-dynamic-sources`. Neue Tool-Gruppe „Divi-Bibliothek“.“
|
||
- §5.2, letzter Punkt: „(Bearbeitung ab Etappe 3)“ → „(bearbeitet werden globale Module seit Etappe 3a im Bibliothekseintrag, E2)“.
|
||
- §5.4, Platzhalter-Tabelle nach `{{field:<meta_key>}}`: „| `{{link:<ID>}}` | interner Link: Dynamic Content `post_link_url_<Typ>` mit `post_id` (nur Link-Felder; Etappe 3a, E13a) |“
|
||
- §5.7: Zeile `lit/divi-dynamic-sources` → „… – Etappe 3a (E12, E14); nur textartige Felder (Antwort F4)“; Zeile `lit/library-list`, `lit/library-get` → „| `lit/library-list` | lesen | Einträge nach Typ (`layout_type`) und Scope, mit `cursor`; mit `id` Detail inkl. Knoten-Übersicht und betroffener Seiten (ersetzt `lit/library-get`, E9) |“; Zeile `lit/library-insert` → „… als Kopie oder globale Instanz im Format des Visual Builders (`localAttrs`-Schnappschuss, `globalParent`) einfügen; direkt“; Zeile `lit/divi-node-copy` → „Knoten von Eintrag A nach Eintrag B kopieren (Seiten und Bibliothekseinträge; byte-gleich, S7/S26-Prüfung E6)“.
|
||
- §9.2, Themenliste: „`divi-library`“ und „`media`“ ergänzen sowie „Thema `all` liefert alle Themen (Etappe 3a)“.
|
||
- §9.3: „(Stand Etappe 3a: noch keine MCP-Prompts im Plugin; `globale-module-vorschlagen` steht als Ablauf im Guide `divi-library`.)“
|
||
|
||
In `docs/superpowers/notes/2026-09-27-etappe-3-entscheidungen-entwurf.md` am Ende anfügen:
|
||
|
||
```markdown
|
||
## 6. Umsetzung Etappe 3a (Plan 2026-09-27-etappe-3a-bibliothek.md)
|
||
|
||
- E5 präzisiert durch die Builder-Fixtures: Instanzen werden wie im Visual Builder erzeugt – `localAttrs` =
|
||
vollständiger Schnappschuss der Wurzel-Attribute (oberste Schlüssel sortiert), Kinder mit `globalParent`,
|
||
ohne Kinder selbstschließend – statt der minimalen Form ohne `localAttrs`. Byte-Test gegen
|
||
`page--globale-instanzen.html`.
|
||
- Neuer Befund 9: Bibliothekseinträge aus Divis Dialog haben `\r\n` zwischen Blöcken (Formular-Upload);
|
||
`LibraryContent::load()` vereinheitlicht das vor jeder Übernahme.
|
||
- Kopie eines normalen Eintrags mit globalen Instanzen: Instanzen bleiben verknüpft (wie Divis `/load`);
|
||
entglobalisiert wird nur der Inhalt globaler Einträge (Divis Schadensbegrenzung, F10).
|
||
- E6 erweitert: `StoredNodeGuard` prüft neben den S7/S26-Pfaden und dem Code-Modul auch `$variable`-Verweise
|
||
(Ablehnung, wenn `canonical()` sie für das Ziel ablehnt oder ihre Einstellungen verändern würde) – Grund:
|
||
R2-Befund 1 (before/after nach dem Autor des Ziel-Posts).
|
||
- E3 ergänzt: neue Einträge zusätzlich nur mit `publish_posts` (Bibliothekseinträge sind immer `publish`).
|
||
- E9 umgesetzt mit: `lit/divi-node-copy` und `lit/divi-dynamic-sources` in der Gruppe „Divi“; die Gruppe
|
||
„Divi-Bibliothek“ sperrt als Ganzes („nur lesen“/deaktiviert) auch Schreibzugriffe der Divi-Werkzeuge auf
|
||
Bibliothekseinträge (`ExposurePolicy::groupWritable`).
|
||
- Antwort F2: jede Änderung eines globalen Eintrags ist zuerst ein Probelauf (auch ohne veröffentlichte
|
||
Instanzen); `lit-divi-delete` nutzt dasselbe `confirm`, sein `confirm_required` nennt dann ebenfalls die
|
||
betroffenen Seiten.
|
||
- Bibliothekseinträge bekommen keine Divi-Flags (Befund 4); `_et_pb_row_layout` wird nicht geschrieben (Befund 5).
|
||
- E15: Adapter `DiviRoles`, `DiviLibraryStore`, Prüfung `DiviCompatibility` in `lit-site-status`.
|
||
- E13d umgesetzt als Hinweis in `notes`; eine eigene Expansion globaler Module im Auszug unterbleibt.
|
||
```
|
||
|
||
- [ ] **Step 8: Tests und Lint**
|
||
|
||
Run: `vendor/bin/phpunit --filter 'InstructionsBuilderTest|ToolNamingTest|GuideRepositoryTest|GuideAbilityTest'`
|
||
Expected: PASS
|
||
|
||
Run: `composer test && composer lint`
|
||
Expected: OK
|
||
|
||
Run: `grep -rn "Claude\|ChatGPT\|claude.ai" docs/guides readme.txt src/Admin src/Guides`
|
||
Expected: keine Treffer
|
||
|
||
- [ ] **Step 9: Commit**
|
||
|
||
```bash
|
||
git add docs/guides src/Guides/InstructionsBuilder.php readme.txt wp-lit-mcp.php src/Plugin.php docs/superpowers/specs/2026-09-25-wp-lit-mcp-design.md docs/superpowers/notes/2026-09-27-etappe-3-entscheidungen-entwurf.md tests/Unit/Guides/InstructionsBuilderTest.php
|
||
```
|
||
Commit wie in den Global Constraints mit der Nachricht `docs: guides, readme and spec for the Divi Library (v0.4.0)`.
|
||
|
||
---
|
||
|
||
### Task 17: Ende-zu-Ende-Test `divi-library-smoke.sh` und Abnahme-Notiz
|
||
|
||
Prüft 3a über den echten OAuth-Endpunkt in DDEV (Divi 5.2.1): Exposition, Speichern normal/global mit Divis Termen, Einfügen als Instanz und Kopie, globaler Probelauf/`confirm`, Knoten kopieren, `{{link:ID}}`, die Übernahmen, ein Redakteur ohne `unfiltered_html` und die Gruppe „nur lesen“. Räumt alles wieder auf. Danach die manuelle Abnahme-Notiz für die Punkte, die den Visual Builder brauchen.
|
||
|
||
**Files:**
|
||
- Create: `tests/Integration/divi-library-smoke.sh`
|
||
- Create: `docs/superpowers/notes/2026-09-27-etappe-3a-abnahme.md`
|
||
|
||
**Interfaces:**
|
||
- Consumes: `tests/Integration/lib.sh` (`connect`, `tool`, `ability`, `rpc`, `error_code`, `pass`, `fail`, `finish`, `guard_exit`, `cleanup_app_passwords_for`), Fixture `tests/Fixtures/divi/converted-landing.html`.
|
||
- Produces: Skript, das mit `ALL CHECKS PASSED` endet.
|
||
|
||
- [ ] **Step 1: Skript schreiben**
|
||
|
||
`tests/Integration/divi-library-smoke.sh`:
|
||
|
||
```bash
|
||
#!/usr/bin/env bash
|
||
# End-to-end checks of Etappe 3a (Divi Library, global modules, node copy) through the OAuth-protected
|
||
# endpoint. Runs INSIDE the DDEV web container (Divi 5 must be the active theme):
|
||
# cd /home/janniclas/Projekte/WordPress && timeout 900 ddev exec bash wp-content/plugins/WP-LIT-MCP/tests/Integration/divi-library-smoke.sh
|
||
# Creates draft pages and library entries (titles "LIT Smoke …"), a temporary role/user without
|
||
# unfiltered_html, and removes everything again (posts with their revisions, backups, change-log rows,
|
||
# role, user, app passwords, options).
|
||
set -euo pipefail
|
||
cd /var/www/html
|
||
# shellcheck source=lib.sh
|
||
source wp-content/plugins/WP-LIT-MCP/tests/Integration/lib.sh
|
||
|
||
ADMIN_LOGIN=$(wp user list --role=administrator --field=user_login | head -1)
|
||
EDITOR_LOGIN=lit-lib-editor
|
||
FIXTURES=$PLUGIN/tests/Fixtures/divi
|
||
ORIGINAL_ROLES=$(wp option get lit_mcp_allowed_roles --format=json 2>/dev/null || echo '["administrator"]')
|
||
ORIGINAL_EXPOSURE=$(wp option get lit_mcp_exposure --format=json 2>/dev/null || echo '__none__')
|
||
CREATED_POSTS=()
|
||
|
||
restore_exposure() {
|
||
if [ "$ORIGINAL_EXPOSURE" = "__none__" ]; then
|
||
wp option delete lit_mcp_exposure >/dev/null 2>&1 || true
|
||
else
|
||
wp option update lit_mcp_exposure "$ORIGINAL_EXPOSURE" --format=json >/dev/null 2>&1 || true
|
||
fi
|
||
}
|
||
|
||
cleanup() {
|
||
# Library entries and backups the tools created ("LIT Smoke …", also from a run that stopped early).
|
||
for id in $(wp post list --post_type=et_pb_layout --post_status=publish,draft,trash --s="LIT Smoke" --field=ID 2>/dev/null); do
|
||
CREATED_POSTS+=("$id")
|
||
done
|
||
for id in "${CREATED_POSTS[@]}"; do
|
||
wp post delete "$id" --force >/dev/null 2>&1 || true
|
||
done
|
||
cleanup_app_passwords_for "$ADMIN_LOGIN"
|
||
cleanup_app_passwords_for "$EDITOR_LOGIN"
|
||
LIT_LOGIN="$EDITOR_LOGIN" LIT_IDS="${CREATED_POSTS[*]}" wp eval '
|
||
global $wpdb;
|
||
$table = $wpdb->prefix . "lit_mcp_log";
|
||
$u = get_user_by("login", getenv("LIT_LOGIN"));
|
||
if ($u) { $wpdb->delete($table, ["user_id" => $u->ID]); }
|
||
foreach (array_filter(explode(" ", (string) getenv("LIT_IDS"))) as $id) {
|
||
$wpdb->delete($table, ["object_id" => $id]);
|
||
}' >/dev/null 2>&1 || true
|
||
wp user delete "$EDITOR_LOGIN" --yes >/dev/null 2>&1 || true
|
||
wp role delete lit_lib_editor >/dev/null 2>&1 || true
|
||
wp option update lit_mcp_allowed_roles "$ORIGINAL_ROLES" --format=json >/dev/null 2>&1 || true
|
||
restore_exposure
|
||
}
|
||
trap 'rc=$?; cleanup; guard_exit "$rc" || exit $?' EXIT
|
||
|
||
create_page() { # $1 = markup (not a file), $2 = title -> prints the ID
|
||
LIT_CONTENT="$1" LIT_TITLE="$2" wp --user="$ADMIN_LOGIN" eval '
|
||
$id = wp_insert_post(["post_type" => "page", "post_status" => "draft", "post_title" => getenv("LIT_TITLE"),
|
||
"post_content" => wp_slash((string) getenv("LIT_CONTENT"))]);
|
||
update_post_meta($id, "_et_pb_use_builder", "on");
|
||
update_post_meta($id, "_et_pb_use_divi_5", "on");
|
||
echo $id;'
|
||
}
|
||
|
||
content_of() { # $1 = post ID
|
||
wp post get "$1" --field=post_content
|
||
}
|
||
|
||
outline() { # $1 = post ID -> the lit-divi-outline result
|
||
tool lit-divi-outline "{\"post_id\":$1}"
|
||
}
|
||
|
||
# 0. Two pages from the converted landing page fixture
|
||
LANDING=$(cat "$FIXTURES/converted-landing.html")
|
||
PAGE_ID=$(create_page "$LANDING" "LIT Smoke Quelle"); CREATED_POSTS+=("$PAGE_ID")
|
||
TARGET_ID=$(create_page "$LANDING" "LIT Smoke Ziel"); CREATED_POSTS+=("$TARGET_ID")
|
||
connect "$ADMIN_LOGIN"
|
||
|
||
# 1. Exposure: lit-library-insert direct, the other new tools indirect
|
||
LIST=$(rpc tools/list '{}')
|
||
echo "$LIST" | jq -e '.result.tools[] | select(.name == "lit-library-insert")' >/dev/null || fail "lit-library-insert is not direct"
|
||
for t in lit-library-list lit-library-save lit-divi-node-copy lit-divi-dynamic-sources; do
|
||
if echo "$LIST" | jq -e --arg t "$t" '.result.tools[] | select(.name == $t)' >/dev/null; then fail "$t must be indirect"; fi
|
||
done
|
||
pass "tools/list: lit-library-insert direct, library-list/-save, node-copy, dynamic-sources indirect"
|
||
|
||
# 2. Save a section as normal library entry: Divi's terms, no Divi flags, unchanged node bytes
|
||
SOURCE=$(outline "$PAGE_ID")
|
||
REV=$(echo "$SOURCE" | jq -r '.tree_rev')
|
||
SECTION=$(echo "$SOURCE" | jq -r '[.nodes[] | select(.type == "section")][1].id')
|
||
SAVED=$(ability lit/library-save "$(jq -cn --argjson id "$PAGE_ID" --arg rev "$REV" --arg s "$SECTION" \
|
||
'{post_id: $id, tree_rev: $rev, id: $s, title: "LIT Smoke Abschnitt"}')")
|
||
LIB_ID=$(echo "$SAVED" | jq -r '.library_id // empty')
|
||
[ -n "$LIB_ID" ] || fail "library-save: $SAVED"
|
||
CREATED_POSTS+=("$LIB_ID")
|
||
[ "$(wp post term list "$LIB_ID" layout_type --field=slug)" = "section" ] || fail "layout_type of $LIB_ID"
|
||
[ "$(wp post term list "$LIB_ID" scope --field=slug)" = "non_global" ] || fail "scope of $LIB_ID"
|
||
[ -z "$(wp post meta get "$LIB_ID" _et_pb_use_divi_5 2>/dev/null || true)" ] || fail "library entry got Divi flags"
|
||
[ "$(LIT_PAGE="$PAGE_ID" LIT_LIB="$LIB_ID" wp eval '
|
||
$page = (string) get_post((int) getenv("LIT_PAGE"))->post_content;
|
||
$lib = (string) get_post((int) getenv("LIT_LIB"))->post_content;
|
||
$open = "<!-- wp:divi/placeholder -->"; $close = "<!-- /wp:divi/placeholder -->";
|
||
$inner = str_starts_with($lib, $open) && str_ends_with($lib, $close) ? substr($lib, strlen($open), -strlen($close)) : "";
|
||
echo $inner !== "" && str_contains($page, $inner) ? "yes" : "no";')" = "yes" ] || fail "library entry does not hold the node bytes"
|
||
ability lit/library-list '{"search":"LIT Smoke"}' | jq -e --argjson id "$LIB_ID" '.items | map(.id) | index($id) != null' >/dev/null \
|
||
|| fail "library-list does not show $LIB_ID"
|
||
pass "lit/library-save: normal section with Divi's terms, node bytes in a divi/placeholder frame, listed"
|
||
|
||
# 3. Save a module as global entry, insert it as instance into the target page
|
||
TEXT=$(echo "$SOURCE" | jq -r '[.nodes[] | select(.type == "text")][0].id')
|
||
GSAVED=$(ability lit/library-save "$(jq -cn --argjson id "$PAGE_ID" --arg rev "$REV" --arg m "$TEXT" \
|
||
'{post_id: $id, tree_rev: $rev, id: $m, title: "LIT Smoke Globales Modul", scope: "global"}')")
|
||
GLOB_ID=$(echo "$GSAVED" | jq -r '.library_id // empty')
|
||
[ -n "$GLOB_ID" ] || fail "global library-save: $GSAVED"
|
||
CREATED_POSTS+=("$GLOB_ID")
|
||
[ "$(wp post term list "$GLOB_ID" scope --field=slug)" = "global" ] || fail "scope of $GLOB_ID"
|
||
[ "$(wp post meta get "$GLOB_ID" _et_pb_excluded_global_options)" = "[]" ] || fail "excluded global options of $GLOB_ID"
|
||
TARGET=$(outline "$TARGET_ID")
|
||
COLUMN=$(echo "$TARGET" | jq -r '[.nodes[] | select(.type == "column")][0].id')
|
||
INSERTED=$(tool lit-library-insert "$(jq -cn --argjson id "$TARGET_ID" --arg rev "$(echo "$TARGET" | jq -r .tree_rev)" \
|
||
--argjson lib "$GLOB_ID" --arg c "$COLUMN" '{post_id: $id, tree_rev: $rev, library_id: $lib, parent: $c}')")
|
||
echo "$INSERTED" | jq -e '.ok == true' >/dev/null || fail "library-insert global: $INSERTED"
|
||
content_of "$TARGET_ID" | grep -q "<!-- wp:divi/global-layout {\"globalModule\":\"$GLOB_ID\",\"blockName\":\"divi/text\",\"localAttrs\":{" \
|
||
|| fail "instance not in the builder's format"
|
||
outline "$TARGET_ID" | jq -e --arg g "[global $GLOB_ID]" '.outline | contains($g)' >/dev/null || fail "outline does not name the instance"
|
||
tool lit-page-render-summary "{\"post_id\":$TARGET_ID}" | jq -e --arg g "Globales Modul $GLOB_ID" '.notes | map(contains($g)) | any' >/dev/null \
|
||
|| fail "render summary does not note the global module"
|
||
pass "global entry saved; lit-library-insert writes the builder's instance; outline and render summary name it"
|
||
|
||
# 4. Change the global entry: dry run lists the target page, confirm saves with a revision, pages untouched
|
||
BEFORE_TARGET=$(content_of "$TARGET_ID" | sha256sum)
|
||
GREV=$(outline "$GLOB_ID" | jq -r '.tree_rev')
|
||
DRY=$(tool lit-divi-update "$(jq -cn --argjson id "$GLOB_ID" --arg rev "$GREV" '{post_id: $id, tree_rev: $rev,
|
||
changes: [{id: "m0", label: "LIT Smoke geändert"}]}')")
|
||
[ "$(error_code "$DRY")" = "confirm_required" ] || fail "global edit without confirm: $DRY"
|
||
echo "$DRY" | jq -r '.__error' | jq -e --argjson t "$TARGET_ID" '.affected | map(.post_id) | index($t) != null' >/dev/null \
|
||
|| fail "dry run does not list the target page: $DRY"
|
||
[ "$(outline "$GLOB_ID" | jq -r '.tree_rev')" = "$GREV" ] || fail "dry run wrote something"
|
||
DONE=$(tool lit-divi-update "$(jq -cn --argjson id "$GLOB_ID" --arg rev "$GREV" '{post_id: $id, tree_rev: $rev, confirm: true,
|
||
changes: [{id: "m0", label: "LIT Smoke geändert"}]}')")
|
||
echo "$DONE" | jq -e '.ok == true and .revision_id != null and .affected_count >= 1' >/dev/null || fail "confirmed global edit: $DONE"
|
||
[ "$(content_of "$TARGET_ID" | sha256sum)" = "$BEFORE_TARGET" ] || fail "the global edit changed the page bytes"
|
||
pass "global entry: dry run with affected pages, confirm saves with revision, pages keep their bytes"
|
||
|
||
# 5. Insert the normal entry as copy: no frame, no CRLF
|
||
TREV=$(outline "$TARGET_ID" | jq -r '.tree_rev')
|
||
COPY=$(tool lit-library-insert "$(jq -cn --argjson id "$TARGET_ID" --arg rev "$TREV" --argjson lib "$LIB_ID" \
|
||
'{post_id: $id, tree_rev: $rev, library_id: $lib, mode: "copy"}')")
|
||
echo "$COPY" | jq -e '.ok == true' >/dev/null || fail "library-insert copy: $COPY"
|
||
if content_of "$TARGET_ID" | grep -q $'\r'; then fail "copy brought CRLF into the page"; fi
|
||
pass "lit-library-insert copy"
|
||
|
||
# 6. Copy a node between pages; a stale source tree_rev writes nothing
|
||
TREV=$(echo "$COPY" | jq -r '.tree_rev')
|
||
STALE=$(ability lit/divi-node-copy "$(jq -cn --argjson id "$TARGET_ID" --arg rev "$TREV" --argjson src "$PAGE_ID" --arg s "$SECTION" \
|
||
'{post_id: $id, tree_rev: $rev, source_post_id: $src, source_id: $s, source_tree_rev: "abcdef012345"}')")
|
||
[ "$(error_code "$STALE")" = "rev_mismatch" ] || fail "stale source_tree_rev: $STALE"
|
||
NODE_COPY=$(ability lit/divi-node-copy "$(jq -cn --argjson id "$TARGET_ID" --arg rev "$TREV" --argjson src "$PAGE_ID" --arg s "$SECTION" \
|
||
--arg srev "$(outline "$PAGE_ID" | jq -r .tree_rev)" '{post_id: $id, tree_rev: $rev, source_post_id: $src, source_id: $s, source_tree_rev: $srev}')")
|
||
echo "$NODE_COPY" | jq -e '.ok == true' >/dev/null || fail "node-copy: $NODE_COPY"
|
||
pass "lit/divi-node-copy: stale source refused, copy saved"
|
||
|
||
# 7. {{link:ID}} in a URL field; refused in a text field
|
||
TREV=$(echo "$NODE_COPY" | jq -r '.tree_rev')
|
||
LINKED=$(tool lit-divi-insert "$(jq -cn --argjson id "$TARGET_ID" --arg rev "$TREV" --arg c "$COLUMN" --arg u "{{link:$PAGE_ID}}" \
|
||
'{post_id: $id, tree_rev: $rev, parent: $c, nodes: [{type: "button", text: "Zur Quelle", url: $u}]}')")
|
||
echo "$LINKED" | jq -e '.ok == true' >/dev/null || fail "{{link}} in a button: $LINKED"
|
||
content_of "$TARGET_ID" | grep -q 'post_link_url_page' || fail "{{link}} not stored as post_link_url_page"
|
||
TREV=$(echo "$LINKED" | jq -r '.tree_rev')
|
||
TEXT_LINK=$(tool lit-divi-insert "$(jq -cn --argjson id "$TARGET_ID" --arg rev "$TREV" --arg c "$COLUMN" --arg u "{{link:$PAGE_ID}}" \
|
||
'{post_id: $id, tree_rev: $rev, parent: $c, nodes: [{type: "heading", text: $u}]}')")
|
||
[ "$(error_code "$TEXT_LINK")" = "validation_failed" ] || fail "{{link}} in a text field: $TEXT_LINK"
|
||
pass "{{link:ID}} stored as Divi's internal link, refused outside link fields"
|
||
|
||
# 8. Carry-overs: guide "all", design-system filter, dynamic sources, site-status compatibility
|
||
tool lit-guide '{"topic":"all"}' | jq -e '.content | contains("Thema `divi-library`")' >/dev/null || fail "guide all"
|
||
tool lit-divi-design-system '{"only":["colors"]}' | jq -e '.variables == [] and .presets == []' >/dev/null || fail "design-system only"
|
||
ability lit/divi-dynamic-sources '{"post_type":"page"}' | jq -e '.sources | map(.name) | index("post_title") != null' >/dev/null \
|
||
|| fail "dynamic sources"
|
||
tool lit-site-status '{}' | jq -e '.components[] | select(.id == "divi") | .problems == []' >/dev/null || fail "Divi compatibility findings"
|
||
pass "lit-guide all, design-system only, dynamic sources, site-status without Divi findings"
|
||
|
||
# 9. A user without unfiltered_html cannot carry custom CSS to another post (E6)
|
||
CSS_ID=$(create_page '<!-- wp:divi/placeholder --><!-- wp:divi/section {"css":{"desktop":{"value":{"freeForm":"body{outline:1px solid red}"}}}} --><!-- wp:divi/row --><!-- wp:divi/column {"module":{"decoration":{"sizing":{"desktop":{"value":{"flexType":"24_24"}}}}}} --><!-- wp:divi/text {"content":{"innerContent":{"desktop":{"value":"<p>CSS</p>"}}}} /--><!-- /wp:divi/column --><!-- /wp:divi/row --><!-- /wp:divi/section --><!-- /wp:divi/placeholder -->' "LIT Smoke CSS")
|
||
CREATED_POSTS+=("$CSS_ID")
|
||
wp role create lit_lib_editor "LIT Smoke Bibliothek" --clone=editor >/dev/null
|
||
wp cap remove lit_lib_editor unfiltered_html >/dev/null
|
||
wp option update lit_mcp_allowed_roles '["administrator","lit_lib_editor"]' --format=json >/dev/null
|
||
wp user create "$EDITOR_LOGIN" lit-lib-editor@example.invalid --role=lit_lib_editor >/dev/null
|
||
connect "$EDITOR_LOGIN"
|
||
BEFORE_TARGET=$(content_of "$TARGET_ID" | sha256sum)
|
||
CARRY=$(ability lit/divi-node-copy "$(jq -cn --argjson id "$TARGET_ID" --arg rev "$(outline "$TARGET_ID" | jq -r .tree_rev)" \
|
||
--argjson src "$CSS_ID" --arg srev "$(outline "$CSS_ID" | jq -r .tree_rev)" \
|
||
'{post_id: $id, tree_rev: $rev, source_post_id: $src, source_id: "s0", source_tree_rev: $srev}')")
|
||
[ "$(error_code "$CARRY")" = "validation_failed" ] || fail "editor carried custom CSS: $CARRY"
|
||
KEEP=$(ability lit/library-save "$(jq -cn --argjson id "$CSS_ID" --arg rev "$(outline "$CSS_ID" | jq -r .tree_rev)" \
|
||
'{post_id: $id, tree_rev: $rev, id: "s0", title: "LIT Smoke CSS-Eintrag"}')")
|
||
[ "$(error_code "$KEEP")" = "validation_failed" ] || fail "editor saved custom CSS to the library: $KEEP"
|
||
[ "$(content_of "$TARGET_ID" | sha256sum)" = "$BEFORE_TARGET" ] || fail "a refused copy wrote something"
|
||
pass "user without unfiltered_html: custom CSS neither copied nor saved to the library"
|
||
|
||
# 10. Group "Divi-Bibliothek" read-only: no writes to library entries, lit-library-insert gone
|
||
wp option update lit_mcp_exposure '{"@readonly:divi-library":true}' --format=json >/dev/null
|
||
connect "$ADMIN_LOGIN"
|
||
if rpc tools/list '{}' | jq -e '.result.tools[] | select(.name == "lit-library-insert")' >/dev/null; then
|
||
fail "lit-library-insert listed although the group is read-only"
|
||
fi
|
||
LREV=$(outline "$LIB_ID" | jq -r '.tree_rev')
|
||
[ "$LREV" != "null" ] || fail "library entry no longer readable"
|
||
BLOCKED=$(tool lit-divi-update "$(jq -cn --argjson id "$LIB_ID" --arg rev "$LREV" '{post_id: $id, tree_rev: $rev,
|
||
changes: [{id: "s0", label: "LIT Smoke gesperrt"}]}')")
|
||
[ "$(error_code "$BLOCKED")" = "forbidden" ] || fail "write to a library entry with the group read-only: $BLOCKED"
|
||
restore_exposure
|
||
pass "group Divi-Bibliothek read-only: entries readable, not writable, lit-library-insert not listed"
|
||
|
||
finish
|
||
```
|
||
|
||
- [ ] **Step 2: Skript ausführen**
|
||
|
||
Run: `cd /home/janniclas/Projekte/WordPress && timeout 900 ddev exec bash wp-content/plugins/WP-LIT-MCP/tests/Integration/divi-library-smoke.sh`
|
||
Expected: alle Zeilen `ok - …`, am Ende `ALL CHECKS PASSED`. Danach prüfen, dass nichts übrig ist:
|
||
|
||
Run: `cd /home/janniclas/Projekte/WordPress && ddev wp post list --post_type=et_pb_layout,page --post_status=publish,draft,trash --s="LIT Smoke" --format=count`
|
||
Expected: `0`
|
||
|
||
Die übrigen Smokes laufen unverändert grün:
|
||
|
||
Run: `cd /home/janniclas/Projekte/WordPress && for s in divi-write-smoke divi-read-smoke mcp-smoke wp-basis-smoke media-admin-smoke; do timeout 900 ddev exec bash wp-content/plugins/WP-LIT-MCP/tests/Integration/$s.sh | tail -1; done`
|
||
Expected: fünfmal `ALL CHECKS PASSED`
|
||
|
||
- [ ] **Step 3: Abnahme-Notiz schreiben**
|
||
|
||
`docs/superpowers/notes/2026-09-27-etappe-3a-abnahme.md`:
|
||
|
||
```markdown
|
||
# Etappe 3a – Manuelle Abnahme (Divi-Bibliothek)
|
||
|
||
Automatisch geprüft sind bereits:
|
||
|
||
- alle Unit-Tests (`composer test`) und Lint (`composer lint`);
|
||
- `divi-library-smoke.sh` (neu) und die fünf bisherigen Integrationsskripte (alle in `tests/Integration/`).
|
||
|
||
`divi-library-smoke.sh` prüft über den OAuth-Endpunkt: `lit-library-insert` direkt, die übrigen neuen Tools
|
||
indirekt; Speichern als normaler und globaler Eintrag mit Divis Begriffen, ohne Divi-Kennzeichen und mit den
|
||
unveränderten Bytes des Knotens; Einfügen als Instanz im Format des Visual Builders und als Kopie; Probelauf,
|
||
`confirm` und Revision beim Ändern eines globalen Eintrags; Knoten kopieren (auch Ablehnung einer veralteten
|
||
Quelle); `{{link:ID}}`; die Übernahmen aus Etappe 2; einen Redakteur ohne `unfiltered_html`, der eigenes CSS
|
||
weder kopieren noch in die Bibliothek speichern kann; die Gruppe „Divi-Bibliothek“ auf „nur lesen“.
|
||
|
||
Die folgenden Punkte brauchen den echten Visual Builder bzw. einen verbundenen KI-Assistenten. Abweichungen
|
||
als kurze Notiz zurückmelden; sie werden Folgeaufgaben.
|
||
|
||
## 1. Vom Plugin angelegte Bibliothekseinträge
|
||
|
||
1. Über den KI-Assistenten einen Abschnitt einer Entwurfsseite als normalen Eintrag und ein Modul als
|
||
globalen Eintrag speichern lassen.
|
||
2. Divi → Divi-Bibliothek öffnen: beide Einträge erscheinen mit richtigem Typ (Abschnitt/Modul), der globale
|
||
als global.
|
||
3. Im Visual Builder einer Seite „Aus Bibliothek hinzufügen“: beide Einträge sind auswählbar und lassen sich
|
||
einfügen.
|
||
|
||
## 2. Vom Plugin eingefügte globale Instanz
|
||
|
||
1. Den globalen Eintrag mit `lit-library-insert` in eine Entwurfsseite einfügen lassen.
|
||
2. Seite im Visual Builder öffnen: das Modul ist als global markiert und zeigt den Inhalt der Bibliothek.
|
||
3. Das Modul im Builder ändern und speichern: die Änderung erscheint im Bibliothekseintrag und auf einer
|
||
zweiten Seite mit derselben Instanz.
|
||
4. Vorschau der Seite: der Inhalt des globalen Moduls wird angezeigt.
|
||
|
||
## 3. Globales Modul über den Assistenten ändern
|
||
|
||
1. Den Assistenten bitten, den Text des globalen Moduls zu ändern. Er muss zuerst die betroffenen Seiten nennen
|
||
und nachfragen.
|
||
2. Nach Zustimmung: Vorschau beider Seiten zeigt den neuen Text; unter Einstellungen → LIT MCP → Protokoll
|
||
steht der Eintrag mit Revision; die Revision ist in WordPress beim Bibliothekseintrag sichtbar.
|
||
|
||
## 4. Kopie und Knoten kopieren
|
||
|
||
1. Einen normalen Eintrag als Kopie einfügen und einen Abschnitt mit `lit/divi-node-copy` auf eine andere Seite
|
||
kopieren lassen.
|
||
2. Beide im Builder öffnen, ändern, speichern – nichts Ungewöhnliches (keine verknüpften Änderungen an anderen
|
||
Seiten).
|
||
|
||
## 5. Interner Link
|
||
|
||
1. Einen Button mit `{{link:<ID einer Entwurfsseite>}}` einfügen lassen.
|
||
2. Im Builder zeigt das Link-Feld dynamischen Inhalt „Seite Link“ mit der gewählten Seite.
|
||
3. Die Zielseite veröffentlichen: der Button verlinkt auf die schöne Adresse.
|
||
|
||
## 6. Rechte und Einstellungen
|
||
|
||
1. In Divi → Rollen-Editor für „Redakteur“ „Globale Bibliothekselemente bearbeiten“ abschalten und als
|
||
Redakteur ein globales Modul ändern lassen: Ablehnung mit Hinweis auf den Rollen-Editor.
|
||
2. Einstellungen → LIT MCP → Tools: Gruppe „Divi-Bibliothek“ ist sichtbar; „nur lesen“ entfernt
|
||
`lit-library-insert` aus der Werkzeugliste (nach neuer Verbindung).
|
||
3. `lit-site-status`: bei Divi keine Einträge unter `problems`.
|
||
|
||
## Aufräumen
|
||
|
||
Die Testeinträge in der Divi-Bibliothek und die Entwurfsseiten löschen (Titel wie bei der Abnahme vergeben).
|
||
Divi legt fehlende Systembegriffe (`scope`, `layout_type`, `module_width`) beim nächsten Speichern selbst an.
|
||
```
|
||
|
||
- [ ] **Step 4: Commit**
|
||
|
||
```bash
|
||
chmod +x tests/Integration/divi-library-smoke.sh
|
||
git add tests/Integration/divi-library-smoke.sh docs/superpowers/notes/2026-09-27-etappe-3a-abnahme.md
|
||
```
|
||
Commit wie in den Global Constraints mit der Nachricht `test: end-to-end smoke and acceptance note for the Divi Library (3a)`.
|
||
|
||
---
|
||
|
||
## Offene Punkte (nicht Teil dieses Plans)
|
||
|
||
- `lit/revision-restore` erreicht Bibliothekseinträge nicht (`ContentSchema::EXCLUDED`); Zurücksetzen über die WordPress-Oberfläche. Kandidat für 3b.
|
||
- `lit/divi-replace-text` durchsucht keine Bibliothekseinträge (je Inhaltstyp); globale Module werden weiter als `skipped_nodes` gemeldet.
|
||
- MCP-Prompts (Spec §9.3) gibt es im Plugin noch nicht; `globale-module-vorschlagen` steht als Ablauf im Guide `divi-library`.
|
||
- Ob der Visual Builder Instanzen mit tief verschachtelten `localAttrs` anders sortiert als nur auf oberster Ebene, zeigt erst ein reicheres Builder-Fixture; die Abnahme (Abschnitt 2) prüft das Verhalten im Builder.
|
||
- Bearbeiten nicht synchronisierter Attribute einer einzelnen Instanz (`localAttrsMap`) bleibt Builder-Sache (E2).
|
||
- `lit/library-make-global`, `lit/library-find-similar`, Theme Builder: Etappe 3b.
|