NCA Social Media
Erstellt:
Aktualisiert:
Autor:
Roland Golla
Grumphp

GrumPHP

GrumPHP ist ein Composer Plugin, das PHP Code vor jedem Commit automatisch prüft. Es hängt sich in die Git Hooks ein und blockiert den Commit, sobald Coding Standards, statische Analyse oder Tests fehlschlagen.

Der Effekt ist simpel und trotzdem groß. Fehlerhafter Code kommt gar nicht erst ins Repository. Das Review dreht sich um Fachlichkeit statt um Formatierung. Und niemand muss mehr im Team der Mensch sein, der ständig Standards einfordert. Das macht die Maschine.

Aktuell ist Version 2.23.0 vom 22. Juli 2026. Das Projekt kommt von der belgischen Agentur Phpro, gepflegt wird es von Toon Verwerft. Über 16 Millionen Composer Installationen und mehr als 4.000 Sterne auf GitHub zeigen, wie verbreitet das Tool im PHP Ökosystem ist.

Inhalt

GrumPHP mit NCA: Schnelle Hilfe vom Experten

Roland Golla ist der Gründer von Never Code Alone in Duisburg. Sein Thema: Die KI schreibt den Code, er sorgt für die Qualität. Seit 2013 dreht sich bei ihm alles um Softwarequalität und automatisierte Tests. GrumPHP gehört dabei zum Alltag, weil der Git Hook der günstigste Ort für Qualität ist. Wer dort prüft, diskutiert im Review über Architektur statt über Leerzeichen.

Wir richten GrumPHP so ein, dass es im Team akzeptiert wird und nicht umgangen wird. Dazu gehört das PHP Consulting für die Toolchain, gezieltes PHP Refactoring für gewachsene Codebasen und das PHP Update auf aktuelle Versionen. Für Teams mit KI Agents verbinden wir Hooks und Guardrails im Vibe Coding Consulting. Alle Werkzeuge rund um Qualität stehen im NCA PHP Glossar.

GrumPHP im Team einführen ohne Reibung

Finde das passende Angebot für dein Projekt

Anfrage-Konfiguration

Starten Sie Ihre Anfrage

Projektart
Infos
Nachricht

Eliminierung technischer Schulden mit PHPStan, Rector PHP und PHPUnit. Über 20 Jahre Praxiserfahrung in skalierbaren Backends.

CORE EXPERTISE

Gesetzliche Konformität & Inklusion. Optimierung von Performance und Conversion durch radikal nutzerzentriertes, universelles Design.

BFSG COMPLIANT

Skalierbare KI-Systeme mit echtem Code Ownership. CI/CD, Backup-Strategien und Infrastruktur, die mit deinem Team wächst.

ENTERPRISE READY

GrumPHP 2026: Das ist neu

Die aktuelle Version ist 2.23.0 vom 22. Juli 2026. GrumPHP läuft auf PHP 8.2 bis 8.5 und unterstützt Symfony 6.4, 7 und 8. Über 16 Millionen Installationen über Composer machen das Tool zum Standard für Pre Commit Checks in PHP Projekten.

Das sind die wichtigsten Änderungen der letzten Releases:

  • Mago Support (2.22.0): Die Rust Toolchain Mago kommt als vier eigene Tasks. Formatter, Linter, Analyzer und Architektur Guard lassen sich einzeln schalten.
  • Symfony 8 Support (2.18.0): GrumPHP läuft in Projekten auf dem Symfony Framework in der aktuellen Major Version.
  • PHP 8.5 Support (2.17.0): Passend zu den neuen PHP 8 Versionen.
  • composer_validate_autoload (2.16.0): Ein neuer Task prüft die Autoload Konfiguration, ergänzend zum Composer Dependency Analyser.
  • Umgebungsvariablen in Tasks (2.14.0): Task Konfigurationen lösen jetzt Environment Variablen auf. Gut für unterschiedliche Setups auf Laptop und Server.

Wichtig beim Update: Seit Version 2.19.0 braucht die Git Anbindung rohe Diffs. Nach dem Upgrade müssen die Hooks einmal neu geschrieben werden, sonst laufen die Checks ins Leere.

Code: 
          
composer update phpro/grumphp
vendor/bin/grumphp git:init

Wer einen eigenen Hook pflegt, ergänzt im Diff Aufruf die Option --raw. Ohne diese Option bekommt GrumPHP keine Dateiliste mehr und meldet nichts.

