9.2. Wat betekent een "hook" in Drupal?

Dit artikel is bedoeld om je vertrouwd te maken met Drupal; we zullen later codevoorbeelden schrijven, nadat we onze eigen aangepaste module hebben toegevoegd.

Drupal is geen monolithisch systeem waarin alles perfect is en niets hoeft te worden veranderd. Heel vaak vragen klanten om deze of gene functionaliteit aan de site toe te voegen. Om de Drupal core code te kunnen onderhouden en functionaliteit toe te voegen aan Drupal, gebruiken we modules. Het modulaire systeem maakt het mogelijk om de mogelijkheden van Drupal uit te breiden. Maar wat als we de mogelijkheden van een kant-en-klare module willen uitbreiden? Natuurlijk kunnen we een verzoek indienen om de gewenste functionaliteit te verbeteren door een issue aan te maken op drupal.org, en mogelijk krijgen we binnen een maand, twee... een jaar of twee, de functionaliteit die we nodig hebben in een bepaalde module. Maar we kunnen ook anders handelen en zelf de code schrijven die we nodig hebben. Om de mogelijkheden van aanvullende modules van Drupal, evenals van Drupal zelf, uit te breiden, zullen we hooks en plugins gebruiken in onze eigen modules.

Het belangrijkste idee is dat we de Drupal code, of de code van aanvullende modules, niet hoeven te onderhouden, en daarmee besparen we veel op de kosten van programmeerwerk. Om eenvoudig de code van modules en Drupal te kunnen updaten, mag je geen wijzigingen aanbrengen in de core van Drupal of in de modules van derden. Anders worden al je wijzigingen overschreven de volgende keer dat de module of de Drupal core wordt bijgewerkt.

Voor de onderlinge verbinding van modules met de Drupal core, evenals tussen modules onderling, heeft Drupal een hook-systeem. Een hook is een callbackfunctie, dat wil zeggen dat wanneer de uitvoering van de code bij de hook komt, de code van onze functie wordt toegevoegd die we in onze module schrijven. Op deze manier kunnen we gebruikersgegevens, menu’s, taxonomieën, nodes van verschillende inhoudstypes op elk moment verwerken — of het nu gaat om wijzigen, toevoegen, verwijderen of gewoon laden en weergeven. Er zijn behoorlijk veel hooks in Drupal 8, maar minder dan in Drupal 7; veel hooks zijn namelijk geïmplementeerd via externe Symfony-componenten:

https://api.drupal.org/api/drupal/core%21core.api.php/group/hooks/8.2.x

Als je naar versie 7 kijkt, moet je een hele tijd scrollen:

https://api.drupal.org/api/drupal/includes%21module.inc/group/hooks/7.x

Maar dit betekent niet dat Drupal 8 minder krachtig is geworden; alles wat in Drupal 7 via hooks wordt gedaan, moet in Drupal 8 worden gerealiseerd door een geschikte plugin toe te voegen.

Als je goed kijkt naar de lijst met hooks in Drupal 8, zie je aan het einde van hun naam _alter staan. Dit betekent dat deze hook bedoeld is om de waarden van variabelen te wijzigen, bijvoorbeeld:

hook_form_alter() – hiermee kun je het array van het formulier wijzigen tijdens de verwerking in Drupal. Later zullen we analyseren hoe formulieren in Drupal worden gegenereerd uit arrays. Om deze hook in een module toe te passen, schrijven we eenvoudig een functie, zoals bij andere hooks:

function mymodule_form_alter() {
  // wijzig de formulier-array
}

Ik heb het voorbeeld vereenvoudigd — ik heb geen argumenten of namespaces in de functie geschreven — voor nu moeten we gewoon begrijpen hoe hooks werken. mymodule is onze module; in plaats van het woord hook schrijven we de naam van onze module, en de functie wordt automatisch herkend en past wijzigingen toe op de formulierarrays. Hoe werkt dit? In de prepareForm-methode wordt een andere methode aangeroepen: alter():

$this->moduleHandler->alter($hooks, $form, $form_state, $form_id);

Dit betekent dat elke module in Drupal die hook_form_alter() implementeert, zijn eigen code op deze plaats invoegt. Dus, als we code aan een bepaalde plek in Drupal willen toevoegen, moeten we eerst proberen dit via een hook te doen, dan via een plugin, en alleen als het echt niet anders kan, zullen we de module moeten aanpassen of patchen (helaas komt dit soms voor). Voor nu hebben we geen taken waarbij we plug-ins hoeven aan te passen, dus laten we leren hoe we onze eigen modules kunnen schrijven.