Jan-Niclas LoosenandClaude Opus 5.5
47090621c7
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
5395 lines
226 KiB
Markdown
5395 lines
226 KiB
Markdown
# Etappe 4a – Designsystem: Änderungs-Pipeline, Snapshots und Presets – 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 liest Presets mit ihren Einstellungen (`lit/divi-preset-get`), legt Modul- und Gruppen-Presets an und ändert sie (`lit/divi-presets-set`, auch aus einem Modul einer Seite und als Standard-Preset), löscht unbenutzte Presets (`lit/divi-presets-delete`) und stellt den Preset-Bestand aus Snapshots wieder her (`lit/divi-design-snapshots`, `lit/divi-design-restore`) – jede Änderung mit Probelauf, `confirm`, Snapshot, Protokoll und über Divis eigenen Speicherweg.
|
||
|
||
**Architecture:** Reines PHP in `Divi/Design/` beschreibt Bestand (`PresetBook`), Bereich (`PresetScope`), Unterschied (`PresetDiff`) und den Aufbau eines Presets (`PresetComposer`, nutzt den vorhandenen `Composer::update()` an einem gedachten Modulblock). Ein neuer Adapter `DesignSystemWriter` ist die einzige Divi-Berührung beim Schreiben; er wiederholt die Schrittfolge von Divis `GlobalPresetController::sync` (Mirror mit Fingerabdruck). Die gemeinsame `DesignChange`-Pipeline (Rechte geprüft vom Tool → Probelauf mit `diff`/`affected`/`design_rev` → `confirm` → `design_rev`-Vergleich → Snapshot (`SnapshotStore`) → Schreiben → Zurücklesen → Protokoll, bei Fehler Rollback) ist für alle Bereiche gebaut und wird hier mit dem Bereich `presets` (`PresetArea`) genutzt. Fundstellen liefert `GlobalUsages` über eine austauschbare Suche (`UsageQuery`): die bisherige Bibliothekssuche wird `LibraryUsageQuery`, neu kommt `PresetUsageQuery`.
|
||
|
||
**Tech Stack:** PHP ≥ 8.1, WordPress 7.x (Abilities API, Optionen, `$wpdb`), Divi 5.15.1 (`GlobalPreset`, `Conversion`, `UserRole`, `ET_Core_PageResource`), `wordpress/mcp-adapter` 0.5, PHPUnit 9.6 + Brain Monkey + Mockery, phpcs (WPCS, PHPCompatibilityWP), DDEV + bash/jq-Smokes.
|
||
|
||
**Spec:** `docs/superpowers/specs/2026-10-16-etappe-4-designsystem-design.md` (§3–§6.4, §10–§14; Annahmen A1–A11 freigegeben), Entscheidungen `docs/superpowers/notes/2026-09-28-etappe-4-entscheidungen-entwurf.md` (G1–G12, verbindlich), Datenformate `docs/superpowers/notes/2026-09-28-etappe-4-divi-formate.md` (Stand 5.2.1, Task 1 führt sie auf 5.15.1 nach), Fixtures `tests/Fixtures/divi/stage4/`, Seed `tests/Integration/divi-seed-stage4-design.php`.
|
||
|
||
**Voraussetzung:** Branch `etappe-4` mit Stand d391cb5 (Spec committet). Divi 5.15.1 ist installiert; die offene Freigabe von 5.15.1 (`DiviReleases::TESTED`, `fingerprints.json`, `vb-sync-flags.txt` im Arbeitsbaum) ist **vor Task 1 vom Benutzer committet**. 2345 Unit-Tests grün.
|
||
|
||
**Teil von Etappe 4:** 4a (dieser Plan) → 4b Zuweisen an Seiten (Stapel, Gruppen, Überdeckungen, Massenzuweisung, detach) → 4c Farben und Variablen → 4d Theme-Optionen und Schriften → 4e Schleifen-Inhalte, Guides, Audit, Version.
|
||
|
||
## 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 stellen den Preset-Bestand am Ende aus dem eigenen Snapshot wieder her.
|
||
- PHP ≥ 8.1 ohne 8.2+-Features; WordPress ≥ 6.9 (getestet 7.x); Divi 5.15.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.
|
||
- **Divi-Grenze (Divi-Absicherung §3):** Divi-Aufrufe (`GlobalPreset`, `Conversion`, `UserRole`, `et_*`, `ET_*`) nur in Adaptern, die in `DiviAdapters::CLASSES` stehen und jeden Aufruf im Manifest führen; nachgebaute Divi-Abläufe als `Mirror` mit Fingerabdruck in `src/Integrations/Divi/Release/fingerprints.json` und Referenz in `tests/Fixtures/divi/reference/<id>.txt`. `DiviBoundaryTest` bleibt grün. Jede schreibende Adapter-Methode ruft zuerst `ReleaseGate::assertWritable()`.
|
||
- `src/Integrations/Divi/BlockTree/*`, `src/Integrations/Divi/Compose/*` und die neuen reinen Klassen `PresetScope`, `PresetBook`, `PresetDiff`, `PresetComposer`, `PresetUsageMatcher` bleiben reines PHP ohne WordPress-Aufrufe.
|
||
- **Eine Engstelle für Client-Werte (D7):** Preset-Attribute aus `set`/`attrs` laufen ausschließlich durch `Composer::update()` (ShortformWriter/AttrWriter/ValueCleaner); Werte aus `from_node` sind gespeicherte Werte einer Seite und laufen durch `StoredNodeGuard` (Sperren S7/S26 für Benutzer ohne `unfiltered_html`). Vor dem Speichern bereinigt zusätzlich Divis `GlobalPreset::prepare_data()`.
|
||
- **Site-weite Änderungen (G2, Spec §4):** Ohne `confirm: true` nie schreiben; Probelauf = `Errors::confirmRequired()` mit `diff`, `affected`, `affected_count`, `design_rev`. Mit `confirm` Pflicht-Eingabe `design_rev`; Abweichung → `Errors::revMismatch()` mit eigener Meldung. Vor jedem Schreiben ein Snapshot; ohne Snapshot kein Schreiben.
|
||
- **Rechte (Spec §10):** Lesen = `edit_posts`. Presets schreiben, löschen, wiederherstellen = `edit_theme_options` + Divi `UserRole::can_current_user_use_visual_builder()` (über `DesignSystemWriter::canUseVisualBuilder()`). Snapshots auflisten = `edit_theme_options`.
|
||
- **Exposition:** Alle neuen Tools sind indirekt (über `mcp-adapter-execute-ability`), Gruppe „Divi“ (`divi`). `docs/guides/overview.md` „Direkt sichtbar:“ bleibt unverändert. Texte nennen indirekte Tools `lit/<name>` (ToolNamingTest).
|
||
- **Sprache:** Meldungen, Hinweise, Guides auf Deutsch mit echten Umlauten; neutral „KI-Assistent“, „MCP-Client“.
|
||
- Tests: 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. Reine Klassen erben von `PHPUnit\Framework\TestCase`. Integration: `cd /home/janniclas/Projekte/WordPress && timeout 900 ddev exec bash wp-content/plugins/WP-LIT-MCP/tests/Integration/<skript>.sh`.
|
||
- Commits: `git commit -m "<Nachricht>" -m "Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>"` (im Folgenden „Commit wie in den Global Constraints“). Nur die Dateien des Tasks stagen.
|
||
|
||
## Review Focus
|
||
|
||
1. **Preset mit Skript- oder HTML-Attributen von einem Redakteur ohne `unfiltered_html`** (über `set`/`attrs` oder `from_node` einer Admin-Seite): abgelehnt, nichts gespeichert → `PresetComposerTest::testEditorCannotCarryBuilderOnlyValuesFromANode`, `PresetsSetAbilityTest::testEditorWithoutUnfilteredHtmlIsRefusedForRawCss` (Tasks 9, 11).
|
||
2. **Inhalte im Preset** (Text, URL, Bild-ID): abgelehnt, weil Divis Preset-Mapping sie nicht als Preset-Attribut führt → `PresetComposerTest::testContentPathsAreRefused` (Task 9).
|
||
3. **Parallele Änderung** zwischen Probelauf und `confirm` (anderes Fenster im Builder): `rev_mismatch`, nichts geschrieben, kein Snapshot → `DesignChangeTest::testStaleDesignRevWritesNothing` (Task 8).
|
||
4. **Schreiben scheitert oder liest anders zurück**: Snapshot wird zurückgeschrieben, `write_failed`; scheitert auch das, `partial_write` mit `snapshot_id` → `DesignChangeTest::testFailedWriteRestoresTheSnapshot`, `::testFailedRollbackIsPartial` (Task 8).
|
||
5. **Löschen eines benutzten Presets** (Seite, Bibliothek, Theme Builder, als verschachteltes Gruppen-Preset): `in_use` mit Fundstellen → `PresetsDeleteAbilityTest::testPresetInUseIsRefused`, `::testNestedUseInAnotherPresetCounts` (Task 12).
|
||
6. **Rechte**: Autor ohne `edit_theme_options`, Administrator mit Divi-Rolle ohne Visual Builder → `forbidden` → `PresetsSetAbilityTest::testNeedsEditThemeOptionsAndTheVisualBuilder` (Task 11).
|
||
7. **Divi nicht freigegeben**: Schreiben gesperrt (`DiviLocked`) vor jedem Snapshot → `DesignSystemWriterTest::testWritesNeedAReleasedDivi` (Task 5), `DesignChangeTest::testLockedDiviWritesNoSnapshot` (Task 8).
|
||
|
||
---
|
||
|
||
## File Structure
|
||
|
||
```
|
||
src/
|
||
Uninstaller.php (geändert) Snapshot-Optionen
|
||
Integrations/Divi/
|
||
DiviIntegration.php (geändert) neue Tools, Writer, Snapshots, Usages
|
||
Release/DiviAdapters.php (geändert) DesignSystemWriter
|
||
Release/fingerprints.json (geändert) preset-sync
|
||
Library/DiviRoles.php (unverändert)
|
||
Library/GlobalUsages.php (geändert) report()/rows() über UsageQuery
|
||
Library/UsageQuery.php (neu) Suchstrategie: Kandidaten-SQL + Treffer
|
||
Library/LibraryUsageQuery.php (neu) bisherige Bibliothekssuche
|
||
Design/
|
||
PresetScope.php (neu) module|group + voller Name
|
||
PresetBook.php (neu) Preset-Bestand im Speicherformat
|
||
PresetDiff.php (neu) Unterschied zweier Bestände
|
||
PresetComposer.php (neu) Preset-Eintrag aus set/attrs/from_node
|
||
PresetUsageMatcher.php (neu) Inhalt verwendet Preset? (rein)
|
||
PresetUsageQuery.php (neu) UsageQuery für ein Preset
|
||
DesignSystemWriter.php (neu) Adapter: Presets schreiben, Mapping, Rechte
|
||
SnapshotStore.php (neu) Snapshots je Bereich
|
||
SnapshotTooLarge.php (neu) Ausnahme
|
||
DesignArea.php (neu) Schnittstelle eines Bereichs
|
||
PresetArea.php (neu) Bereich presets
|
||
DesignChange.php (neu) Pipeline
|
||
DesignPlan.php (neu) Ergebnis der Planung (neuer Bestand, diff, affected)
|
||
DiviPresetGetAbility.php (neu) lit/divi-preset-get
|
||
DiviPresetsSetAbility.php (neu) lit/divi-presets-set
|
||
DiviPresetsDeleteAbility.php (neu) lit/divi-presets-delete
|
||
DiviDesignSnapshotsAbility.php (neu) lit/divi-design-snapshots
|
||
DiviDesignRestoreAbility.php (neu) lit/divi-design-restore
|
||
tests/
|
||
Fixtures/divi/reference/preset-sync.txt (neu) Referenz des Mirrors
|
||
Unit/Integrations/Divi/Design/…Test.php (neu) je Klasse
|
||
Unit/Integrations/Divi/Library/GlobalUsagesTest.php (geändert) Suche über UsageQuery
|
||
Unit/UninstallerTest.php (geändert)
|
||
Integration/divi-presets-smoke.sh (neu) Ende-zu-Ende gegen echtes Divi
|
||
docs/
|
||
guides/divi-design-system.md (geändert) Abschnitt „Presets anlegen und ändern“
|
||
superpowers/notes/2026-09-28-etappe-4-divi-formate.md (geändert) Stand 5.15.1
|
||
```
|
||
|
||
---
|
||
|
||
### Task 1: Datenformate und Signaturen gegen Divi 5.15.1 prüfen (Presets, Rechte, Caches)
|
||
|
||
Reiner Recherche-Task; Ergebnis ist die nachgeführte Formate-Notiz. Kein Produktionscode.
|
||
|
||
**Files:**
|
||
- Modify: `docs/superpowers/notes/2026-09-28-etappe-4-divi-formate.md`
|
||
|
||
**Interfaces:**
|
||
- Consumes: —
|
||
- Produces: verifizierte Fakten, auf die Tasks 2–14 bauen (Abschnitt „Nachtrag 5.15.1“).
|
||
|
||
- [ ] **Step 1: Divi-Version und Preset-Funktionen feststellen**
|
||
|
||
Run:
|
||
```bash
|
||
cd /home/janniclas/Projekte/WordPress/wp-content/themes/Divi
|
||
grep -m1 "Version:" style.css
|
||
cd includes/builder-5/server
|
||
grep -n "public static function \(option_name\|get_data\|prepare_data\|validate_preset_count\|save_data\|get_deleted_preset_ids\|remove_preset_from_legacy_option\)" Packages/GlobalData/GlobalPreset.php
|
||
grep -n "public static function \(get_preset_attrs\|get_preset_attrs_mapping\)" Packages/Conversion/Conversion.php
|
||
grep -n "public static function can_current_user_use_visual_builder" Framework/UserRole/UserRole.php
|
||
grep -n "public static function sync\|sync_permission\|edit_theme_options" Packages/GlobalData/GlobalPresetController.php
|
||
```
|
||
Expected (Stand 5.15.1, beim Schreiben dieses Plans geprüft): `Version: 5.15.1`; `prepare_data( array $schema_items ): array`, `validate_preset_count( array $current_presets, array $presets_to_sync, string $action_type ): ?WP_Error`, `save_data( array $data, bool $skip_external_cache = false ): array`, `get_deleted_preset_ids( array $current_presets, array $incoming_presets, string $preset_type ): array`, `remove_preset_from_legacy_option( string $preset_id, string $module_name ): bool`; `sync_permission` = `UserRole::can_current_user_use_visual_builder() && current_user_can( 'edit_theme_options' )`. Weicht etwas ab, die Abweichung in Step 4 notieren und die betroffenen Tasks vor der Umsetzung anpassen.
|
||
|
||
- [ ] **Step 2: Ablauf von `GlobalPresetController::sync` lesen**
|
||
|
||
Run: `sed -n '/public static function sync/,/^\t}/p' Packages/GlobalData/GlobalPresetController.php`
|
||
Festhalten (für den Mirror in Task 5): ohne Chunks `prepare_data($presets)` → `get_data()` → `validate_preset_count($current, $prepared, $actionType)` → bei `DELETE_MODULE_PRESET`/`DELETE_OPTION_GROUP_PRESET` `get_deleted_preset_ids(…, 'module'|'group')` und je Eintrag `remove_preset_from_legacy_option($id, $moduleName)` → `save_data($prepared)`.
|
||
|
||
- [ ] **Step 3: Gespeichertes Format am lebenden Bestand prüfen**
|
||
|
||
Run:
|
||
```bash
|
||
cd /home/janniclas/Projekte/WordPress
|
||
ddev wp eval-file wp-content/plugins/WP-LIT-MCP/tests/Integration/divi-seed-stage4-design.php
|
||
ddev wp eval 'echo wp_json_encode(ET\Builder\Packages\GlobalData\GlobalPreset::get_data(), JSON_PRETTY_PRINT);' | head -80
|
||
ddev wp eval '$m = ET\Builder\Packages\Conversion\Conversion::get_preset_attrs_mapping("divi/button"); echo wp_json_encode(array_slice($m, 0, 5, true), JSON_PRETTY_PRINT);'
|
||
```
|
||
Expected: Speicherformat wie Formate §3 (`module`/`group` → Name → `{default, items: {id: item}}`, Einträge mit `type`, `id`, `name`, `moduleName`, `version`, `created`/`updated` in Millisekunden, `attrs`, `styleAttrs`, `renderAttrs`). Das Mapping ist ein Array Attributname → Einträge mit `attrName`, `preset` (Liste aus `style`/`html`/`script`/`content`). Abweichungen notieren.
|
||
|
||
- [ ] **Step 4: Notiz nachführen**
|
||
|
||
In `docs/superpowers/notes/2026-09-28-etappe-4-divi-formate.md` direkt nach der Einleitung einfügen:
|
||
|
||
```markdown
|
||
## Nachtrag Divi 5.15.1 (Etappe 4a, 2026-10-16)
|
||
|
||
Geprüft gegen Divi 5.15.1 (installiert, freigegeben):
|
||
- `GlobalPreset::save_data()` hat den zweiten Parameter `$skip_external_cache = false`; das Plugin übergibt ihn nicht.
|
||
- `GlobalPresetController::sync_permission()` verlangt jetzt **zusätzlich `edit_theme_options`** (5.2.1: nur Visual-Builder-Recht). Die Rechte in Spec §10 entsprechen damit Divi.
|
||
- Der Sync nimmt Chunks an (`requestId`, `chunkIndex`, `totalChunks`, Transient `et_global_preset_chunks_<user>_<id>`); das Plugin schickt nie Chunks.
|
||
- Schrittfolge des Sync (ohne Chunks) unverändert: `prepare_data` → `get_data` → `validate_preset_count` → bei Löschaktionen `get_deleted_preset_ids` + `remove_preset_from_legacy_option` → `save_data`. Das Plugin wiederholt sie in `DesignSystemWriter::savePresets()` (Mirror `preset-sync`).
|
||
- <weitere Abweichungen aus Step 1–3 oder „keine“>
|
||
```
|
||
Die letzte Zeile mit dem Ergebnis von Step 1–3 füllen (bei keiner Abweichung „Keine weiteren Abweichungen zu §3.“).
|
||
|
||
- [ ] **Step 5: Commit**
|
||
|
||
```bash
|
||
git add docs/superpowers/notes/2026-09-28-etappe-4-divi-formate.md
|
||
git commit -m "docs: Divi-Formate der Presets gegen 5.15.1 geprüft" -m "Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>"
|
||
```
|
||
|
||
---
|
||
|
||
### Task 2: `PresetScope` und `PresetBook` – Preset-Bestand im Speicherformat
|
||
|
||
**Files:**
|
||
- Create: `src/Integrations/Divi/Design/PresetScope.php`
|
||
- Create: `src/Integrations/Divi/Design/PresetBook.php`
|
||
- Test: `tests/Unit/Integrations/Divi/Design/PresetScopeTest.php`
|
||
- Test: `tests/Unit/Integrations/Divi/Design/PresetBookTest.php`
|
||
|
||
**Interfaces:**
|
||
- Consumes: `LIT\MCP\Abilities\Rev::of(string): string`.
|
||
- Produces:
|
||
- `final class PresetScope { public readonly string $kind; public readonly string $name; public function __construct(string $kind, string $name); public static function fromInput(array $item, string $field): self /* throws InvalidArgumentException */; public function label(): string; public function equals(self $other): bool }` – `$kind` ist `module` oder `group`, `$name` der volle Name (`divi/button`, `divi/font-body`).
|
||
- `final class PresetBook { public static function fromDivi(array $raw): self; public function data(): array; public function rev(): string; public function count(): int; public function items(PresetScope $scope): array /* id => item */; public function defaultId(PresetScope $scope): string; public function find(PresetScope $scope, string $idOrName): ?array /* throws InvalidArgumentException bei mehrdeutigem Namen */; public function idsNamed(PresetScope $scope, string $name): array; public function scopeOf(string $id): ?PresetScope; public function with(PresetScope $scope, array $item): self; public function withDefault(PresetScope $scope, string $id): self; public function without(PresetScope $scope, string $id): self; public function nestedUsers(string $groupPresetId): list<array{scope: PresetScope, id: string, name: string}>; public function toRest(): array; public static function newId(): string }`
|
||
|
||
- [ ] **Step 1: Failing tests schreiben**
|
||
|
||
`tests/Unit/Integrations/Divi/Design/PresetScopeTest.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Tests\Unit\Integrations\Divi\Design;
|
||
|
||
use InvalidArgumentException;
|
||
use LIT\MCP\Integrations\Divi\Design\PresetScope;
|
||
use PHPUnit\Framework\TestCase;
|
||
|
||
final class PresetScopeTest extends TestCase
|
||
{
|
||
public function testShortAndFullNames(): void
|
||
{
|
||
self::assertSame('divi/button', PresetScope::fromInput(['module' => 'button'], 'items[0]')->name);
|
||
self::assertSame('module', PresetScope::fromInput(['module' => 'divi/button'], 'items[0]')->kind);
|
||
$group = PresetScope::fromInput(['group' => 'font-body'], 'items[0]');
|
||
self::assertSame(['group', 'divi/font-body'], [$group->kind, $group->name]);
|
||
self::assertSame('Gruppen-Preset divi/font-body', $group->label());
|
||
self::assertTrue($group->equals(new PresetScope('group', 'divi/font-body')));
|
||
}
|
||
|
||
/** @return array<string, array{array<string, mixed>, string}> */
|
||
public static function invalid(): array
|
||
{
|
||
return [
|
||
'nothing' => [[], 'items[0]'],
|
||
'both' => [['module' => 'button', 'group' => 'font'], 'items[0]'],
|
||
'not a name' => [['module' => 'Button 1'], 'items[0].module'],
|
||
'not a string' => [['group' => 5], 'items[0].group'],
|
||
'two slashes' => [['module' => 'divi/a/b'], 'items[0].module'],
|
||
];
|
||
}
|
||
|
||
/**
|
||
* @dataProvider invalid
|
||
* @param array<string, mixed> $item
|
||
*/
|
||
public function testInvalidInputNamesTheField(array $item, string $field): void
|
||
{
|
||
try {
|
||
PresetScope::fromInput($item, 'items[0]');
|
||
self::fail('expected an exception');
|
||
} catch (InvalidArgumentException $e) {
|
||
self::assertStringStartsWith($field . ':', $e->getMessage());
|
||
}
|
||
}
|
||
}
|
||
```
|
||
|
||
`tests/Unit/Integrations/Divi/Design/PresetBookTest.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Tests\Unit\Integrations\Divi\Design;
|
||
|
||
use InvalidArgumentException;
|
||
use LIT\MCP\Integrations\Divi\Design\PresetBook;
|
||
use LIT\MCP\Integrations\Divi\Design\PresetScope;
|
||
use PHPUnit\Framework\TestCase;
|
||
use stdClass;
|
||
|
||
final class PresetBookTest extends TestCase
|
||
{
|
||
/** @return array<string, mixed> Stored format like GlobalPreset::get_data(). */
|
||
public static function stored(): array
|
||
{
|
||
return [
|
||
'module' => [
|
||
'divi/button' => ['default' => '', 'items' => [
|
||
'aaaaaaaaaa' => ['type' => 'module', 'id' => 'aaaaaaaaaa', 'name' => 'CTA primär',
|
||
'moduleName' => 'divi/button', 'attrs' => ['button' => ['x' => 1]]],
|
||
'bbbbbbbbbb' => ['type' => 'module', 'id' => 'bbbbbbbbbb', 'name' => 'Doppelt',
|
||
'moduleName' => 'divi/button', 'attrs' => []],
|
||
'cccccccccc' => ['type' => 'module', 'id' => 'cccccccccc', 'name' => 'doppelt',
|
||
'moduleName' => 'divi/button', 'attrs' => []],
|
||
]],
|
||
'divi/text' => ['default' => 'dddddddddd', 'items' => [
|
||
'dddddddddd' => ['type' => 'module', 'id' => 'dddddddddd', 'name' => 'Fließtext',
|
||
'moduleName' => 'divi/text', 'attrs' => [],
|
||
'groupPresets' => ['content.decoration.bodyFont' => [
|
||
'presetId' => ['gggggggggg'], 'groupName' => 'divi/font-body']]],
|
||
]],
|
||
],
|
||
'group' => [
|
||
'divi/font-body' => ['default' => '', 'items' => [
|
||
'gggggggggg' => ['type' => 'group', 'id' => 'gggggggggg', 'name' => 'Lesetext',
|
||
'groupName' => 'divi/font-body', 'groupId' => 'content.decoration.bodyFont',
|
||
'moduleName' => 'divi/text', 'attrs' => []],
|
||
]],
|
||
],
|
||
];
|
||
}
|
||
|
||
public function testFindsByIdOrUniqueName(): void
|
||
{
|
||
$book = PresetBook::fromDivi(self::stored());
|
||
$button = new PresetScope('module', 'divi/button');
|
||
|
||
self::assertSame('aaaaaaaaaa', $book->find($button, 'aaaaaaaaaa')['id']);
|
||
self::assertSame('aaaaaaaaaa', $book->find($button, 'cta PRIMÄR')['id']);
|
||
self::assertNull($book->find($button, 'Fehlt'));
|
||
self::assertNull($book->find(new PresetScope('module', 'divi/text'), 'aaaaaaaaaa'));
|
||
self::assertSame(['bbbbbbbbbb', 'cccccccccc'], $book->idsNamed($button, 'DOPPELT'));
|
||
}
|
||
|
||
public function testAmbiguousNameListsTheIds(): void
|
||
{
|
||
$this->expectException(InvalidArgumentException::class);
|
||
$this->expectExceptionMessage('Preset-Name "Doppelt" ist mehrdeutig; bitte die ID angeben: bbbbbbbbbb, cccccccccc.');
|
||
|
||
PresetBook::fromDivi(self::stored())->find(new PresetScope('module', 'divi/button'), 'Doppelt');
|
||
}
|
||
|
||
public function testStdClassGroupsBecomeArraysAndCountCoversBothKinds(): void
|
||
{
|
||
$raw = self::stored();
|
||
$raw['group'] = (object) ['divi/font-body' => (object) $raw['group']['divi/font-body']];
|
||
$book = PresetBook::fromDivi($raw);
|
||
|
||
self::assertSame(5, $book->count());
|
||
self::assertIsArray($book->data()['group']['divi/font-body']['items']);
|
||
self::assertSame('group', $book->scopeOf('gggggggggg')?->kind);
|
||
self::assertNull($book->scopeOf('zzzzzzzzzz'));
|
||
self::assertSame(0, PresetBook::fromDivi(new stdClass())->count());
|
||
}
|
||
|
||
public function testWithWithoutAndDefaultAreImmutable(): void
|
||
{
|
||
$book = PresetBook::fromDivi(self::stored());
|
||
$button = new PresetScope('module', 'divi/button');
|
||
$new = ['type' => 'module', 'id' => 'eeeeeeeeee', 'name' => 'Neu', 'moduleName' => 'divi/button', 'attrs' => []];
|
||
|
||
$added = $book->with($button, $new)->withDefault($button, 'eeeeeeeeee');
|
||
$removed = $added->without($button, 'eeeeeeeeee');
|
||
|
||
self::assertSame(5, $book->count());
|
||
self::assertSame(6, $added->count());
|
||
self::assertSame('eeeeeeeeee', $added->defaultId($button));
|
||
self::assertSame('', $removed->defaultId($button), 'removing the default clears it');
|
||
self::assertNotSame($book->rev(), $added->rev());
|
||
self::assertSame($book->rev(), PresetBook::fromDivi(self::stored())->rev());
|
||
self::assertSame('', $book->defaultId(new PresetScope('group', 'divi/spacing')));
|
||
}
|
||
|
||
public function testNestedUsersOfAGroupPreset(): void
|
||
{
|
||
$users = PresetBook::fromDivi(self::stored())->nestedUsers('gggggggggg');
|
||
|
||
self::assertCount(1, $users);
|
||
self::assertSame(['dddddddddd', 'Fließtext'], [$users[0]['id'], $users[0]['name']]);
|
||
self::assertSame('divi/text', $users[0]['scope']->name);
|
||
}
|
||
|
||
public function testRestFormatListsItemsPerName(): void
|
||
{
|
||
$rest = PresetBook::fromDivi(self::stored())->toRest();
|
||
|
||
self::assertSame('dddddddddd', $rest['module'][1]['default']);
|
||
self::assertSame(['aaaaaaaaaa', 'bbbbbbbbbb', 'cccccccccc'], array_column($rest['module'][0]['items'], 'id'));
|
||
self::assertSame('gggggggggg', $rest['group'][0]['items'][0]['id']);
|
||
self::assertTrue(array_is_list($rest['module']));
|
||
}
|
||
|
||
public function testNewIdsLookLikeTheBuildersIds(): void
|
||
{
|
||
self::assertMatchesRegularExpression('/^[0-9a-z]{10}$/', PresetBook::newId());
|
||
self::assertNotSame(PresetBook::newId(), PresetBook::newId());
|
||
}
|
||
}
|
||
```
|
||
|
||
- [ ] **Step 2: Tests laufen lassen – sie scheitern**
|
||
|
||
Run: `php vendor/bin/phpunit tests/Unit/Integrations/Divi/Design/PresetScopeTest.php tests/Unit/Integrations/Divi/Design/PresetBookTest.php`
|
||
Expected: FAIL, `Class "LIT\MCP\Integrations\Divi\Design\PresetScope" not found`.
|
||
|
||
- [ ] **Step 3: `PresetScope` implementieren**
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Integrations\Divi\Design;
|
||
|
||
use InvalidArgumentException;
|
||
|
||
defined('ABSPATH') || exit;
|
||
|
||
/**
|
||
* Where a preset lives (spec §6.1): a module preset ("module" + divi/<module>) or an option group preset
|
||
* ("group" + divi/<group>). Input takes the short ("button", "font-body") or the full name. Pure PHP.
|
||
*/
|
||
final class PresetScope
|
||
{
|
||
public const MODULE = 'module';
|
||
public const GROUP = 'group';
|
||
|
||
private const NAME = '/^[a-z0-9][a-z0-9-]*\/[a-z0-9][a-z0-9-]*$/D';
|
||
|
||
public function __construct(public readonly string $kind, public readonly string $name)
|
||
{
|
||
}
|
||
|
||
/**
|
||
* @param array<array-key, mixed> $item An input entry with exactly one of "module" or "group".
|
||
* @throws InvalidArgumentException "<field>: <problem>" for the input path.
|
||
*/
|
||
public static function fromInput(array $item, string $field): self
|
||
{
|
||
$kinds = array_values(array_filter(
|
||
[self::MODULE, self::GROUP],
|
||
static fn (string $kind): bool => array_key_exists($kind, $item)
|
||
));
|
||
if (count($kinds) !== 1) {
|
||
throw new InvalidArgumentException($field . ': genau eines von module oder group angeben');
|
||
}
|
||
|
||
$kind = $kinds[0];
|
||
$value = $item[$kind];
|
||
$name = is_string($value) ? (str_contains($value, '/') ? $value : 'divi/' . $value) : '';
|
||
if (preg_match(self::NAME, $name) !== 1) {
|
||
throw new InvalidArgumentException(sprintf(
|
||
'%s.%s: Name wie "button" bzw. "divi/button" (Gruppe: "font-body") erwartet',
|
||
$field,
|
||
$kind
|
||
));
|
||
}
|
||
|
||
return new self($kind, $name);
|
||
}
|
||
|
||
public function label(): string
|
||
{
|
||
return ($this->kind === self::MODULE ? 'Modul-Preset ' : 'Gruppen-Preset ') . $this->name;
|
||
}
|
||
|
||
public function equals(self $other): bool
|
||
{
|
||
return $this->kind === $other->kind && $this->name === $other->name;
|
||
}
|
||
}
|
||
```
|
||
|
||
- [ ] **Step 4: `PresetBook` implementieren**
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Integrations\Divi\Design;
|
||
|
||
use InvalidArgumentException;
|
||
use LIT\MCP\Abilities\Rev;
|
||
|
||
defined('ABSPATH') || exit;
|
||
|
||
/**
|
||
* The preset inventory in Divi's stored format (GlobalPreset::get_data(), formats §3):
|
||
* {module|group: {<name>: {default: id|"", items: {id: item}}}}. Immutable – with()/without()/withDefault() return a
|
||
* new book. rev() is the design_rev of the area "presets" (spec §2). toRest() gives the REST/sync format
|
||
* ({module|group: list<{default, items: list}>}) that GlobalPreset::prepare_data() takes. Pure PHP.
|
||
*/
|
||
final class PresetBook
|
||
{
|
||
private const KINDS = [PresetScope::MODULE, PresetScope::GROUP];
|
||
|
||
private const ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz';
|
||
|
||
/** @param array{module: array<string, array{default: string, items: array<string, array<string, mixed>>}>,
|
||
* group: array<string, array{default: string, items: array<string, array<string, mixed>>}>} $data */
|
||
private function __construct(private array $data)
|
||
{
|
||
}
|
||
|
||
/** @param array<array-key, mixed>|object $raw GlobalPreset::get_data() – groups may be stdClass. */
|
||
public static function fromDivi(array|object $raw): self
|
||
{
|
||
$raw = self::plain($raw);
|
||
$data = [PresetScope::MODULE => [], PresetScope::GROUP => []];
|
||
foreach (self::KINDS as $kind) {
|
||
foreach (is_array($raw[$kind] ?? null) ? $raw[$kind] : [] as $name => $record) {
|
||
if (! is_array($record)) {
|
||
continue;
|
||
}
|
||
$items = [];
|
||
foreach (is_array($record['items'] ?? null) ? $record['items'] : [] as $id => $item) {
|
||
if (is_array($item)) {
|
||
$items[(string) $id] = $item;
|
||
}
|
||
}
|
||
$data[$kind][(string) $name] = [
|
||
'default' => is_string($record['default'] ?? null) ? $record['default'] : '',
|
||
'items' => $items,
|
||
];
|
||
}
|
||
}
|
||
|
||
return new self($data);
|
||
}
|
||
|
||
/** @return array<string, mixed> */
|
||
public function data(): array
|
||
{
|
||
return $this->data;
|
||
}
|
||
|
||
public function rev(): string
|
||
{
|
||
return Rev::of('presets' . "\0" . (string) json_encode($this->data, JSON_UNESCAPED_UNICODE));
|
||
}
|
||
|
||
public function count(): int
|
||
{
|
||
$count = 0;
|
||
foreach ($this->data as $records) {
|
||
foreach ($records as $record) {
|
||
$count += count($record['items']);
|
||
}
|
||
}
|
||
|
||
return $count;
|
||
}
|
||
|
||
/** @return array<string, array<string, mixed>> id => item */
|
||
public function items(PresetScope $scope): array
|
||
{
|
||
return $this->data[$scope->kind][$scope->name]['items'] ?? [];
|
||
}
|
||
|
||
public function defaultId(PresetScope $scope): string
|
||
{
|
||
return $this->data[$scope->kind][$scope->name]['default'] ?? '';
|
||
}
|
||
|
||
/**
|
||
* The preset with ID $idOrName, else the one preset named $idOrName (case-insensitive).
|
||
*
|
||
* @return array<string, mixed>|null
|
||
* @throws InvalidArgumentException When several presets of $scope share the name (ruling S13a).
|
||
*/
|
||
public function find(PresetScope $scope, string $idOrName): ?array
|
||
{
|
||
$items = $this->items($scope);
|
||
if (isset($items[$idOrName])) {
|
||
return $items[$idOrName];
|
||
}
|
||
|
||
$ids = $this->idsNamed($scope, $idOrName);
|
||
if (count($ids) > 1) {
|
||
throw new InvalidArgumentException(sprintf(
|
||
'Preset-Name "%s" ist mehrdeutig; bitte die ID angeben: %s.',
|
||
trim($idOrName),
|
||
implode(', ', $ids)
|
||
));
|
||
}
|
||
|
||
return $ids === [] ? null : $items[$ids[0]];
|
||
}
|
||
|
||
/** @return list<string> IDs of the presets of $scope named $name (case-insensitive, trimmed). */
|
||
public function idsNamed(PresetScope $scope, string $name): array
|
||
{
|
||
$key = mb_strtolower(trim($name));
|
||
$ids = [];
|
||
foreach ($this->items($scope) as $id => $item) {
|
||
if (is_string($item['name'] ?? null) && mb_strtolower(trim($item['name'])) === $key) {
|
||
$ids[] = (string) $id;
|
||
}
|
||
}
|
||
|
||
return $ids;
|
||
}
|
||
|
||
public function scopeOf(string $id): ?PresetScope
|
||
{
|
||
foreach ($this->data as $kind => $records) {
|
||
foreach ($records as $name => $record) {
|
||
if (isset($record['items'][$id])) {
|
||
return new PresetScope($kind, $name);
|
||
}
|
||
}
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
/** @param array<string, mixed> $item Needs a string "id"; added or replaced. */
|
||
public function with(PresetScope $scope, array $item): self
|
||
{
|
||
$data = $this->data;
|
||
$data[$scope->kind][$scope->name] ??= ['default' => '', 'items' => []];
|
||
$data[$scope->kind][$scope->name]['items'][(string) $item['id']] = $item;
|
||
|
||
return new self($data);
|
||
}
|
||
|
||
public function withDefault(PresetScope $scope, string $id): self
|
||
{
|
||
$data = $this->data;
|
||
$data[$scope->kind][$scope->name] ??= ['default' => '', 'items' => []];
|
||
$data[$scope->kind][$scope->name]['default'] = $id;
|
||
|
||
return new self($data);
|
||
}
|
||
|
||
/** Removes the preset; a default that pointed to it becomes "" (spec §6.4). */
|
||
public function without(PresetScope $scope, string $id): self
|
||
{
|
||
$data = $this->data;
|
||
unset($data[$scope->kind][$scope->name]['items'][$id]);
|
||
if (($data[$scope->kind][$scope->name]['default'] ?? '') === $id) {
|
||
$data[$scope->kind][$scope->name]['default'] = '';
|
||
}
|
||
|
||
return new self($data);
|
||
}
|
||
|
||
/**
|
||
* Presets that nest group preset $groupPresetId in their groupPresets (formats §3).
|
||
*
|
||
* @return list<array{scope: PresetScope, id: string, name: string}>
|
||
*/
|
||
public function nestedUsers(string $groupPresetId): array
|
||
{
|
||
$users = [];
|
||
foreach ($this->data as $kind => $records) {
|
||
foreach ($records as $name => $record) {
|
||
foreach ($record['items'] as $id => $item) {
|
||
foreach (is_array($item['groupPresets'] ?? null) ? $item['groupPresets'] : [] as $nested) {
|
||
$ids = is_array($nested) ? (array) ($nested['presetId'] ?? []) : [];
|
||
if (in_array($groupPresetId, $ids, true)) {
|
||
$users[] = [
|
||
'scope' => new PresetScope($kind, $name),
|
||
'id' => (string) $id,
|
||
'name' => is_string($item['name'] ?? null) ? $item['name'] : (string) $id,
|
||
];
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return $users;
|
||
}
|
||
|
||
/** @return array{module: list<array{default: string, items: list<array<string, mixed>>}>,
|
||
* group: list<array{default: string, items: list<array<string, mixed>>}>} */
|
||
public function toRest(): array
|
||
{
|
||
$rest = [PresetScope::MODULE => [], PresetScope::GROUP => []];
|
||
foreach ($this->data as $kind => $records) {
|
||
foreach ($records as $record) {
|
||
$rest[$kind][] = ['default' => $record['default'], 'items' => array_values($record['items'])];
|
||
}
|
||
}
|
||
|
||
return $rest;
|
||
}
|
||
|
||
/** A new preset ID like the Visual Builder's generateNanoUuid(): 10 characters of [0-9a-z] (formats §3). */
|
||
public static function newId(): string
|
||
{
|
||
$id = '';
|
||
for ($i = 0; $i < 10; ++$i) {
|
||
$id .= self::ALPHABET[random_int(0, 35)];
|
||
}
|
||
|
||
return $id;
|
||
}
|
||
|
||
private static function plain(mixed $value): mixed
|
||
{
|
||
if (is_object($value)) {
|
||
$value = get_object_vars($value);
|
||
}
|
||
|
||
return is_array($value) ? array_map([self::class, 'plain'], $value) : $value;
|
||
}
|
||
}
|
||
```
|
||
|
||
- [ ] **Step 5: Tests laufen lassen – sie bestehen**
|
||
|
||
Run: `php vendor/bin/phpunit tests/Unit/Integrations/Divi/Design/PresetScopeTest.php tests/Unit/Integrations/Divi/Design/PresetBookTest.php`
|
||
Expected: PASS (alle Tests grün).
|
||
|
||
- [ ] **Step 6: Gesamtlauf und Lint**
|
||
|
||
Run: `composer test && composer lint`
|
||
Expected: OK, keine phpcs-Fehler.
|
||
|
||
- [ ] **Step 7: Commit**
|
||
|
||
```bash
|
||
git add src/Integrations/Divi/Design/PresetScope.php src/Integrations/Divi/Design/PresetBook.php tests/Unit/Integrations/Divi/Design/PresetScopeTest.php tests/Unit/Integrations/Divi/Design/PresetBookTest.php
|
||
git commit -m "feat: PresetScope und PresetBook – Preset-Bestand im Divi-Speicherformat" -m "Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>"
|
||
```
|
||
|
||
---
|
||
|
||
### Task 3: `PresetDiff` – Unterschied zweier Preset-Bestände
|
||
|
||
**Files:**
|
||
- Create: `src/Integrations/Divi/Design/PresetDiff.php`
|
||
- Test: `tests/Unit/Integrations/Divi/Design/PresetDiffTest.php`
|
||
|
||
**Interfaces:**
|
||
- Consumes: `PresetBook::data()`, `PresetScope` (Task 2).
|
||
- Produces: `final class PresetDiff { public static function between(PresetBook $before, PresetBook $after): list<array{kind: string, scope: string, id: string, name: string, action: string, fields?: list<string>}> }` – `action` ∈ `added`, `changed`, `removed`, `default_set`, `default_cleared`; bei `changed` listet `fields` die geänderten Schlüssel der obersten Ebene (`attrs`, `name`, `groupPresets` …; `updated`, `styleAttrs`, `renderAttrs` und `version` zählen nicht).
|
||
|
||
- [ ] **Step 1: Failing test schreiben**
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Tests\Unit\Integrations\Divi\Design;
|
||
|
||
use LIT\MCP\Integrations\Divi\Design\PresetBook;
|
||
use LIT\MCP\Integrations\Divi\Design\PresetDiff;
|
||
use LIT\MCP\Integrations\Divi\Design\PresetScope;
|
||
use PHPUnit\Framework\TestCase;
|
||
|
||
final class PresetDiffTest extends TestCase
|
||
{
|
||
public function testNoChangeIsAnEmptyDiff(): void
|
||
{
|
||
$book = PresetBook::fromDivi(PresetBookTest::stored());
|
||
|
||
self::assertSame([], PresetDiff::between($book, PresetBook::fromDivi(PresetBookTest::stored())));
|
||
}
|
||
|
||
public function testAddedChangedRemovedAndDefaults(): void
|
||
{
|
||
$before = PresetBook::fromDivi(PresetBookTest::stored());
|
||
$button = new PresetScope('module', 'divi/button');
|
||
$text = new PresetScope('module', 'divi/text');
|
||
$changed = $before->items($button)['aaaaaaaaaa'];
|
||
$changed['attrs'] = ['button' => ['x' => 2]];
|
||
$changed['updated'] = 99;
|
||
$changed['styleAttrs'] = ['ignored' => true];
|
||
$after = $before
|
||
->with($button, $changed)
|
||
->with($button, ['id' => 'eeeeeeeeee', 'name' => 'Neu', 'attrs' => []])
|
||
->withDefault($button, 'eeeeeeeeee')
|
||
->without($button, 'bbbbbbbbbb')
|
||
->withDefault($text, '');
|
||
|
||
self::assertSame([
|
||
['kind' => 'module', 'scope' => 'divi/button', 'id' => 'aaaaaaaaaa', 'name' => 'CTA primär',
|
||
'action' => 'changed', 'fields' => ['attrs']],
|
||
['kind' => 'module', 'scope' => 'divi/button', 'id' => 'bbbbbbbbbb', 'name' => 'Doppelt',
|
||
'action' => 'removed'],
|
||
['kind' => 'module', 'scope' => 'divi/button', 'id' => 'eeeeeeeeee', 'name' => 'Neu', 'action' => 'added'],
|
||
['kind' => 'module', 'scope' => 'divi/button', 'id' => 'eeeeeeeeee', 'name' => 'Neu',
|
||
'action' => 'default_set'],
|
||
['kind' => 'module', 'scope' => 'divi/text', 'id' => 'dddddddddd', 'name' => 'Fließtext',
|
||
'action' => 'default_cleared'],
|
||
], PresetDiff::between($before, $after));
|
||
}
|
||
}
|
||
```
|
||
|
||
- [ ] **Step 2: Test laufen lassen – er scheitert**
|
||
|
||
Run: `php vendor/bin/phpunit tests/Unit/Integrations/Divi/Design/PresetDiffTest.php`
|
||
Expected: FAIL, `Class "LIT\MCP\Integrations\Divi\Design\PresetDiff" not found`.
|
||
|
||
- [ ] **Step 3: Implementieren**
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Integrations\Divi\Design;
|
||
|
||
defined('ABSPATH') || exit;
|
||
|
||
/**
|
||
* What a preset change does (spec §4 step 4, "diff"): per preset added, changed (with the changed top-level keys),
|
||
* removed, and per module/group a default that is set or cleared. Keys the plugin derives or Divi maintains
|
||
* (updated, styleAttrs, renderAttrs, version) are no change of their own. Sorted by kind, scope, id, action.
|
||
* Pure PHP.
|
||
*/
|
||
final class PresetDiff
|
||
{
|
||
private const DERIVED = ['updated', 'styleAttrs', 'renderAttrs', 'version'];
|
||
|
||
/** @return list<array{kind: string, scope: string, id: string, name: string, action: string, fields?: list<string>}> */
|
||
public static function between(PresetBook $before, PresetBook $after): array
|
||
{
|
||
$old = $before->data();
|
||
$new = $after->data();
|
||
$rows = [];
|
||
foreach ([PresetScope::MODULE, PresetScope::GROUP] as $kind) {
|
||
$names = array_unique(array_merge(array_keys($old[$kind] ?? []), array_keys($new[$kind] ?? [])));
|
||
sort($names);
|
||
foreach ($names as $name) {
|
||
$was = $old[$kind][$name] ?? ['default' => '', 'items' => []];
|
||
$is = $new[$kind][$name] ?? ['default' => '', 'items' => []];
|
||
array_push($rows, ...self::items($kind, (string) $name, $was['items'], $is['items']));
|
||
array_push($rows, ...self::defaults($kind, (string) $name, $was, $is));
|
||
}
|
||
}
|
||
|
||
return $rows;
|
||
}
|
||
|
||
/**
|
||
* @param array<string, array<string, mixed>> $was
|
||
* @param array<string, array<string, mixed>> $is
|
||
* @return list<array<string, mixed>>
|
||
*/
|
||
private static function items(string $kind, string $scope, array $was, array $is): array
|
||
{
|
||
$ids = array_unique(array_merge(array_keys($was), array_keys($is)));
|
||
sort($ids);
|
||
$rows = [];
|
||
foreach ($ids as $id) {
|
||
$id = (string) $id;
|
||
$before = $was[$id] ?? null;
|
||
$after = $is[$id] ?? null;
|
||
if ($before === null || $after === null) {
|
||
$rows[] = self::row($kind, $scope, $id, $after ?? $before, $before === null ? 'added' : 'removed');
|
||
continue;
|
||
}
|
||
$fields = self::changedFields($before, $after);
|
||
if ($fields !== []) {
|
||
$rows[] = self::row($kind, $scope, $id, $after, 'changed') + ['fields' => $fields];
|
||
}
|
||
}
|
||
|
||
return $rows;
|
||
}
|
||
|
||
/**
|
||
* @param array{default: string, items: array<string, array<string, mixed>>} $was
|
||
* @param array{default: string, items: array<string, array<string, mixed>>} $is
|
||
* @return list<array<string, mixed>>
|
||
*/
|
||
private static function defaults(string $kind, string $scope, array $was, array $is): array
|
||
{
|
||
if ($was['default'] === $is['default']) {
|
||
return [];
|
||
}
|
||
if ($is['default'] === '') {
|
||
return [self::row($kind, $scope, $was['default'], $was['items'][$was['default']] ?? null, 'default_cleared')];
|
||
}
|
||
|
||
return [self::row($kind, $scope, $is['default'], $is['items'][$is['default']] ?? null, 'default_set')];
|
||
}
|
||
|
||
/**
|
||
* @param array<string, mixed> $before
|
||
* @param array<string, mixed> $after
|
||
* @return list<string>
|
||
*/
|
||
private static function changedFields(array $before, array $after): array
|
||
{
|
||
$keys = array_diff(array_unique(array_merge(array_keys($before), array_keys($after))), self::DERIVED);
|
||
$fields = [];
|
||
foreach ($keys as $key) {
|
||
if (($before[$key] ?? null) != ($after[$key] ?? null)) { // phpcs:ignore Universal.Operators.StrictComparisons
|
||
$fields[] = (string) $key;
|
||
}
|
||
}
|
||
sort($fields);
|
||
|
||
return $fields;
|
||
}
|
||
|
||
/**
|
||
* @param array<string, mixed>|null $item
|
||
* @return array{kind: string, scope: string, id: string, name: string, action: string}
|
||
*/
|
||
private static function row(string $kind, string $scope, string $id, ?array $item, string $action): array
|
||
{
|
||
return [
|
||
'kind' => $kind,
|
||
'scope' => $scope,
|
||
'id' => $id,
|
||
'name' => is_string($item['name'] ?? null) ? $item['name'] : $id,
|
||
'action' => $action,
|
||
];
|
||
}
|
||
}
|
||
```
|
||
|
||
Hinweis zur losen Gleichheit in `changedFields()`: Divi speichert Zahlen mal als String, mal als Zahl (`order: "1"`); `!=` vergleicht Arrays rekursiv ohne Typ- und Schlüsselreihenfolge-Strenge – genau das gewünschte „inhaltlich gleich“. Meldet phpcs eine andere Regel als `Universal.Operators.StrictComparisons`, den Regelnamen im `phpcs:ignore` daran anpassen.
|
||
|
||
Die erwartete Reihenfolge im Test folgt aus der Sortierung: je Bereich zuerst alle Einträge nach ID (`aaaaaaaaaa` changed, `bbbbbbbbbb` removed, `eeeeeeeeee` added), dann der Standard.
|
||
|
||
- [ ] **Step 4: Test laufen lassen – er besteht**
|
||
|
||
Run: `php vendor/bin/phpunit tests/Unit/Integrations/Divi/Design/PresetDiffTest.php`
|
||
Expected: PASS.
|
||
|
||
- [ ] **Step 5: Gesamtlauf, Lint, Commit**
|
||
|
||
Run: `composer test && composer lint`
|
||
|
||
```bash
|
||
git add src/Integrations/Divi/Design/PresetDiff.php tests/Unit/Integrations/Divi/Design/PresetDiffTest.php
|
||
git commit -m "feat: PresetDiff – Unterschied zweier Preset-Bestände für den Probelauf" -m "Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>"
|
||
```
|
||
|
||
---
|
||
|
||
### Task 4: `SnapshotStore` – Snapshots je Bereich (Spec §5)
|
||
|
||
**Files:**
|
||
- Create: `src/Integrations/Divi/Design/SnapshotStore.php`
|
||
- Create: `src/Integrations/Divi/Design/SnapshotTooLarge.php`
|
||
- Modify: `src/Uninstaller.php` (Konstante `OPTIONS`)
|
||
- Test: `tests/Unit/Integrations/Divi/Design/SnapshotStoreTest.php`
|
||
- Test: `tests/Unit/UninstallerTest.php`
|
||
|
||
**Interfaces:**
|
||
- Consumes: WordPress `get_option`, `update_option`, `get_current_user_id`, `gmdate`.
|
||
- Produces:
|
||
- `class SnapshotStore { public const AREAS = ['colors', 'variables', 'presets', 'theme_options']; public const LIMIT = 20; public const MAX_BYTES = 2000000; public static function option(string $area): string; public function save(string $area, array $data, string $ability): string /* id; throws SnapshotTooLarge, RuntimeException */; public function attachLog(string $area, string $id, ?int $logId): void; public function list(string $area): list<array{id: string, created: string, user_id: int, ability: string, log_id: ?int, size: int}>; public function get(string $area, string $id): ?array /* Eintrag mit data */ }` – nicht final (Mocks in Ability-Tests).
|
||
- `final class SnapshotTooLarge extends RuntimeException { public function __construct(public readonly int $size) }`
|
||
|
||
- [ ] **Step 1: Failing tests schreiben**
|
||
|
||
`tests/Unit/Integrations/Divi/Design/SnapshotStoreTest.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Tests\Unit\Integrations\Divi\Design;
|
||
|
||
use Brain\Monkey\Functions;
|
||
use InvalidArgumentException;
|
||
use LIT\MCP\Integrations\Divi\Design\SnapshotStore;
|
||
use LIT\MCP\Integrations\Divi\Design\SnapshotTooLarge;
|
||
use LIT\MCP\Tests\Unit\TestCase;
|
||
use RuntimeException;
|
||
|
||
final class SnapshotStoreTest extends TestCase
|
||
{
|
||
/** @var array<string, mixed> */
|
||
private array $options = [];
|
||
|
||
protected function setUp(): void
|
||
{
|
||
parent::setUp();
|
||
$this->options = [];
|
||
Functions\when('get_option')->alias(fn (string $name, mixed $default = false): mixed => $this->options[$name] ?? $default);
|
||
Functions\when('update_option')->alias(function (string $name, mixed $value, mixed $autoload = null): bool {
|
||
self::assertFalse($autoload, 'snapshots are never autoloaded');
|
||
$this->options[$name] = $value;
|
||
|
||
return true;
|
||
});
|
||
Functions\when('get_current_user_id')->justReturn(7);
|
||
}
|
||
|
||
public function testSavesListsAndReturnsTheNewestFirst(): void
|
||
{
|
||
$store = new SnapshotStore();
|
||
$first = $store->save('presets', ['module' => ['a' => 1]], 'lit/divi-presets-set');
|
||
$second = $store->save('presets', ['module' => ['a' => 2]], 'lit/divi-presets-set');
|
||
$store->attachLog('presets', $second, 42);
|
||
|
||
self::assertSame('lit_mcp_snapshots_presets', SnapshotStore::option('presets'));
|
||
self::assertMatchesRegularExpression('/^presets-\d{8}T\d{6}Z-[0-9a-f]{6}$/', $first);
|
||
$list = $store->list('presets');
|
||
self::assertSame([$second, $first], array_column($list, 'id'));
|
||
self::assertSame(42, $list[0]['log_id']);
|
||
self::assertSame(7, $list[0]['user_id']);
|
||
self::assertArrayNotHasKey('data', $list[0]);
|
||
self::assertSame(['module' => ['a' => 1]], $store->get('presets', $first)['data']);
|
||
self::assertNull($store->get('presets', 'presets-unknown'));
|
||
self::assertSame([], $store->list('colors'));
|
||
}
|
||
|
||
public function testKeepsAtMostTwentyPerArea(): void
|
||
{
|
||
$store = new SnapshotStore();
|
||
$ids = [];
|
||
for ($i = 0; $i < 22; ++$i) {
|
||
$ids[] = $store->save('presets', ['n' => $i], 'lit/divi-presets-set');
|
||
}
|
||
|
||
$list = $store->list('presets');
|
||
self::assertCount(SnapshotStore::LIMIT, $list);
|
||
self::assertSame($ids[21], $list[0]['id']);
|
||
self::assertNull($store->get('presets', $ids[0]));
|
||
self::assertNull($store->get('presets', $ids[1]));
|
||
}
|
||
|
||
public function testRefusesSnapshotsAboveTheLimit(): void
|
||
{
|
||
$this->expectException(SnapshotTooLarge::class);
|
||
|
||
(new SnapshotStore())->save('presets', ['x' => str_repeat('a', SnapshotStore::MAX_BYTES)], 'lit/divi-presets-set');
|
||
}
|
||
|
||
public function testUnknownAreaIsAProgrammingError(): void
|
||
{
|
||
$this->expectException(InvalidArgumentException::class);
|
||
|
||
SnapshotStore::option('pages');
|
||
}
|
||
|
||
public function testAFailedOptionWriteThrows(): void
|
||
{
|
||
Functions\when('update_option')->justReturn(false);
|
||
$this->expectException(RuntimeException::class);
|
||
$this->expectExceptionMessage('snapshot presets could not be stored');
|
||
|
||
(new SnapshotStore())->save('presets', ['a' => 1], 'lit/divi-presets-set');
|
||
}
|
||
|
||
public function testCorruptOptionReadsAsEmpty(): void
|
||
{
|
||
$this->options['lit_mcp_snapshots_presets'] = 'kaputt';
|
||
|
||
self::assertSame([], (new SnapshotStore())->list('presets'));
|
||
}
|
||
}
|
||
```
|
||
|
||
`update_option()` liefert `false`, wenn der Wert unverändert ist. Ein neuer Snapshot ändert die Liste immer (neue ID am Anfang), daher ist `false` hier ein echter Fehler.
|
||
|
||
In `tests/Unit/UninstallerTest.php` den Test, der die gelöschten Optionen prüft, um die vier Snapshot-Optionen ergänzen. Dafür in der Liste der erwarteten Optionen (Suche nach `'lit_mcp_divi_check_lock'`) anhängen:
|
||
|
||
```php
|
||
'lit_mcp_snapshots_colors', 'lit_mcp_snapshots_variables', 'lit_mcp_snapshots_presets',
|
||
'lit_mcp_snapshots_theme_options',
|
||
```
|
||
|
||
- [ ] **Step 2: Tests laufen lassen – sie scheitern**
|
||
|
||
Run: `php vendor/bin/phpunit tests/Unit/Integrations/Divi/Design/SnapshotStoreTest.php tests/Unit/UninstallerTest.php`
|
||
Expected: FAIL (`SnapshotStore` fehlt; Uninstaller löscht die neuen Optionen nicht).
|
||
|
||
- [ ] **Step 3: Implementieren**
|
||
|
||
`src/Integrations/Divi/Design/SnapshotTooLarge.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Integrations\Divi\Design;
|
||
|
||
use RuntimeException;
|
||
|
||
defined('ABSPATH') || exit;
|
||
|
||
/** A snapshot above SnapshotStore::MAX_BYTES (spec §5): the change is refused instead of writing without a backup. */
|
||
final class SnapshotTooLarge extends RuntimeException
|
||
{
|
||
public function __construct(public readonly int $size)
|
||
{
|
||
parent::__construct(sprintf('snapshot of %d bytes exceeds %d', $size, SnapshotStore::MAX_BYTES));
|
||
}
|
||
}
|
||
```
|
||
|
||
`src/Integrations/Divi/Design/SnapshotStore.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Integrations\Divi\Design;
|
||
|
||
use InvalidArgumentException;
|
||
use RuntimeException;
|
||
|
||
defined('ABSPATH') || exit;
|
||
|
||
/**
|
||
* Snapshots of the design system (spec §5, G6): one option per area (lit_mcp_snapshots_<area>, never autoloaded),
|
||
* newest first, at most LIMIT entries – the oldest falls out. An entry keeps the area's raw inventory as Divi stores
|
||
* it plus who made it with which tool and the change log entry. The only way back for colors, variables and presets:
|
||
* Divi 5 keeps no server-side history (formats §7.6). Not final so abilities can be tested with a mock.
|
||
*/
|
||
class SnapshotStore
|
||
{
|
||
public const AREAS = ['colors', 'variables', 'presets', 'theme_options'];
|
||
|
||
public const LIMIT = 20;
|
||
|
||
/** Spec §5: a larger snapshot refuses the change. */
|
||
public const MAX_BYTES = 2000000;
|
||
|
||
private const PREFIX = 'lit_mcp_snapshots_';
|
||
|
||
public static function option(string $area): string
|
||
{
|
||
if (! in_array($area, self::AREAS, true)) {
|
||
throw new InvalidArgumentException(sprintf('Unknown design area "%s".', $area));
|
||
}
|
||
|
||
return self::PREFIX . $area;
|
||
}
|
||
|
||
/**
|
||
* @param array<array-key, mixed> $data The area's raw inventory.
|
||
* @throws SnapshotTooLarge
|
||
* @throws RuntimeException When the option could not be written.
|
||
*/
|
||
public function save(string $area, array $data, string $ability): string
|
||
{
|
||
$size = strlen((string) json_encode($data, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES));
|
||
if ($size > self::MAX_BYTES) {
|
||
throw new SnapshotTooLarge($size);
|
||
}
|
||
|
||
$id = sprintf('%s-%s-%s', $area, gmdate('Ymd\THis\Z'), bin2hex(random_bytes(3)));
|
||
$entries = $this->entries($area);
|
||
array_unshift($entries, [
|
||
'id' => $id,
|
||
'created' => gmdate('c'),
|
||
'user_id' => get_current_user_id(),
|
||
'ability' => $ability,
|
||
'log_id' => null,
|
||
'size' => $size,
|
||
'data' => $data,
|
||
]);
|
||
if (! update_option(self::option($area), array_slice($entries, 0, self::LIMIT), false)) {
|
||
throw new RuntimeException(sprintf('snapshot %s could not be stored', $area));
|
||
}
|
||
|
||
return $id;
|
||
}
|
||
|
||
/** Notes the change log entry of the change the snapshot belongs to (the log entry is written after it). */
|
||
public function attachLog(string $area, string $id, ?int $logId): void
|
||
{
|
||
if ($logId === null) {
|
||
return;
|
||
}
|
||
|
||
$entries = $this->entries($area);
|
||
foreach ($entries as $index => $entry) {
|
||
if ($entry['id'] === $id) {
|
||
$entries[$index]['log_id'] = $logId;
|
||
update_option(self::option($area), $entries, false);
|
||
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
|
||
/** @return list<array{id: string, created: string, user_id: int, ability: string, log_id: ?int, size: int}> */
|
||
public function list(string $area): array
|
||
{
|
||
return array_map(static function (array $entry): array {
|
||
unset($entry['data']);
|
||
|
||
return $entry;
|
||
}, $this->entries($area));
|
||
}
|
||
|
||
/** @return array{id: string, created: string, user_id: int, ability: string, log_id: ?int, size: int,
|
||
* data: array<array-key, mixed>}|null */
|
||
public function get(string $area, string $id): ?array
|
||
{
|
||
foreach ($this->entries($area) as $entry) {
|
||
if ($entry['id'] === $id) {
|
||
return $entry;
|
||
}
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
/** @return list<array{id: string, created: string, user_id: int, ability: string, log_id: ?int, size: int,
|
||
* data: array<array-key, mixed>}> */
|
||
private function entries(string $area): array
|
||
{
|
||
$stored = get_option(self::option($area), []);
|
||
if (! is_array($stored)) {
|
||
return [];
|
||
}
|
||
|
||
$entries = [];
|
||
foreach ($stored as $entry) {
|
||
if (is_array($entry) && is_string($entry['id'] ?? null) && is_array($entry['data'] ?? null)) {
|
||
$entries[] = [
|
||
'id' => $entry['id'],
|
||
'created' => (string) ($entry['created'] ?? ''),
|
||
'user_id' => (int) ($entry['user_id'] ?? 0),
|
||
'ability' => (string) ($entry['ability'] ?? ''),
|
||
'log_id' => isset($entry['log_id']) ? (int) $entry['log_id'] : null,
|
||
'size' => (int) ($entry['size'] ?? 0),
|
||
'data' => $entry['data'],
|
||
];
|
||
}
|
||
}
|
||
|
||
return $entries;
|
||
}
|
||
}
|
||
```
|
||
|
||
In `src/Uninstaller.php` die Konstante `OPTIONS` erweitern:
|
||
|
||
```php
|
||
private const OPTIONS = [
|
||
'lit_mcp_allowed_roles', 'lit_mcp_exposure', 'lit_mcp_limits', 'lit_mcp_db_version',
|
||
'lit_mcp_divi_releases', 'lit_mcp_divi_check_report', 'lit_mcp_divi_check_lock',
|
||
'lit_mcp_snapshots_colors', 'lit_mcp_snapshots_variables', 'lit_mcp_snapshots_presets',
|
||
'lit_mcp_snapshots_theme_options',
|
||
];
|
||
```
|
||
|
||
Den Docblock von `Uninstaller` um „Snapshots des Designsystems (Etappe 4)“ in der Aufzählung der entfernten Daten ergänzen.
|
||
|
||
- [ ] **Step 4: Tests laufen lassen – sie bestehen**
|
||
|
||
Run: `php vendor/bin/phpunit tests/Unit/Integrations/Divi/Design/SnapshotStoreTest.php tests/Unit/UninstallerTest.php`
|
||
Expected: PASS.
|
||
|
||
- [ ] **Step 5: Gesamtlauf, Lint, Commit**
|
||
|
||
Run: `composer test && composer lint`
|
||
|
||
```bash
|
||
git add src/Integrations/Divi/Design/SnapshotStore.php src/Integrations/Divi/Design/SnapshotTooLarge.php src/Uninstaller.php tests/Unit/Integrations/Divi/Design/SnapshotStoreTest.php tests/Unit/UninstallerTest.php
|
||
git commit -m "feat: SnapshotStore – Snapshots des Designsystems je Bereich" -m "Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>"
|
||
```
|
||
|
||
---
|
||
### Task 5: Adapter `DesignSystemWriter` – Presets über Divis Sync-Ablauf schreiben
|
||
|
||
**Files:**
|
||
- Create: `src/Integrations/Divi/Design/DesignSystemWriter.php`
|
||
- Modify: `src/Integrations/Divi/Release/DiviAdapters.php`
|
||
- Modify: `src/Integrations/Divi/Release/fingerprints.json` (per WP-CLI erzeugt)
|
||
- Create: `tests/Fixtures/divi/reference/preset-sync.txt` (per WP-CLI erzeugt)
|
||
- Test: `tests/Unit/Integrations/Divi/Design/DesignSystemWriterTest.php`
|
||
|
||
**Interfaces:**
|
||
- Consumes: `ReleaseGate::assertWritable()`, `Manifest`, `Call`, `Mirror` (vorhanden).
|
||
- Produces: `class DesignSystemWriter implements DiviAdapter` (nicht final) mit
|
||
- `public function presets(): array` – roher Bestand (`GlobalPreset::get_data()`).
|
||
- `public function savePresets(array $rest, bool $mayRemove): array` – REST-Format (`PresetBook::toRest()`) speichern wie Divis Sync; `$mayRemove` erlaubt weniger Presets (Löschen, Wiederherstellen) und bereinigt dann Divis Divi-4-Altoption; gibt den gespeicherten Bestand zurück; `@throws DiviLocked`, `@throws RuntimeException` (Divi meldet einen Fehler).
|
||
- `public function presetAttrs(string $moduleName, array $attrs): array{all: array, style: array, render: array}` – Teilmengen nach Divis Preset-Mapping.
|
||
- `public function canUseVisualBuilder(): bool`.
|
||
- Konstanten `ACTION_SAVE = 'ADD_NEW_MODULE_PRESET'`, `ACTION_DELETE_MODULE = 'DELETE_MODULE_PRESET'`, `ACTION_DELETE_GROUP = 'DELETE_OPTION_GROUP_PRESET'`, `PRESET_TYPES = ['style', 'html', 'script']`.
|
||
|
||
- [ ] **Step 1: Failing test schreiben**
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Tests\Unit\Integrations\Divi\Design;
|
||
|
||
use LIT\MCP\Integrations\Divi\Design\DesignSystemWriter;
|
||
use LIT\MCP\Integrations\Divi\Release\Call;
|
||
use LIT\MCP\Integrations\Divi\Release\DiviAdapters;
|
||
use LIT\MCP\Integrations\Divi\Release\DiviLocked;
|
||
use LIT\MCP\Integrations\Divi\Release\Manifest;
|
||
use LIT\MCP\Integrations\Divi\Release\ReleaseGate;
|
||
use LIT\MCP\Integrations\Divi\Release\ReleaseState;
|
||
use LIT\MCP\Integrations\Divi\Release\ReleaseStatus;
|
||
use LIT\MCP\Tests\Unit\TestCase;
|
||
|
||
final class DesignSystemWriterTest extends TestCase
|
||
{
|
||
public function testIsARegisteredDesignAdapterWithTheSyncMirror(): void
|
||
{
|
||
$manifest = DesignSystemWriter::manifest();
|
||
|
||
self::assertContains(DesignSystemWriter::class, DiviAdapters::CLASSES);
|
||
self::assertSame(Manifest::DESIGN, $manifest->area);
|
||
self::assertSame(
|
||
[
|
||
'GlobalPreset::get_data()', 'GlobalPreset::prepare_data()', 'GlobalPreset::validate_preset_count()',
|
||
'GlobalPreset::get_deleted_preset_ids()', 'GlobalPreset::remove_preset_from_legacy_option()',
|
||
'GlobalPreset::save_data()', 'Conversion::get_preset_attrs_mapping()', 'Conversion::get_preset_attrs()',
|
||
'UserRole::can_current_user_use_visual_builder()',
|
||
],
|
||
array_map(static fn (Call $call): string => $call->label(), $manifest->calls)
|
||
);
|
||
self::assertSame(['preset-sync'], array_map(static fn ($mirror): string => $mirror->id, $manifest->mirrors));
|
||
self::assertSame('GlobalPresetController', $manifest->mirrors[0]->class);
|
||
}
|
||
|
||
public function testWritesNeedAReleasedDivi(): void
|
||
{
|
||
ReleaseGate::useResolver(static fn (): ReleaseStatus => new ReleaseStatus(ReleaseState::Untested, '5.16.0'));
|
||
|
||
$this->expectException(DiviLocked::class);
|
||
|
||
(new DesignSystemWriter())->savePresets(['module' => [], 'group' => []], false);
|
||
}
|
||
|
||
public function testWithoutDiviNobodyUsesTheVisualBuilder(): void
|
||
{
|
||
self::assertFalse((new DesignSystemWriter())->canUseVisualBuilder());
|
||
}
|
||
}
|
||
```
|
||
|
||
`UserRole` ist im Unit-Test nicht geladen; `canUseVisualBuilder()` prüft `class_exists()` und antwortet dann `false` (fail closed).
|
||
|
||
- [ ] **Step 2: Test laufen lassen – er scheitert**
|
||
|
||
Run: `php vendor/bin/phpunit tests/Unit/Integrations/Divi/Design/DesignSystemWriterTest.php`
|
||
Expected: FAIL, Klasse fehlt.
|
||
|
||
- [ ] **Step 3: Implementieren**
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Integrations\Divi\Design;
|
||
|
||
use ET\Builder\Framework\UserRole\UserRole;
|
||
use ET\Builder\Packages\Conversion\Conversion;
|
||
use ET\Builder\Packages\GlobalData\GlobalPreset;
|
||
use LIT\MCP\Integrations\Divi\Release\Call;
|
||
use LIT\MCP\Integrations\Divi\Release\DiviAdapter;
|
||
use LIT\MCP\Integrations\Divi\Release\DiviLocked;
|
||
use LIT\MCP\Integrations\Divi\Release\Manifest;
|
||
use LIT\MCP\Integrations\Divi\Release\Mirror;
|
||
use LIT\MCP\Integrations\Divi\Release\ReleaseGate;
|
||
use RuntimeException;
|
||
use WP_Error;
|
||
|
||
defined('ABSPATH') || exit;
|
||
|
||
/**
|
||
* Adapter "Designsystem" (spec §3) for writing (Etappe 4): presets are saved the way Divi's own sync route does it
|
||
* (mirror preset-sync of GlobalPresetController::sync, formats "Nachtrag 5.15.1"): prepare_data() sanitizes the REST
|
||
* format, validate_preset_count() refuses a smaller inventory unless presets may be removed, removed presets leave
|
||
* Divi's Divi-4 legacy option, save_data() writes the option and clears the static CSS. Chunks and the route's nonce
|
||
* are not needed in-process; the tools check the rights themselves (spec §10). Also Divi's preset attribute mapping
|
||
* (which attributes a preset may carry) and the Visual Builder role right. Not final so abilities can be tested with
|
||
* a mock.
|
||
*/
|
||
class DesignSystemWriter implements DiviAdapter
|
||
{
|
||
public const ACTION_SAVE = 'ADD_NEW_MODULE_PRESET';
|
||
|
||
public const ACTION_DELETE_MODULE = 'DELETE_MODULE_PRESET';
|
||
|
||
public const ACTION_DELETE_GROUP = 'DELETE_OPTION_GROUP_PRESET';
|
||
|
||
/** Preset attribute types Divi copies into a preset (Conversion::get_preset_attrs). */
|
||
public const PRESET_TYPES = ['style', 'html', 'script'];
|
||
|
||
public static function manifest(): Manifest
|
||
{
|
||
return new Manifest(
|
||
Manifest::DESIGN,
|
||
calls: [
|
||
new Call(GlobalPreset::class . '::get_data', 0),
|
||
new Call(GlobalPreset::class . '::prepare_data', 1),
|
||
new Call(GlobalPreset::class . '::validate_preset_count', 3),
|
||
new Call(GlobalPreset::class . '::get_deleted_preset_ids', 3),
|
||
new Call(GlobalPreset::class . '::remove_preset_from_legacy_option', 2),
|
||
new Call(GlobalPreset::class . '::save_data', 1),
|
||
new Call(Conversion::class . '::get_preset_attrs_mapping', 1),
|
||
new Call(Conversion::class . '::get_preset_attrs', 3),
|
||
new Call(UserRole::class . '::can_current_user_use_visual_builder', 0),
|
||
],
|
||
mirrors: [
|
||
new Mirror(
|
||
'preset-sync',
|
||
'includes/builder-5/server/Packages/GlobalData/GlobalPresetController.php',
|
||
'sync',
|
||
'GlobalPresetController',
|
||
'Speicherablauf der Presets (prepare_data, validate_preset_count, Bereinigung der Divi-4-Option '
|
||
. 'beim Löschen, save_data)'
|
||
),
|
||
]
|
||
);
|
||
}
|
||
|
||
/** @return array<array-key, mixed> The stored inventory (GlobalPreset::get_data(), formats §3). */
|
||
public function presets(): array
|
||
{
|
||
$data = GlobalPreset::get_data();
|
||
|
||
return is_array($data) ? $data : [];
|
||
}
|
||
|
||
/**
|
||
* @param array<array-key, mixed> $rest REST/sync format, see PresetBook::toRest().
|
||
* @param bool $mayRemove Deleting or restoring: fewer presets are allowed and removed ones
|
||
* leave Divi's legacy option (like a DELETE_* sync).
|
||
* @return array<array-key, mixed> The inventory Divi stored.
|
||
* @throws DiviLocked
|
||
* @throws RuntimeException When Divi refuses the inventory.
|
||
*/
|
||
public function savePresets(array $rest, bool $mayRemove): array
|
||
{
|
||
ReleaseGate::assertWritable();
|
||
$prepared = GlobalPreset::prepare_data($rest);
|
||
$current = GlobalPreset::get_data();
|
||
$refusal = GlobalPreset::validate_preset_count(
|
||
$current,
|
||
$prepared,
|
||
$mayRemove ? self::ACTION_DELETE_MODULE : self::ACTION_SAVE
|
||
);
|
||
if ($refusal instanceof WP_Error) {
|
||
throw new RuntimeException('preset sync refused: ' . $refusal->get_error_code() . ' '
|
||
. $refusal->get_error_message());
|
||
}
|
||
|
||
if ($mayRemove) {
|
||
foreach (['module', 'group'] as $kind) {
|
||
foreach (GlobalPreset::get_deleted_preset_ids($current, $prepared, $kind) as $deleted) {
|
||
GlobalPreset::remove_preset_from_legacy_option(
|
||
(string) ($deleted['id'] ?? ''),
|
||
(string) ($deleted['moduleName'] ?? '')
|
||
);
|
||
}
|
||
}
|
||
}
|
||
|
||
$saved = GlobalPreset::save_data($prepared);
|
||
|
||
return is_array($saved) ? $saved : [];
|
||
}
|
||
|
||
/**
|
||
* The parts of $attrs a preset of $moduleName carries (Divi's preset attribute mapping): all, style
|
||
* (styleAttrs) and render (renderAttrs: html + script).
|
||
*
|
||
* @param array<string, mixed> $attrs
|
||
* @return array{all: array<string, mixed>, style: array<string, mixed>, render: array<string, mixed>}
|
||
*/
|
||
public function presetAttrs(string $moduleName, array $attrs): array
|
||
{
|
||
$map = Conversion::get_preset_attrs_mapping($moduleName);
|
||
|
||
return [
|
||
'all' => (array) Conversion::get_preset_attrs($attrs, self::PRESET_TYPES, $map),
|
||
'style' => (array) Conversion::get_preset_attrs($attrs, ['style'], $map),
|
||
'render' => (array) Conversion::get_preset_attrs($attrs, ['html', 'script'], $map),
|
||
];
|
||
}
|
||
|
||
/** Divi's role right "Visual Builder verwenden"; fail closed without Divi. */
|
||
public function canUseVisualBuilder(): bool
|
||
{
|
||
return class_exists(UserRole::class) && UserRole::can_current_user_use_visual_builder();
|
||
}
|
||
}
|
||
```
|
||
|
||
In `src/Integrations/Divi/Release/DiviAdapters.php` `DesignSystemWriter::class` direkt nach `DesignSystemReader::class` in `CLASSES` aufnehmen und importieren (`use LIT\MCP\Integrations\Divi\Design\DesignSystemWriter;`).
|
||
|
||
- [ ] **Step 4: Unit-Tests laufen lassen**
|
||
|
||
Run: `php vendor/bin/phpunit tests/Unit/Integrations/Divi/Design/DesignSystemWriterTest.php tests/Unit/Integrations/Divi/Release`
|
||
Expected: PASS bis auf Tests, die den Fingerabdruck jedes Mirrors in `fingerprints.json` erwarten (z. B. „Mirror ohne Soll-Fingerabdruck“) – die werden in Step 5 grün.
|
||
|
||
- [ ] **Step 5: Fingerabdruck und Referenz erzeugen**
|
||
|
||
Run:
|
||
```bash
|
||
cd /home/janniclas/Projekte/WordPress
|
||
ddev wp --user=admin lit-mcp divi-check --update-reference
|
||
cd wp-content/plugins/WP-LIT-MCP && git diff --stat src/Integrations/Divi/Release/fingerprints.json && ls tests/Fixtures/divi/reference/preset-sync.txt
|
||
```
|
||
Expected: `fingerprints.json` bekommt genau den neuen Schlüssel `preset-sync` (die übrigen Werte bleiben); `tests/Fixtures/divi/reference/preset-sync.txt` existiert und enthält den normalisierten Quelltext von `GlobalPresetController::sync`. Ändern sich andere Schlüssel, nicht committen, sondern prüfen (installiertes Divi ≠ freigegebene Version).
|
||
|
||
- [ ] **Step 6: Gesamtlauf, Lint, Commit**
|
||
|
||
Run: `composer test && composer lint`
|
||
Expected: OK; `DiviBoundaryTest` grün (alle Divi-Namen des Writers stehen im Manifest).
|
||
|
||
```bash
|
||
git add src/Integrations/Divi/Design/DesignSystemWriter.php src/Integrations/Divi/Release/DiviAdapters.php src/Integrations/Divi/Release/fingerprints.json tests/Fixtures/divi/reference/preset-sync.txt tests/Unit/Integrations/Divi/Design/DesignSystemWriterTest.php
|
||
git commit -m "feat: DesignSystemWriter – Presets über Divis Sync-Ablauf schreiben (Mirror preset-sync)" -m "Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>"
|
||
```
|
||
|
||
---
|
||
|
||
### Task 6: `GlobalUsages` mit austauschbarer Suche (`UsageQuery`, `LibraryUsageQuery`)
|
||
|
||
Refaktorierung ohne Verhaltensänderung: Rechte, Grenzen und Bericht von `GlobalUsages` werden für beliebige Verweise nutzbar; die bisherige Suche nach Bibliotheksverweisen wird `LibraryUsageQuery`.
|
||
|
||
**Files:**
|
||
- Create: `src/Integrations/Divi/Library/UsageQuery.php`
|
||
- Create: `src/Integrations/Divi/Library/LibraryUsageQuery.php`
|
||
- Modify: `src/Integrations/Divi/Library/GlobalUsages.php`
|
||
- Test: `tests/Unit/Integrations/Divi/Library/GlobalUsagesTest.php`
|
||
- Test: `tests/Unit/Integrations/Divi/Library/LibraryUsageQueryTest.php`
|
||
|
||
**Interfaces:**
|
||
- Consumes: `UsageMatcher::shows()` (vorhanden).
|
||
- Produces:
|
||
- `interface UsageQuery { public function candidateCondition(\wpdb $db): string; public function matches(string $content): bool; }` – `candidateCondition()` liefert eine **fertig vorbereitete** SQL-Bedingung (mit `$db->prepare()`), die Kandidaten über `post_content` vorfiltert; `matches()` entscheidet am Inhalt (fail closed).
|
||
- `final class LibraryUsageQuery implements UsageQuery { public function __construct(int $libraryId) }`.
|
||
- `GlobalUsages::reportFor(UsageQuery $query, bool $withBlocked = true): UsageReport` und `GlobalUsages::rowsFor(UsageQuery $query): list<array{id: int, status: string, type: string}>`; `report(int, bool)` und `rows(int)` bleiben und delegieren an `new LibraryUsageQuery($id)`.
|
||
|
||
- [ ] **Step 1: Failing tests schreiben**
|
||
|
||
`tests/Unit/Integrations/Divi/Library/LibraryUsageQueryTest.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Tests\Unit\Integrations\Divi\Library;
|
||
|
||
use LIT\MCP\Integrations\Divi\Library\LibraryUsageQuery;
|
||
use LIT\MCP\Tests\Unit\TestCase;
|
||
use Mockery;
|
||
|
||
final class LibraryUsageQueryTest extends TestCase
|
||
{
|
||
public function testConditionIsTheFormerCandidateFilter(): void
|
||
{
|
||
$db = Mockery::mock(\wpdb::class);
|
||
$db->allows('esc_like')->andReturnUsing(static fn (string $text): string => $text);
|
||
$db->expects('prepare')
|
||
->with(
|
||
'(LOWER(post_content) LIKE %s OR LOWER(post_content) LIKE %s OR post_content REGEXP %s)',
|
||
'%globalmodule%',
|
||
'%global_module%',
|
||
'\\\\u00[4-7][0-9a-fA-F]'
|
||
)
|
||
->andReturn('(prepared)');
|
||
|
||
self::assertSame('(prepared)', (new LibraryUsageQuery(12))->candidateCondition($db));
|
||
}
|
||
|
||
public function testMatchesThroughTheUsageMatcher(): void
|
||
{
|
||
$query = new LibraryUsageQuery(12);
|
||
|
||
self::assertTrue($query->matches('<!-- wp:divi/section {"globalModule":"12"} /-->'));
|
||
self::assertFalse($query->matches('<!-- wp:divi/section {"globalModule":"13"} /-->'));
|
||
}
|
||
}
|
||
```
|
||
|
||
In `tests/Unit/Integrations/Divi/Library/GlobalUsagesTest.php` ergänzen (Aufbau der vorhandenen `$wpdb`-Mocks des Tests übernehmen; der Test erwartet, dass die Kandidatenabfrage die Bedingung der Suche enthält):
|
||
|
||
```php
|
||
public function testRowsForUsesTheConditionAndMatcherOfTheQuery(): void
|
||
{
|
||
$db = Mockery::mock(\wpdb::class)->makePartial();
|
||
$queries = [];
|
||
$db->allows('get_results')->andReturnUsing(static function (string $sql) use (&$queries): array {
|
||
$queries[] = $sql;
|
||
|
||
return str_contains($sql, 'post_content FROM')
|
||
? [['ID' => '5', 'post_content' => 'treffer'], ['ID' => '6', 'post_content' => 'nichts']]
|
||
: [['ID' => '5', 'post_status' => 'draft', 'post_type' => 'page'],
|
||
['ID' => '6', 'post_status' => 'draft', 'post_type' => 'page']];
|
||
});
|
||
$query = new class implements \LIT\MCP\Integrations\Divi\Library\UsageQuery {
|
||
public function candidateCondition(\wpdb $db): string
|
||
{
|
||
return '(MARKER)';
|
||
}
|
||
|
||
public function matches(string $content): bool
|
||
{
|
||
return $content === 'treffer';
|
||
}
|
||
};
|
||
|
||
$rows = (new GlobalUsages($db))->rowsFor($query);
|
||
|
||
self::assertSame([['id' => 5, 'status' => 'draft', 'type' => 'page']], $rows);
|
||
self::assertStringContainsString('WHERE (MARKER) AND post_type', $queries[0]);
|
||
}
|
||
```
|
||
|
||
Der bestehende `testFindsEveryFormatDiviRendersFromCandidates` bleibt unverändert und muss grün bleiben: `LibraryUsageQuery` erzeugt mit dem echten `prepare()` des `wpdb`-Stubs wörtlich dieselbe Kandidaten-SQL wie bisher.
|
||
|
||
- [ ] **Step 2: Tests laufen lassen – sie scheitern**
|
||
|
||
Run: `php vendor/bin/phpunit tests/Unit/Integrations/Divi/Library/LibraryUsageQueryTest.php tests/Unit/Integrations/Divi/Library/GlobalUsagesTest.php`
|
||
Expected: FAIL (`LibraryUsageQuery`/`UsageQuery` fehlen, `rowsFor()` unbekannt).
|
||
|
||
- [ ] **Step 3: Implementieren**
|
||
|
||
`src/Integrations/Divi/Library/UsageQuery.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Integrations\Divi\Library;
|
||
|
||
defined('ABSPATH') || exit;
|
||
|
||
/**
|
||
* What GlobalUsages looks for (ruling P23 pattern, fail closed): a prepared SQL condition on post_content that
|
||
* keeps every post that may reference the thing (one query, ID/status/type only), and the decision on the
|
||
* content of each candidate. A library entry (LibraryUsageQuery), a preset (PresetUsageQuery, Etappe 4) …
|
||
*/
|
||
interface UsageQuery
|
||
{
|
||
/** A condition for "WHERE (…)", already passed through $db->prepare(). */
|
||
public function candidateCondition(\wpdb $db): string;
|
||
|
||
/** Whether $content references the thing; true when unsure (fail closed). */
|
||
public function matches(string $content): bool;
|
||
}
|
||
```
|
||
|
||
`src/Integrations/Divi/Library/LibraryUsageQuery.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Integrations\Divi\Library;
|
||
|
||
defined('ABSPATH') || exit;
|
||
|
||
/**
|
||
* The usages of library entry $libraryId (rulings P23, P24): candidates with "globalModule", a Divi 4
|
||
* "global_module" (both case-insensitive, LOWER() under any collation) or a JSON escape of a letter (an escaped
|
||
* key such as globalModule always has one); the decision is UsageMatcher's.
|
||
*/
|
||
final class LibraryUsageQuery implements UsageQuery
|
||
{
|
||
public function __construct(private int $libraryId)
|
||
{
|
||
}
|
||
|
||
public function candidateCondition(\wpdb $db): string
|
||
{
|
||
return (string) $db->prepare(
|
||
'(LOWER(post_content) LIKE %s OR LOWER(post_content) LIKE %s OR post_content REGEXP %s)',
|
||
'%' . $db->esc_like('globalmodule') . '%',
|
||
'%' . $db->esc_like('global_module') . '%',
|
||
str_repeat(chr(92), 2) . 'u00[4-7][0-9a-fA-F]'
|
||
);
|
||
}
|
||
|
||
public function matches(string $content): bool
|
||
{
|
||
return UsageMatcher::shows($content, $this->libraryId);
|
||
}
|
||
}
|
||
```
|
||
|
||
In `src/Integrations/Divi/Library/GlobalUsages.php`:
|
||
|
||
1. `report()`, `rows()` und die neuen Methoden – `report()` ruft weiter `rows()` auf, damit bestehende Tests, die `rows()` überschreiben, wirksam bleiben:
|
||
|
||
```php
|
||
/**
|
||
* The usages of $libraryId with the caller's rights; $withBlocked adds the P8a check (edit_post
|
||
* on every live post) – the dry run and the confirm of an edit need it, a listing does not.
|
||
*/
|
||
public function report(int $libraryId, bool $withBlocked = true): UsageReport
|
||
{
|
||
return $this->reportOfRows($this->rows($libraryId), $withBlocked);
|
||
}
|
||
|
||
/** report() for any reference – a library entry, a preset (Etappe 4) – described by $query. */
|
||
public function reportFor(UsageQuery $query, bool $withBlocked = true): UsageReport
|
||
{
|
||
return $this->reportOfRows($this->rowsFor($query), $withBlocked);
|
||
}
|
||
|
||
/** @return list<array{id: int, status: string, type: string}> */
|
||
public function rows(int $libraryId): array
|
||
{
|
||
return $this->rowsFor(new LibraryUsageQuery($libraryId));
|
||
}
|
||
|
||
/**
|
||
* Every post (no revision, not trashed) whose content $query matches (fail closed). Candidates come from one
|
||
* query (ID, status and type only); their content is read in chunks of CONTENT_CHUNK; beyond PARSE_CAP
|
||
* candidates the rest counts as references unread (audit L1).
|
||
*
|
||
* @return list<array{id: int, status: string, type: string}>
|
||
*/
|
||
public function rowsFor(UsageQuery $query): array
|
||
{
|
||
$candidates = $this->candidates($query);
|
||
$result = [];
|
||
foreach (array_chunk(array_slice($candidates, 0, self::PARSE_CAP), self::CONTENT_CHUNK) as $chunk) {
|
||
$contents = $this->contents(array_map(static fn (array $row): int => $row['id'], $chunk));
|
||
foreach ($chunk as $row) {
|
||
if (! isset($contents[$row['id']]) || $query->matches($contents[$row['id']])) {
|
||
$result[] = $row;
|
||
}
|
||
}
|
||
}
|
||
|
||
return array_merge($result, array_slice($candidates, self::PARSE_CAP));
|
||
}
|
||
```
|
||
|
||
2. Der bisherige Rumpf von `report()` ab der Zeile `$live = count(array_filter($rows, …));` bis zum `return new UsageReport(…);` wird **wörtlich** in die neue private Methode verschoben:
|
||
|
||
```php
|
||
/** @param list<array{id: int, status: string, type: string}> $rows */
|
||
private function reportOfRows(array $rows, bool $withBlocked): UsageReport
|
||
{
|
||
$live = count(array_filter($rows, static fn (array $row): bool => in_array($row['status'], self::LIVE, true)));
|
||
// … ab hier die bisherigen Zeilen von report() bis einschließlich "return new UsageReport(…);" …
|
||
}
|
||
```
|
||
|
||
3. `candidates()` nimmt die Suche:
|
||
|
||
```php
|
||
/** @return list<array{id: int, status: string, type: string}> */
|
||
private function candidates(UsageQuery $query): array
|
||
{
|
||
$db = $this->db();
|
||
// phpcs:disable WordPress.DB.PreparedSQL.InterpolatedNotPrepared, WordPress.DB.DirectDatabaseQuery
|
||
$rows = $db->get_results(
|
||
'SELECT ID, post_status, post_type FROM ' . $db->posts . ' WHERE ' . $query->candidateCondition($db)
|
||
. " AND post_type <> 'revision' AND " . self::LISTED . ' ORDER BY ID ASC',
|
||
'ARRAY_A'
|
||
);
|
||
// phpcs:enable
|
||
// … unveränderte Umwandlung in $result …
|
||
}
|
||
```
|
||
|
||
4. Klassen-Docblock: erster Satz „Posts (pages, Theme Builder layouts, other library entries) that reference something a UsageQuery describes – a library entry $id (LibraryUsageQuery) or, since Etappe 4, a preset: …“; der Rest bleibt.
|
||
|
||
Alle übrigen Erwartungen von `GlobalUsagesTest` (Kandidaten-SQL, Rechte, Grenzen, Theme Builder) bleiben unverändert.
|
||
|
||
- [ ] **Step 4: Tests laufen lassen – sie bestehen**
|
||
|
||
Run: `php vendor/bin/phpunit tests/Unit/Integrations/Divi/Library`
|
||
Expected: PASS, alle Bibliotheks-Tests grün.
|
||
|
||
- [ ] **Step 5: Gesamtlauf, Lint, Commit**
|
||
|
||
Run: `composer test && composer lint`
|
||
|
||
```bash
|
||
git add src/Integrations/Divi/Library/UsageQuery.php src/Integrations/Divi/Library/LibraryUsageQuery.php src/Integrations/Divi/Library/GlobalUsages.php tests/Unit/Integrations/Divi/Library/GlobalUsagesTest.php tests/Unit/Integrations/Divi/Library/LibraryUsageQueryTest.php
|
||
git commit -m "refactor: GlobalUsages sucht über UsageQuery – Bibliothekssuche als LibraryUsageQuery" -m "Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>"
|
||
```
|
||
|
||
---
|
||
|
||
### Task 7: Fundstellen eines Presets – `PresetUsageMatcher`, `PresetUsageQuery`
|
||
|
||
**Files:**
|
||
- Create: `src/Integrations/Divi/Design/PresetUsageMatcher.php`
|
||
- Create: `src/Integrations/Divi/Design/PresetUsageQuery.php`
|
||
- Test: `tests/Unit/Integrations/Divi/Design/PresetUsageMatcherTest.php`
|
||
- Test: `tests/Unit/Integrations/Divi/Design/PresetUsageQueryTest.php`
|
||
|
||
**Interfaces:**
|
||
- Consumes: `Parser::parse()`, `MalformedMarkup`, `NodeIndex::build()`, `NodeIndex::entries()`, `NodeSummary::presetIds()` (vorhanden), `PresetScope` (Task 2), `UsageQuery` (Task 6).
|
||
- Produces:
|
||
- `final class PresetUsageMatcher { public function __construct(private Parser $parser = new Parser()); public function uses(string $content, PresetScope $scope, string $id, bool $isDefault): bool }` – Modul-Preset: ein Block von `$scope->name` mit `$id` in `modulePreset` oder – wenn `$isDefault` – ohne eigenes Modul-Preset (bzw. `""`/`default`/`_initial`); Gruppen-Preset: ein Block mit `$id` in einem `groupPreset.*.presetId` mit `groupName` `$scope->name` oder – wenn `$isDefault` – ein Block mit dieser Gruppe ohne eigenes Gruppen-Preset ist **nicht** Teil von 4a (siehe Hinweis); fail closed bei kaputtem Markup.
|
||
- `final class PresetUsageQuery implements UsageQuery { public function __construct(array $targets, PresetUsageMatcher $matcher = new PresetUsageMatcher()) }` – `$targets`: `list<array{scope: PresetScope, id: string, default: bool}>`, nicht leer; ein Beitrag zählt, wenn er **eines** der Presets verwendet (ein Aufruf von `lit/divi-presets-set` kann mehrere Presets ändern).
|
||
|
||
Hinweis: Welche Module ein **Standard-Gruppen-Preset** erreicht, hängt von Divis Gruppenliste je Modul ab (`get_group_preset_default_attr`, Formate §3) – das kommt mit der Gruppen-Zuweisung in 4b. In 4a meldet der Probelauf für ein Standard-Gruppen-Preset nur die Seiten mit expliziter Zuweisung und warnt: „Standard-Gruppen-Presets wirken zusätzlich auf alle Module mit dieser Gruppe; diese Seiten sind nicht aufgelistet.“
|
||
|
||
- [ ] **Step 1: Failing tests schreiben**
|
||
|
||
`tests/Unit/Integrations/Divi/Design/PresetUsageMatcherTest.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Tests\Unit\Integrations\Divi\Design;
|
||
|
||
use LIT\MCP\Integrations\Divi\Design\PresetScope;
|
||
use LIT\MCP\Integrations\Divi\Design\PresetUsageMatcher;
|
||
use PHPUnit\Framework\TestCase;
|
||
|
||
final class PresetUsageMatcherTest extends TestCase
|
||
{
|
||
private const BUTTON = '<!-- wp:divi/section --><!-- wp:divi/row --><!-- wp:divi/column -->'
|
||
. '<!-- wp:divi/button %s /--><!-- /wp:divi/column --><!-- /wp:divi/row --><!-- /wp:divi/section -->';
|
||
|
||
private static function page(string $buttonAttrs): string
|
||
{
|
||
return sprintf(self::BUTTON, $buttonAttrs);
|
||
}
|
||
|
||
public function testModulePresetInTheStack(): void
|
||
{
|
||
$matcher = new PresetUsageMatcher();
|
||
$button = new PresetScope('module', 'divi/button');
|
||
|
||
self::assertTrue($matcher->uses(self::page('{"modulePreset":["aaaaaaaaaa"]}'), $button, 'aaaaaaaaaa', false));
|
||
self::assertTrue($matcher->uses(self::page('{"modulePreset":["x","aaaaaaaaaa"]}'), $button, 'aaaaaaaaaa', false));
|
||
self::assertTrue($matcher->uses(self::page('{"modulePreset":"aaaaaaaaaa"}'), $button, 'aaaaaaaaaa', false));
|
||
self::assertFalse($matcher->uses(self::page('{"modulePreset":["bbbbbbbbbb"]}'), $button, 'aaaaaaaaaa', false));
|
||
self::assertFalse(
|
||
$matcher->uses(self::page('{"modulePreset":["aaaaaaaaaa"]}'), new PresetScope('module', 'divi/text'), 'aaaaaaaaaa', false),
|
||
'an ID of another module does not count'
|
||
);
|
||
}
|
||
|
||
public function testDefaultModulePresetReachesModulesWithoutOwnPreset(): void
|
||
{
|
||
$matcher = new PresetUsageMatcher();
|
||
$button = new PresetScope('module', 'divi/button');
|
||
|
||
self::assertTrue($matcher->uses(self::page('{}'), $button, 'dddddddddd', true));
|
||
self::assertTrue($matcher->uses(self::page('{"modulePreset":["default"]}'), $button, 'dddddddddd', true));
|
||
self::assertFalse($matcher->uses(self::page('{"modulePreset":["aaaaaaaaaa"]}'), $button, 'dddddddddd', true));
|
||
}
|
||
|
||
public function testGroupPresetById(): void
|
||
{
|
||
$matcher = new PresetUsageMatcher();
|
||
$group = new PresetScope('group', 'divi/font-body');
|
||
$attrs = '{"groupPreset":{"content.decoration.bodyFont":{"presetId":["gggggggggg"],"groupName":"divi/font-body"}}}';
|
||
|
||
self::assertTrue($matcher->uses(self::page($attrs), $group, 'gggggggggg', false));
|
||
self::assertFalse($matcher->uses(self::page($attrs), new PresetScope('group', 'divi/spacing'), 'gggggggggg', false));
|
||
}
|
||
|
||
public function testBrokenMarkupCountsAsUse(): void
|
||
{
|
||
self::assertTrue((new PresetUsageMatcher())->uses(
|
||
'<!-- wp:divi/section {"a": --><!-- /wp:divi/row -->',
|
||
new PresetScope('module', 'divi/button'),
|
||
'aaaaaaaaaa',
|
||
false
|
||
));
|
||
}
|
||
}
|
||
```
|
||
|
||
`tests/Unit/Integrations/Divi/Design/PresetUsageQueryTest.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Tests\Unit\Integrations\Divi\Design;
|
||
|
||
use LIT\MCP\Integrations\Divi\Design\PresetScope;
|
||
use LIT\MCP\Integrations\Divi\Design\PresetUsageQuery;
|
||
use LIT\MCP\Tests\Unit\TestCase;
|
||
use Mockery;
|
||
|
||
final class PresetUsageQueryTest extends TestCase
|
||
{
|
||
public function testCandidatesContainAnIdOrAJsonEscape(): void
|
||
{
|
||
$db = Mockery::mock(\wpdb::class);
|
||
$db->allows('esc_like')->andReturnUsing(static fn (string $text): string => $text);
|
||
$db->expects('prepare')
|
||
->with(
|
||
'(post_content LIKE %s OR post_content LIKE %s OR post_content REGEXP %s)',
|
||
'%aaaaaaaaaa%',
|
||
'%gggggggggg%',
|
||
'\\\\u00[4-7][0-9a-fA-F]'
|
||
)
|
||
->andReturn('(prepared)');
|
||
|
||
$query = new PresetUsageQuery([
|
||
['scope' => new PresetScope('module', 'divi/button'), 'id' => 'aaaaaaaaaa', 'default' => false],
|
||
['scope' => new PresetScope('group', 'divi/font-body'), 'id' => 'gggggggggg', 'default' => false],
|
||
]);
|
||
|
||
self::assertSame('(prepared)', $query->candidateCondition($db));
|
||
self::assertTrue($query->matches('<!-- wp:divi/text {"groupPreset":{"content.decoration.bodyFont":'
|
||
. '{"presetId":["gggggggggg"],"groupName":"divi/font-body"}}} /-->'));
|
||
self::assertFalse($query->matches('<!-- wp:divi/text {} /-->'));
|
||
}
|
||
|
||
public function testADefaultModulePresetLooksForTheModule(): void
|
||
{
|
||
$db = Mockery::mock(\wpdb::class);
|
||
$db->allows('esc_like')->andReturnUsing(static fn (string $text): string => $text);
|
||
$db->expects('prepare')
|
||
->with(
|
||
'(post_content LIKE %s OR post_content LIKE %s OR post_content REGEXP %s)',
|
||
'%dddddddddd%',
|
||
'%wp:divi/button %',
|
||
'\\\\u00[4-7][0-9a-fA-F]'
|
||
)
|
||
->andReturn('(prepared)');
|
||
|
||
$query = new PresetUsageQuery([
|
||
['scope' => new PresetScope('module', 'divi/button'), 'id' => 'dddddddddd', 'default' => true],
|
||
]);
|
||
|
||
self::assertSame('(prepared)', $query->candidateCondition($db));
|
||
self::assertTrue($query->matches('<!-- wp:divi/button {} /-->'));
|
||
}
|
||
|
||
public function testNeedsATarget(): void
|
||
{
|
||
$this->expectException(\InvalidArgumentException::class);
|
||
|
||
new PresetUsageQuery([]);
|
||
}
|
||
}
|
||
```
|
||
|
||
Warum die JSON-Escape-Bedingung: Divi kann Schlüssel und Werte in Blockattributen mit `\u00XX` schreiben; eine so kodierte ID fände `LIKE` nicht (fail closed wie Ruling P23). Kandidaten ohne Treffer filtert `matches()` heraus.
|
||
|
||
- [ ] **Step 2: Tests laufen lassen – sie scheitern**
|
||
|
||
Run: `php vendor/bin/phpunit tests/Unit/Integrations/Divi/Design/PresetUsageMatcherTest.php tests/Unit/Integrations/Divi/Design/PresetUsageQueryTest.php`
|
||
Expected: FAIL, Klassen fehlen.
|
||
|
||
- [ ] **Step 3: Implementieren**
|
||
|
||
`src/Integrations/Divi/Design/PresetUsageMatcher.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Integrations\Divi\Design;
|
||
|
||
use LIT\MCP\Integrations\Divi\BlockTree\Block;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\MalformedMarkup;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\NodeIndex;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\NodeSummary;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\Parser;
|
||
|
||
defined('ABSPATH') || exit;
|
||
|
||
/**
|
||
* Whether post content uses a preset (spec §6.4, formats §3 "Verweise in Blöcken"), fail closed:
|
||
* - module preset $id: a block of the module with $id in its modulePreset stack (array or legacy string);
|
||
* the default preset additionally reaches every block of the module without an own preset ("" / "default" /
|
||
* "_initial" mean the default, GlobalPreset::is_preset_id_as_default);
|
||
* - group preset $id: a block with $id in groupPreset.<attr>.presetId whose groupName is the group;
|
||
* - markup the parser rejects counts as a use.
|
||
* Pure PHP.
|
||
*/
|
||
final class PresetUsageMatcher
|
||
{
|
||
private const DEFAULT_IDS = ['', 'default', '_initial'];
|
||
|
||
public function __construct(private Parser $parser = new Parser())
|
||
{
|
||
}
|
||
|
||
public function uses(string $content, PresetScope $scope, string $id, bool $isDefault): bool
|
||
{
|
||
try {
|
||
$index = NodeIndex::build($this->parser->parse($content));
|
||
} catch (MalformedMarkup) {
|
||
return true;
|
||
}
|
||
|
||
foreach ($index->entries() as $entry) {
|
||
$block = $entry['block'];
|
||
if ($scope->kind === PresetScope::MODULE ? $this->usesModulePreset($block, $scope, $id, $isDefault)
|
||
: $this->usesGroupPreset($block->attrs(), $scope, $id)) {
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
private function usesModulePreset(Block $block, PresetScope $scope, string $id, bool $isDefault): bool
|
||
{
|
||
if ($block->name() !== $scope->name) {
|
||
return false;
|
||
}
|
||
|
||
$stack = NodeSummary::presetIds($block);
|
||
if (in_array($id, $stack, true)) {
|
||
return true;
|
||
}
|
||
|
||
return $isDefault && array_diff($stack, self::DEFAULT_IDS) === [];
|
||
}
|
||
|
||
/** @param array<string, mixed> $attrs */
|
||
private function usesGroupPreset(array $attrs, PresetScope $scope, string $id): bool
|
||
{
|
||
$groups = is_array($attrs['groupPreset'] ?? null) ? $attrs['groupPreset'] : [];
|
||
foreach ($groups as $group) {
|
||
if (! is_array($group) || ($group['groupName'] ?? null) !== $scope->name) {
|
||
continue;
|
||
}
|
||
if (in_array($id, (array) ($group['presetId'] ?? []), true)) {
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
}
|
||
```
|
||
|
||
`NodeSummary::presetIds()` filtert leere Strings heraus; ein `modulePreset: [""]` ergibt also `[]` und zählt für das Standard-Preset – wie in Divi.
|
||
|
||
`src/Integrations/Divi/Design/PresetUsageQuery.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Integrations\Divi\Design;
|
||
|
||
use InvalidArgumentException;
|
||
use LIT\MCP\Integrations\Divi\Library\UsageQuery;
|
||
|
||
defined('ABSPATH') || exit;
|
||
|
||
/**
|
||
* The posts that use any of the presets $targets (GlobalUsages::reportFor()): candidates contain one of the IDs, a
|
||
* JSON escape of a letter (an escaped ID or key, fail closed like ruling P23) or – for a default module preset – a
|
||
* block of the module; PresetUsageMatcher decides per target.
|
||
*/
|
||
final class PresetUsageQuery implements UsageQuery
|
||
{
|
||
private const ESCAPED_LETTER = '\\\\u00[4-7][0-9a-fA-F]';
|
||
|
||
/** @var list<array{scope: PresetScope, id: string, default: bool}> */
|
||
private array $targets;
|
||
|
||
/**
|
||
* @param list<array{scope: PresetScope, id: string, default: bool}> $targets
|
||
* @throws InvalidArgumentException Without targets.
|
||
*/
|
||
public function __construct(array $targets, private PresetUsageMatcher $matcher = new PresetUsageMatcher())
|
||
{
|
||
if ($targets === []) {
|
||
throw new InvalidArgumentException('PresetUsageQuery needs at least one preset.');
|
||
}
|
||
$this->targets = array_values($targets);
|
||
}
|
||
|
||
public function candidateCondition(\wpdb $db): string
|
||
{
|
||
$likes = [];
|
||
foreach ($this->targets as $target) {
|
||
$likes[] = '%' . $db->esc_like($target['id']) . '%';
|
||
if ($target['default'] && $target['scope']->kind === PresetScope::MODULE) {
|
||
$likes[] = '%' . $db->esc_like('wp:' . $target['scope']->name . ' ') . '%';
|
||
}
|
||
}
|
||
$likes = array_values(array_unique($likes));
|
||
|
||
return (string) $db->prepare(
|
||
'(' . str_repeat('post_content LIKE %s OR ', count($likes)) . 'post_content REGEXP %s)',
|
||
...array_merge($likes, [self::ESCAPED_LETTER])
|
||
);
|
||
}
|
||
|
||
public function matches(string $content): bool
|
||
{
|
||
foreach ($this->targets as $target) {
|
||
if ($this->matcher->uses($content, $target['scope'], $target['id'], $target['default'])) {
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
}
|
||
```
|
||
|
||
`'\\\\u00[4-7][0-9a-fA-F]'` in einfachen Anführungszeichen ergibt die Zeichenfolge `\\u00[4-7][0-9a-fA-F]` – dieselbe wie `str_repeat(chr(92), 2) . 'u00…'` in `LibraryUsageQuery` (MySQL-REGEXP sieht nach dem Entschärfen `\u00…`).
|
||
|
||
Ein Modul ohne Attribute steht als `<!-- wp:divi/button /-->` im Inhalt (ohne Leerzeichen-JSON); die Kandidatenbedingung `wp:divi/button ` (mit Leerzeichen) trifft beide Schreibweisen, weil auf den Namen immer ein Leerzeichen folgt.
|
||
|
||
- [ ] **Step 4: Tests laufen lassen – sie bestehen**
|
||
|
||
Run: `php vendor/bin/phpunit tests/Unit/Integrations/Divi/Design/PresetUsageMatcherTest.php tests/Unit/Integrations/Divi/Design/PresetUsageQueryTest.php`
|
||
Expected: PASS.
|
||
|
||
- [ ] **Step 5: Gesamtlauf, Lint, Commit**
|
||
|
||
Run: `composer test && composer lint`
|
||
|
||
```bash
|
||
git add src/Integrations/Divi/Design/PresetUsageMatcher.php src/Integrations/Divi/Design/PresetUsageQuery.php tests/Unit/Integrations/Divi/Design/PresetUsageMatcherTest.php tests/Unit/Integrations/Divi/Design/PresetUsageQueryTest.php
|
||
git commit -m "feat: Fundstellen eines Presets (PresetUsageMatcher, PresetUsageQuery)" -m "Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>"
|
||
```
|
||
|
||
---
|
||
### Task 8: Änderungs-Pipeline – `DesignArea`, `DesignPlan`, `DesignChange`, `PresetArea`
|
||
|
||
**Files:**
|
||
- Create: `src/Integrations/Divi/Design/DesignArea.php`
|
||
- Create: `src/Integrations/Divi/Design/DesignPlan.php`
|
||
- Create: `src/Integrations/Divi/Design/DesignChange.php`
|
||
- Create: `src/Integrations/Divi/Design/PresetArea.php`
|
||
- Test: `tests/Unit/Integrations/Divi/Design/DesignChangeTest.php`
|
||
- Test: `tests/Unit/Integrations/Divi/Design/PresetAreaTest.php`
|
||
|
||
**Interfaces:**
|
||
- Consumes: `SnapshotStore`, `SnapshotTooLarge` (Task 4), `DesignSystemWriter::savePresets()`/`presets()` (Task 5), `PresetBook`, `PresetDiff` (Tasks 2–3), `UsageReport` (vorhanden), `ChangeLog::record()/recordPartial()`, `Errors`, `ToolResult`, `Rollback`, `WriteFailed`, `ReleaseGate::assertWritable()`, `DiviLocked::in()`.
|
||
- Produces:
|
||
- `interface DesignArea { public function name(): string; public function label(): string; public function raw(): array; public function rev(array $raw): string; public function write(array $raw, bool $mayRemove): array; public function verify(array $expected, array $actual): bool; }`
|
||
- `final class DesignPlan { public function __construct(public readonly array $raw, public readonly array $diff, public readonly string $summary, public readonly ?UsageReport $usages = null, public readonly array $warnings = [], public readonly bool $mayRemove = false); public function isEmpty(): bool }`
|
||
- `final class DesignChange { public function __construct(SnapshotStore $snapshots, ChangeLog $log); public function run(string $ability, DesignArea $area, array $input, callable $plan): array|WP_Error; public static function inputProperties(): array; public static function outputSchema(): array }` – `$plan` ist `callable(array $currentRaw): DesignPlan|WP_Error`.
|
||
- `final class PresetArea implements DesignArea { public function __construct(DesignSystemWriter $writer) }`.
|
||
|
||
Antworten von `run()`:
|
||
- Plan liefert `WP_Error` → unverändert zurück.
|
||
- Leerer Plan → `ToolResult` „Keine Änderung …“ mit `diff: []`, `design_rev`.
|
||
- Ohne `confirm: true` → `Errors::confirmRequired($summary . ' Nichts wurde gespeichert (Probelauf).', ['diff' => …, 'design_rev' => …] + affected-Liste + ggf. `blocked_ids`)`.
|
||
- `confirm` ohne/mit falscher `design_rev` → `Errors::revMismatch(<Bereich> wurde seit dem Probelauf geändert …)`.
|
||
- Fundstellen blockieren (Live-Seite ohne `edit_post`, über `HARD_CAP`) → `forbidden` mit `blocked_ids`.
|
||
- Schreiben → `ToolResult` mit `snapshot_id`, `log_id`, `diff`, `design_rev` (nach dem Schreiben), `warnings`.
|
||
|
||
- [ ] **Step 1: Failing test für `DesignChange` schreiben**
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Tests\Unit\Integrations\Divi\Design;
|
||
|
||
use LIT\MCP\Integrations\Divi\Design\DesignArea;
|
||
use LIT\MCP\Integrations\Divi\Design\DesignChange;
|
||
use LIT\MCP\Integrations\Divi\Design\DesignPlan;
|
||
use LIT\MCP\Integrations\Divi\Design\SnapshotStore;
|
||
use LIT\MCP\Integrations\Divi\Design\SnapshotTooLarge;
|
||
use LIT\MCP\Integrations\Divi\Library\UsageReport;
|
||
use LIT\MCP\Integrations\Divi\Release\DiviLocked;
|
||
use LIT\MCP\Integrations\Divi\Release\ReleaseGate;
|
||
use LIT\MCP\Integrations\Divi\Release\ReleaseState;
|
||
use LIT\MCP\Integrations\Divi\Release\ReleaseStatus;
|
||
use LIT\MCP\Abilities\WriteFailed;
|
||
use LIT\MCP\Tests\Support\FakeChangeLog;
|
||
use LIT\MCP\Tests\Unit\TestCase;
|
||
use Mockery;
|
||
use RuntimeException;
|
||
|
||
final class DesignChangeTest extends TestCase
|
||
{
|
||
/** A DesignArea over an array; $failWrite/$failRestore make write()/the rollback throw. */
|
||
private static function area(array &$stored, int $failWrites = 0, bool $verify = true): DesignArea
|
||
{
|
||
return new class ($stored, $failWrites, $verify) implements DesignArea {
|
||
public array $writes = [];
|
||
|
||
public function __construct(private array &$stored, private int $failWrites, private bool $verify)
|
||
{
|
||
}
|
||
|
||
public function name(): string
|
||
{
|
||
return 'presets';
|
||
}
|
||
|
||
public function label(): string
|
||
{
|
||
return 'Presets';
|
||
}
|
||
|
||
public function raw(): array
|
||
{
|
||
return $this->stored;
|
||
}
|
||
|
||
public function rev(array $raw): string
|
||
{
|
||
return substr(md5((string) json_encode($raw)), 0, 12);
|
||
}
|
||
|
||
public function write(array $raw, bool $mayRemove): array
|
||
{
|
||
$this->writes[] = [$raw, $mayRemove];
|
||
if ($this->failWrites > 0) {
|
||
--$this->failWrites;
|
||
throw new RuntimeException('divi refused');
|
||
}
|
||
$this->stored = $raw;
|
||
|
||
return $raw;
|
||
}
|
||
|
||
public function verify(array $expected, array $actual): bool
|
||
{
|
||
return $this->verify;
|
||
}
|
||
};
|
||
}
|
||
|
||
private static function plan(array $raw, ?UsageReport $usages = null): callable
|
||
{
|
||
return static fn (array $current): DesignPlan => new DesignPlan(
|
||
$raw,
|
||
[['kind' => 'module', 'scope' => 'divi/button', 'id' => 'a', 'name' => 'CTA', 'action' => 'added']],
|
||
'Preset „CTA“ wird angelegt.',
|
||
$usages
|
||
);
|
||
}
|
||
|
||
private static function usages(array $blocked = []): UsageReport
|
||
{
|
||
return new UsageReport(1, [['post_id' => 3, 'title' => 'Start', 'status' => 'publish', 'type' => 'page']],
|
||
0, 1, $blocked, 0, false);
|
||
}
|
||
|
||
public function testDryRunListsDiffAffectedAndRevAndSavesNothing(): void
|
||
{
|
||
$stored = ['v' => 1];
|
||
$area = self::area($stored);
|
||
$snapshots = Mockery::mock(SnapshotStore::class);
|
||
$snapshots->shouldNotReceive('save');
|
||
|
||
$result = (new DesignChange($snapshots, FakeChangeLog::forbidden()))
|
||
->run('lit/divi-presets-set', $area, [], self::plan(['v' => 2], self::usages()));
|
||
|
||
$details = self::assertToolError($result, 'confirm_required');
|
||
self::assertStringContainsString('Preset „CTA“ wird angelegt. Nichts wurde gespeichert (Probelauf).', $result->get_error_message());
|
||
self::assertSame('added', $details['diff'][0]['action']);
|
||
self::assertSame($area->rev(['v' => 1]), $details['design_rev']);
|
||
self::assertSame(3, $details['affected'][0]['post_id']);
|
||
self::assertSame(1, $details['affected_count']);
|
||
self::assertSame([], $area->writes);
|
||
}
|
||
|
||
public function testNothingToDoIsNoDryRun(): void
|
||
{
|
||
$stored = ['v' => 1];
|
||
$empty = static fn (array $current): DesignPlan => new DesignPlan($current, [], 'Nichts.');
|
||
|
||
$result = (new DesignChange(Mockery::mock(SnapshotStore::class), FakeChangeLog::forbidden()))
|
||
->run('lit/divi-presets-set', self::area($stored), [], $empty);
|
||
|
||
self::assertTrue($result['ok']);
|
||
self::assertSame([], $result['diff']);
|
||
self::assertStringStartsWith('Keine Änderung', $result['summary']);
|
||
}
|
||
|
||
public function testStaleDesignRevWritesNothing(): void
|
||
{
|
||
$stored = ['v' => 1];
|
||
$area = self::area($stored);
|
||
$snapshots = Mockery::mock(SnapshotStore::class);
|
||
$snapshots->shouldNotReceive('save');
|
||
|
||
$result = (new DesignChange($snapshots, FakeChangeLog::forbidden()))
|
||
->run('lit/divi-presets-set', $area, ['confirm' => true, 'design_rev' => 'veraltet'], self::plan(['v' => 2]));
|
||
|
||
self::assertToolError($result, 'rev_mismatch');
|
||
self::assertStringContainsString('Presets wurden seit dem Probelauf geändert', $result->get_error_message());
|
||
self::assertSame([], $area->writes);
|
||
}
|
||
|
||
public function testBlockedUsagesRefuseTheConfirm(): void
|
||
{
|
||
$stored = ['v' => 1];
|
||
$area = self::area($stored);
|
||
$snapshots = Mockery::mock(SnapshotStore::class);
|
||
$snapshots->shouldNotReceive('save');
|
||
|
||
$result = (new DesignChange($snapshots, FakeChangeLog::forbidden()))->run(
|
||
'lit/divi-presets-set',
|
||
$area,
|
||
['confirm' => true, 'design_rev' => $area->rev($stored)],
|
||
self::plan(['v' => 2], self::usages([3]))
|
||
);
|
||
|
||
$details = self::assertToolError($result, 'forbidden');
|
||
self::assertSame([3], $details['blocked_ids']);
|
||
}
|
||
|
||
public function testConfirmTakesASnapshotWritesAndLogs(): void
|
||
{
|
||
$stored = ['v' => 1];
|
||
$area = self::area($stored);
|
||
$snapshots = Mockery::mock(SnapshotStore::class);
|
||
$snapshots->expects('save')->with('presets', ['v' => 1], 'lit/divi-presets-set')->andReturn('presets-1');
|
||
$snapshots->expects('attachLog')->with('presets', 'presets-1', 9);
|
||
$log = new FakeChangeLog(9);
|
||
|
||
$result = (new DesignChange($snapshots, $log))->run(
|
||
'lit/divi-presets-set',
|
||
$area,
|
||
['confirm' => true, 'design_rev' => $area->rev(['v' => 1])],
|
||
self::plan(['v' => 2])
|
||
);
|
||
|
||
self::assertTrue($result['ok']);
|
||
self::assertSame('presets-1', $result['snapshot_id']);
|
||
self::assertSame(9, $result['log_id']);
|
||
self::assertSame($area->rev(['v' => 2]), $result['design_rev']);
|
||
self::assertSame(['v' => 2], $stored);
|
||
self::assertSame('presets', $log->records[0]['object_id']);
|
||
self::assertSame('divi_design', $log->records[0]['object_type']);
|
||
self::assertSame('presets-1', $log->records[0]['snapshot_id']);
|
||
}
|
||
|
||
public function testLockedDiviWritesNoSnapshot(): void
|
||
{
|
||
ReleaseGate::useResolver(static fn (): ReleaseStatus => new ReleaseStatus(ReleaseState::Untested, '5.16.0'));
|
||
$stored = ['v' => 1];
|
||
$area = self::area($stored);
|
||
$snapshots = Mockery::mock(SnapshotStore::class);
|
||
$snapshots->shouldNotReceive('save');
|
||
|
||
$this->expectException(DiviLocked::class);
|
||
|
||
(new DesignChange($snapshots, FakeChangeLog::forbidden()))->run(
|
||
'lit/divi-presets-set',
|
||
$area,
|
||
['confirm' => true, 'design_rev' => $area->rev($stored)],
|
||
self::plan(['v' => 2])
|
||
);
|
||
}
|
||
|
||
public function testTooLargeSnapshotRefusesTheChange(): void
|
||
{
|
||
$stored = ['v' => 1];
|
||
$area = self::area($stored);
|
||
$snapshots = Mockery::mock(SnapshotStore::class);
|
||
$snapshots->expects('save')->andThrow(new SnapshotTooLarge(3000000));
|
||
|
||
$result = (new DesignChange($snapshots, FakeChangeLog::forbidden()))->run(
|
||
'lit/divi-presets-set',
|
||
$area,
|
||
['confirm' => true, 'design_rev' => $area->rev($stored)],
|
||
self::plan(['v' => 2])
|
||
);
|
||
|
||
self::assertToolError($result, 'snapshot_too_large');
|
||
self::assertSame([], $area->writes);
|
||
}
|
||
|
||
public function testFailedWriteRestoresTheSnapshot(): void
|
||
{
|
||
$stored = ['v' => 1];
|
||
$area = self::area($stored, 1);
|
||
$snapshots = Mockery::mock(SnapshotStore::class);
|
||
$snapshots->expects('save')->andReturn('presets-1');
|
||
|
||
try {
|
||
(new DesignChange($snapshots, FakeChangeLog::forbidden()))->run(
|
||
'lit/divi-presets-set',
|
||
$area,
|
||
['confirm' => true, 'design_rev' => $area->rev($stored)],
|
||
self::plan(['v' => 2])
|
||
);
|
||
self::fail('expected WriteFailed');
|
||
} catch (WriteFailed $e) {
|
||
self::assertTrue($e->rolledBack);
|
||
self::assertSame('presets-1', $e->details['snapshot_id']);
|
||
}
|
||
|
||
self::assertSame([[['v' => 2], false], [['v' => 1], true]], $area->writes);
|
||
self::assertSame(['v' => 1], $stored);
|
||
}
|
||
|
||
public function testReadBackMismatchRestoresTheSnapshot(): void
|
||
{
|
||
$stored = ['v' => 1];
|
||
$area = self::area($stored, 0, false);
|
||
$snapshots = Mockery::mock(SnapshotStore::class);
|
||
$snapshots->expects('save')->andReturn('presets-1');
|
||
|
||
$this->expectException(WriteFailed::class);
|
||
|
||
(new DesignChange($snapshots, FakeChangeLog::forbidden()))->run(
|
||
'lit/divi-presets-set',
|
||
$area,
|
||
['confirm' => true, 'design_rev' => $area->rev($stored)],
|
||
self::plan(['v' => 2])
|
||
);
|
||
}
|
||
|
||
public function testFailedRollbackIsPartial(): void
|
||
{
|
||
$stored = ['v' => 1];
|
||
$area = self::area($stored, 2);
|
||
$snapshots = Mockery::mock(SnapshotStore::class);
|
||
$snapshots->expects('save')->andReturn('presets-1');
|
||
$log = FakeChangeLog::partialsOnly();
|
||
|
||
try {
|
||
(new DesignChange($snapshots, $log))->run(
|
||
'lit/divi-presets-set',
|
||
$area,
|
||
['confirm' => true, 'design_rev' => $area->rev($stored)],
|
||
self::plan(['v' => 2])
|
||
);
|
||
self::fail('expected WriteFailed');
|
||
} catch (WriteFailed $e) {
|
||
self::assertFalse($e->rolledBack);
|
||
self::assertStringContainsString('presets-1', (string) $e->hint);
|
||
}
|
||
|
||
self::assertCount(1, $log->partials);
|
||
}
|
||
}
|
||
```
|
||
|
||
`assertToolError()` (Trait `AssertsToolErrors`) gibt die Fehlerdaten zurück, wie der Client sie sieht (JSON der Meldung inklusive aller Details).
|
||
|
||
- [ ] **Step 2: Test laufen lassen – er scheitert**
|
||
|
||
Run: `php vendor/bin/phpunit tests/Unit/Integrations/Divi/Design/DesignChangeTest.php`
|
||
Expected: FAIL, Klassen fehlen.
|
||
|
||
- [ ] **Step 3: `DesignArea` und `DesignPlan` implementieren**
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Integrations\Divi\Design;
|
||
|
||
defined('ABSPATH') || exit;
|
||
|
||
/**
|
||
* One area of the design system for DesignChange (spec §2, §4): colors, variables, presets or theme options – its
|
||
* raw inventory as Divi stores it (also the snapshot), its design_rev, how it is written through Divi and how a
|
||
* read-back is judged. write() throws on failure; it is also how a snapshot is written back ($mayRemove = true).
|
||
*/
|
||
interface DesignArea
|
||
{
|
||
/** One of SnapshotStore::AREAS. */
|
||
public function name(): string;
|
||
|
||
/** German name for messages, e.g. "Presets". */
|
||
public function label(): string;
|
||
|
||
/** @return array<array-key, mixed> */
|
||
public function raw(): array;
|
||
|
||
/** @param array<array-key, mixed> $raw */
|
||
public function rev(array $raw): string;
|
||
|
||
/**
|
||
* @param array<array-key, mixed> $raw
|
||
* @return array<array-key, mixed> The inventory as read back after writing.
|
||
*/
|
||
public function write(array $raw, bool $mayRemove): array;
|
||
|
||
/**
|
||
* Whether Divi stored what was written – sanitizing may change values, never which entries exist.
|
||
*
|
||
* @param array<array-key, mixed> $expected
|
||
* @param array<array-key, mixed> $actual
|
||
*/
|
||
public function verify(array $expected, array $actual): bool;
|
||
}
|
||
```
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Integrations\Divi\Design;
|
||
|
||
use LIT\MCP\Integrations\Divi\Library\UsageReport;
|
||
|
||
defined('ABSPATH') || exit;
|
||
|
||
/**
|
||
* What a design change would do (spec §4 step 3–4): the new raw inventory, the diff, a one-sentence German summary,
|
||
* the posts it affects (null = none to report), warnings and whether entries are removed (delete/restore).
|
||
*/
|
||
final class DesignPlan
|
||
{
|
||
/**
|
||
* @param array<array-key, mixed> $raw
|
||
* @param list<array<string, mixed>> $diff
|
||
* @param list<string> $warnings
|
||
*/
|
||
public function __construct(
|
||
public readonly array $raw,
|
||
public readonly array $diff,
|
||
public readonly string $summary,
|
||
public readonly ?UsageReport $usages = null,
|
||
public readonly array $warnings = [],
|
||
public readonly bool $mayRemove = false
|
||
) {
|
||
}
|
||
|
||
public function isEmpty(): bool
|
||
{
|
||
return $this->diff === [];
|
||
}
|
||
}
|
||
```
|
||
|
||
- [ ] **Step 4: `DesignChange` implementieren**
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Integrations\Divi\Design;
|
||
|
||
use LIT\MCP\Abilities\Errors;
|
||
use LIT\MCP\Abilities\Rollback;
|
||
use LIT\MCP\Abilities\ToolResult;
|
||
use LIT\MCP\Abilities\WriteFailed;
|
||
use LIT\MCP\ChangeLog\ChangeLog;
|
||
use LIT\MCP\Integrations\Divi\Release\DiviLocked;
|
||
use LIT\MCP\Integrations\Divi\Release\ReleaseGate;
|
||
use RuntimeException;
|
||
use Throwable;
|
||
use WP_Error;
|
||
|
||
defined('ABSPATH') || exit;
|
||
|
||
/**
|
||
* The change pipeline of every design system write (spec §4, G2, G6): plan on the live inventory → without
|
||
* confirm a dry run (diff, affected posts, design_rev; nothing saved) → with confirm the design_rev must still match
|
||
* → no live post may block (P8/P8a) → release lock → snapshot of the area → write through Divi → read back and
|
||
* verify → change log. A failed write or read-back writes the snapshot back (Rollback); when that fails too the
|
||
* error is partial_write with the snapshot to restore by hand. The rights are the tool's (spec §10).
|
||
*/
|
||
final class DesignChange
|
||
{
|
||
public const OBJECT_TYPE = 'divi_design';
|
||
|
||
private const LISTED_IDS = 10;
|
||
|
||
public function __construct(private SnapshotStore $snapshots, private ChangeLog $log)
|
||
{
|
||
}
|
||
|
||
/** @return array<string, array<string, mixed>> Input properties every design write tool takes. */
|
||
public static function inputProperties(): array
|
||
{
|
||
return [
|
||
'confirm' => ['type' => 'boolean', 'description' => 'Erst nach dem Probelauf und der Rückfrage beim Nutzer.'],
|
||
'design_rev' => ['type' => 'string', 'description' => 'design_rev aus dem Probelauf (Pflicht mit confirm).'],
|
||
];
|
||
}
|
||
|
||
/** @return array<string, mixed> */
|
||
public static function outputSchema(): array
|
||
{
|
||
return ToolResult::schema([
|
||
'diff' => ['type' => 'array', 'items' => ['type' => 'object']],
|
||
'design_rev' => ['type' => 'string'],
|
||
], ['diff', 'design_rev']);
|
||
}
|
||
|
||
/**
|
||
* @param array<string, mixed> $input The tool input (confirm, design_rev).
|
||
* @param callable(array<array-key, mixed>): (DesignPlan|WP_Error) $plan
|
||
* @return array<string, mixed>|WP_Error
|
||
* @throws WriteFailed
|
||
* @throws DiviLocked
|
||
*/
|
||
public function run(string $ability, DesignArea $area, array $input, callable $plan): array|WP_Error
|
||
{
|
||
$current = $area->raw();
|
||
$rev = $area->rev($current);
|
||
$planned = $plan($current);
|
||
if ($planned instanceof WP_Error) {
|
||
return $planned;
|
||
}
|
||
|
||
if ($planned->isEmpty()) {
|
||
return ToolResult::ok('Keine Änderung – ' . $planned->summary)
|
||
->with('diff', [])
|
||
->with('design_rev', $rev)
|
||
->warnings($planned->warnings)
|
||
->toArray();
|
||
}
|
||
|
||
if (($input['confirm'] ?? false) !== true) {
|
||
return Errors::confirmRequired(
|
||
$planned->summary . ' Nichts wurde gespeichert (Probelauf).',
|
||
['diff' => $planned->diff, 'design_rev' => $rev, 'warnings' => $planned->warnings]
|
||
+ ($planned->usages?->listing() ?? ['affected' => [], 'affected_count' => 0])
|
||
+ ($planned->usages !== null && $planned->usages->blocked !== []
|
||
? ['blocked_ids' => array_slice($planned->usages->blocked, 0, self::LISTED_IDS)] : [])
|
||
);
|
||
}
|
||
|
||
if (($input['design_rev'] ?? null) !== $rev) {
|
||
return Errors::revMismatch(
|
||
sprintf('Die %s wurden seit dem Probelauf geändert; nichts wurde gespeichert.', $area->label()),
|
||
'Erneut ohne confirm aufrufen (Probelauf), dem Nutzer die Änderung zeigen und mit der neuen '
|
||
. 'design_rev bestätigen.'
|
||
);
|
||
}
|
||
|
||
$blocked = $this->blocked($planned);
|
||
if ($blocked !== null) {
|
||
return $blocked;
|
||
}
|
||
|
||
ReleaseGate::assertWritable();
|
||
try {
|
||
$snapshotId = $this->snapshots->save($area->name(), $current, $ability);
|
||
} catch (SnapshotTooLarge $e) {
|
||
return Errors::make(
|
||
'snapshot_too_large',
|
||
sprintf(
|
||
'Die %s sind zu groß für eine Sicherung (%d Bytes, höchstens %d); nichts wurde gespeichert.',
|
||
$area->label(),
|
||
$e->size,
|
||
SnapshotStore::MAX_BYTES
|
||
),
|
||
'Ohne Sicherung schreibt LIT MCP nicht. Die Änderung im Divi-Builder vornehmen oder unbenutzte '
|
||
. 'Einträge dort entfernen.',
|
||
413
|
||
);
|
||
}
|
||
|
||
$saved = $this->write($ability, $area, $planned, $current, $snapshotId);
|
||
$logId = $this->log->record(
|
||
$ability,
|
||
self::OBJECT_TYPE,
|
||
$area->name(),
|
||
$planned->summary,
|
||
snapshotId: $snapshotId
|
||
);
|
||
$this->snapshots->attachLog($area->name(), $snapshotId, $logId);
|
||
|
||
return ToolResult::ok($planned->summary)
|
||
->snapshotId($snapshotId)
|
||
->logId($logId)
|
||
->warnings($planned->warnings)
|
||
->with('diff', $planned->diff)
|
||
->with('design_rev', $area->rev($saved))
|
||
->toArray();
|
||
}
|
||
|
||
/** Spec §4 / rulings P8, P8a: a confirmed change is refused while the caller may not edit a live post it changes. */
|
||
private function blocked(DesignPlan $plan): ?WP_Error
|
||
{
|
||
$usages = $plan->usages;
|
||
if ($usages === null || ! $usages->blocks()) {
|
||
return null;
|
||
}
|
||
|
||
return Errors::make(
|
||
'forbidden',
|
||
$usages->tooMany
|
||
? 'Die Änderung betrifft zu viele veröffentlichte Seiten, um sie einzeln zu prüfen; nichts wurde '
|
||
. 'gespeichert.'
|
||
: 'Die Änderung wirkt auf veröffentlichte Seiten, die dieses Konto nicht bearbeiten darf; nichts wurde '
|
||
. 'gespeichert.',
|
||
'Einen Administrator die Änderung vornehmen lassen oder sie im Divi-Builder ausführen.',
|
||
403,
|
||
['blocked_ids' => array_slice($usages->blocked, 0, self::LISTED_IDS)]
|
||
+ ($usages->blockedHidden > 0 ? ['blocked_hidden_count' => $usages->blockedHidden] : [])
|
||
);
|
||
}
|
||
|
||
/**
|
||
* @param array<array-key, mixed> $current
|
||
* @return array<array-key, mixed>
|
||
* @throws WriteFailed
|
||
*/
|
||
private function write(string $ability, DesignArea $area, DesignPlan $plan, array $current, string $snapshotId): array
|
||
{
|
||
try {
|
||
$saved = $area->write($plan->raw, $plan->mayRemove);
|
||
if (! $area->verify($plan->raw, $saved)) {
|
||
throw new RuntimeException(sprintf('%s read back differs from what was written', $area->name()));
|
||
}
|
||
|
||
return $saved;
|
||
} catch (Throwable $e) {
|
||
if (DiviLocked::in($e) !== null) {
|
||
throw $e;
|
||
}
|
||
$this->rollBack($ability, $area, $current, $snapshotId, $e);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @param array<array-key, mixed> $current
|
||
* @throws WriteFailed Always.
|
||
*/
|
||
private function rollBack(string $ability, DesignArea $area, array $current, string $snapshotId, Throwable $cause): never
|
||
{
|
||
$reason = sprintf('Die %s konnten nicht gespeichert werden.', $area->label());
|
||
$failures = Rollback::attempt(static fn () => $area->write($current, true));
|
||
if ($failures === []) {
|
||
throw WriteFailed::rolledBack(
|
||
$reason,
|
||
$cause,
|
||
sprintf('design %s write failed: %s', $area->name(), $cause->getMessage()),
|
||
details: ['snapshot_id' => $snapshotId]
|
||
);
|
||
}
|
||
|
||
$this->log->recordPartial(
|
||
$ability,
|
||
self::OBJECT_TYPE,
|
||
$area->name(),
|
||
sprintf('%s nicht zurückgenommen (%s); Snapshot %s', $area->label(), $failures[0], $snapshotId)
|
||
);
|
||
throw WriteFailed::partial(
|
||
$reason,
|
||
$cause,
|
||
sprintf('design %s rollback failed: %s', $area->name(), $failures[0]),
|
||
state: sprintf('Die %s sind möglicherweise teilweise geändert (Stand vorher: Snapshot %s).', $area->label(), $snapshotId),
|
||
hint: sprintf(
|
||
'Den Aufruf nicht wiederholen. Mit lit/divi-design-restore und snapshot_id %s (Probelauf, dann '
|
||
. 'confirm: true) den vorherigen Stand wiederherstellen und dem Nutzer Bescheid geben.',
|
||
$snapshotId
|
||
),
|
||
details: ['snapshot_id' => $snapshotId]
|
||
);
|
||
}
|
||
}
|
||
```
|
||
|
||
Zeilen über 120 Zeichen meldet phpcs; sie wie im übrigen Code umbrechen (Argumente je Zeile).
|
||
|
||
- [ ] **Step 5: Test laufen lassen – er besteht**
|
||
|
||
Run: `php vendor/bin/phpunit tests/Unit/Integrations/Divi/Design/DesignChangeTest.php`
|
||
Expected: PASS.
|
||
|
||
- [ ] **Step 6: Failing test für `PresetArea` schreiben**
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Tests\Unit\Integrations\Divi\Design;
|
||
|
||
use LIT\MCP\Integrations\Divi\Design\DesignSystemWriter;
|
||
use LIT\MCP\Integrations\Divi\Design\PresetArea;
|
||
use LIT\MCP\Integrations\Divi\Design\PresetBook;
|
||
use LIT\MCP\Tests\Unit\TestCase;
|
||
use Mockery;
|
||
|
||
final class PresetAreaTest extends TestCase
|
||
{
|
||
public function testWritesTheRestFormatAndReadsBack(): void
|
||
{
|
||
$writer = Mockery::mock(DesignSystemWriter::class);
|
||
$stored = PresetBookTest::stored();
|
||
$writer->allows('presets')->andReturn($stored);
|
||
$writer->expects('savePresets')
|
||
->with(PresetBook::fromDivi($stored)->toRest(), true)
|
||
->andReturn($stored);
|
||
$area = new PresetArea($writer);
|
||
|
||
self::assertSame(['presets', 'Presets'], [$area->name(), $area->label()]);
|
||
self::assertSame(PresetBook::fromDivi($stored)->data(), $area->raw());
|
||
self::assertSame(PresetBook::fromDivi($stored)->rev(), $area->rev($stored));
|
||
self::assertSame(PresetBook::fromDivi($stored)->data(), $area->write($stored, true));
|
||
}
|
||
|
||
public function testVerifyIgnoresSanitizedValuesButNotMissingPresets(): void
|
||
{
|
||
$area = new PresetArea(Mockery::mock(DesignSystemWriter::class));
|
||
$expected = PresetBookTest::stored();
|
||
$sanitized = $expected;
|
||
$sanitized['module']['divi/button']['items']['aaaaaaaaaa']['attrs'] = ['button' => ['x' => 'bereinigt']];
|
||
$missing = $expected;
|
||
unset($missing['module']['divi/button']['items']['bbbbbbbbbb']);
|
||
$otherDefault = $expected;
|
||
$otherDefault['module']['divi/text']['default'] = '';
|
||
|
||
self::assertTrue($area->verify($expected, $sanitized));
|
||
self::assertFalse($area->verify($expected, $missing));
|
||
self::assertFalse($area->verify($expected, $otherDefault));
|
||
}
|
||
}
|
||
```
|
||
|
||
- [ ] **Step 7: `PresetArea` implementieren**
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Integrations\Divi\Design;
|
||
|
||
defined('ABSPATH') || exit;
|
||
|
||
/**
|
||
* The area "presets" (spec §6): the inventory in Divi's stored format (PresetBook), written as REST format through
|
||
* DesignSystemWriter::savePresets(). Divi's prepare_data() may sanitize values; verify() only insists on the same
|
||
* presets and defaults (PresetDiff without "changed").
|
||
*/
|
||
final class PresetArea implements DesignArea
|
||
{
|
||
public function __construct(private DesignSystemWriter $writer)
|
||
{
|
||
}
|
||
|
||
public function name(): string
|
||
{
|
||
return 'presets';
|
||
}
|
||
|
||
public function label(): string
|
||
{
|
||
return 'Presets';
|
||
}
|
||
|
||
public function raw(): array
|
||
{
|
||
return PresetBook::fromDivi($this->writer->presets())->data();
|
||
}
|
||
|
||
public function rev(array $raw): string
|
||
{
|
||
return PresetBook::fromDivi($raw)->rev();
|
||
}
|
||
|
||
public function write(array $raw, bool $mayRemove): array
|
||
{
|
||
return PresetBook::fromDivi($this->writer->savePresets(PresetBook::fromDivi($raw)->toRest(), $mayRemove))
|
||
->data();
|
||
}
|
||
|
||
public function verify(array $expected, array $actual): bool
|
||
{
|
||
$structural = array_filter(
|
||
PresetDiff::between(PresetBook::fromDivi($expected), PresetBook::fromDivi($actual)),
|
||
static fn (array $row): bool => $row['action'] !== 'changed'
|
||
);
|
||
|
||
return $structural === [];
|
||
}
|
||
}
|
||
```
|
||
|
||
- [ ] **Step 8: Tests laufen lassen – sie bestehen**
|
||
|
||
Run: `php vendor/bin/phpunit tests/Unit/Integrations/Divi/Design`
|
||
Expected: PASS.
|
||
|
||
- [ ] **Step 9: Gesamtlauf, Lint, Commit**
|
||
|
||
Run: `composer test && composer lint`
|
||
|
||
```bash
|
||
git add src/Integrations/Divi/Design/DesignArea.php src/Integrations/Divi/Design/DesignPlan.php src/Integrations/Divi/Design/DesignChange.php src/Integrations/Divi/Design/PresetArea.php tests/Unit/Integrations/Divi/Design/DesignChangeTest.php tests/Unit/Integrations/Divi/Design/PresetAreaTest.php
|
||
git commit -m "feat: Änderungs-Pipeline des Designsystems (Probelauf, design_rev, Snapshot, Rollback) und Bereich presets" -m "Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>"
|
||
```
|
||
|
||
---
|
||
### Task 9: `PresetComposer` – Preset-Eintrag aus `set`, `attrs`, `from_node` und `group_presets`
|
||
|
||
**Files:**
|
||
- Create: `src/Integrations/Divi/Design/PresetComposer.php`
|
||
- Modify: `src/Integrations/Divi/Design/DesignSystemWriter.php` (neue Methode `groupsOf()`, Manifest)
|
||
- Modify: `tests/Unit/Integrations/Divi/Design/DesignSystemWriterTest.php` (Manifest-Liste)
|
||
- Test: `tests/Unit/Integrations/Divi/Design/PresetComposerTest.php`
|
||
|
||
**Interfaces:**
|
||
- Consumes: `Composer::update(Block, array, string)` (vorhanden; Rückgabe `{attrs, errors, invalid_paths}`), `StoredNodeGuard::problems(Block)` (vorhanden), `Block::create()`, `AttrMap::flatten()`, `PresetBook`, `PresetScope` (Task 2).
|
||
- Produces:
|
||
- `DesignSystemWriter::groupsOf(string $moduleName): array` – `array<string, string>` Attributpfad der Gruppe (`groupId`) → Gruppenname (`divi/spacing`), aus `GlobalPreset::get_group_preset_default_attr(ModuleRegistration::get_module_settings($moduleName))`; `[]` ohne Divi.
|
||
- `final class PresetComposer { public function __construct(Composer $composer, StoredNodeGuard $guard, Closure $presetAttrs, Closure $groupsOf, string $version, Closure $now); public function compose(PresetBook $book, PresetScope $scope, ?array $existing, array $input, string $field, ?Block $source): array }` – Rückgabe `array{item: array<string, mixed>, errors: array<string, string>, invalid_paths: list<string>}`; `$presetAttrs` = `DesignSystemWriter::presetAttrs(...)`, `$groupsOf` = `DesignSystemWriter::groupsOf(...)`, `$now` liefert Millisekunden.
|
||
|
||
Regeln von `compose()` (Spec §6.3):
|
||
- Modul des Presets: Modul-Preset → `$scope->name`; Gruppen-Preset → `existing.moduleName`, sonst Modul von `$source`, sonst `divi/<source_module>` aus der Eingabe; fehlt alles → Fehler `<field>.source_module`.
|
||
- Gruppe (`groupId`) eines neuen Gruppen-Presets: der eine Pfad aus `groupsOf(<Modul>)` mit Gruppenname `$scope->name`; mehrere → Eingabe `group_id` nötig; keiner → Fehler.
|
||
- Ausgangswerte: `existing.attrs` bzw. `[]`; mit `$source`: zuerst `StoredNodeGuard::problems($source)` (Fehler `<field>.from_node`), dann die Preset-Attribute des Knotens (`presetAttrs(<Modul>, $source->attrs())['all']`, bei Gruppen nur unterhalb `groupId`) über die Ausgangswerte gelegt.
|
||
- `set`/`attrs` laufen durch `Composer::update()` an `Block::create(<Modul>, <Ausgangswerte>)`.
|
||
- Danach muss jeder Pfad Preset-Attribut sein (`presetAttrs(...)['all']` enthält ihn) – sonst `<field>.attrs.<pfad>`: „kein Preset-Attribut (Inhalte wie Texte, Links und Bilder gehören ins Modul)“; bei Gruppen zusätzlich unterhalb `groupId` – sonst „gehört nicht zur Gruppe <groupId>“.
|
||
- `group_presets` (nur Modul-Presets): `{ "<Gruppe>": "<Name|ID>" | null }`, Gruppe als Kurzname (`font`), voller Name (`divi/font`) oder Pfad (`button.decoration.font`); Auflösung über `groupsOf(<Modul>)`, Preset über `PresetBook::find()` im Bereich `group`.
|
||
- Eintrag: `type`, `id` (bestehend oder `PresetBook::newId()`), `name` (`rename` vor `name` vor bestehend), bei Gruppen `groupName`/`groupId`, `moduleName`, `version`, `created` (bestehend oder jetzt), `updated` (jetzt), `attrs`, `styleAttrs`/`renderAttrs` (nur wenn nicht leer), `groupPresets` (nur wenn nicht leer), `priority`/`order` vom bestehenden Eintrag.
|
||
|
||
- [ ] **Step 1: `groupsOf()` im Writer – Test ergänzen**
|
||
|
||
In `DesignSystemWriterTest::testIsARegisteredDesignAdapterWithTheSyncMirror` die erwartete Liste um zwei Einträge ergänzen (nach `'Conversion::get_preset_attrs()',`):
|
||
|
||
```php
|
||
'GlobalPreset::get_group_preset_default_attr()', 'ModuleRegistration::get_module_settings()',
|
||
```
|
||
|
||
und einen Test anhängen:
|
||
|
||
```php
|
||
public function testWithoutDiviAModuleHasNoGroups(): void
|
||
{
|
||
self::assertSame([], (new DesignSystemWriter())->groupsOf('divi/button'));
|
||
}
|
||
```
|
||
|
||
- [ ] **Step 2: `groupsOf()` implementieren**
|
||
|
||
In `DesignSystemWriter`: Import `use ET\Builder\Packages\ModuleLibrary\ModuleRegistration;`, im Manifest nach `Conversion::get_preset_attrs` ergänzen:
|
||
|
||
```php
|
||
new Call(GlobalPreset::class . '::get_group_preset_default_attr', 1),
|
||
new Call(ModuleRegistration::class . '::get_module_settings', 1),
|
||
```
|
||
|
||
und die Methode:
|
||
|
||
```php
|
||
/**
|
||
* The option groups of $moduleName that take group presets: attribute path (groupId) => group name, e.g.
|
||
* "module.decoration.spacing" => "divi/spacing" (formats §3). [] without Divi or for an unknown module.
|
||
*
|
||
* @return array<string, string>
|
||
*/
|
||
public function groupsOf(string $moduleName): array
|
||
{
|
||
if (! class_exists(ModuleRegistration::class)) {
|
||
return [];
|
||
}
|
||
|
||
$settings = ModuleRegistration::get_module_settings($moduleName);
|
||
if ($settings === null) {
|
||
return [];
|
||
}
|
||
|
||
$groups = [];
|
||
foreach (GlobalPreset::get_group_preset_default_attr($settings) as $groupId => $group) {
|
||
if (is_array($group) && is_string($group['groupName'] ?? null)) {
|
||
$groups[(string) $groupId] = $group['groupName'];
|
||
}
|
||
}
|
||
|
||
return $groups;
|
||
}
|
||
```
|
||
|
||
Run: `php vendor/bin/phpunit tests/Unit/Integrations/Divi/Design/DesignSystemWriterTest.php tests/Unit/Integrations/Divi/Release`
|
||
Expected: PASS.
|
||
|
||
- [ ] **Step 3: Failing test für `PresetComposer` schreiben**
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Tests\Unit\Integrations\Divi\Design;
|
||
|
||
use LIT\MCP\Integrations\Divi\BlockTree\Block;
|
||
use LIT\MCP\Integrations\Divi\Compose\StoredNodeGuard;
|
||
use LIT\MCP\Integrations\Divi\Design\PresetBook;
|
||
use LIT\MCP\Integrations\Divi\Design\PresetComposer;
|
||
use LIT\MCP\Integrations\Divi\Design\PresetScope;
|
||
use LIT\MCP\Tests\Support\ComposeFixture;
|
||
use PHPUnit\Framework\TestCase;
|
||
|
||
final class PresetComposerTest extends TestCase
|
||
{
|
||
private const NOW = 1760000000000;
|
||
|
||
/** Divi's mapping in small: decoration paths are preset attributes, innerContent is content. */
|
||
private static function presetAttrs(): \Closure
|
||
{
|
||
return static function (string $module, array $attrs): array {
|
||
$all = [];
|
||
foreach ($attrs as $key => $value) {
|
||
if (is_array($value)) {
|
||
$kept = array_diff_key($value, ['innerContent' => true]);
|
||
if ($kept !== []) {
|
||
$all[$key] = $kept;
|
||
}
|
||
}
|
||
}
|
||
|
||
return ['all' => $all, 'style' => $all, 'render' => []];
|
||
};
|
||
}
|
||
|
||
private static function composer(bool $unfiltered = true): PresetComposer
|
||
{
|
||
return new PresetComposer(
|
||
ComposeFixture::composer($unfiltered),
|
||
new StoredNodeGuard(
|
||
ComposeFixture::cleaner($unfiltered),
|
||
ComposeFixture::references(),
|
||
ComposeFixture::sanitizer($unfiltered)
|
||
),
|
||
self::presetAttrs(),
|
||
static fn (string $module): array => [
|
||
'module.decoration.spacing' => 'divi/spacing',
|
||
'button.decoration.font' => 'divi/font',
|
||
],
|
||
'5.15.1',
|
||
static fn (): int => self::NOW
|
||
);
|
||
}
|
||
|
||
private static function book(): PresetBook
|
||
{
|
||
return PresetBook::fromDivi(PresetBookTest::stored());
|
||
}
|
||
|
||
public function testNewModulePresetFromAttrs(): void
|
||
{
|
||
$result = self::composer()->compose(self::book(), new PresetScope('module', 'divi/button'), null, [
|
||
'name' => 'CTA sekundär',
|
||
'attrs' => ['button.decoration.background' => ['desktop' => ['color' => '#123456']]],
|
||
], 'items[0]', null);
|
||
|
||
self::assertSame([], $result['errors']);
|
||
$item = $result['item'];
|
||
self::assertMatchesRegularExpression('/^[0-9a-z]{10}$/', $item['id']);
|
||
self::assertSame(['module', 'CTA sekundär', 'divi/button', '5.15.1'], [$item['type'], $item['name'],
|
||
$item['moduleName'], $item['version']]);
|
||
self::assertSame([self::NOW, self::NOW], [$item['created'], $item['updated']]);
|
||
self::assertSame('#123456', $item['attrs']['button']['decoration']['background']['desktop']['value']['color']);
|
||
self::assertSame($item['attrs'], $item['styleAttrs']);
|
||
self::assertArrayNotHasKey('renderAttrs', $item);
|
||
}
|
||
|
||
public function testContentPathsAreRefused(): void
|
||
{
|
||
$result = self::composer()->compose(self::book(), new PresetScope('module', 'divi/button'), null, [
|
||
'name' => 'Mit Text',
|
||
'set' => ['text' => 'Jetzt buchen'],
|
||
], 'items[0]', null);
|
||
|
||
self::assertArrayHasKey('items[0].attrs.button.innerContent.desktop.value.text', $result['errors']);
|
||
self::assertStringContainsString('kein Preset-Attribut', $result['errors']['items[0].attrs.button.innerContent.desktop.value.text']);
|
||
}
|
||
|
||
public function testChangingMergesKeepsIdCreatedAndOrder(): void
|
||
{
|
||
$existing = self::book()->items(new PresetScope('module', 'divi/button'))['aaaaaaaaaa'];
|
||
$existing['created'] = 5;
|
||
$existing['order'] = 3;
|
||
$existing['attrs'] = ['button' => ['decoration' => ['border' => ['desktop' => ['value' => ['radius' => '4px']]]]]];
|
||
|
||
$result = self::composer()->compose(self::book(), new PresetScope('module', 'divi/button'), $existing, [
|
||
'rename' => 'CTA Primär',
|
||
'attrs' => ['button.decoration.background' => ['desktop' => ['color' => '#000000']]],
|
||
], 'items[0]', null);
|
||
|
||
self::assertSame([], $result['errors']);
|
||
self::assertSame(['aaaaaaaaaa', 'CTA Primär', 5, self::NOW, 3], [$result['item']['id'], $result['item']['name'],
|
||
$result['item']['created'], $result['item']['updated'], $result['item']['order']]);
|
||
self::assertSame('4px', $result['item']['attrs']['button']['decoration']['border']['desktop']['value']['radius']);
|
||
}
|
||
|
||
public function testFromNodeTakesTheDesignButNotTheContent(): void
|
||
{
|
||
$node = Block::create('divi/button', [
|
||
'button' => [
|
||
'innerContent' => ['desktop' => ['value' => ['text' => 'Hallo']]],
|
||
'decoration' => ['background' => ['desktop' => ['value' => ['color' => '#abcdef']]]],
|
||
],
|
||
]);
|
||
|
||
$result = self::composer()->compose(self::book(), new PresetScope('module', 'divi/button'), null, [
|
||
'name' => 'Aus Seite',
|
||
], 'items[0]', $node);
|
||
|
||
self::assertSame([], $result['errors']);
|
||
self::assertSame('#abcdef', $result['item']['attrs']['button']['decoration']['background']['desktop']['value']['color']);
|
||
self::assertArrayNotHasKey('innerContent', $result['item']['attrs']['button']);
|
||
}
|
||
|
||
public function testEditorCannotCarryBuilderOnlyValuesFromANode(): void
|
||
{
|
||
$node = Block::create('divi/button', [
|
||
'css' => ['desktop' => ['value' => ['mainElement' => 'color:red']]],
|
||
'button' => ['decoration' => ['background' => ['desktop' => ['value' => ['color' => '#000000']]]]],
|
||
]);
|
||
|
||
$result = self::composer(false)->compose(self::book(), new PresetScope('module', 'divi/button'), null, [
|
||
'name' => 'Mit CSS',
|
||
], 'items[0]', $node);
|
||
|
||
self::assertArrayHasKey('items[0].from_node', $result['errors']);
|
||
}
|
||
|
||
public function testGroupPresetOnlyTakesItsGroup(): void
|
||
{
|
||
$result = self::composer()->compose(self::book(), new PresetScope('group', 'divi/spacing'), null, [
|
||
'name' => 'Abstand groß',
|
||
'source_module' => 'button',
|
||
'attrs' => [
|
||
'module.decoration.spacing' => ['desktop' => ['padding' => ['top' => '40px']]],
|
||
'button.decoration.background' => ['desktop' => ['color' => '#000000']],
|
||
],
|
||
], 'items[0]', null);
|
||
|
||
self::assertSame(
|
||
'gehört nicht zur Gruppe module.decoration.spacing',
|
||
$result['errors']['items[0].attrs.button.decoration.background.desktop.value.color']
|
||
);
|
||
self::assertSame(['group', 'divi/spacing', 'module.decoration.spacing', 'divi/button'], [
|
||
$result['item']['type'], $result['item']['groupName'], $result['item']['groupId'],
|
||
$result['item']['moduleName'],
|
||
]);
|
||
}
|
||
|
||
public function testNestedGroupPresetsByShortName(): void
|
||
{
|
||
$book = self::book()->with(new PresetScope('group', 'divi/font'), [
|
||
'type' => 'group', 'id' => 'ffffffffff', 'name' => 'Button-Schrift', 'groupName' => 'divi/font',
|
||
'groupId' => 'button.decoration.font', 'moduleName' => 'divi/button', 'attrs' => [],
|
||
]);
|
||
|
||
$result = self::composer()->compose($book, new PresetScope('module', 'divi/button'), null, [
|
||
'name' => 'Mit Schrift',
|
||
'group_presets' => ['font' => 'Button-Schrift'],
|
||
], 'items[0]', null);
|
||
|
||
self::assertSame([], $result['errors']);
|
||
self::assertSame(
|
||
['button.decoration.font' => ['presetId' => ['ffffffffff'], 'groupName' => 'divi/font']],
|
||
$result['item']['groupPresets']
|
||
);
|
||
}
|
||
|
||
public function testUnknownGroupAndPresetAreErrors(): void
|
||
{
|
||
$result = self::composer()->compose(self::book(), new PresetScope('module', 'divi/button'), null, [
|
||
'name' => 'X',
|
||
'group_presets' => ['sizing' => 'Gibt es nicht', 'font' => 'Fehlt'],
|
||
], 'items[0]', null);
|
||
|
||
self::assertStringContainsString('keine Gruppe', $result['errors']['items[0].group_presets.sizing']);
|
||
self::assertStringContainsString('unbekanntes Gruppen-Preset', $result['errors']['items[0].group_presets.font']);
|
||
}
|
||
|
||
public function testNewPresetNeedsAName(): void
|
||
{
|
||
$result = self::composer()->compose(self::book(), new PresetScope('module', 'divi/button'), null, [],
|
||
'items[0]', null);
|
||
|
||
self::assertSame('Name des neuen Presets fehlt', $result['errors']['items[0].name']);
|
||
}
|
||
}
|
||
```
|
||
|
||
Hinweis zu den Fehlerschlüsseln: `PresetComposer` meldet unerlaubte Pfade auf **Blattebene** (`AttrMap::flatten()`-Schlüssel) mit dem Präfix `<field>.attrs.`. `Composer::update()` speichert die Kurzform `{"desktop": {"color": …}}` als `desktop.value.color`; daher die Schlüssel im Test.
|
||
|
||
`StoredNodeGuard` sperrt für Benutzer ohne `unfiltered_html` jeden gespeicherten Pfad, der `ValueCleaner::BUILDER_ONLY` trifft (`css`, `css.*`, `*.css.*`, `decoration.attributes` …) – unabhängig vom Katalog; der Knoten im Test trägt `css.desktop.value.mainElement`.
|
||
|
||
- [ ] **Step 4: Test laufen lassen – er scheitert**
|
||
|
||
Run: `php vendor/bin/phpunit tests/Unit/Integrations/Divi/Design/PresetComposerTest.php`
|
||
Expected: FAIL, Klasse fehlt.
|
||
|
||
- [ ] **Step 5: Implementieren**
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Integrations\Divi\Design;
|
||
|
||
use Closure;
|
||
use InvalidArgumentException;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\AttrMap;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\Block;
|
||
use LIT\MCP\Integrations\Divi\Compose\Composer;
|
||
use LIT\MCP\Integrations\Divi\Compose\StoredNodeGuard;
|
||
|
||
defined('ABSPATH') || exit;
|
||
|
||
/**
|
||
* Builds one preset item (spec §6.3, formats §3) from the tool input: the short form ("set") and the full form
|
||
* ("attrs") pass Composer::update() on a virtual block of the preset's module – the same choke point, placeholders
|
||
* and S7/S26 locks as for modules (D7) –, from_node takes the preset attributes of a stored node after
|
||
* StoredNodeGuard (E6), group_presets nest option group presets. Every resulting path must be a preset attribute
|
||
* of the module (Divi's mapping, $presetAttrs) and, for a group preset, lie below its group. styleAttrs/renderAttrs
|
||
* are split with the same mapping, like the Visual Builder does. Pure PHP; Divi enters through the closures.
|
||
*/
|
||
final class PresetComposer
|
||
{
|
||
private const CONTENT = 'kein Preset-Attribut (Inhalte wie Texte, Links und Bilder gehören ins Modul)';
|
||
|
||
/**
|
||
* @param Closure(string, array<string, mixed>): array{all: array<string, mixed>, style: array<string, mixed>,
|
||
* render: array<string, mixed>} $presetAttrs DesignSystemWriter::presetAttrs()
|
||
* @param Closure(string): array<string, string> $groupsOf DesignSystemWriter::groupsOf()
|
||
* @param Closure(): int $now Milliseconds, like the builder's Date.now().
|
||
*/
|
||
public function __construct(
|
||
private Composer $composer,
|
||
private StoredNodeGuard $guard,
|
||
private Closure $presetAttrs,
|
||
private Closure $groupsOf,
|
||
private string $version,
|
||
private Closure $now
|
||
) {
|
||
}
|
||
|
||
/**
|
||
* @param array<string, mixed>|null $existing The preset to change, null for a new one.
|
||
* @param array<string, mixed> $input One item of lit/divi-presets-set.
|
||
* @return array{item: array<string, mixed>, errors: array<string, string>, invalid_paths: list<string>}
|
||
*/
|
||
public function compose(
|
||
PresetBook $book,
|
||
PresetScope $scope,
|
||
?array $existing,
|
||
array $input,
|
||
string $field,
|
||
?Block $source
|
||
): array {
|
||
$errors = [];
|
||
$module = $this->moduleOf($scope, $existing, $input, $source);
|
||
if ($module === null) {
|
||
$errors[$field . '.source_module'] = 'Modul des Gruppen-Presets fehlt (source_module oder from_node)';
|
||
|
||
return ['item' => [], 'errors' => $errors, 'invalid_paths' => []];
|
||
}
|
||
|
||
$groupId = null;
|
||
if ($scope->kind === PresetScope::GROUP) {
|
||
$groupId = $this->groupIdOf($scope, $module, $existing, $input, $field, $errors);
|
||
if ($groupId === null) {
|
||
return ['item' => [], 'errors' => $errors, 'invalid_paths' => []];
|
||
}
|
||
}
|
||
|
||
$attrs = is_array($existing['attrs'] ?? null) ? $existing['attrs'] : [];
|
||
if ($source !== null) {
|
||
$problems = $this->guard->problems($source);
|
||
if ($problems !== []) {
|
||
$errors[$field . '.from_node'] = implode('; ', $problems);
|
||
}
|
||
$taken = ($this->presetAttrs)($module, $source->attrs())['all'];
|
||
$attrs = array_replace_recursive($attrs, $groupId === null ? $taken : self::below($taken, $groupId));
|
||
}
|
||
|
||
$change = array_intersect_key($input, ['set' => true, 'attrs' => true]);
|
||
if ($change !== []) {
|
||
$updated = $this->composer->update(Block::create($module, $attrs), $change, $field);
|
||
$attrs = $updated['attrs'];
|
||
$errors += $updated['errors'];
|
||
if ($updated['invalid_paths'] !== []) {
|
||
return ['item' => [], 'errors' => $errors, 'invalid_paths' => $updated['invalid_paths']];
|
||
}
|
||
}
|
||
|
||
$split = ($this->presetAttrs)($module, $attrs);
|
||
$allowed = AttrMap::flatten($split['all']);
|
||
foreach (array_keys(AttrMap::flatten($attrs)) as $path) {
|
||
if (! array_key_exists($path, $allowed)) {
|
||
$errors[$field . '.attrs.' . $path] = self::CONTENT;
|
||
} elseif ($groupId !== null && ! str_starts_with($path, $groupId . '.')) {
|
||
$errors[$field . '.attrs.' . $path] = 'gehört nicht zur Gruppe ' . $groupId;
|
||
}
|
||
}
|
||
|
||
$nested = $this->groupPresets($book, $scope, $module, $existing, $input, $field, $errors);
|
||
$name = $this->nameOf($existing, $input, $field, $errors);
|
||
|
||
return [
|
||
'item' => $this->item($scope, $existing, $name, $module, $groupId, $attrs, $split, $nested),
|
||
'errors' => $errors,
|
||
'invalid_paths' => [],
|
||
];
|
||
}
|
||
|
||
/**
|
||
* @param array<string, mixed>|null $existing
|
||
* @param array<string, mixed> $input
|
||
*/
|
||
private function moduleOf(PresetScope $scope, ?array $existing, array $input, ?Block $source): ?string
|
||
{
|
||
if ($scope->kind === PresetScope::MODULE) {
|
||
return $scope->name;
|
||
}
|
||
if (is_string($existing['moduleName'] ?? null)) {
|
||
return $existing['moduleName'];
|
||
}
|
||
if ($source !== null) {
|
||
return $source->name();
|
||
}
|
||
$short = $input['source_module'] ?? null;
|
||
if (! is_string($short) || preg_match('/^[a-z0-9][a-z0-9-]*(\/[a-z0-9][a-z0-9-]*)?$/D', $short) !== 1) {
|
||
return null;
|
||
}
|
||
|
||
return str_contains($short, '/') ? $short : 'divi/' . $short;
|
||
}
|
||
|
||
/**
|
||
* @param array<string, mixed>|null $existing
|
||
* @param array<string, mixed> $input
|
||
* @param array<string, string> $errors
|
||
*/
|
||
private function groupIdOf(
|
||
PresetScope $scope,
|
||
string $module,
|
||
?array $existing,
|
||
array $input,
|
||
string $field,
|
||
array &$errors
|
||
): ?string {
|
||
if (is_string($existing['groupId'] ?? null)) {
|
||
return $existing['groupId'];
|
||
}
|
||
|
||
$paths = array_keys(array_filter(
|
||
($this->groupsOf)($module),
|
||
static fn (string $group): bool => $group === $scope->name
|
||
));
|
||
$wanted = $input['group_id'] ?? null;
|
||
if (is_string($wanted) && in_array($wanted, $paths, true)) {
|
||
return $wanted;
|
||
}
|
||
if (count($paths) === 1 && $wanted === null) {
|
||
return (string) $paths[0];
|
||
}
|
||
|
||
$errors[$field . '.group_id'] = $paths === []
|
||
? sprintf('%s hat keine Gruppe %s', $module, $scope->name)
|
||
: sprintf('mehrere Gruppen %s in %s – group_id angeben: %s', $scope->name, $module, implode(', ', $paths));
|
||
|
||
return null;
|
||
}
|
||
|
||
/**
|
||
* @param array<string, mixed>|null $existing
|
||
* @param array<string, mixed> $input
|
||
* @param array<string, string> $errors
|
||
* @return array<string, array{presetId: list<string>, groupName: string}>
|
||
*/
|
||
private function groupPresets(
|
||
PresetBook $book,
|
||
PresetScope $scope,
|
||
string $module,
|
||
?array $existing,
|
||
array $input,
|
||
string $field,
|
||
array &$errors
|
||
): array {
|
||
$nested = is_array($existing['groupPresets'] ?? null) ? $existing['groupPresets'] : [];
|
||
$wanted = $input['group_presets'] ?? null;
|
||
if ($wanted === null) {
|
||
return $nested;
|
||
}
|
||
if ($scope->kind !== PresetScope::MODULE || ! is_array($wanted)) {
|
||
$errors[$field . '.group_presets'] = 'nur bei Modul-Presets, als Objekt Gruppe → Preset';
|
||
|
||
return $nested;
|
||
}
|
||
|
||
$groups = ($this->groupsOf)($module);
|
||
foreach ($wanted as $group => $preset) {
|
||
$path = $field . '.group_presets.' . $group;
|
||
$groupId = self::findGroup($groups, (string) $group);
|
||
if ($groupId === null) {
|
||
$errors[$path] = sprintf('keine Gruppe "%s" in %s', $group, $module);
|
||
continue;
|
||
}
|
||
if ($preset === null) {
|
||
unset($nested[$groupId]);
|
||
continue;
|
||
}
|
||
try {
|
||
$found = is_string($preset) ? $book->find(new PresetScope(PresetScope::GROUP, $groups[$groupId]), $preset)
|
||
: null;
|
||
} catch (InvalidArgumentException $e) {
|
||
$errors[$path] = $e->getMessage();
|
||
continue;
|
||
}
|
||
if ($found === null) {
|
||
$errors[$path] = sprintf('unbekanntes Gruppen-Preset "%s" (%s)', (string) $preset, $groups[$groupId]);
|
||
continue;
|
||
}
|
||
$nested[$groupId] = ['presetId' => [(string) $found['id']], 'groupName' => $groups[$groupId]];
|
||
}
|
||
|
||
return $nested;
|
||
}
|
||
|
||
/** @param array<string, string> $groups groupId => groupName */
|
||
private static function findGroup(array $groups, string $wanted): ?string
|
||
{
|
||
foreach ($groups as $groupId => $name) {
|
||
if ($wanted === $groupId || $wanted === $name || 'divi/' . $wanted === $name) {
|
||
return (string) $groupId;
|
||
}
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
/**
|
||
* @param array<string, mixed>|null $existing
|
||
* @param array<string, mixed> $input
|
||
* @param array<string, string> $errors
|
||
*/
|
||
private function nameOf(?array $existing, array $input, string $field, array &$errors): string
|
||
{
|
||
foreach (['rename', 'name'] as $key) {
|
||
if (is_string($input[$key] ?? null) && trim($input[$key]) !== '') {
|
||
return trim($input[$key]);
|
||
}
|
||
}
|
||
if (is_string($existing['name'] ?? null)) {
|
||
return $existing['name'];
|
||
}
|
||
$errors[$field . '.name'] = 'Name des neuen Presets fehlt';
|
||
|
||
return '';
|
||
}
|
||
|
||
/**
|
||
* @param array<string, mixed>|null $existing
|
||
* @param array<string, mixed> $attrs
|
||
* @param array{all: array<string, mixed>, style: array<string, mixed>, render: array<string, mixed>} $split
|
||
* @param array<string, mixed> $nested
|
||
* @return array<string, mixed>
|
||
*/
|
||
private function item(
|
||
PresetScope $scope,
|
||
?array $existing,
|
||
string $name,
|
||
string $module,
|
||
?string $groupId,
|
||
array $attrs,
|
||
array $split,
|
||
array $nested
|
||
): array {
|
||
$now = ($this->now)();
|
||
$item = ['type' => $scope->kind, 'id' => (string) ($existing['id'] ?? PresetBook::newId()), 'name' => $name];
|
||
if ($groupId !== null) {
|
||
$item += ['groupName' => $scope->name, 'groupId' => $groupId];
|
||
}
|
||
$item += [
|
||
'moduleName' => $module,
|
||
'version' => $this->version,
|
||
'created' => (int) ($existing['created'] ?? $now),
|
||
'updated' => $now,
|
||
'attrs' => $attrs,
|
||
];
|
||
if ($split['style'] !== []) {
|
||
$item['styleAttrs'] = $split['style'];
|
||
}
|
||
if ($split['render'] !== []) {
|
||
$item['renderAttrs'] = $split['render'];
|
||
}
|
||
if ($nested !== []) {
|
||
$item['groupPresets'] = $nested;
|
||
}
|
||
foreach (['priority', 'order'] as $key) {
|
||
if (isset($existing[$key])) {
|
||
$item[$key] = $existing[$key];
|
||
}
|
||
}
|
||
|
||
return $item;
|
||
}
|
||
|
||
/**
|
||
* The part of $attrs below the dotted path $groupId.
|
||
*
|
||
* @param array<string, mixed> $attrs
|
||
* @return array<string, mixed>
|
||
*/
|
||
private static function below(array $attrs, string $groupId): array
|
||
{
|
||
$value = AttrMap::get($attrs, $groupId);
|
||
|
||
return $value === null ? [] : AttrMap::set([], $groupId, $value);
|
||
}
|
||
}
|
||
```
|
||
|
||
`AttrMap::get()` liest einen Punkt-Pfad (`null`, wenn er fehlt), `AttrMap::set()` legt fehlende Zwischenstufen an.
|
||
|
||
- [ ] **Step 6: Test laufen lassen – er besteht**
|
||
|
||
Run: `php vendor/bin/phpunit tests/Unit/Integrations/Divi/Design/PresetComposerTest.php`
|
||
Expected: PASS.
|
||
|
||
- [ ] **Step 7: Gesamtlauf, Lint, Commit**
|
||
|
||
Run: `composer test && composer lint`
|
||
|
||
```bash
|
||
git add src/Integrations/Divi/Design/PresetComposer.php src/Integrations/Divi/Design/DesignSystemWriter.php tests/Unit/Integrations/Divi/Design/PresetComposerTest.php tests/Unit/Integrations/Divi/Design/DesignSystemWriterTest.php
|
||
git commit -m "feat: PresetComposer – Preset aus Kurz-/Vollform, Modul und Gruppen-Presets" -m "Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>"
|
||
```
|
||
|
||
---
|
||
|
||
### Task 10: `lit/divi-preset-get` – ein Preset mit Einstellungen und Fundstellen lesen
|
||
|
||
**Files:**
|
||
- Create: `src/Integrations/Divi/Design/DiviPresetGetAbility.php`
|
||
- Modify: `src/Integrations/Divi/DiviIntegration.php` (Writer-Instanz, Tool registrieren)
|
||
- Modify: `tests/Unit/Integrations/Divi/DiviIntegrationTest.php` (Namensliste)
|
||
- Test: `tests/Unit/Integrations/Divi/Design/DiviPresetGetAbilityTest.php`
|
||
|
||
**Interfaces:**
|
||
- Consumes: `DesignSystemWriter::presets()`, `PresetBook`, `PresetScope`, `PresetUsageQuery`, `GlobalUsages::reportFor()`, `UsageReport::listing()`, `ShortformMap::values()`, `AttrMap::flatten()`, `JsonMap::of()`, `Annotations::read()`, `Errors`.
|
||
- Produces: `final class DiviPresetGetAbility implements Ability { public function __construct(DesignSystemWriter $writer, GlobalUsages $usages) }`; Name `lit/divi-preset-get`; Ausgabe `{id, name, kind, scope, default, module_name, group_id, set, attrs, group_presets, usage, design_rev}`.
|
||
|
||
- [ ] **Step 1: Failing test schreiben**
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Tests\Unit\Integrations\Divi\Design;
|
||
|
||
use Brain\Monkey\Functions;
|
||
use LIT\MCP\Integrations\Divi\Design\DesignSystemWriter;
|
||
use LIT\MCP\Integrations\Divi\Design\DiviPresetGetAbility;
|
||
use LIT\MCP\Integrations\Divi\Design\PresetBook;
|
||
use LIT\MCP\Integrations\Divi\Design\PresetUsageQuery;
|
||
use LIT\MCP\Integrations\Divi\Library\GlobalUsages;
|
||
use LIT\MCP\Integrations\Divi\Library\UsageReport;
|
||
use LIT\MCP\Tests\Unit\TestCase;
|
||
use Mockery;
|
||
|
||
final class DiviPresetGetAbilityTest extends TestCase
|
||
{
|
||
private function ability(?GlobalUsages $usages = null): DiviPresetGetAbility
|
||
{
|
||
$writer = Mockery::mock(DesignSystemWriter::class);
|
||
$writer->allows('presets')->andReturn(PresetBookTest::stored());
|
||
$usages ??= Mockery::mock(GlobalUsages::class);
|
||
|
||
return new DiviPresetGetAbility($writer, $usages);
|
||
}
|
||
|
||
public function testReadsAPresetWithItsUsage(): void
|
||
{
|
||
Functions\when('current_user_can')->justReturn(true);
|
||
$usages = Mockery::mock(GlobalUsages::class);
|
||
$usages->expects('reportFor')
|
||
->with(Mockery::type(PresetUsageQuery::class), false)
|
||
->andReturn(new UsageReport(1, [['post_id' => 3, 'title' => 'Start', 'status' => 'publish',
|
||
'type' => 'page']], 0, 1, [], 0, false));
|
||
$ability = $this->ability($usages);
|
||
|
||
self::assertTrue($ability->permission(['module' => 'text', 'preset' => 'Fließtext']));
|
||
$result = $ability->execute(['module' => 'text', 'preset' => 'Fließtext']);
|
||
|
||
self::assertSame(['dddddddddd', 'Fließtext', 'module', 'divi/text', true], [$result['id'], $result['name'],
|
||
$result['kind'], $result['scope'], $result['default']]);
|
||
self::assertSame([[
|
||
'group_id' => 'content.decoration.bodyFont',
|
||
'group_name' => 'divi/font-body',
|
||
'presets' => [['id' => 'gggggggggg', 'name' => 'Lesetext']],
|
||
]], $result['group_presets']);
|
||
self::assertSame(3, $result['usage']['affected'][0]['post_id']);
|
||
self::assertSame(PresetBook::fromDivi(PresetBookTest::stored())->rev(), $result['design_rev']);
|
||
self::assertFalse($ability->isDirect());
|
||
self::assertTrue($ability->annotations()['readonly']);
|
||
}
|
||
|
||
public function testFlattensAttrsLikeNodeGet(): void
|
||
{
|
||
Functions\when('current_user_can')->justReturn(true);
|
||
$usages = Mockery::mock(GlobalUsages::class);
|
||
$usages->allows('reportFor')->andReturn(new UsageReport(0, [], 0, 0, [], 0, false));
|
||
|
||
$result = $this->ability($usages)->execute(['module' => 'button', 'preset' => 'aaaaaaaaaa']);
|
||
|
||
self::assertSame(['button.x' => 1], (array) $result['attrs']);
|
||
}
|
||
|
||
public function testUnknownAndAmbiguousPresets(): void
|
||
{
|
||
Functions\when('current_user_can')->justReturn(true);
|
||
|
||
self::assertToolError($this->ability()->execute(['module' => 'button', 'preset' => 'Fehlt']), 'not_found');
|
||
$ambiguous = self::assertToolError($this->ability()->execute(['module' => 'button', 'preset' => 'Doppelt']),
|
||
'validation_failed');
|
||
self::assertStringContainsString('bbbbbbbbbb, cccccccccc', $ambiguous['fields']['preset']);
|
||
self::assertToolError($this->ability()->execute(['preset' => 'x']), 'validation_failed');
|
||
}
|
||
|
||
public function testNeedsEditPosts(): void
|
||
{
|
||
Functions\when('current_user_can')->justReturn(false);
|
||
|
||
self::assertToolError($this->ability()->permission([]), 'forbidden');
|
||
}
|
||
}
|
||
```
|
||
|
||
`AttrMap::flatten()` liefert für `['button' => ['x' => 1]]` den Schlüssel `button.x` (Blätter); `JsonMap::of()` gibt ein `stdClass` zurück, daher der Cast im Test.
|
||
|
||
- [ ] **Step 2: Test laufen lassen – er scheitert**
|
||
|
||
Run: `php vendor/bin/phpunit tests/Unit/Integrations/Divi/Design/DiviPresetGetAbilityTest.php`
|
||
Expected: FAIL, Klasse fehlt.
|
||
|
||
- [ ] **Step 3: Implementieren**
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Integrations\Divi\Design;
|
||
|
||
use InvalidArgumentException;
|
||
use LIT\MCP\Abilities\Ability;
|
||
use LIT\MCP\Abilities\Annotations;
|
||
use LIT\MCP\Abilities\Errors;
|
||
use LIT\MCP\Abilities\JsonMap;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\AttrMap;
|
||
use LIT\MCP\Integrations\Divi\Library\GlobalUsages;
|
||
use LIT\MCP\Integrations\Divi\Schema\ShortformMap;
|
||
use WP_Error;
|
||
|
||
defined('ABSPATH') || exit;
|
||
|
||
/**
|
||
* lit/divi-preset-get (spec §6.2): one module or option group preset with its settings – short form where the
|
||
* module's short form reaches them, the full form as attribute path => value like lit/divi-node-get –, its nested
|
||
* group presets with names, the posts that use it (readable ones by title, the rest as a count) and the design_rev
|
||
* for a following lit/divi-presets-set.
|
||
*/
|
||
final class DiviPresetGetAbility implements Ability
|
||
{
|
||
public function __construct(private DesignSystemWriter $writer, private GlobalUsages $usages)
|
||
{
|
||
}
|
||
|
||
public function name(): string
|
||
{
|
||
return 'lit/divi-preset-get';
|
||
}
|
||
|
||
public function label(): string
|
||
{
|
||
return 'Divi-Preset lesen';
|
||
}
|
||
|
||
public function description(): string
|
||
{
|
||
return 'Liest ein Modul-Preset (module, z. B. "button") oder Gruppen-Preset (group, z. B. "font-body") mit '
|
||
. 'seinen Einstellungen (set in Kurzform, attrs als Attributpfad → Wert), verschachtelten Gruppen-Presets, '
|
||
. 'den Seiten, die es verwenden (usage), und der design_rev für lit/divi-presets-set. preset = Name oder '
|
||
. 'ID aus lit/divi-design-system (direkt: lit-divi-design-system).';
|
||
}
|
||
|
||
public function inputSchema(): array
|
||
{
|
||
return [
|
||
'type' => 'object',
|
||
'properties' => [
|
||
'module' => ['type' => 'string', 'description' => 'Modul, z. B. "button" (Modul-Preset).'],
|
||
'group' => ['type' => 'string', 'description' => 'Gruppe, z. B. "font-body" (Gruppen-Preset).'],
|
||
'preset' => ['type' => 'string', 'description' => 'Name oder ID des Presets.'],
|
||
],
|
||
'required' => ['preset'],
|
||
'additionalProperties' => false,
|
||
];
|
||
}
|
||
|
||
public function outputSchema(): ?array
|
||
{
|
||
return [
|
||
'type' => 'object',
|
||
'properties' => [
|
||
'id' => ['type' => 'string'],
|
||
'name' => ['type' => 'string'],
|
||
'kind' => ['type' => 'string'],
|
||
'scope' => ['type' => 'string'],
|
||
'default' => ['type' => 'boolean'],
|
||
'module_name' => ['type' => 'string'],
|
||
'group_id' => ['type' => ['string', 'null']],
|
||
'set' => ['type' => 'object'],
|
||
'attrs' => ['type' => 'object'],
|
||
'group_presets' => ['type' => 'array', 'items' => ['type' => 'object']],
|
||
'usage' => ['type' => 'object'],
|
||
'design_rev' => ['type' => 'string'],
|
||
],
|
||
'required' => ['id', 'name', 'kind', 'scope', 'default', 'module_name', 'group_id', 'set', 'attrs',
|
||
'group_presets', 'usage', 'design_rev'],
|
||
];
|
||
}
|
||
|
||
public function annotations(): array
|
||
{
|
||
return Annotations::read();
|
||
}
|
||
|
||
public function isDirect(): bool
|
||
{
|
||
return false;
|
||
}
|
||
|
||
public function permission(array $input): bool|WP_Error
|
||
{
|
||
return current_user_can('edit_posts')
|
||
? true
|
||
: Errors::forbidden('Presets lesen erfordert das Recht, Beiträge zu bearbeiten.');
|
||
}
|
||
|
||
public function execute(array $input): mixed
|
||
{
|
||
try {
|
||
$scope = PresetScope::fromInput($input, 'input');
|
||
} catch (InvalidArgumentException $e) {
|
||
return Errors::invalidInput('Modul oder Gruppe fehlt bzw. ist ungültig.', ['module' => $e->getMessage()]);
|
||
}
|
||
|
||
$book = PresetBook::fromDivi($this->writer->presets());
|
||
$wanted = is_string($input['preset'] ?? null) ? $input['preset'] : '';
|
||
try {
|
||
$item = $book->find($scope, $wanted);
|
||
} catch (InvalidArgumentException $e) {
|
||
return Errors::invalidInput('Der Preset-Name ist mehrdeutig.', ['preset' => $e->getMessage()]);
|
||
}
|
||
if ($item === null) {
|
||
return Errors::notFound(
|
||
sprintf('%s „%s“ gibt es nicht.', $scope->label(), $wanted),
|
||
'Vorhandene Presets mit lit/divi-design-system (direkt: lit-divi-design-system) und module auflisten.'
|
||
);
|
||
}
|
||
|
||
$id = (string) $item['id'];
|
||
$isDefault = $book->defaultId($scope) === $id;
|
||
$attrs = is_array($item['attrs'] ?? null) ? $item['attrs'] : [];
|
||
$module = is_string($item['moduleName'] ?? null) ? $item['moduleName'] : $scope->name;
|
||
$usage = $this->usages->reportFor(
|
||
new PresetUsageQuery([['scope' => $scope, 'id' => $id, 'default' => $isDefault]]),
|
||
false
|
||
);
|
||
|
||
return [
|
||
'id' => $id,
|
||
'name' => (string) ($item['name'] ?? $id),
|
||
'kind' => $scope->kind,
|
||
'scope' => $scope->name,
|
||
'default' => $isDefault,
|
||
'module_name' => $module,
|
||
'group_id' => is_string($item['groupId'] ?? null) ? $item['groupId'] : null,
|
||
'set' => JsonMap::of(ShortformMap::values(substr($module, (int) strpos($module, '/') + 1), $attrs)),
|
||
'attrs' => JsonMap::of(AttrMap::flatten($attrs)),
|
||
'group_presets' => $this->nested($book, $item),
|
||
'usage' => $usage->listing(),
|
||
'design_rev' => $book->rev(),
|
||
];
|
||
}
|
||
|
||
/**
|
||
* @param array<string, mixed> $item
|
||
* @return list<array{group_id: string, group_name: string, presets: list<array{id: string, name: string}>}>
|
||
*/
|
||
private function nested(PresetBook $book, array $item): array
|
||
{
|
||
$rows = [];
|
||
foreach (is_array($item['groupPresets'] ?? null) ? $item['groupPresets'] : [] as $groupId => $nested) {
|
||
$groupName = is_array($nested) && is_string($nested['groupName'] ?? null) ? $nested['groupName'] : '';
|
||
$presets = [];
|
||
foreach (is_array($nested) ? (array) ($nested['presetId'] ?? []) : [] as $presetId) {
|
||
$found = $book->items(new PresetScope(PresetScope::GROUP, $groupName))[(string) $presetId] ?? null;
|
||
$presets[] = ['id' => (string) $presetId, 'name' => (string) ($found['name'] ?? $presetId)];
|
||
}
|
||
$rows[] = ['group_id' => (string) $groupId, 'group_name' => $groupName, 'presets' => $presets];
|
||
}
|
||
|
||
return $rows;
|
||
}
|
||
}
|
||
```
|
||
|
||
`ShortformMap::values()` erwartet den kurzen Modultyp (`button`), wie `Block::shortName()` ihn aus `divi/button` bildet; für einen Typ ohne Kurzform liefert es `[]` (`fields()` gibt dann `[]`).
|
||
|
||
In `DiviIntegration`:
|
||
- Eigenschaft `private DesignSystemWriter $designWriter;`, im Konstruktor `$this->designWriter = new DesignSystemWriter();`.
|
||
- In `abilities()` am Ende `new DiviPresetGetAbility($this->designWriter, $this->globalUsages()),` ergänzen; Import.
|
||
|
||
In `tests/Unit/Integrations/Divi/DiviIntegrationTest.php` die Namensliste um `'lit/divi-preset-get',` ergänzen (hinter `'lit/divi-dynamic-sources',`).
|
||
|
||
- [ ] **Step 4: Tests laufen lassen – sie bestehen**
|
||
|
||
Run: `php vendor/bin/phpunit tests/Unit/Integrations/Divi/Design/DiviPresetGetAbilityTest.php tests/Unit/Integrations/Divi/DiviIntegrationTest.php tests/Unit/Guides/ToolNamingTest.php`
|
||
Expected: PASS.
|
||
|
||
- [ ] **Step 5: Gesamtlauf, Lint, Commit**
|
||
|
||
Run: `composer test && composer lint`
|
||
|
||
```bash
|
||
git add src/Integrations/Divi/Design/DiviPresetGetAbility.php src/Integrations/Divi/DiviIntegration.php tests/Unit/Integrations/Divi/Design/DiviPresetGetAbilityTest.php tests/Unit/Integrations/Divi/DiviIntegrationTest.php
|
||
git commit -m "feat: lit/divi-preset-get – Preset mit Einstellungen und Fundstellen lesen" -m "Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>"
|
||
```
|
||
|
||
---
|
||
### Task 11: `lit/divi-presets-set` – Presets anlegen und ändern
|
||
|
||
**Files:**
|
||
- Create: `src/Integrations/Divi/Design/DesignRights.php`
|
||
- Create: `src/Integrations/Divi/Design/DiviPresetsSetAbility.php`
|
||
- Modify: `src/Integrations/Divi/Design/PresetDiff.php` (neue Methode `summary()`)
|
||
- Modify: `tests/Unit/Integrations/Divi/Design/PresetDiffTest.php`
|
||
- Modify: `src/Integrations/Divi/DiviIntegration.php`, `tests/Unit/Integrations/Divi/DiviIntegrationTest.php`
|
||
- Test: `tests/Unit/Integrations/Divi/Design/DesignRightsTest.php`
|
||
- Test: `tests/Unit/Integrations/Divi/Design/DiviPresetsSetAbilityTest.php`
|
||
|
||
**Interfaces:**
|
||
- Consumes: `DesignChange::run()`, `DesignChange::inputProperties()`, `DesignChange::outputSchema()`, `DesignPlan`, `PresetArea`, `PresetBook`, `PresetScope`, `PresetDiff`, `PresetComposer`, `PresetUsageQuery`, `GlobalUsages::reportFor()`, `DiviPageLoader::load(mixed, bool)` (→ `DiviPage|WP_Error`, `$page->index->find(string): ?Block`).
|
||
- Produces:
|
||
- `final class DesignRights { public static function presets(DesignSystemWriter $writer): ?WP_Error }` – `edit_theme_options` + Visual Builder.
|
||
- `PresetDiff::summary(array $diff): string` – z. B. „Presets: 1 angelegt, 1 geändert, Standard 1× gesetzt.“
|
||
- `final class DiviPresetsSetAbility implements Ability { public const MAX_ITEMS = 20; public function __construct(DesignSystemWriter $writer, DesignChange $change, GlobalUsages $usages, DiviPageLoader $loader, Closure $composer) }` – `$composer`: `Closure(): PresetComposer`.
|
||
|
||
Eingabe (Spec §6.3): `items` (1–20) mit je `module`|`group`, `preset` (zu ändern: Name oder ID; fehlt → neu), `name` (neu), `rename`, `set`, `attrs`, `from_node` (`{post_id, id}`), `source_module`, `group_id`, `group_presets`, `make_default` (bool); dazu `confirm`, `design_rev`.
|
||
|
||
- [ ] **Step 1: Failing tests für `PresetDiff::summary()` und `DesignRights` schreiben**
|
||
|
||
In `PresetDiffTest` anhängen:
|
||
|
||
```php
|
||
public function testSummaryCountsTheActions(): void
|
||
{
|
||
self::assertSame(
|
||
'Presets: 1 angelegt, 1 geändert, 1 gelöscht, Standard 1× gesetzt, 1× entfernt.',
|
||
PresetDiff::summary([
|
||
['action' => 'added'], ['action' => 'changed'], ['action' => 'removed'],
|
||
['action' => 'default_set'], ['action' => 'default_cleared'],
|
||
])
|
||
);
|
||
self::assertSame('Presets: 2 angelegt.', PresetDiff::summary([['action' => 'added'], ['action' => 'added']]));
|
||
self::assertSame('Presets: keine Änderung.', PresetDiff::summary([]));
|
||
}
|
||
```
|
||
|
||
`tests/Unit/Integrations/Divi/Design/DesignRightsTest.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Tests\Unit\Integrations\Divi\Design;
|
||
|
||
use Brain\Monkey\Functions;
|
||
use LIT\MCP\Integrations\Divi\Design\DesignRights;
|
||
use LIT\MCP\Integrations\Divi\Design\DesignSystemWriter;
|
||
use LIT\MCP\Tests\Unit\TestCase;
|
||
use Mockery;
|
||
|
||
final class DesignRightsTest extends TestCase
|
||
{
|
||
public function testPresetsNeedEditThemeOptionsAndTheVisualBuilder(): void
|
||
{
|
||
$writer = Mockery::mock(DesignSystemWriter::class);
|
||
$writer->allows('canUseVisualBuilder')->andReturn(true, false);
|
||
Functions\when('current_user_can')->alias(static fn (string $cap): bool => $cap === 'edit_theme_options');
|
||
|
||
self::assertNull(DesignRights::presets($writer));
|
||
$refusal = self::assertToolError(DesignRights::presets($writer), 'forbidden');
|
||
self::assertStringContainsString('Visual Builder', $refusal['message']);
|
||
|
||
Functions\when('current_user_can')->justReturn(false);
|
||
$refusal = self::assertToolError(DesignRights::presets($writer), 'forbidden');
|
||
self::assertStringContainsString('edit_theme_options', $refusal['message']);
|
||
}
|
||
}
|
||
```
|
||
|
||
- [ ] **Step 2: Tests laufen lassen – sie scheitern**
|
||
|
||
Run: `php vendor/bin/phpunit tests/Unit/Integrations/Divi/Design/PresetDiffTest.php tests/Unit/Integrations/Divi/Design/DesignRightsTest.php`
|
||
Expected: FAIL.
|
||
|
||
- [ ] **Step 3: `summary()` und `DesignRights` implementieren**
|
||
|
||
In `PresetDiff`:
|
||
|
||
```php
|
||
/** One German sentence for the dry run and the change log (spec §4 step 6). */
|
||
public static function summary(array $diff): string
|
||
{
|
||
$count = array_count_values(array_map(static fn (array $row): string => (string) $row['action'], $diff));
|
||
$parts = array_filter([
|
||
isset($count['added']) ? $count['added'] . ' angelegt' : null,
|
||
isset($count['changed']) ? $count['changed'] . ' geändert' : null,
|
||
isset($count['removed']) ? $count['removed'] . ' gelöscht' : null,
|
||
]);
|
||
$defaults = array_filter([
|
||
isset($count['default_set']) ? $count['default_set'] . '× gesetzt' : null,
|
||
isset($count['default_cleared']) ? $count['default_cleared'] . '× entfernt' : null,
|
||
]);
|
||
if ($defaults !== []) {
|
||
$parts[] = 'Standard ' . implode(', ', $defaults);
|
||
}
|
||
|
||
return 'Presets: ' . ($parts === [] ? 'keine Änderung' : implode(', ', $parts)) . '.';
|
||
}
|
||
```
|
||
|
||
(`@param list<array<string, mixed>> $diff` im Docblock ergänzen.)
|
||
|
||
`src/Integrations/Divi/Design/DesignRights.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Integrations\Divi\Design;
|
||
|
||
use LIT\MCP\Abilities\Errors;
|
||
use WP_Error;
|
||
|
||
defined('ABSPATH') || exit;
|
||
|
||
/**
|
||
* Who may change the design system (spec §10): presets need edit_theme_options and Divi's role right "Visual Builder
|
||
* verwenden" – what Divi's own preset sync asks since 5.15 (formats "Nachtrag 5.15.1").
|
||
*/
|
||
final class DesignRights
|
||
{
|
||
public static function presets(DesignSystemWriter $writer): ?WP_Error
|
||
{
|
||
if (! current_user_can('edit_theme_options')) {
|
||
return Errors::forbidden(
|
||
'Presets ändern erfordert das Recht, das Design der Website anzupassen (edit_theme_options).'
|
||
);
|
||
}
|
||
if (! $writer->canUseVisualBuilder()) {
|
||
return Errors::forbidden(
|
||
'Die Divi-Rolle dieses Kontos erlaubt den Visual Builder nicht; ohne ihn ändert LIT MCP keine Presets.',
|
||
'Einen Administrator bitten, das Recht unter Divi → Rollen-Editor freizugeben.'
|
||
);
|
||
}
|
||
|
||
return null;
|
||
}
|
||
}
|
||
```
|
||
|
||
Run: `php vendor/bin/phpunit tests/Unit/Integrations/Divi/Design/PresetDiffTest.php tests/Unit/Integrations/Divi/Design/DesignRightsTest.php`
|
||
Expected: PASS.
|
||
|
||
- [ ] **Step 4: Failing test für die Ability schreiben**
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Tests\Unit\Integrations\Divi\Design;
|
||
|
||
use Brain\Monkey\Functions;
|
||
use LIT\MCP\Abilities\Errors;
|
||
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\Design\DesignChange;
|
||
use LIT\MCP\Integrations\Divi\Design\DesignSystemWriter;
|
||
use LIT\MCP\Integrations\Divi\Design\DiviPresetsSetAbility;
|
||
use LIT\MCP\Integrations\Divi\Design\PresetBook;
|
||
use LIT\MCP\Integrations\Divi\Design\PresetComposer;
|
||
use LIT\MCP\Integrations\Divi\Design\PresetScope;
|
||
use LIT\MCP\Integrations\Divi\Design\SnapshotStore;
|
||
use LIT\MCP\Integrations\Divi\Library\GlobalUsages;
|
||
use LIT\MCP\Integrations\Divi\Library\UsageReport;
|
||
use LIT\MCP\Integrations\Divi\Pages\DiviPage;
|
||
use LIT\MCP\Integrations\Divi\Pages\DiviPageLoader;
|
||
use LIT\MCP\Tests\Support\ComposeFixture;
|
||
use LIT\MCP\Tests\Support\DiviFixtures;
|
||
use LIT\MCP\Tests\Support\FakeChangeLog;
|
||
use LIT\MCP\Tests\Unit\TestCase;
|
||
use Mockery;
|
||
|
||
final class DiviPresetsSetAbilityTest extends TestCase
|
||
{
|
||
/** @var array<string, mixed> */
|
||
private array $stored;
|
||
|
||
private SnapshotStore $snapshots;
|
||
|
||
protected function setUp(): void
|
||
{
|
||
parent::setUp();
|
||
$this->stored = PresetBookTest::stored();
|
||
$this->snapshots = Mockery::mock(SnapshotStore::class);
|
||
Functions\when('current_user_can')->justReturn(true);
|
||
}
|
||
|
||
private function ability(bool $unfiltered = true, ?GlobalUsages $usages = null, ?DiviPageLoader $loader = null): DiviPresetsSetAbility
|
||
{
|
||
$writer = Mockery::mock(DesignSystemWriter::class);
|
||
$writer->allows('presets')->andReturnUsing(fn (): array => $this->stored);
|
||
$writer->allows('canUseVisualBuilder')->andReturn(true);
|
||
$writer->allows('savePresets')->andReturnUsing(function (array $rest, bool $mayRemove): array {
|
||
$data = ['module' => [], 'group' => []];
|
||
foreach ($rest as $kind => $records) {
|
||
foreach ($records as $record) {
|
||
$first = $record['items'][0] ?? null;
|
||
$name = $kind === 'group' ? ($first['groupName'] ?? 'x') : ($first['moduleName'] ?? 'x');
|
||
$data[$kind][$name] = ['default' => $record['default'], 'items' => array_column($record['items'], null, 'id')];
|
||
}
|
||
}
|
||
|
||
return $this->stored = $data;
|
||
});
|
||
$usages ??= Mockery::mock(GlobalUsages::class);
|
||
$usages->allows('reportFor')->andReturn(new UsageReport(0, [], 0, 0, [], 0, false));
|
||
$composer = static fn (): PresetComposer => new PresetComposer(
|
||
ComposeFixture::composer($unfiltered),
|
||
new StoredNodeGuard(ComposeFixture::cleaner($unfiltered), ComposeFixture::references(),
|
||
ComposeFixture::sanitizer($unfiltered)),
|
||
static fn (string $module, array $attrs): array => ['all' => array_map(
|
||
static fn (mixed $v): mixed => is_array($v) ? array_diff_key($v, ['innerContent' => 1]) : $v,
|
||
$attrs
|
||
), 'style' => [], 'render' => []],
|
||
static fn (string $module): array => ['module.decoration.spacing' => 'divi/spacing'],
|
||
'5.15.1',
|
||
static fn (): int => 1
|
||
);
|
||
|
||
return new DiviPresetsSetAbility(
|
||
$writer,
|
||
new DesignChange($this->snapshots, new FakeChangeLog(5)),
|
||
$usages,
|
||
$loader ?? Mockery::mock(DiviPageLoader::class),
|
||
$composer
|
||
);
|
||
}
|
||
|
||
private static function newButton(array $extra = []): array
|
||
{
|
||
return ['items' => [['module' => 'button', 'name' => 'CTA dunkel',
|
||
'attrs' => ['button.decoration.background' => ['desktop' => ['color' => '#111111']]]] + $extra]];
|
||
}
|
||
|
||
public function testDryRunThenConfirmCreatesThePreset(): void
|
||
{
|
||
$ability = $this->ability();
|
||
|
||
$dry = self::assertToolError($ability->execute(self::newButton()), 'confirm_required');
|
||
self::assertSame('added', $dry['diff'][0]['action']);
|
||
self::assertStringContainsString('Presets: 1 angelegt.', $dry['message']);
|
||
|
||
$this->snapshots->expects('save')->andReturn('presets-1');
|
||
$this->snapshots->expects('attachLog');
|
||
$result = $ability->execute(self::newButton() + ['confirm' => true, 'design_rev' => $dry['design_rev']]);
|
||
|
||
self::assertTrue($result['ok']);
|
||
self::assertSame('presets-1', $result['snapshot_id']);
|
||
$names = array_column(PresetBook::fromDivi($this->stored)->items(new PresetScope('module', 'divi/button')), 'name');
|
||
self::assertContains('CTA dunkel', $names);
|
||
}
|
||
|
||
public function testExistingNameIsRefusedForANewPreset(): void
|
||
{
|
||
$result = self::assertToolError($this->ability()->execute(['items' => [
|
||
['module' => 'button', 'name' => 'CTA primär'],
|
||
]]), 'validation_failed');
|
||
|
||
self::assertStringContainsString('aaaaaaaaaa', $result['fields']['items[0].name']);
|
||
}
|
||
|
||
public function testChangingAndMakingDefault(): void
|
||
{
|
||
$dry = self::assertToolError($this->ability()->execute(['items' => [[
|
||
'module' => 'button', 'preset' => 'CTA primär', 'make_default' => true,
|
||
'attrs' => ['button.decoration.background' => ['desktop' => ['color' => '#222222']]],
|
||
]]]), 'confirm_required');
|
||
|
||
self::assertSame(['changed', 'default_set'], array_column($dry['diff'], 'action'));
|
||
}
|
||
|
||
public function testUnknownPresetAndBadItemsAreCollected(): void
|
||
{
|
||
$result = self::assertToolError($this->ability()->execute(['items' => [
|
||
['module' => 'button', 'preset' => 'Fehlt'],
|
||
['name' => 'ohne Modul'],
|
||
]]), 'validation_failed');
|
||
|
||
self::assertArrayHasKey('items[0].preset', $result['fields']);
|
||
self::assertArrayHasKey('items[1]', $result['fields']);
|
||
}
|
||
|
||
public function testEditorWithoutUnfilteredHtmlIsRefusedForRawCss(): void
|
||
{
|
||
$result = $this->ability(false)->execute(['items' => [[
|
||
'module' => 'button', 'name' => 'Mit CSS',
|
||
'attrs' => ['css' => ['desktop' => ['mainElement' => 'color:red']]],
|
||
]]]);
|
||
|
||
self::assertNotTrue(is_array($result) && ($result['ok'] ?? false));
|
||
self::assertContains(Errors::codeOf($result), ['validation_failed', 'invalid_attr_path']);
|
||
}
|
||
|
||
public function testFromNodeReadsThePage(): void
|
||
{
|
||
$loader = Mockery::mock(DiviPageLoader::class);
|
||
$content = '<!-- wp:divi/section --><!-- wp:divi/row --><!-- wp:divi/column -->'
|
||
. '<!-- wp:divi/button {"button":{"decoration":{"background":{"desktop":{"value":{"color":"#abcdef"}}}}}} /-->'
|
||
. '<!-- /wp:divi/column --><!-- /wp:divi/row --><!-- /wp:divi/section -->';
|
||
$document = (new Parser())->parse($content);
|
||
$page = new DiviPage(DiviFixtures::givenPost($content), $document, NodeIndex::build($document));
|
||
$loader->expects('load')->with(12, false)->andReturn($page);
|
||
|
||
$dry = self::assertToolError($this->ability(true, null, $loader)->execute(['items' => [[
|
||
'module' => 'button', 'name' => 'Aus Seite', 'from_node' => ['post_id' => 12, 'id' => 's0.r0.c0.m0'],
|
||
]]]), 'confirm_required');
|
||
|
||
self::assertSame('added', $dry['diff'][0]['action']);
|
||
}
|
||
|
||
public function testNeedsEditThemeOptionsAndTheVisualBuilder(): void
|
||
{
|
||
Functions\when('current_user_can')->justReturn(false);
|
||
|
||
self::assertToolError($this->ability()->permission(self::newButton()), 'forbidden');
|
||
}
|
||
|
||
public function testSchemaAndMeta(): void
|
||
{
|
||
$ability = $this->ability();
|
||
|
||
self::assertSame('lit/divi-presets-set', $ability->name());
|
||
self::assertFalse($ability->isDirect());
|
||
self::assertSame(DiviPresetsSetAbility::MAX_ITEMS, $ability->inputSchema()['properties']['items']['maxItems']);
|
||
self::assertSame(['diff', 'design_rev'], array_slice($ability->outputSchema()['required'], -2));
|
||
}
|
||
}
|
||
```
|
||
|
||
`DiviFixtures::givenPost(string $content, array $fields = []): WP_Post` baut den Beitrag ohne WordPress.
|
||
|
||
Die Pfad-ID des Buttons im Testinhalt ist `s0.r0.c0.m0` (`NodeIndex::ID_PATTERN`: `s` Abschnitt, `r` Zeile, `c` Spalte, `m` Modul).
|
||
|
||
- [ ] **Step 5: Test laufen lassen – er scheitert**
|
||
|
||
Run: `php vendor/bin/phpunit tests/Unit/Integrations/Divi/Design/DiviPresetsSetAbilityTest.php`
|
||
Expected: FAIL, Klasse fehlt.
|
||
|
||
- [ ] **Step 6: Ability implementieren**
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Integrations\Divi\Design;
|
||
|
||
use Closure;
|
||
use InvalidArgumentException;
|
||
use LIT\MCP\Abilities\Ability;
|
||
use LIT\MCP\Abilities\Annotations;
|
||
use LIT\MCP\Abilities\Errors;
|
||
use LIT\MCP\Integrations\Divi\BlockTree\Block;
|
||
use LIT\MCP\Integrations\Divi\Library\GlobalUsages;
|
||
use LIT\MCP\Integrations\Divi\Pages\DiviPageLoader;
|
||
use WP_Error;
|
||
|
||
defined('ABSPATH') || exit;
|
||
|
||
/**
|
||
* lit/divi-presets-set (spec §6.3, G7): creates and changes module and option group presets – from the short and full
|
||
* form, from a module of a page (from_node), with nested group presets and as the default preset – through the
|
||
* change pipeline (dry run, design_rev, snapshot, Divi's sync, change log). New names must be free within the
|
||
* module/group (A5). The dry run lists the posts that use a changed preset or reach a new default.
|
||
*/
|
||
final class DiviPresetsSetAbility implements Ability
|
||
{
|
||
public const MAX_ITEMS = 20;
|
||
|
||
private const GROUP_DEFAULT_WARNING = 'Standard-Gruppen-Presets wirken zusätzlich auf alle Module mit dieser '
|
||
. 'Gruppe ohne eigenes Gruppen-Preset; diese Seiten sind nicht aufgelistet.';
|
||
|
||
/** @param Closure(): PresetComposer $composer */
|
||
public function __construct(
|
||
private DesignSystemWriter $writer,
|
||
private DesignChange $change,
|
||
private GlobalUsages $usages,
|
||
private DiviPageLoader $loader,
|
||
private Closure $composer
|
||
) {
|
||
}
|
||
|
||
public function name(): string
|
||
{
|
||
return 'lit/divi-presets-set';
|
||
}
|
||
|
||
public function label(): string
|
||
{
|
||
return 'Divi-Presets anlegen und ändern';
|
||
}
|
||
|
||
public function description(): string
|
||
{
|
||
return 'Legt Modul-Presets (module) und Gruppen-Presets (group) an oder ändert sie (preset = Name oder ID). '
|
||
. 'Einstellungen in attrs (Vollform wie bei lit-divi-update, mit Platzhaltern {{color:…}}/{{var:…}}) oder '
|
||
. 'aus einem Modul einer Seite (from_node: post_id + Pfad-ID); nur Gestaltung, keine Texte oder Links. '
|
||
. 'group_presets verschachtelt Gruppen-Presets, make_default macht das Preset zum Standard. Wirkt auf alle '
|
||
. 'Seiten: zuerst Probelauf (diff, betroffene Seiten, design_rev), nach Rückfrage beim Nutzer confirm: true '
|
||
. 'mit design_rev. Vorher wird ein Snapshot angelegt (lit/divi-design-restore).';
|
||
}
|
||
|
||
public function inputSchema(): array
|
||
{
|
||
return [
|
||
'type' => 'object',
|
||
'properties' => [
|
||
'items' => [
|
||
'type' => 'array',
|
||
'minItems' => 1,
|
||
'maxItems' => self::MAX_ITEMS,
|
||
'items' => [
|
||
'type' => 'object',
|
||
'properties' => [
|
||
'module' => ['type' => 'string'],
|
||
'group' => ['type' => 'string'],
|
||
'preset' => ['type' => 'string', 'description' => 'Zu änderndes Preset (Name oder ID).'],
|
||
'name' => ['type' => 'string', 'description' => 'Name eines neuen Presets.'],
|
||
'rename' => ['type' => 'string'],
|
||
'set' => ['type' => 'object'],
|
||
'attrs' => ['type' => 'object'],
|
||
'from_node' => [
|
||
'type' => 'object',
|
||
'properties' => ['post_id' => ['type' => 'integer'], 'id' => ['type' => 'string']],
|
||
'required' => ['post_id', 'id'],
|
||
],
|
||
'source_module' => ['type' => 'string', 'description' => 'Neues Gruppen-Preset: Modul.'],
|
||
'group_id' => ['type' => 'string'],
|
||
'group_presets' => ['type' => 'object'],
|
||
'make_default' => ['type' => 'boolean'],
|
||
],
|
||
],
|
||
],
|
||
] + DesignChange::inputProperties(),
|
||
'required' => ['items'],
|
||
'additionalProperties' => false,
|
||
];
|
||
}
|
||
|
||
public function outputSchema(): ?array
|
||
{
|
||
return DesignChange::outputSchema();
|
||
}
|
||
|
||
public function annotations(): array
|
||
{
|
||
return Annotations::destructive(false);
|
||
}
|
||
|
||
public function isDirect(): bool
|
||
{
|
||
return false;
|
||
}
|
||
|
||
public function permission(array $input): bool|WP_Error
|
||
{
|
||
return DesignRights::presets($this->writer) ?? true;
|
||
}
|
||
|
||
public function execute(array $input): mixed
|
||
{
|
||
$refusal = DesignRights::presets($this->writer);
|
||
if ($refusal !== null) {
|
||
return $refusal;
|
||
}
|
||
$items = $input['items'] ?? null;
|
||
if (! is_array($items) || ! array_is_list($items) || $items === [] || count($items) > self::MAX_ITEMS) {
|
||
return Errors::invalidInput(
|
||
'items fehlt oder ist zu lang; nichts wurde gespeichert.',
|
||
['items' => sprintf('1 bis %d Einträge', self::MAX_ITEMS)]
|
||
);
|
||
}
|
||
|
||
return $this->change->run(
|
||
$this->name(),
|
||
new PresetArea($this->writer),
|
||
$input,
|
||
fn (array $raw): DesignPlan|WP_Error => $this->plan(PresetBook::fromDivi($raw), $items)
|
||
);
|
||
}
|
||
|
||
/** @param list<mixed> $items */
|
||
private function plan(PresetBook $before, array $items): DesignPlan|WP_Error
|
||
{
|
||
$composer = ($this->composer)();
|
||
$book = $before;
|
||
$errors = [];
|
||
$invalid = [];
|
||
$targets = [];
|
||
$warnings = [];
|
||
foreach ($items as $index => $item) {
|
||
$field = sprintf('items[%d]', $index);
|
||
if (! is_array($item)) {
|
||
$errors[$field] = 'Objekt erwartet';
|
||
continue;
|
||
}
|
||
$prepared = $this->prepare($book, $item, $field, $errors);
|
||
if ($prepared === null) {
|
||
continue;
|
||
}
|
||
[$scope, $existing, $source] = $prepared;
|
||
$result = $composer->compose($book, $scope, $existing, $item, $field, $source);
|
||
$invalid = array_merge($invalid, $result['invalid_paths']);
|
||
if ($result['errors'] !== [] || $result['invalid_paths'] !== []) {
|
||
$errors += $result['errors'];
|
||
continue;
|
||
}
|
||
$id = (string) $result['item']['id'];
|
||
$book = $book->with($scope, $result['item']);
|
||
if (($item['make_default'] ?? null) === true) {
|
||
$book = $book->withDefault($scope, $id);
|
||
if ($scope->kind === PresetScope::GROUP) {
|
||
$warnings[] = self::GROUP_DEFAULT_WARNING;
|
||
}
|
||
} elseif (($item['make_default'] ?? null) === false && $book->defaultId($scope) === $id) {
|
||
$book = $book->withDefault($scope, '');
|
||
}
|
||
if ($existing !== null || $book->defaultId($scope) === $id) {
|
||
$targets[] = ['scope' => $scope, 'id' => $id, 'default' => $before->defaultId($scope) === $id
|
||
|| $book->defaultId($scope) === $id];
|
||
}
|
||
}
|
||
|
||
if ($invalid !== []) {
|
||
return Errors::invalidAttrPath($errors);
|
||
}
|
||
if ($errors !== []) {
|
||
return Errors::invalidInput('Ungültige Preset-Angaben; nichts wurde gespeichert.', $errors);
|
||
}
|
||
|
||
$diff = PresetDiff::between($before, $book);
|
||
|
||
return new DesignPlan(
|
||
$book->data(),
|
||
$diff,
|
||
PresetDiff::summary($diff),
|
||
$targets === [] ? null : $this->usages->reportFor(new PresetUsageQuery($targets)),
|
||
array_values(array_unique($warnings))
|
||
);
|
||
}
|
||
|
||
/**
|
||
* Scope, preset to change and source node of one item; null after noting the problem in $errors.
|
||
*
|
||
* @param array<array-key, mixed> $item
|
||
* @param array<string, string> $errors
|
||
* @return array{PresetScope, array<string, mixed>|null, Block|null}|null
|
||
*/
|
||
private function prepare(PresetBook $book, array $item, string $field, array &$errors): ?array
|
||
{
|
||
try {
|
||
$scope = PresetScope::fromInput($item, $field);
|
||
} catch (InvalidArgumentException $e) {
|
||
[$path, $problem] = explode(': ', $e->getMessage(), 2) + [1 => ''];
|
||
$errors[$path] = $problem;
|
||
|
||
return null;
|
||
}
|
||
|
||
$existing = null;
|
||
try {
|
||
if (is_string($item['preset'] ?? null)) {
|
||
$existing = $book->find($scope, $item['preset']);
|
||
if ($existing === null) {
|
||
$errors[$field . '.preset'] = sprintf('unbekanntes %s „%s“', $scope->label(), $item['preset']);
|
||
|
||
return null;
|
||
}
|
||
}
|
||
} catch (InvalidArgumentException $e) {
|
||
$errors[$field . '.preset'] = $e->getMessage();
|
||
|
||
return null;
|
||
}
|
||
|
||
foreach (['name' => $existing === null, 'rename' => $existing !== null] as $key => $applies) {
|
||
if (! $applies || ! is_string($item[$key] ?? null)) {
|
||
continue;
|
||
}
|
||
$taken = array_diff($book->idsNamed($scope, $item[$key]), [(string) ($existing['id'] ?? '')]);
|
||
if ($taken !== []) {
|
||
$errors[$field . '.' . $key] = sprintf(
|
||
'Name schon vergeben (%s); zum Ändern preset angeben oder einen anderen Namen wählen',
|
||
implode(', ', $taken)
|
||
);
|
||
|
||
return null;
|
||
}
|
||
}
|
||
|
||
$source = $this->source($scope, $item, $field, $errors);
|
||
if ($source === false) {
|
||
return null;
|
||
}
|
||
|
||
return [$scope, $existing, $source];
|
||
}
|
||
|
||
/**
|
||
* @param array<array-key, mixed> $item
|
||
* @param array<string, string> $errors
|
||
*/
|
||
private function source(PresetScope $scope, array $item, string $field, array &$errors): Block|false|null
|
||
{
|
||
$from = $item['from_node'] ?? null;
|
||
if ($from === null) {
|
||
return null;
|
||
}
|
||
if (! is_array($from) || ! is_string($from['id'] ?? null)) {
|
||
$errors[$field . '.from_node'] = 'post_id und id (Pfad-ID aus lit-divi-outline) erwartet';
|
||
|
||
return false;
|
||
}
|
||
|
||
$page = $this->loader->load($from['post_id'] ?? null, false);
|
||
if ($page instanceof WP_Error) {
|
||
$errors[$field . '.from_node.post_id'] = Errors::clientMessage($page);
|
||
|
||
return false;
|
||
}
|
||
$block = $page->index->find($from['id']);
|
||
if ($block === null) {
|
||
$errors[$field . '.from_node.id'] = sprintf('unbekannte Pfad-ID %s (lit-divi-outline)', $from['id']);
|
||
|
||
return false;
|
||
}
|
||
if ($scope->kind === PresetScope::MODULE && $block->name() !== $scope->name) {
|
||
$errors[$field . '.from_node.id'] = sprintf('%s ist %s, nicht %s', $from['id'], $block->name(), $scope->name);
|
||
|
||
return false;
|
||
}
|
||
|
||
return $block;
|
||
}
|
||
}
|
||
```
|
||
|
||
`false` steht für „Fehler schon in `$errors` notiert“, `null` für „kein `from_node`“ (`Block|false|null` ist ab PHP 8.0 gültig).
|
||
|
||
In `DiviIntegration::abilities()` ergänzen:
|
||
|
||
```php
|
||
new DiviPresetsSetAbility(
|
||
$this->designWriter,
|
||
$this->designChange(),
|
||
$this->globalUsages(),
|
||
$loader,
|
||
$this->presetComposer(...)
|
||
),
|
||
```
|
||
|
||
und die Helfer:
|
||
|
||
```php
|
||
private function designChange(): DesignChange
|
||
{
|
||
return new DesignChange(new SnapshotStore(), $this->log);
|
||
}
|
||
|
||
private function presetComposer(): PresetComposer
|
||
{
|
||
$composition = new DiviComposition($this->modules, $this->design);
|
||
|
||
return new PresetComposer(
|
||
$composition->composer(),
|
||
$composition->storedGuard(),
|
||
$this->designWriter->presetAttrs(...),
|
||
$this->designWriter->groupsOf(...),
|
||
$this->modules->builderVersion(),
|
||
static fn (): int => (int) floor(microtime(true) * 1000)
|
||
);
|
||
}
|
||
```
|
||
|
||
Namensliste in `DiviIntegrationTest` um `'lit/divi-presets-set',` ergänzen.
|
||
|
||
- [ ] **Step 7: Tests laufen lassen – sie bestehen**
|
||
|
||
Run: `php vendor/bin/phpunit tests/Unit/Integrations/Divi/Design tests/Unit/Integrations/Divi/DiviIntegrationTest.php tests/Unit/Guides/ToolNamingTest.php`
|
||
Expected: PASS.
|
||
|
||
- [ ] **Step 8: Gesamtlauf, Lint, Commit**
|
||
|
||
Run: `composer test && composer lint`
|
||
|
||
```bash
|
||
git add src/Integrations/Divi/Design/DesignRights.php src/Integrations/Divi/Design/DiviPresetsSetAbility.php src/Integrations/Divi/Design/PresetDiff.php src/Integrations/Divi/DiviIntegration.php tests/Unit/Integrations/Divi/Design/DesignRightsTest.php tests/Unit/Integrations/Divi/Design/DiviPresetsSetAbilityTest.php tests/Unit/Integrations/Divi/Design/PresetDiffTest.php tests/Unit/Integrations/Divi/DiviIntegrationTest.php
|
||
git commit -m "feat: lit/divi-presets-set – Presets anlegen und ändern mit Probelauf und Snapshot" -m "Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>"
|
||
```
|
||
|
||
---
|
||
|
||
### Task 12: `lit/divi-presets-delete` – unbenutzte Presets löschen
|
||
|
||
**Files:**
|
||
- Create: `src/Integrations/Divi/Design/DiviPresetsDeleteAbility.php`
|
||
- Modify: `src/Abilities/Errors.php` (`inUse()` mit eigenem Hinweis)
|
||
- Modify: `tests/Unit/Abilities/ErrorsTest.php`
|
||
- Modify: `src/Integrations/Divi/DiviIntegration.php`, `tests/Unit/Integrations/Divi/DiviIntegrationTest.php`
|
||
- Test: `tests/Unit/Integrations/Divi/Design/DiviPresetsDeleteAbilityTest.php`
|
||
|
||
**Interfaces:**
|
||
- Consumes: wie Task 11, dazu `PresetBook::without()`, `PresetBook::nestedUsers()`, `UsageReport::exists()/listing()`.
|
||
- Produces:
|
||
- `Errors::inUse(string $message, array $usages, ?string $hint = null): WP_Error` – ohne `$hint` unverändert („… nur mit force: true …“, für `lit/media-delete`).
|
||
- `final class DiviPresetsDeleteAbility implements Ability { public const MAX_ITEMS = 20; public function __construct(DesignSystemWriter $writer, DesignChange $change, GlobalUsages $usages) }`.
|
||
|
||
- [ ] **Step 1: Failing tests schreiben**
|
||
|
||
In `tests/Unit/Abilities/ErrorsTest.php` anhängen:
|
||
|
||
```php
|
||
public function testInUseTakesItsOwnHint(): void
|
||
{
|
||
$error = Errors::inUse('Wird verwendet.', [['post_id' => 3]], 'Erst die Verweise entfernen.');
|
||
|
||
$payload = self::assertToolError($error, 'in_use');
|
||
self::assertSame('Erst die Verweise entfernen.', $payload['hint']);
|
||
self::assertStringContainsString('force: true', Errors::inUse('x', [])->get_error_data()['hint']);
|
||
}
|
||
```
|
||
|
||
(`ErrorsTest` erbt von `LIT\MCP\Tests\Unit\TestCase` und hat damit `assertToolError()`.)
|
||
|
||
`tests/Unit/Integrations/Divi/Design/DiviPresetsDeleteAbilityTest.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Tests\Unit\Integrations\Divi\Design;
|
||
|
||
use Brain\Monkey\Functions;
|
||
use LIT\MCP\Integrations\Divi\Design\DesignChange;
|
||
use LIT\MCP\Integrations\Divi\Design\DesignSystemWriter;
|
||
use LIT\MCP\Integrations\Divi\Design\DiviPresetsDeleteAbility;
|
||
use LIT\MCP\Integrations\Divi\Design\SnapshotStore;
|
||
use LIT\MCP\Integrations\Divi\Library\GlobalUsages;
|
||
use LIT\MCP\Integrations\Divi\Library\UsageReport;
|
||
use LIT\MCP\Tests\Support\FakeChangeLog;
|
||
use LIT\MCP\Tests\Unit\TestCase;
|
||
use Mockery;
|
||
|
||
final class DiviPresetsDeleteAbilityTest extends TestCase
|
||
{
|
||
private function ability(UsageReport $report, ?DesignSystemWriter $writer = null, ?SnapshotStore $snapshots = null): DiviPresetsDeleteAbility
|
||
{
|
||
Functions\when('current_user_can')->justReturn(true);
|
||
if ($writer === null) {
|
||
$writer = Mockery::mock(DesignSystemWriter::class);
|
||
$writer->allows('presets')->andReturn(PresetBookTest::stored());
|
||
$writer->allows('canUseVisualBuilder')->andReturn(true);
|
||
}
|
||
$usages = Mockery::mock(GlobalUsages::class);
|
||
$usages->allows('reportFor')->andReturn($report);
|
||
|
||
return new DiviPresetsDeleteAbility(
|
||
$writer,
|
||
new DesignChange($snapshots ?? Mockery::mock(SnapshotStore::class), new FakeChangeLog(3)),
|
||
$usages
|
||
);
|
||
}
|
||
|
||
private static function unused(): UsageReport
|
||
{
|
||
return new UsageReport(0, [], 0, 0, [], 0, false);
|
||
}
|
||
|
||
public function testUnusedPresetIsDeletedAfterConfirm(): void
|
||
{
|
||
$writer = Mockery::mock(DesignSystemWriter::class);
|
||
$writer->allows('presets')->andReturn(PresetBookTest::stored());
|
||
$writer->allows('canUseVisualBuilder')->andReturn(true);
|
||
$writer->expects('savePresets')
|
||
->with(Mockery::on(static function (array $rest): bool {
|
||
$ids = array_column($rest['module'][0]['items'], 'id');
|
||
|
||
return $ids === ['aaaaaaaaaa', 'cccccccccc'];
|
||
}), true)
|
||
->andReturnUsing(static function (): array {
|
||
$stored = PresetBookTest::stored();
|
||
unset($stored['module']['divi/button']['items']['bbbbbbbbbb']);
|
||
|
||
return $stored;
|
||
});
|
||
$snapshots = Mockery::mock(SnapshotStore::class);
|
||
$snapshots->expects('save')->andReturn('presets-9');
|
||
$snapshots->expects('attachLog');
|
||
$ability = $this->ability(self::unused(), $writer, $snapshots);
|
||
$input = ['items' => [['module' => 'button', 'preset' => 'bbbbbbbbbb']]];
|
||
|
||
$dry = self::assertToolError($ability->execute($input), 'confirm_required');
|
||
self::assertSame('removed', $dry['diff'][0]['action']);
|
||
|
||
$result = $ability->execute($input + ['confirm' => true, 'design_rev' => $dry['design_rev']]);
|
||
self::assertSame('presets-9', $result['snapshot_id']);
|
||
}
|
||
|
||
public function testPresetInUseIsRefused(): void
|
||
{
|
||
$used = new UsageReport(2, [['post_id' => 3, 'title' => 'Start', 'status' => 'publish', 'type' => 'page']],
|
||
1, 1, [], 0, false);
|
||
|
||
$error = self::assertToolError(
|
||
$this->ability($used)->execute(['items' => [['module' => 'button', 'preset' => 'CTA primär']]]),
|
||
'in_use'
|
||
);
|
||
|
||
self::assertSame(3, $error['usages'][0]['post_id']);
|
||
self::assertStringContainsString('lit/divi-design-detach', $error['hint']);
|
||
}
|
||
|
||
public function testNestedUseInAnotherPresetCounts(): void
|
||
{
|
||
$error = self::assertToolError(
|
||
$this->ability(self::unused())->execute(['items' => [['group' => 'font-body', 'preset' => 'Lesetext']]]),
|
||
'in_use'
|
||
);
|
||
|
||
self::assertSame('preset', $error['usages'][0]['type']);
|
||
self::assertSame('dddddddddd', $error['usages'][0]['preset_id']);
|
||
}
|
||
|
||
public function testDeletingTheDefaultClearsIt(): void
|
||
{
|
||
$dry = self::assertToolError(
|
||
$this->ability(self::unused())->execute(['items' => [['module' => 'text', 'preset' => 'Fließtext']]]),
|
||
'confirm_required'
|
||
);
|
||
|
||
self::assertSame(['removed', 'default_cleared'], array_column($dry['diff'], 'action'));
|
||
}
|
||
|
||
public function testUnknownPreset(): void
|
||
{
|
||
self::assertToolError(
|
||
$this->ability(self::unused())->execute(['items' => [['module' => 'button', 'preset' => 'Fehlt']]]),
|
||
'validation_failed'
|
||
);
|
||
}
|
||
}
|
||
```
|
||
|
||
- [ ] **Step 2: Tests laufen lassen – sie scheitern**
|
||
|
||
Run: `php vendor/bin/phpunit tests/Unit/Abilities/ErrorsTest.php tests/Unit/Integrations/Divi/Design/DiviPresetsDeleteAbilityTest.php`
|
||
Expected: FAIL.
|
||
|
||
- [ ] **Step 3: `Errors::inUse()` erweitern**
|
||
|
||
```php
|
||
/**
|
||
* @param list<array<string, mixed>> $usages
|
||
* @param string|null $hint Replaces the default hint (force: true, for lit/media-delete).
|
||
*/
|
||
public static function inUse(string $message, array $usages, ?string $hint = null): WP_Error
|
||
{
|
||
return self::make(
|
||
'in_use',
|
||
$message,
|
||
$hint ?? 'Verwendungen prüfen; nur mit force: true trotzdem ausführen.',
|
||
409,
|
||
['usages' => $usages]
|
||
);
|
||
}
|
||
```
|
||
|
||
- [ ] **Step 4: Ability implementieren**
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Integrations\Divi\Design;
|
||
|
||
use InvalidArgumentException;
|
||
use LIT\MCP\Abilities\Ability;
|
||
use LIT\MCP\Abilities\Annotations;
|
||
use LIT\MCP\Abilities\Errors;
|
||
use LIT\MCP\Integrations\Divi\Library\GlobalUsages;
|
||
use WP_Error;
|
||
|
||
defined('ABSPATH') || exit;
|
||
|
||
/**
|
||
* lit/divi-presets-delete (spec §6.4, G5): deletes presets nothing uses any more – no page, library entry or Theme
|
||
* Builder layout (GlobalUsages with PresetUsageQuery), and no other preset that nests it. A used preset is refused
|
||
* with its usages (in_use); lit/divi-design-detach (Etappe 4b) removes the references first. A default preset loses
|
||
* its default. Through the change pipeline with Divi's delete semantics (legacy option cleaned).
|
||
*/
|
||
final class DiviPresetsDeleteAbility implements Ability
|
||
{
|
||
public const MAX_ITEMS = 20;
|
||
|
||
private const DETACH_HINT = 'Erst die Verweise entfernen: lit/divi-design-detach (ab Etappe 4b) oder im '
|
||
. 'Divi-Builder; danach erneut löschen.';
|
||
|
||
public function __construct(
|
||
private DesignSystemWriter $writer,
|
||
private DesignChange $change,
|
||
private GlobalUsages $usages
|
||
) {
|
||
}
|
||
|
||
public function name(): string
|
||
{
|
||
return 'lit/divi-presets-delete';
|
||
}
|
||
|
||
public function label(): string
|
||
{
|
||
return 'Divi-Presets löschen';
|
||
}
|
||
|
||
public function description(): string
|
||
{
|
||
return 'Löscht Modul- oder Gruppen-Presets (items: module bzw. group + preset als Name oder ID), die nirgends '
|
||
. 'mehr verwendet werden; sonst Fehler in_use mit den Fundstellen. Zuerst Probelauf, nach Rückfrage beim '
|
||
. 'Nutzer confirm: true mit design_rev; vorher wird ein Snapshot angelegt (lit/divi-design-restore).';
|
||
}
|
||
|
||
public function inputSchema(): array
|
||
{
|
||
return [
|
||
'type' => 'object',
|
||
'properties' => [
|
||
'items' => [
|
||
'type' => 'array',
|
||
'minItems' => 1,
|
||
'maxItems' => self::MAX_ITEMS,
|
||
'items' => [
|
||
'type' => 'object',
|
||
'properties' => [
|
||
'module' => ['type' => 'string'],
|
||
'group' => ['type' => 'string'],
|
||
'preset' => ['type' => 'string'],
|
||
],
|
||
'required' => ['preset'],
|
||
],
|
||
],
|
||
] + DesignChange::inputProperties(),
|
||
'required' => ['items'],
|
||
'additionalProperties' => false,
|
||
];
|
||
}
|
||
|
||
public function outputSchema(): ?array
|
||
{
|
||
return DesignChange::outputSchema();
|
||
}
|
||
|
||
public function annotations(): array
|
||
{
|
||
return Annotations::destructive(true);
|
||
}
|
||
|
||
public function isDirect(): bool
|
||
{
|
||
return false;
|
||
}
|
||
|
||
public function permission(array $input): bool|WP_Error
|
||
{
|
||
return DesignRights::presets($this->writer) ?? true;
|
||
}
|
||
|
||
public function execute(array $input): mixed
|
||
{
|
||
$refusal = DesignRights::presets($this->writer);
|
||
if ($refusal !== null) {
|
||
return $refusal;
|
||
}
|
||
$items = $input['items'] ?? null;
|
||
if (! is_array($items) || ! array_is_list($items) || $items === [] || count($items) > self::MAX_ITEMS) {
|
||
return Errors::invalidInput(
|
||
'items fehlt oder ist zu lang; nichts wurde gelöscht.',
|
||
['items' => sprintf('1 bis %d Einträge', self::MAX_ITEMS)]
|
||
);
|
||
}
|
||
|
||
return $this->change->run(
|
||
$this->name(),
|
||
new PresetArea($this->writer),
|
||
$input,
|
||
fn (array $raw): DesignPlan|WP_Error => $this->plan(PresetBook::fromDivi($raw), $items)
|
||
);
|
||
}
|
||
|
||
/** @param list<mixed> $items */
|
||
private function plan(PresetBook $before, array $items): DesignPlan|WP_Error
|
||
{
|
||
$book = $before;
|
||
$errors = [];
|
||
$targets = [];
|
||
foreach ($items as $index => $item) {
|
||
$field = sprintf('items[%d]', $index);
|
||
try {
|
||
$scope = PresetScope::fromInput(is_array($item) ? $item : [], $field);
|
||
$found = $before->find($scope, is_string($item['preset'] ?? null) ? $item['preset'] : '');
|
||
} catch (InvalidArgumentException $e) {
|
||
$errors[$field] = $e->getMessage();
|
||
continue;
|
||
}
|
||
if ($found === null) {
|
||
$errors[$field . '.preset'] = sprintf('unbekanntes %s „%s“', $scope->label(), (string) $item['preset']);
|
||
continue;
|
||
}
|
||
$id = (string) $found['id'];
|
||
$targets[] = ['scope' => $scope, 'id' => $id, 'default' => $before->defaultId($scope) === $id];
|
||
$book = $book->without($scope, $id);
|
||
}
|
||
if ($errors !== []) {
|
||
return Errors::invalidInput('Ungültige Angaben; nichts wurde gelöscht.', $errors);
|
||
}
|
||
|
||
$deleted = array_column($targets, 'id');
|
||
$nested = [];
|
||
foreach ($targets as $target) {
|
||
foreach ($before->nestedUsers($target['id']) as $user) {
|
||
if (! in_array($user['id'], $deleted, true)) {
|
||
$nested[] = ['type' => 'preset', 'preset_id' => $user['id'], 'name' => $user['name'],
|
||
'scope' => $user['scope']->name];
|
||
}
|
||
}
|
||
}
|
||
$report = $this->usages->reportFor(new PresetUsageQuery($targets), false);
|
||
if ($nested !== [] || $report->exists()) {
|
||
return Errors::inUse(
|
||
'Die Presets werden noch verwendet; nichts wurde gelöscht.',
|
||
array_merge($nested, $report->listing()['affected']),
|
||
self::DETACH_HINT
|
||
);
|
||
}
|
||
|
||
$diff = PresetDiff::between($before, $book);
|
||
|
||
return new DesignPlan($book->data(), $diff, PresetDiff::summary($diff), null, [], true);
|
||
}
|
||
}
|
||
```
|
||
|
||
Bei `PresetScope::fromInput()`-Fehlern steht der Pfad schon in der Meldung (`items[0]: …`); hier wird die ganze Meldung unter `items[i]` abgelegt – im Test reicht der Code `validation_failed`.
|
||
|
||
In `DiviIntegration::abilities()` ergänzen: `new DiviPresetsDeleteAbility($this->designWriter, $this->designChange(), $this->globalUsages()),`; Namensliste in `DiviIntegrationTest` um `'lit/divi-presets-delete',`.
|
||
|
||
Der Hinweis nennt `lit/divi-design-detach`, das erst mit 4b registriert wird; `ToolNamingTest` erlaubt das (er prüft nur die Schreibweise direkter und indirekter Tools).
|
||
|
||
- [ ] **Step 5: Tests laufen lassen – sie bestehen**
|
||
|
||
Run: `php vendor/bin/phpunit tests/Unit/Abilities/ErrorsTest.php tests/Unit/Integrations/Divi tests/Unit/Guides/ToolNamingTest.php`
|
||
Expected: PASS.
|
||
|
||
- [ ] **Step 6: Gesamtlauf, Lint, Commit**
|
||
|
||
Run: `composer test && composer lint`
|
||
|
||
```bash
|
||
git add src/Abilities/Errors.php src/Integrations/Divi/Design/DiviPresetsDeleteAbility.php src/Integrations/Divi/DiviIntegration.php tests/Unit/Abilities/ErrorsTest.php tests/Unit/Integrations/Divi/Design/DiviPresetsDeleteAbilityTest.php tests/Unit/Integrations/Divi/DiviIntegrationTest.php
|
||
git commit -m "feat: lit/divi-presets-delete – unbenutzte Presets löschen" -m "Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>"
|
||
```
|
||
|
||
---
|
||
|
||
### Task 13: `lit/divi-design-snapshots` und `lit/divi-design-restore`
|
||
|
||
**Files:**
|
||
- Create: `src/Integrations/Divi/Design/DiviDesignSnapshotsAbility.php`
|
||
- Create: `src/Integrations/Divi/Design/DiviDesignRestoreAbility.php`
|
||
- Modify: `src/Integrations/Divi/DiviIntegration.php`, `tests/Unit/Integrations/Divi/DiviIntegrationTest.php`
|
||
- Test: `tests/Unit/Integrations/Divi/Design/DiviDesignSnapshotsAbilityTest.php`
|
||
- Test: `tests/Unit/Integrations/Divi/Design/DiviDesignRestoreAbilityTest.php`
|
||
|
||
**Interfaces:**
|
||
- Consumes: `SnapshotStore::list()/get()`, `Cursor::inputProperties()/decode()/limit()/page()`, `DesignChange::run()`, `PresetArea`, `PresetBook`, `PresetDiff`, `DesignRights::presets()`.
|
||
- Produces:
|
||
- `final class DiviDesignSnapshotsAbility implements Ability { public function __construct(SnapshotStore $snapshots) }` – Name `lit/divi-design-snapshots`, Eingabe `area` (Standard `presets`), `cursor`, `limit`; Ausgabe `{area, snapshots, next_cursor}`; Recht `edit_theme_options`.
|
||
- `final class DiviDesignRestoreAbility implements Ability { public function __construct(DesignSystemWriter $writer, DesignChange $change, SnapshotStore $snapshots) }` – Name `lit/divi-design-restore`, Eingabe `snapshot_id`, `confirm`, `design_rev`. In 4a nur Bereich `presets`; andere Bereiche → `unsupported` („ab Etappe 4c/4d“).
|
||
|
||
`Cursor` (vorhanden): `decode(?string): ?int` (0 ohne Cursor, `null` = ungültig), `limit(mixed): int` (Standard 20, höchstens 100), `page(array $rows, int $limit, int $offset): array{items, next_cursor}` – `$rows` beginnen beim Offset (der Aufrufer schneidet ab), `next_cursor` entsteht, wenn mehr als `$limit` Zeilen übergeben werden.
|
||
|
||
- [ ] **Step 1: Failing tests schreiben**
|
||
|
||
`tests/Unit/Integrations/Divi/Design/DiviDesignSnapshotsAbilityTest.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Tests\Unit\Integrations\Divi\Design;
|
||
|
||
use Brain\Monkey\Functions;
|
||
use LIT\MCP\Integrations\Divi\Design\DiviDesignSnapshotsAbility;
|
||
use LIT\MCP\Integrations\Divi\Design\SnapshotStore;
|
||
use LIT\MCP\Tests\Unit\TestCase;
|
||
use Mockery;
|
||
|
||
final class DiviDesignSnapshotsAbilityTest extends TestCase
|
||
{
|
||
public function testListsTheSnapshotsOfAnArea(): void
|
||
{
|
||
Functions\when('current_user_can')->alias(static fn (string $cap): bool => $cap === 'edit_theme_options');
|
||
$store = Mockery::mock(SnapshotStore::class);
|
||
$store->expects('list')->with('presets')->andReturn([
|
||
['id' => 'presets-2', 'created' => '2026-10-16T10:00:00+00:00', 'user_id' => 1,
|
||
'ability' => 'lit/divi-presets-set', 'log_id' => 4, 'size' => 120],
|
||
]);
|
||
$ability = new DiviDesignSnapshotsAbility($store);
|
||
|
||
self::assertTrue($ability->permission([]));
|
||
$result = $ability->execute([]);
|
||
|
||
self::assertSame('presets', $result['area']);
|
||
self::assertSame('presets-2', $result['snapshots'][0]['id']);
|
||
self::assertTrue($ability->annotations()['readonly']);
|
||
}
|
||
|
||
public function testUnknownAreaAndRights(): void
|
||
{
|
||
Functions\when('current_user_can')->justReturn(false);
|
||
$ability = new DiviDesignSnapshotsAbility(Mockery::mock(SnapshotStore::class));
|
||
|
||
self::assertToolError($ability->permission([]), 'forbidden');
|
||
Functions\when('current_user_can')->justReturn(true);
|
||
self::assertToolError($ability->execute(['area' => 'seiten']), 'validation_failed');
|
||
}
|
||
}
|
||
```
|
||
|
||
`tests/Unit/Integrations/Divi/Design/DiviDesignRestoreAbilityTest.php`:
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Tests\Unit\Integrations\Divi\Design;
|
||
|
||
use Brain\Monkey\Functions;
|
||
use LIT\MCP\Integrations\Divi\Design\DesignChange;
|
||
use LIT\MCP\Integrations\Divi\Design\DesignSystemWriter;
|
||
use LIT\MCP\Integrations\Divi\Design\DiviDesignRestoreAbility;
|
||
use LIT\MCP\Integrations\Divi\Design\SnapshotStore;
|
||
use LIT\MCP\Tests\Support\FakeChangeLog;
|
||
use LIT\MCP\Tests\Unit\TestCase;
|
||
use Mockery;
|
||
|
||
final class DiviDesignRestoreAbilityTest extends TestCase
|
||
{
|
||
public function testRestoresWithDryRunAndASnapshotOfTheCurrentState(): void
|
||
{
|
||
Functions\when('current_user_can')->justReturn(true);
|
||
$older = PresetBookTest::stored();
|
||
unset($older['module']['divi/button']['items']['bbbbbbbbbb']);
|
||
$writer = Mockery::mock(DesignSystemWriter::class);
|
||
$writer->allows('presets')->andReturn(PresetBookTest::stored());
|
||
$writer->allows('canUseVisualBuilder')->andReturn(true);
|
||
$writer->expects('savePresets')->with(Mockery::type('array'), true)->andReturn($older);
|
||
$snapshots = Mockery::mock(SnapshotStore::class);
|
||
$snapshots->allows('get')->with('presets', 'presets-1')->andReturn(['id' => 'presets-1', 'data' => $older,
|
||
'created' => 'x', 'user_id' => 1, 'ability' => 'lit/divi-presets-set', 'log_id' => 2, 'size' => 1]);
|
||
$snapshots->expects('save')->with('presets', Mockery::type('array'), 'lit/divi-design-restore')->andReturn('presets-3');
|
||
$snapshots->expects('attachLog');
|
||
$ability = new DiviDesignRestoreAbility($writer, new DesignChange($snapshots, new FakeChangeLog(8)), $snapshots);
|
||
|
||
$dry = self::assertToolError($ability->execute(['snapshot_id' => 'presets-1']), 'confirm_required');
|
||
self::assertSame('removed', $dry['diff'][0]['action']);
|
||
|
||
$result = $ability->execute(['snapshot_id' => 'presets-1', 'confirm' => true, 'design_rev' => $dry['design_rev']]);
|
||
self::assertSame('presets-3', $result['snapshot_id']);
|
||
}
|
||
|
||
public function testUnknownSnapshotAndOtherAreas(): void
|
||
{
|
||
Functions\when('current_user_can')->justReturn(true);
|
||
$writer = Mockery::mock(DesignSystemWriter::class);
|
||
$writer->allows('canUseVisualBuilder')->andReturn(true);
|
||
$snapshots = Mockery::mock(SnapshotStore::class);
|
||
$snapshots->allows('get')->andReturn(null);
|
||
$ability = new DiviDesignRestoreAbility($writer, new DesignChange($snapshots, FakeChangeLog::forbidden()), $snapshots);
|
||
|
||
self::assertToolError($ability->execute(['snapshot_id' => 'presets-20261016T100000Z-abcdef']), 'not_found');
|
||
self::assertToolError($ability->execute(['snapshot_id' => 'colors-20261016T100000Z-abcdef']), 'unsupported');
|
||
self::assertToolError($ability->execute(['snapshot_id' => 'kaputt']), 'validation_failed');
|
||
}
|
||
}
|
||
```
|
||
|
||
- [ ] **Step 2: Tests laufen lassen – sie scheitern**
|
||
|
||
Run: `php vendor/bin/phpunit tests/Unit/Integrations/Divi/Design/DiviDesignSnapshotsAbilityTest.php tests/Unit/Integrations/Divi/Design/DiviDesignRestoreAbilityTest.php`
|
||
Expected: FAIL, Klassen fehlen.
|
||
|
||
- [ ] **Step 3: `DiviDesignSnapshotsAbility` implementieren**
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Integrations\Divi\Design;
|
||
|
||
use LIT\MCP\Abilities\Ability;
|
||
use LIT\MCP\Abilities\Annotations;
|
||
use LIT\MCP\Abilities\Cursor;
|
||
use LIT\MCP\Abilities\Errors;
|
||
use WP_Error;
|
||
|
||
defined('ABSPATH') || exit;
|
||
|
||
/** lit/divi-design-snapshots (spec §5): the snapshots of one design area, newest first, without their content. */
|
||
final class DiviDesignSnapshotsAbility implements Ability
|
||
{
|
||
public function __construct(private SnapshotStore $snapshots)
|
||
{
|
||
}
|
||
|
||
public function name(): string
|
||
{
|
||
return 'lit/divi-design-snapshots';
|
||
}
|
||
|
||
public function label(): string
|
||
{
|
||
return 'Snapshots des Designsystems';
|
||
}
|
||
|
||
public function description(): string
|
||
{
|
||
return 'Listet die Snapshots eines Bereichs des Designsystems (area: presets, colors, variables, '
|
||
. 'theme_options; Standard presets), neueste zuerst, mit Zeitpunkt, Tool und Protokolleintrag. '
|
||
. 'Wiederherstellen mit lit/divi-design-restore.';
|
||
}
|
||
|
||
public function inputSchema(): array
|
||
{
|
||
return [
|
||
'type' => 'object',
|
||
'properties' => [
|
||
'area' => ['type' => 'string', 'enum' => SnapshotStore::AREAS],
|
||
] + Cursor::inputProperties(),
|
||
'additionalProperties' => false,
|
||
];
|
||
}
|
||
|
||
public function outputSchema(): ?array
|
||
{
|
||
return [
|
||
'type' => 'object',
|
||
'properties' => [
|
||
'area' => ['type' => 'string'],
|
||
'snapshots' => ['type' => 'array', 'items' => ['type' => 'object']],
|
||
'next_cursor' => ['type' => ['string', 'null']],
|
||
],
|
||
'required' => ['area', 'snapshots', 'next_cursor'],
|
||
];
|
||
}
|
||
|
||
public function annotations(): array
|
||
{
|
||
return Annotations::read();
|
||
}
|
||
|
||
public function isDirect(): bool
|
||
{
|
||
return false;
|
||
}
|
||
|
||
public function permission(array $input): bool|WP_Error
|
||
{
|
||
return current_user_can('edit_theme_options')
|
||
? true
|
||
: Errors::forbidden('Snapshots ansehen erfordert das Recht, das Design anzupassen (edit_theme_options).');
|
||
}
|
||
|
||
public function execute(array $input): mixed
|
||
{
|
||
$area = $input['area'] ?? 'presets';
|
||
if (! in_array($area, SnapshotStore::AREAS, true)) {
|
||
return Errors::invalidInput('Unbekannter Bereich.', ['area' => implode(', ', SnapshotStore::AREAS)]);
|
||
}
|
||
$offset = Cursor::decode(is_string($input['cursor'] ?? null) ? $input['cursor'] : null);
|
||
if ($offset === null) {
|
||
return Cursor::invalid();
|
||
}
|
||
$limit = Cursor::limit($input['limit'] ?? null);
|
||
$page = Cursor::page(array_slice($this->snapshots->list($area), $offset, $limit + 1), $limit, $offset);
|
||
|
||
return ['area' => $area, 'snapshots' => $page['items'], 'next_cursor' => $page['next_cursor']];
|
||
}
|
||
}
|
||
```
|
||
|
||
- [ ] **Step 4: `DiviDesignRestoreAbility` implementieren**
|
||
|
||
```php
|
||
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
namespace LIT\MCP\Integrations\Divi\Design;
|
||
|
||
use LIT\MCP\Abilities\Ability;
|
||
use LIT\MCP\Abilities\Annotations;
|
||
use LIT\MCP\Abilities\Errors;
|
||
use WP_Error;
|
||
|
||
defined('ABSPATH') || exit;
|
||
|
||
/**
|
||
* lit/divi-design-restore (spec §5, G6): writes a snapshot back through the change pipeline – dry run with the diff
|
||
* to the current state, confirm with design_rev, and first a snapshot of the current state, so a restore can be
|
||
* undone as well. Etappe 4a restores presets; the other areas follow with their tools (4c, 4d).
|
||
*/
|
||
final class DiviDesignRestoreAbility implements Ability
|
||
{
|
||
private const ID = '/^(colors|variables|presets|theme_options)-\d{8}T\d{6}Z-[0-9a-f]{6}$/D';
|
||
|
||
public function __construct(
|
||
private DesignSystemWriter $writer,
|
||
private DesignChange $change,
|
||
private SnapshotStore $snapshots
|
||
) {
|
||
}
|
||
|
||
public function name(): string
|
||
{
|
||
return 'lit/divi-design-restore';
|
||
}
|
||
|
||
public function label(): string
|
||
{
|
||
return 'Designsystem wiederherstellen';
|
||
}
|
||
|
||
public function description(): string
|
||
{
|
||
return 'Stellt einen Snapshot des Designsystems wieder her (snapshot_id aus lit/divi-design-snapshots oder '
|
||
. 'einer Änderungsantwort). Zuerst Probelauf (Unterschied zum aktuellen Stand, design_rev), nach Rückfrage '
|
||
. 'beim Nutzer confirm: true; vorher wird der aktuelle Stand selbst gesichert.';
|
||
}
|
||
|
||
public function inputSchema(): array
|
||
{
|
||
return [
|
||
'type' => 'object',
|
||
'properties' => ['snapshot_id' => ['type' => 'string']] + DesignChange::inputProperties(),
|
||
'required' => ['snapshot_id'],
|
||
'additionalProperties' => false,
|
||
];
|
||
}
|
||
|
||
public function outputSchema(): ?array
|
||
{
|
||
return DesignChange::outputSchema();
|
||
}
|
||
|
||
public function annotations(): array
|
||
{
|
||
return Annotations::destructive(false);
|
||
}
|
||
|
||
public function isDirect(): bool
|
||
{
|
||
return false;
|
||
}
|
||
|
||
public function permission(array $input): bool|WP_Error
|
||
{
|
||
return DesignRights::presets($this->writer) ?? true;
|
||
}
|
||
|
||
public function execute(array $input): mixed
|
||
{
|
||
$refusal = DesignRights::presets($this->writer);
|
||
if ($refusal !== null) {
|
||
return $refusal;
|
||
}
|
||
$id = is_string($input['snapshot_id'] ?? null) ? $input['snapshot_id'] : '';
|
||
if (preg_match(self::ID, $id, $match) !== 1) {
|
||
return Errors::invalidInput('Ungültige Snapshot-ID.', ['snapshot_id' => 'z. B. presets-20261016T101500Z-a1b2c3']);
|
||
}
|
||
if ($match[1] !== 'presets') {
|
||
return Errors::unsupported(
|
||
'Snapshots dieses Bereichs lassen sich noch nicht wiederherstellen.',
|
||
'Farben und Variablen folgen mit Etappe 4c, Theme-Optionen mit 4d.'
|
||
);
|
||
}
|
||
$snapshot = $this->snapshots->get('presets', $id);
|
||
if ($snapshot === null) {
|
||
return Errors::notFound(
|
||
sprintf('Snapshot %s gibt es nicht (mehr).', $id),
|
||
'Vorhandene Snapshots mit lit/divi-design-snapshots auflisten; je Bereich bleiben die letzten 20.'
|
||
);
|
||
}
|
||
|
||
return $this->change->run(
|
||
$this->name(),
|
||
new PresetArea($this->writer),
|
||
$input,
|
||
static function (array $raw) use ($snapshot, $id): DesignPlan {
|
||
$before = PresetBook::fromDivi($raw);
|
||
$after = PresetBook::fromDivi($snapshot['data']);
|
||
$diff = PresetDiff::between($before, $after);
|
||
|
||
return new DesignPlan(
|
||
$after->data(),
|
||
$diff,
|
||
sprintf('Snapshot %s wiederherstellen – %s', $id, PresetDiff::summary($diff)),
|
||
null,
|
||
['Seiten, die Presets verwenden, die es im Snapshot nicht gibt, behalten den Verweis; das Modul '
|
||
. 'fällt dann auf das Standard-Preset zurück.'],
|
||
true
|
||
);
|
||
}
|
||
);
|
||
}
|
||
}
|
||
```
|
||
|
||
In `DiviIntegration::abilities()` ergänzen:
|
||
|
||
```php
|
||
new DiviDesignSnapshotsAbility(new SnapshotStore()),
|
||
new DiviDesignRestoreAbility($this->designWriter, $this->designChange(), new SnapshotStore()),
|
||
```
|
||
|
||
Namensliste in `DiviIntegrationTest` um `'lit/divi-design-snapshots', 'lit/divi-design-restore',` ergänzen.
|
||
|
||
- [ ] **Step 5: Tests laufen lassen – sie bestehen**
|
||
|
||
Run: `php vendor/bin/phpunit tests/Unit/Integrations/Divi tests/Unit/Guides/ToolNamingTest.php`
|
||
Expected: PASS.
|
||
|
||
- [ ] **Step 6: Gesamtlauf, Lint, Commit**
|
||
|
||
Run: `composer test && composer lint`
|
||
|
||
```bash
|
||
git add src/Integrations/Divi/Design/DiviDesignSnapshotsAbility.php src/Integrations/Divi/Design/DiviDesignRestoreAbility.php src/Integrations/Divi/DiviIntegration.php tests/Unit/Integrations/Divi/Design/DiviDesignSnapshotsAbilityTest.php tests/Unit/Integrations/Divi/Design/DiviDesignRestoreAbilityTest.php tests/Unit/Integrations/Divi/DiviIntegrationTest.php
|
||
git commit -m "feat: lit/divi-design-snapshots und lit/divi-design-restore (Bereich presets)" -m "Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>"
|
||
```
|
||
|
||
---
|
||
|
||
### Task 14: Guide, Ende-zu-Ende-Test gegen echtes Divi, Entscheidungsnotiz
|
||
|
||
**Files:**
|
||
- Modify: `docs/guides/divi-design-system.md`
|
||
- Create: `tests/Integration/divi-presets-smoke.sh`
|
||
- Modify: `docs/superpowers/notes/2026-09-28-etappe-4-entscheidungen-entwurf.md`
|
||
|
||
**Interfaces:**
|
||
- Consumes: alle Tools aus Tasks 10–13; `tests/Integration/lib.sh` (`connect`, `ability`, `error_code`, `pass`, `fail`, `finish`, `guard_exit`).
|
||
- Produces: Smoke `divi-presets-smoke.sh`, der grün endet mit `ALL CHECKS PASSED`.
|
||
|
||
- [ ] **Step 1: Guide ergänzen**
|
||
|
||
In `docs/guides/divi-design-system.md` nach den Regeln anhängen:
|
||
|
||
```markdown
|
||
## Presets anlegen, ändern, löschen
|
||
|
||
Über `mcp-adapter-execute-ability`:
|
||
|
||
- `lit/divi-preset-get` – ein Preset mit Einstellungen (`attrs` als Pfad → Wert wie bei `lit-divi-node-get`),
|
||
verschachtelten Gruppen-Presets und den Seiten, die es verwenden (`usage`).
|
||
- `lit/divi-presets-set` – `items` mit `module` (z. B. `"button"`) oder `group` (z. B. `"font-body"`):
|
||
- neu: `name` + Einstellungen; ändern: `preset` (Name oder ID), optional `rename`;
|
||
- Einstellungen in `attrs` (Vollform, Platzhalter `{{color:…}}`, `{{var:…}}`, `{{font:…}}`) oder aus einem
|
||
gestalteten Modul: `from_node` = `{"post_id": 12, "id": "s0.r0.c1.m2"}` (Pfad-ID aus `lit-divi-outline`);
|
||
- Presets tragen nur Gestaltung – Texte, Links und Bilder gehören ins Modul (sonst `validation_failed`);
|
||
- `group_presets` (nur Modul-Presets), z. B. `{"font": "Button-Schrift"}`; `make_default: true` macht das
|
||
Preset zum Standard seines Moduls bzw. seiner Gruppe;
|
||
- neue Gruppen-Presets brauchen das Modul, aus dem die Gruppe stammt: `source_module` oder `from_node`.
|
||
- `lit/divi-presets-delete` – nur Presets, die nirgends verwendet werden; sonst `in_use` mit den Fundstellen.
|
||
- `lit/divi-design-snapshots` / `lit/divi-design-restore` – vor jeder Änderung legt LIT MCP einen Snapshot an
|
||
(je Bereich die letzten 20); wiederherstellen mit `snapshot_id`.
|
||
|
||
Ablauf jeder Änderung: Aufruf ohne `confirm` = Probelauf (`confirm_required` mit `diff`, betroffenen Seiten und
|
||
`design_rev`), dem Nutzer die Änderung zeigen, dann derselbe Aufruf mit `confirm: true` und `design_rev`. Hat sich
|
||
der Bestand inzwischen geändert (z. B. im Divi-Builder), kommt `rev_mismatch` – neu prüfen.
|
||
|
||
Rechte: Presets ändern verlangt das Recht, das Design anzupassen, und in Divis Rollen-Editor den Visual Builder.
|
||
```
|
||
|
||
- [ ] **Step 2: Smoke-Skript schreiben**
|
||
|
||
`tests/Integration/divi-presets-smoke.sh`:
|
||
|
||
```bash
|
||
#!/usr/bin/env bash
|
||
# End-to-end checks of Etappe 4a (presets: read, create, change, default, delete, snapshots, restore) through the
|
||
# OAuth-protected endpoint against the real Divi. Runs INSIDE the DDEV web container:
|
||
# cd /home/janniclas/Projekte/WordPress && timeout 900 ddev exec bash wp-content/plugins/WP-LIT-MCP/tests/Integration/divi-presets-smoke.sh
|
||
# Creates presets named "LIT Smoke <run> …" and one draft page; the EXIT trap restores the preset inventory from the
|
||
# snapshot taken before the first change and deletes the page (with revisions) by exact ID.
|
||
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)
|
||
RUN="$(date +%s)-$$"
|
||
PREFIX="LIT Smoke $RUN"
|
||
ORIGINAL_PRESETS=$(wp eval 'echo wp_json_encode(ET\Builder\Packages\GlobalData\GlobalPreset::get_data());')
|
||
PAGE_ID=""
|
||
|
||
cleanup() {
|
||
wp eval '$d = json_decode(getenv("LIT_PRESETS"), true); et_update_option(ET\Builder\Packages\GlobalData\GlobalPreset::option_name(), $d, false, "", "", true);' \
|
||
--user="$ADMIN_LOGIN" >/dev/null 2>&1 || echo "WARN: preset inventory not restored"
|
||
if [ -n "$PAGE_ID" ]; then wp post delete "$PAGE_ID" --force >/dev/null 2>&1 || true; fi
|
||
cleanup_app_passwords_for "$ADMIN_LOGIN"
|
||
}
|
||
export LIT_PRESETS="$ORIGINAL_PRESETS"
|
||
trap 'rc=$?; cleanup; guard_exit "$rc" || exit $?' EXIT
|
||
|
||
connect "$ADMIN_LOGIN"
|
||
|
||
# 1. Create a button preset: dry run, then confirm.
|
||
NEW=$(jq -cn --arg n "$PREFIX CTA" '{items: [{module: "button", name: $n,
|
||
attrs: {"button.decoration.background": {desktop: {color: "#123456"}}}}]}')
|
||
DRY=$(ability lit/divi-presets-set "$NEW")
|
||
[ "$(error_code "$DRY")" = "confirm_required" ] || fail "create without confirm: $DRY"
|
||
REV=$(echo "$DRY" | jq -r '.__error | fromjson | .design_rev')
|
||
DONE=$(ability lit/divi-presets-set "$(echo "$NEW" | jq -c --arg r "$REV" '. + {confirm: true, design_rev: $r}')")
|
||
[ "$(echo "$DONE" | jq -r '.ok')" = "true" ] || fail "create with confirm: $DONE"
|
||
SNAPSHOT=$(echo "$DONE" | jq -r '.snapshot_id')
|
||
pass "preset created (snapshot $SNAPSHOT)"
|
||
|
||
# 2. Read it back through Divi and the tool.
|
||
GET=$(ability lit/divi-preset-get "$(jq -cn --arg p "$PREFIX CTA" '{module: "button", preset: $p}')")
|
||
ID=$(echo "$GET" | jq -r '.id')
|
||
[ "$(echo "$GET" | jq -r '.attrs["button.decoration.background.desktop.value.color"]')" = "#123456" ] \
|
||
|| fail "preset-get attrs: $GET"
|
||
wp eval "\$d = ET\Builder\Packages\GlobalData\GlobalPreset::get_data(); exit(isset(\$d['module']['divi/button']['items']['$ID']['styleAttrs']) ? 0 : 1);" \
|
||
|| fail "Divi does not store styleAttrs for $ID"
|
||
pass "preset readable, styleAttrs stored"
|
||
|
||
# 3. A page with the preset renders its class.
|
||
PAGE_ID=$(wp post create --post_type=page --post_status=draft --post_title="$PREFIX Seite" \
|
||
--post_content="<!-- wp:divi/placeholder --><!-- wp:divi/section --><!-- wp:divi/row --><!-- wp:divi/column {\"module\":{\"decoration\":{\"sizing\":{\"desktop\":{\"value\":{\"flexType\":\"24_24\"}}}}}} --><!-- wp:divi/button {\"modulePreset\":[\"$ID\"],\"button\":{\"innerContent\":{\"desktop\":{\"value\":{\"text\":\"Los\"}}}}} /--><!-- /wp:divi/column --><!-- /wp:divi/row --><!-- /wp:divi/section --><!-- /wp:divi/placeholder -->" \
|
||
--porcelain)
|
||
HTML=$(wp eval "echo apply_filters('the_content', get_post($PAGE_ID)->post_content);")
|
||
echo "$HTML" | grep -q "preset--module--divi-button--$ID" || fail "rendered page lacks the preset class"
|
||
pass "page renders preset class"
|
||
|
||
# 4. Deleting a used preset is refused.
|
||
DEL=$(jq -cn --arg p "$ID" '{items: [{module: "button", preset: $p}]}')
|
||
[ "$(error_code "$(ability lit/divi-presets-delete "$DEL")")" = "in_use" ] || fail "delete of a used preset"
|
||
pass "used preset not deletable"
|
||
|
||
# 5. Stale design_rev.
|
||
STALE=$(ability lit/divi-presets-set "$(echo "$NEW" | jq -c '.items[0].name += " 2" | . + {confirm: true, design_rev: "veraltet"}')")
|
||
[ "$(error_code "$STALE")" = "rev_mismatch" ] || fail "stale design_rev: $STALE"
|
||
pass "stale design_rev refused"
|
||
|
||
# 6. Restore the snapshot taken before step 1: the preset is gone again.
|
||
DRY=$(ability lit/divi-design-restore "$(jq -cn --arg s "$SNAPSHOT" '{snapshot_id: $s}')")
|
||
[ "$(error_code "$DRY")" = "confirm_required" ] || fail "restore dry run: $DRY"
|
||
REV=$(echo "$DRY" | jq -r '.__error | fromjson | .design_rev')
|
||
RESTORED=$(ability lit/divi-design-restore "$(jq -cn --arg s "$SNAPSHOT" --arg r "$REV" '{snapshot_id: $s, confirm: true, design_rev: $r}')")
|
||
[ "$(echo "$RESTORED" | jq -r '.ok')" = "true" ] || fail "restore: $RESTORED"
|
||
wp eval "\$d = ET\Builder\Packages\GlobalData\GlobalPreset::get_data(); exit(isset(\$d['module']['divi/button']['items']['$ID']) ? 1 : 0);" \
|
||
|| fail "restored inventory still has $ID"
|
||
pass "snapshot restored"
|
||
|
||
finish
|
||
```
|
||
|
||
Die Helfer `cleanup_app_passwords_for`, `guard_exit`, `pass`, `fail`, `finish` stammen aus `lib.sh`; der Trap folgt dem Muster aus `divi-library-smoke.sh` (`guard_exit` macht jedes Ende ohne `finish` zum Fehler). Der Preset-Bestand wird direkt in Divis Option zurückgeschrieben – unabhängig davon, ob das Plugin noch funktioniert.
|
||
|
||
- [ ] **Step 3: Smoke laufen lassen**
|
||
|
||
Run: `cd /home/janniclas/Projekte/WordPress && timeout 900 ddev exec bash wp-content/plugins/WP-LIT-MCP/tests/Integration/divi-presets-smoke.sh`
|
||
Expected: sechs `ok - …`-Zeilen und `ALL CHECKS PASSED`. Danach prüfen, dass der Preset-Bestand wieder dem Stand vor dem Lauf entspricht:
|
||
`ddev wp eval 'echo count(ET\Builder\Packages\GlobalData\GlobalPreset::get_data()["module"]["divi/button"]["items"] ?? []);'` (gleiche Zahl wie vor dem Lauf).
|
||
|
||
Scheitert Schritt 3 (Preset-Klasse fehlt), mit `ddev wp eval` die gerenderte Ausgabe ansehen und mit einer im Builder angelegten Fixture-Seite vergleichen (`[Fixture] Designsystem`, Seite 3182) – nicht den Test lockern.
|
||
|
||
- [ ] **Step 4: Entscheidungsnotiz nachführen**
|
||
|
||
In `docs/superpowers/notes/2026-09-28-etappe-4-entscheidungen-entwurf.md` am Ende ergänzen:
|
||
|
||
```markdown
|
||
## Umsetzung 4a (Plan 2026-10-16-etappe-4a-presets.md)
|
||
- Pipeline `DesignChange` (alle Bereiche), Snapshots `SnapshotStore`, Bereich `presets`.
|
||
- Tools: lit/divi-preset-get, lit/divi-presets-set, lit/divi-presets-delete, lit/divi-design-snapshots, lit/divi-design-restore (alle indirekt).
|
||
- Schreiben über die Schrittfolge von `GlobalPresetController::sync` (Mirror `preset-sync`).
|
||
- Offen für 4b: Fundstellen von Standard-Gruppen-Presets (Gruppenliste je Modul), lit/divi-design-detach.
|
||
```
|
||
|
||
- [ ] **Step 5: Gesamtlauf, Lint, Commit**
|
||
|
||
Run: `composer test && composer lint`
|
||
|
||
```bash
|
||
git add docs/guides/divi-design-system.md tests/Integration/divi-presets-smoke.sh docs/superpowers/notes/2026-09-28-etappe-4-entscheidungen-entwurf.md
|
||
git commit -m "test: Ende-zu-Ende-Test der Presets gegen Divi; Guide und Entscheidungsnotiz zu 4a" -m "Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>"
|
||
```
|
||
|
||
---
|
||
|
||
## Abschluss von 4a
|
||
|
||
- [ ] `composer test` und `composer lint` grün; alle bisherigen Smokes (`divi-write-smoke.sh`, `divi-library-smoke.sh`, `tb-smoke.sh`, `divi-release-smoke.sh`) grün.
|
||
- [ ] Review nach `superpowers:requesting-code-review` mit dem Review Focus oben; Clean-Code-Review (`anthropic-skills:clean-code-review`) über die neuen Klassen in `Divi/Design/`.
|
||
- [ ] Danach Plan 4b schreiben (Zuweisen an Seiten, Massenzuweisung, detach).
|