Mago in GrumPHP: Vier Tasks aus einer Rust Binary

Mago ist eine PHP Toolchain in Rust. Der Name bedeutet Zauberer und das passt, denn ein einziges Binary macht die Arbeit von vier Werkzeugen: Formatter, Linter, statischer Analyzer und Architektur Wächter. GrumPHP bindet Mago nicht als einen großen Task ein, sondern als vier getrennte. Jedes Team schaltet nur das an, was es braucht.

  • mago_format hält den Code Style einheitlich, vergleichbar mit dem PHP Coding Standards Fixer.
  • mago_lint findet Style Ausrutscher, Smells und wahrscheinliche Bugs, ähnlich dem PHP Mess Detector.
  • mago_analyze geht tiefer und prüft Typen, Control Flow und Logikfehler wie PHPStan oder Psalm.
  • mago_guard setzt Architektur und Layer Regeln durch, im Geist von Deptrac und phpat.

Format, Lint und Analyze laufen standardmäßig nur lesend. Schlägt ein Task fehl, bietet GrumPHP an, ihn mit Fixes erneut auszuführen. Die Entscheidung bleibt beim Entwickler. Guard meldet ausschließlich, denn ein Architekturproblem lässt sich nicht automatisch reparieren.

Installation und Grundkonfiguration:

Code: 
          
composer require --dev carthage-software/mago
vendor/bin/mago init

Danach werden die gewünschten Tasks in der grumphp.yml aktiviert:

Code: 
          
grumphp:
  tasks:
    mago_format: ~
    mago_lint: ~
    mago_analyze: ~
    mago_guard: ~

Der Geschwindigkeitsvorteil ist der eigentliche Punkt. Ein Rust Binary startet ohne PHP Bootstrap. Genau das entscheidet darüber, ob ein Hook im Team akzeptiert oder mit no verify umgangen wird.

Installation und Einrichtung

GrumPHP wird als Dev Dependency installiert. Der Rest ist ein Kommando.

Code: 
          
composer require --dev phpro/grumphp

Seit Composer 2.2 müssen Plugins freigegeben werden. Composer fragt beim Installieren nach. Wer im CI ohne Rückfrage arbeitet, setzt die Freigabe direkt:

Code: 
          
composer config allow-plugins.phpro/grumphp true

Danach entsteht die Konfigurationsdatei grumphp.yml im Projektstamm. Die Git Hooks werden mit einem Befehl geschrieben:

Code: 
          
vendor/bin/grumphp git:init

Ab jetzt läuft GrumPHP bei jedem Commit. Zum Testen ohne Commit reicht ein manueller Lauf:

Code: 
          
vendor/bin/grumphp run

Typische Stolpersteine: Nach einem Update von GrumPHP müssen die Hooks neu geschrieben werden, sonst laufen alte Hooks mit falschen Diff Optionen. In Container Setups wie DDEV muss der Hook den Befehl im Container ausführen, nicht auf dem Host. Und alle konfigurierten Tools müssen wirklich installiert sein, sonst bricht der Hook mit einer Meldung ab, die nach einem Bug aussieht.

Konfiguration und Anpassung

Die grumphp.yml entscheidet über Erfolg oder Frust. Ein Hook, der 90 Sekunden braucht, wird umgangen. Ein Hook, der in fünf Sekunden durch ist, wird akzeptiert. Also gehört in den Hook nur, was schnell ist.

Code: 
          
grumphp:
  process_timeout: 120
  stop_on_failure: false
  parallel:
    enabled: true
    max_workers: 8
  tasks:
    composer: ~
    composer_validate_autoload: ~
    phpcsfixer:
      config: .php-cs-fixer.php
    phpstan:
      configuration: phpstan.neon
    mago_lint: ~
    phpunit:
      testsuite: unit

Seit Version 2 läuft die parallele Ausführung über Fibers. Mehrere Tasks arbeiten gleichzeitig, die Wartezeit sinkt spürbar. stop_on_failure: false sorgt dafür, dass alle Tasks durchlaufen. Entwickler sehen alle Probleme auf einmal statt eines nach dem anderen.

Sinnvolle Bausteine für den Task Katalog sind PHP CodeSniffer für PSR 12, der PHP Coding Standards Fixer oder Easy Coding Standard für die Formatierung, PHPStan für die statische Analyse und der Magic Number Detector gegen fest verdrahtete Zahlen.

