Table of contents
GrumPHP
GrumPHP is an essential quality assurance tool for PHP projects, designed to prevent code issues before they reach the repository. It performs automated pre-commit checks to ensure that no erroneous or poorly formatted code changes are committed. This is particularly important to ensure code quality, consistency and stability. Our agency has successfully used GrumPHP in many projects and integrated it into GitLab CI/CD pipelines to ensure automated and consistent code checks.
Installation and setup
GrumPHP is easy to install and can be integrated into any PHP project. Follow these steps:
1. install GrumPHP via Composer:
composer require --dev phpro/grumphp
2. create the configuration file grumphp.yml in the root directory of your project.
3. install GrumPHP in Git Hooks:
vendor/bin/grumphp git:init
GrumPHP is now automatically executed before each commit and ensures that all tests and rules are adhered to.
Possible stumbling blocks:
- Make sure that all dependencies are installed correctly and that the configuration files are set up correctly.
Configuration and customisation
GrumPHP can be flexibly customised to meet the requirements of your project. You can set up a variety of tasks that are checked before each commit, e.g. code styling, static code analysis, unit tests and much more.
An example of a grumphp.yml file:
parameters:
git_dir: .
bin_dir: ./vendor/bin
tasks:
phpcsfixer:
config: .php-cs-fixer.php
phpstan:
level: 7
phpmnd:
ignore_strings: true
phpcs:
standard: PSR12
Best practices:
- Integrate tasks like PHP_CodeSniffer, PHPStan and PHP-CS-Fixerto ensure that the code meets the best standards.
- Configure custom tasks tailored to your project requirements.
Advantages:
- A high degree of flexibility in the configuration of pre-commit checks.
- Improve code quality and avoid erroneous commits.
Use of GrumPHP
GrumPHP is executed with every commit and checks the defined tasks. If one of the tasks fails, the commit is blocked until the error is rectified.
Typical use cases:
- Ensuring code quality: GrumPHP ensures that no poorly formatted or incorrect code changes make it into the repository.
- Refactoring legacy code: By integrating static analysis tools and formatting tools, you can incrementally improve outdated code.
Example of manual execution of GrumPHP:
vendor/bin/grumphp run
Integration in CI/CD-Pipelines
Our agency successfully integrates GrumPHP into GitLab CI/CD pipelines to ensure that code quality is checked not only during the commit, but also throughout the entire pipeline.
Example of a GitLab CI configuration:
grumphp_analysis:
stage: test
script:
- vendor/bin/grumphp run
only:
- merge_requests
Advantages of integration:
- Prevention of problems in the code base before each merge.
- Automated code analyses that improve the overall quality of the project.
Frequently asked questions (FAQ)
What is GrumPHP?
GrumPHP is a PHP tool that uses pre-commit hooks to ensure that no erroneous or badly formatted commits get into the repository.
Why is GrumPHP important for PHP projects?
It helps to improve code quality by performing automatic checks before each commit and preventing developers from committing faulty code.
What tasks can GrumPHP perform?
GrumPHP can perform a variety of tasks, including code formatting, static code analysis, unit tests and much more.
How do I configure GrumPHP for my project?
The configuration is carried out via the grumphp.yml file, in which you define the tasks to be checked.
Can I integrate GrumPHP into my CI/CD pipeline?
Yes, GrumPHP can be easily integrated into GitLab CI/CD pipelines to ensure continuous code quality checks.
How can GrumPHP help to improve legacy code?
By integrating tools such as PHPStan or PHPMD, you can gradually identify and refactor outdated and error-prone code.
Which PHP versions does GrumPHP support?
GrumPHP supports all current PHP versions that are compatible with Composer.
What to do if GrumPHP reports many errors?
Check the reported errors, fix the problems and recommit the code. You can also adjust the configuration to avoid unnecessary checks.
How do I improve the performance of GrumPHP in large projects?
Restrict the checks to specific directories or files and only perform time-consuming checks when necessary.
Are there alternatives to GrumPHP?
Other tools such as Husky or Git Hooks offer similar functionalities, but GrumPHP is specifically tailored to PHP projects.
Conclusion
GrumPHP is a powerful tool for ensuring code quality in PHP projects. With automated pre-commit checks and integration into CI/CD pipelines, it helps to prevent incorrect commits and improve the quality of the code base. Our agency has extensive experience with the implementation of GrumPHP and supports you in optimising your development processes. Contact us if you need support with setup or customisation.
Reach our specialists for accessible web design
We are here to help you. Together we can master your digital challenges and promote inclusion on the Internet. Let us make your projects successful with accessible web design.
Picture gallery GrumPHP
Welcome to our GrumPHP image gallery! Here we show visual insights into the world of GrumPHP, the handy PHP tool that helps developers keep their code clean and consistent. GrumPHP is like a faithful guardian, ensuring that every commit and every push meets the defined quality standards - be it through code sniffs, static analyses or automatic 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.