Task Konfigurationen lösen seit Version 2.14.0 Umgebungsvariablen auf. Damit lässt sich derselbe Task lokal anders parametrisieren als im CI, ohne zwei Konfigurationsdateien zu pflegen.

Täglicher Workflow: Was beim Commit passiert

Der Ablauf ist immer gleich. Entwickler committen, GrumPHP startet, die konfigurierten Tasks laufen. Ist alles grün, wandert der Commit ins Repository. Schlägt ein Task fehl, bricht der Commit ab und die Meldung steht im Terminal. Der grimmige ASCII Kopf mit dem Wort NOPE ist inzwischen ein kleines Markenzeichen des Tools.

Fehler beheben, Dateien erneut stagen, erneut committen. Wer vorher prüfen will, ob der Commit durchgeht, ruft den Lauf manuell auf:

Code: 
          
vendor/bin/grumphp run

Es gibt eine Notbremse. git commit --no-verify überspringt alle Hooks. Das ist manchmal nötig, etwa bei einem Hotfix um drei Uhr nachts. Wird es zur Gewohnheit, ist nicht das Team das Problem, sondern die Konfiguration. Dann gehören langsame Tasks in die Pipeline und nicht in den Hook.

Für Legacy Projekte gilt: schrittweise einführen. Erst Formatierung, dann ein niedriges Analyse Level, dann höher. Wer sofort auf die härteste Stufe geht, bekommt tausende Meldungen und ein Team, das den Hook am ersten Tag deaktiviert. Beim Aufräumen der Historie hilft Git Interactive Rebase, um Fix Commits sauber zusammenzufassen.

GrumPHP in CI und CD Pipelines

Ein Hook lässt sich lokal umgehen. Die Pipeline nicht. Deshalb läuft GrumPHP bei uns an beiden Stellen: schnell beim Commit und vollständig im Merge Request.

GitLab CI:

Code: 
          
grumphp_analysis:
  stage: test
  script:
    - composer install --no-interaction
    - vendor/bin/grumphp run
  only:
    - merge_requests

GitHub Actions:

Code: 
          
name: Quality
on: [pull_request]
jobs:
  grumphp:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v7
      - uses: shivammathur/setup-php@v2
        with:
          php-version: '8.4'
      - run: composer install --no-interaction
      - run: vendor/bin/grumphp run

In der Pipeline dürfen die schweren Läufe stattfinden. Vollständige Testsuiten mit PHPUnit, parallelisiert über Paratest, dazu Patch Coverage für die tatsächlich geänderten Zeilen und Composer Audit für bekannte Sicherheitslücken.

GrumPHP erkennt die CI Umgebung selbst und passt die Ausgabe an. Für das Setup solcher Pipelines beraten wir Teams im PHP Consulting und richten die Stufen so ein, dass Feedback früh kommt und trotzdem nichts durchrutscht.

GrumPHP Tasks 2026 im Überblick

Task Prüft Auto Fix
mago_format, mago_lint Formatierung, Smells und wahrscheinliche Bugs Ja, GrumPHP fragt nach dem Rerun mit Fix
mago_analyze, phpstan Typen, Control Flow und Logikfehler Teilweise, Analyse meldet nur
mago_guard, deptrac Architektur und Layer Regeln Nein, Architektur bleibt Handarbeit
phpunit, composer_validate_autoload Tests und Autoload Konsistenz Nein, nur Report

The grump approves. Welcome to the family, Mago.

Toon Verwerft, Maintainer GrumPHP bei Phpro – GrumPHP Release Notes v2.22.0

Unsere Erfahrung mit GrumPHP in PHP Projekten

GrumPHP ist bei uns kein Selbstzweck. Der Hook ist der Ort, an dem Qualität billig ist. Ein Fehler, den PHPStan vor dem Commit findet, kostet Sekunden. Derselbe Fehler im Review kostet zwei Menschen eine halbe Stunde. Im Produktivsystem kostet er einen Abend.

Wir bauen Setups, die schnell bleiben. Formatierung über Easy Coding Standard oder den PHP Coding Standards Fixer läuft im Hook. Schwere Läufe wie PHPUnit mit Paratest wandern in die Pipeline. Architekturregeln prüfen wir mit Deptrac oder PHP Arkitect.

In Legacy Projekten ist die Reihenfolge entscheidend. Erst Rector PHP für die grobe Modernisierung, dann GrumPHP als Wächter, damit der alte Zustand nicht zurückkommt. Composer Audit hält Sicherheitslücken aus dem Repository. Lokal läuft alles reproduzierbar in DDEV.

Mit KI generiertem Code wird der Hook noch wichtiger. Ein Agent schreibt in Minuten mehr Code, als ein Team am Tag reviewen kann. GrumPHP ist dann die Leitplanke, die maschinellen Output auf denselben Standard zwingt wie handgeschriebenen. Genau darum geht es in unserem Vibe Coding Consulting und in den Vibe Coding Best Practices.

CYPRESS.IO Ambassador und IT Consultant für QA Engenieering und Qualität in PHP Projekten.

Erreichen Sie unsere PHP Consultant Spezialisten

Wir sind Experten für PHP und helfen Ihnen, Ihre digitalen Herausforderungen zu meistern. Unser erfahrenes Team unterstützt Sie bei PHP Updates, PHP Refactoring und berät Sie remote zu allen Fragen rund um PHP. Mit unseren vollautomatischen CI/CD Deployments und einer robusten Docker-Infrastruktur bringen wir Ihre PHP-Projekte auf das nächste Level. Vertrauen Sie auf unsere Expertise für zuverlässige und skalierbare PHP-Lösungen.

Demo Team Workshop Anrufen

Häufige Fragen zu GrumPHP

Die Fragen, die uns zu GrumPHP am häufigsten begegnen. Von der ersten Installation über die Performance in großen Projekten bis zum Zusammenspiel mit KI generiertem Code.

Was ist GrumPHP 2026?

GrumPHP ist ein Composer Plugin, das PHP Code vor jedem Commit prüft. Es klinkt sich in die Git Hooks ein und startet die konfigurierten Tasks automatisch. Schlägt einer fehl, bricht der Commit ab. Aktuell ist Version 2.23.0 vom Juli 2026. Entwickelt wird das Tool von der belgischen Agentur Phpro.

Welche PHP Versionen unterstützt GrumPHP 2026?

GrumPHP 2.23 läuft auf PHP 8.2, 8.3, 8.4 und 8.5. Ältere PHP Versionen bräuchten die 1.x Linie, die offiziell als nicht mehr unterstützt markiert ist. Auf Framework Seite werden Symfony 6.4, 7 und 8 abgedeckt. Wer noch auf PHP 8.1 oder darunter steht, geht sinnvollerweise zuerst das PHP Update an.

Was ist neu in GrumPHP 2026?

Das größte Feature ist die Anbindung von Mago, einer PHP Toolchain in Rust. Sie kommt als vier eigene Tasks für Formatierung, Linting, Analyse und Architektur. Dazu kamen Symfony 8 Support, PHP 8.5 Support und der Task composer_validate_autoload. Seit Version 2.19.0 müssen die Git Hooks nach einem Update einmal neu geschrieben werden.

Lohnt sich GrumPHP 2026 neben einer CI Pipeline?

Ja, denn beide haben unterschiedliche Aufgaben. Der Hook gibt Feedback in Sekunden, direkt am Arbeitsplatz. Die Pipeline ist die verbindliche Kontrolle, die niemand umgehen kann. Ohne Hook wandern Formatierungsfehler in Merge Requests und blockieren Reviews. Ohne Pipeline reicht ein einzelnes no verify, um die ganze Absicherung auszuhebeln.

Wie schnell muss ein GrumPHP Hook 2026 sein?

Als Faustregel unter zehn Sekunden. Alles darüber wird im Alltag umgangen. Formatierung und schnelle Linter gehören in den Hook, vollständige Testsuiten in die Pipeline. Die parallele Ausführung über Fibers und die Option max_workers helfen zusätzlich. Rust basierte Tools wie Mago starten ohne PHP Bootstrap und sind spürbar schneller.

Wie installiere ich GrumPHP?

Mit composer require --dev phpro/grumphp. Composer fragt anschließend nach der Freigabe des Plugins, alternativ setzt man sie über composer config allow-plugins. Danach schreibt vendor/bin/grumphp git:init die Hooks in das Repository. Die Konfiguration liegt in der Datei grumphp.yml im Projektstamm.

Wie konfiguriere ich die Tasks in der grumphp.yml?

Unter dem Schlüssel tasks werden die gewünschten Prüfungen aufgelistet, jeweils mit eigenen Optionen. Ein Task ohne Optionen bekommt eine Tilde. Zusätzlich lassen sich process_timeout, stop_on_failure und die parallele Ausführung steuern. Seit Version 2.14.0 löst GrumPHP Umgebungsvariablen in den Task Optionen auf.

Was ist Mago und warum steckt es in GrumPHP?

Mago ist eine PHP Toolchain in Rust, die Formatter, Linter, statischen Analyzer und Architektur Guard in einer Binary bündelt. GrumPHP bindet sie seit Version 2.22.0 als vier getrennte Tasks ein. Format, Lint und Analyze laufen lesend, bei Fehlern bietet GrumPHP einen erneuten Lauf mit Fixes an. Guard meldet ausschließlich.

Wie umgehe ich GrumPHP im Notfall?

Mit git commit --no-verify werden alle Hooks übersprungen. Für einen dringenden Hotfix ist das legitim. Wird es zur Gewohnheit, stimmt die Konfiguration nicht. Dann sind entweder die Regeln unrealistisch oder der Hook ist zu langsam. Beides lässt sich beheben, indem schwere Tasks in die Pipeline wandern.

Warum meldet GrumPHP nach einem Update nichts mehr?

Sehr wahrscheinlich liegt es an den alten Git Hooks. Seit Version 2.19.0 braucht die Git Anbindung rohe Diffs, der Hook muss die Option --raw übergeben. Ein einmaliges vendor/bin/grumphp git:init schreibt die Hooks neu. Bei selbst gepflegten Hooks wird die Option von Hand im Diff Aufruf ergänzt.

Wie führe ich GrumPHP in einem Legacy Projekt ein?

Schrittweise. Zuerst nur Formatierung, damit das Team einen schnellen Erfolg sieht. Dann statische Analyse auf niedrigem Level, das später angehoben wird. Grobe Modernisierungen erledigt vorher Rector, danach hält GrumPHP den erreichten Stand. Wer sofort die härteste Stufe aktiviert, produziert tausende Meldungen und ein Setup, das nach einem Tag deaktiviert wird.

Hilft GrumPHP bei KI generiertem Code?

Ja, sogar besonders. KI Agents schreiben in Minuten mehr Code, als ein Team am Tag reviewen kann. Der Hook prüft maschinellen Output nach denselben Regeln wie handgeschriebenen und meldet Abweichungen sofort. Damit wird GrumPHP zur Leitplanke, die verhindert, dass generierter Code ungeprüft in das Repository wandert.

Bildergallerie GrumPHP

Willkommen in unserer GrumPHP-Bildergalerie! Hier zeigen wir visuelle Einblicke in die Welt von GrumPHP, dem praktischen PHP-Tool, das Entwicklern hilft, ihren Code sauber und konsistent zu halten. GrumPHP ist wie ein treuer Wächter, der sicherstellt, dass jeder Commit und jeder Push den festgelegten Qualitätsstandards entspricht – sei es durch Code-Sniffs, statische Analysen oder automatische Tests.

Eine Cartoon-Grafik des GrumPHP-Maskottchens: Ein grimmig dreinblickendes Gesicht mit dunklem Bart und Haaren, das eine grüne Mütze mit der Aufschrift 'GrumPHP' trägt.

Terminalausgabe von GrumPHP mit einer Fehlermeldung. Der Fehler tritt bei der Codeprüfung mit phpcs auf. Es wird angegeben, dass die öffnende geschweifte Klammer einer Klasse in Zeile 7 nicht korrekt positioniert ist. Die Ausgabe zeigt eine rote ASCII-Grafik eines grimmigen Gesichts mit Bart und Hut sowie das Wort 'NOPE' in großen Buchstaben darunter, was signalisiert, dass die Prüfung nicht bestanden wurde.

Weitere Werkzeuge aus dem NCA PHP Glossar

GrumPHP ist der Türsteher. Die eigentliche Arbeit machen die Tasks dahinter. Passend dazu findest du im Glossar unter anderem PHP Parallel Lint für schnelle Syntaxprüfungen, Type Coverage für die Typabdeckung, Infection für Mutation Testing und PHP Insights für den schnellen Überblick über eine fremde Codebasis.