phpro/grumphp
66.7
Adequate · 17 November 2026
13.4k
lines of production code
PHP
primary language
5
measurements over time
What this system is
GrumPHP is a PHP-based command-line tool that integrates static analysis, linting, and code style checks into the Git workflow via pre-commit and commit-msg hooks. It executes a configurable suite of tasks—such as PHP parsing, JSON/XML/YAML validation, and external tool integration—using a middleware-based runner that supports parallel execution and automatic code fixing. The system manages task configuration, environment variables, and result reporting, providing structured feedback to developers and CI environments.
How it got here
2015–2017 — v2 architecture modernization
43 changes.
This period focused on a comprehensive architectural overhaul to support PHP 8.2+ and Symfony 6.4+, introducing a dependency injection container, strict typing, and a middleware-based task runner. The project expanded its capabilities with new linters, a robust configuration system, and extensive PhpSpec test coverage to ensure stability during the major version transition.
2019–2020 — Async runner and configuration restructuring
29 changes.
This period focused on refactoring the task runner to support asynchronous, parallel execution via Amp v3 and a middleware-based architecture, introducing features like stop-on-failure and auto-fix. Concurrently, the project overhauled its configuration system by introducing structured model classes and resolvers, while significantly expanding test coverage across the new components and existing utilities.
2022–2023 — Configuration loader and test infrastructure
4 changes.
This period focused on enhancing the configuration system by adding support for .dist files and expanding unit test coverage for configuration handling and IO factory logic. Developers also introduced helper traits to streamline mocking context and task objects, improving the robustness of the test suite.
Features
Add POSIX-compatible local git hooks for commit-msg and pre-commit
New shell scripts for the local git hooks (commit-msg and pre-commit) have been added to the resources/hooks/local directory. These hooks are written in POSIX sh to ensure compatibility across different environments and correctly capture the git diff using the --raw flag to handle special characters and whitespace safely. They pass the diff and git user information to GrumPHP, allowing the tool to run checks on staged changes and commit messages.
resources/hooks/local · high confidence
Add Symfony event dispatcher bridge
A new bridge class (SymfonyEventDispatcher) has been added to integrate with Symfony's event dispatcher, supporting both the legacy Symfony 4/5 interface and the newer Symfony Contracts interface. This allows the application to dispatch events using Symfony's infrastructure while maintaining compatibility across different Symfony versions.
src/Event/Dispatcher · high confidence
Added JSON linter with optional key conflict detection
Users can now lint JSON files using the Seld JsonLint parser. The new JsonLinter validates syntax and, when the detectKeyConflicts option is enabled, also flags duplicate keys. Lint errors are reported via the new JsonLintError class, which formats output as \[ERROR\] \<file\>: \<message\>.
src/Linter/Json · high confidence
Auto-fix capability for fixable tasks
The system now includes an auto-fix feature that allows users to automatically correct issues in tasks that support it. When enabled, the system will prompt the user to confirm whether they want to proceed with automatic fixes. If confirmed, it iterates through all fixable task results, applies the necessary corrections, and displays the status of each fix (success or failure) along with any errors in verbose mode. A warning is shown at the end to remind users to review the changes made.
src/Fixer · high confidence
Automatic git stash for unstaged changes and verbose logging
Two new event subscribers have been added to the event system. The StashUnstagedChangesSubscriber now automatically stashes unstaged and untracked files before running tasks in a pre-commit context and reapplies them afterwards, with an option to ignore these changes on errors via configuration. The VerboseLoggerSubscriber now logs detailed path information (config file, working dir, project dir, git dirs, bin dir, composer file) to stdout when the console output is set to verbose mode.
src/Event/Subscriber · high confidence
Initial project scaffolding and configuration
The repository is initialized with essential configuration files including a default GrumPHP configuration (grumphp.yml.dist), a Makefile for build automation, and standard documentation (README, CONTRIBUTING, LICENSE, SECURITY). It also introduces static analysis and testing tooling configurations (psalm.xml, phpunit.xml.dist, phpspec.yml) and enforces code style via .editorconfig.
(repo-wide) · high confidence
Introduce TaskConfigResolver for structured task configuration resolution
A new TaskConfigResolver class has been added to the GrumPHP configuration namespace to handle the resolution of task-specific configurations. This component maps task names to their respective configuration options and metadata, allowing the system to validate and resolve task settings against defined interfaces. Users benefit from a more robust configuration resolution process that ensures task configurations are correctly interpreted and validated before execution.
src/Configuration/Resolver · high confidence
Introduction of a new task system with dedicated task classes and base abstractions
The task execution model has been restructured to use a new set of base classes (AbstractExternalTask, AbstractLinterTask, AbstractParserTask) and a context system (GitPreCommitContext, RunContext, GitCommitMsgContext) to manage file filtering and execution environments. This change introduces a comprehensive suite of new task implementations for tools such as Ant, Atoum, Behat, Brunch, Codeception, Composer, Deptrac, Doctrine ORM, ESLint, Easy Coding Standard (ECS), and others, providing users with standardized, configurable integration for these external tools within the pre-commit and run workflows.
src/Task · high confidence
New Git tasks for blacklist, branch naming, and commit message validation
This change introduces three new Git task implementations: Blacklist, BranchName, and CommitMessage. The Blacklist task allows users to define keywords to forbid in files, with configurable whitelist patterns, ignore patterns, regex types (G, E, P), and word-matching options. The BranchName task enforces naming conventions on Git branches using configurable blacklist and whitelist regex patterns, with an option to allow detached HEAD states. The CommitMessage task validates commit messages against various rules, including subject capitalization, single-line enforcement, punctuation restrictions, width limits, and optional type/scope conventions (e.g., Conventional Commits), with support for skipping merge commits and custom matchers.
src/Task/Git · high confidence
New XML linter with configurable validation modes
Users can now lint XML files using a new XmlLinter that supports DTD and XML Schema validation, XInclude processing, and configurable network access for remote resources. The linter provides detailed error reporting including line and column numbers, and handles edge cases like remote DTD blocking by setting a specific user agent.
src/Linter/Xml · high confidence
New collection classes and test suite abstraction
This change introduces a set of new collection classes in src/Collection to manage specific domain objects with type-safe filtering and formatting: FilesCollection (filtering by name, path, extension, size, date), LintErrorsCollection and ParseErrorsCollection (string representation of errors), ProcessArgumentsCollection (safe CLI argument building with path escaping), TaskResultCollection (aggregating task outcomes), TasksCollection (filtering by context/test suite and grouping by priority), and TestSuiteCollection (retrieving test suites). It also adds the TestSuiteInterface and TestSuite implementation to define named groups of tasks. These components provide the structural foundation for task execution, result reporting, and argument handling within the application.
src/Collection · high confidence
New configure and run console commands with task filtering and stdin support
The \src/Console/Command\ directory now introduces two new Symfony-based console commands: \configure\ and \run\. The \configure\ command allows users to interactively create a \grumphp.yml\ configuration file, including selecting which tasks to enable, with options to force overwrite or run silently. The \run\ command executes the configured tasks, supporting a new \--tasks\ option to filter specific tasks by name (comma-separated) and a \--testsuite\ option to target specific test suites. Additionally, the \run\ command now supports reading file inputs from standard input (stdin), enabling integration with pipe-based workflows.
src/Console/Command · high confidence
New environment configuration and path management components
Added three new classes to handle environment setup: DotEnvRegistrar loads and populates environment variables from .env files and config arrays using Symfony's Dotenv; DotEnvSerializer provides a utility to export environment variables in shell-compatible format; and PathsRegistrar prepends specified directories to the system PATH variable to ensure local dependencies are detected first, mirroring Composer's behavior.
src/Configuration/Environment · high confidence
New process runners for STDIN and temporary file input
Added InputWritingProcessRunner and TmpFileUsingProcessRunner classes to src/Process, enabling processes to be executed with data written to STDIN or via temporary files respectively. These new runners complement the existing ProcessBuilder and ProcessFactory infrastructure for constructing and executing external commands.
src/Process · high confidence
Support for .dist configuration files
The configuration loader now supports loading settings from files with the .dist extension. A new DistFileLoader decorator has been introduced to handle these files, allowing users to provide default or example configuration files that can be loaded alongside standard configuration files.
src/Configuration/Loader · high confidence
Removals
Removal of empty Composer plugin stub
The empty \QualityCheckerPlugin\ class, which previously implemented Composer's \PluginInterface\ and \EventSubscriberInterface\ but contained no logic in its \activate\ and \getSubscribedEvents\ methods, has been removed from the codebase.
src/GrumPHP · high confidence
Behavioural changes
4 commits (1 fix) modifying tools
A change to existing behaviour in tools — 4 commits (1 fix), 8 files.
tools · medium confidence · unverified
Async-first task execution with middleware pipeline
Task execution in the runner has been refactored to be async-first, utilizing the Amp library to return Futures for non-blocking operation. The previous monolithic handler is replaced by a middleware pipeline (TaskHandler) that chains specific concerns: parallel processing via worker pools, error handling, event dispatching, result memoization, reporting, and stop-on-failure logic. This change enables tasks to run concurrently and improves resource management by swapping serialized contexts back to original objects to aid garbage collection.
src/Runner/TaskHandler · high confidence
Configurable success exit codes for fixer processes
Users can now specify which exit codes are considered successful when running fixer commands, rather than relying solely on exit code 0. The new \FixableProcessProvider\ and \FixableProcessResultProvider\ classes allow passing a \successExitCodes\ array to define acceptable outcomes, enabling fixers that return non-zero codes for success to be handled correctly.
src/Fixer/Provider · high confidence
Git hook commands rewritten for Symfony 5 and PHP 7.1+ compatibility
The git hook commands (git:commit-msg, git:pre-commit, git:init, git:deinit) have been refactored to use the Symfony Console \\#\[AsCommand\]\ attribute instead of legacy command declarations, and now require PHP 7.1+ and Symfony 5. This change updates the internal implementation to use modern dependency injection and strict typing, ensuring the hooks function correctly in newer environments while maintaining the same user-facing behavior for running and managing git hooks.
src/Console/Command/Git · high confidence
Improved Composer plugin integration and compatibility
The Composer plugin now includes a new DevelopmentIntegrator class that automatically copies the GrumPHP executable to the Composer bin directory and initializes git hooks during development, ensuring the tool is ready to sniff commits immediately after installation. The plugin's core logic has been refined to better detect GrumPHP package operations (install, update, uninstall) and schedule configuration and initialization tasks appropriately, preventing redundant executions. Additionally, the codebase addresses compatibility issues with older Composer versions by fixing internal Symfony Process version conflicts, ensuring the plugin functions correctly across different Composer environments.
src/Composer · high confidence
Introduce new ProcessFormatterInterface and dedicated formatters for Git, PHP CS Fixer, and PHPCS
The Formatter module now uses a new ProcessFormatterInterface to standardize how external tool outputs are displayed. This change introduces dedicated formatters: GitBlacklistFormatter (which adds color-coded highlighting for long lines), PhpCsFixerFormatter (which parses JSON output to show applied fixers and code diffs), and PhpcsFormatter (which parses JSON to extract fixable file suggestions). A RawProcessFormatter is also provided for unformatted output. This refactors the existing formatting logic to be more structured and feature-rich for these specific tools.
src/Formatter · high confidence
Introduce strict-typed event classes and new TASK\_SKIPPED event
The event system in src/Event has been refactored to use strict PHP types and extends Symfony's Event contract. New event classes (RunnerEvent, TaskEvent, RunnerFailedEvent, TaskFailedEvent) and corresponding event name constants (RunnerEvents, TaskEvents) are introduced to structure task and runner lifecycle notifications. Notably, a new TASK\_SKIPPED event constant is added to TaskEvents, enabling subscribers to react when a task is skipped.
src/Event · high confidence
Introduce structured IO layer with GitHub Actions grouping support
The IO subsystem has been refactored into a dedicated namespace with a new \IOInterface\ and factory pattern (\IOFactory\) that automatically selects the appropriate implementation based on the environment. A new \ConsoleIO\ class handles standard console output, input, and serialization for parallel execution, while a new \GitHubActionsIO\ class extends this to wrap output in GitHub Actions workflow commands (\::group::\ / \::endgroup::\) for better visibility in CI logs. The system also improves stdin handling by detecting piped input and reading it non-blockingly when appropriate.
src/IO · high confidence
Introduce structured configuration models for GrumPHP settings
The configuration system in src/Configuration/Model now uses dedicated model classes (AsciiConfig, EnvConfig, FixerConfig, GitStashConfig, HooksConfig, ParallelConfig, ProcessConfig, and RunnerConfig) to manage specific settings. This replaces the previous approach of injecting raw parameters, providing a more structured and type-safe way to access configuration values such as parallel worker limits, fixer options, and environment variables.
src/Configuration/Model · high confidence
Introduce structured task configuration and metadata models
The task system now uses a dedicated configuration layer in the \GrumPHP\\Task\\Config\ namespace, introducing \TaskConfig\, \EmptyTaskConfig\, and \Metadata\ classes to manage task settings. This change centralizes configurable options such as priority, blocking behavior, and enabled status within the \Metadata\ class, which leverages a new \ConfigOptionsResolver\ for validation. Users benefit from a more robust and structured way to define and resolve task configurations, ensuring that options are consistently handled and validated before being applied to tasks.
src/Task/Config · high confidence
Introduced strict typing and new Linter/Parser interfaces
The Linter and Parser components now enforce strict type checking via \declare(strict\_types=1)\ and utilize new, explicitly typed interfaces (\LinterInterface\, \ParserInterface\) along with dedicated error value objects (\LintError\, \ParseError\). This change standardizes how linting and parsing errors are represented and processed, ensuring that method signatures for \lint()\ and \parse()\ strictly return their respective error collections and that error details are encapsulated in strongly-typed classes rather than loose structures.
src/Linter, src/Parser · high confidence
Introduces a middleware-based runner architecture with priority grouping and stop-on-failure support
The task runner execution flow has been refactored into a chain of dedicated middleware components, replacing the previous monolithic implementation. This change introduces structured task execution where tasks are now grouped and executed by priority level, allowing for more predictable output ordering. It also adds support for a 'stop on failure' configuration, which halts the execution of subsequent tasks immediately when a blocking failure occurs, rather than continuing to run the entire suite. Additionally, the runner now leverages asynchronous task handling via Amp futures for parallel execution capabilities, and integrates event dispatching and reporting hooks at specific stages of the run lifecycle.
src/Runner/Middleware · high confidence
Introduction of a dedicated GrumPHP exception hierarchy
The \src/Exception\ directory now contains a structured set of exception classes (e.g., \ExecutableNotFoundException\, \FixerException\, \PlatformException\) that extend a new base \RuntimeException\ and implement \ExceptionInterface\. This change replaces generic error handling with specific, typed exceptions that provide clearer, context-aware error messages for users, such as identifying missing executables, file not found errors, or process command-line limits on Windows.
src/Exception · high confidence
Lazy-loaded Git repository wrapper with fail-safe config fetching
A new GitRepository wrapper class has been introduced to manage Git operations more robustly. It implements lazy loading for the underlying Gitonomy repository, preventing exceptions when Git is unavailable during non-interactive commands like help or list. Additionally, it provides a tryToRunWithFallback method that allows git commands (such as fetching configuration values) to return a default string instead of throwing an exception if they fail, improving resilience in environments where Git might be partially configured or missing.
src/Git · high confidence
New ApplicationConfigurator centralizes console setup and versioning
A new ApplicationConfigurator class has been introduced in src/Console to manage the initialization of the GrumPHP console application. This component explicitly sets the application name to 'GrumPHP' and hardcodes the version to 2.25.0, while also registering a global '--config' (short: -c) input option to allow users to specify a custom configuration file path.
src/Console · high confidence
New configuration system with environment variable support and path guessing
The configuration layer has been rewritten to introduce a new Symfony-based configuration tree (Configuration.php) that defines settings for hooks, tasks, test suites, parallel execution, and fixers. A key behavioral change is the addition of an 'environment' configuration node that allows users to specify .env files, variables, and paths, which are now resolved and enriched into the application context during bootstrapping via ContainerFactory. Additionally, the system now automatically guesses project paths (working dir, repository dir, config file) using locators before loading the container, improving out-of-the-box usability for users who do not explicitly configure paths.
src/Configuration · high confidence
New file and path locator components for Git worktrees and environment configuration
The src/Locator directory now includes a suite of new classes that refine how GrumPHP discovers files and resolves paths. GitRepositoryDirLocator and GitRepositoryLocator now explicitly support Git worktrees and submodules, ensuring diffs and repository operations target the correct worktree-specific git directory rather than collapsing to the shared root. GuessedPathsLocator and EnrichedGuessedPathsFromDotEnvLocator allow configuration of project, bin, and git directories via environment variables (e.g., GRUMPHP\_PROJECT\_DIR) and improve fallback logic when no git repository is present. Additionally, new locators like ChangedFiles, ListedFiles, RegisteredFiles, and StdInFiles provide more robust mechanisms for identifying which files to process, including support for raw diff input and stdin.
src/Locator · high confidence
New v2 extension and task configuration system
The configuration layer has been reworked to support a new v2 extension system and a more robust task compilation process. New compiler passes now handle the registration of extensions, PHP parser visitors, and event listeners (including a workaround for Symfony's removal of custom tag support). The task system has been updated to resolve configurations lazily via a new TaskConfigResolver, allowing for environment variable resolution and conditional task enabling. Additionally, a new TestSuiteCompilerPass validates that test suites only reference registered tasks, and a TaskConfigurator applies resolved configurations to task instances.
src/Configuration/Compiler · high confidence
Parallel runner now uses Amp v3 with a new worker pool factory
The parallel execution engine has been updated to support Amp v3, replacing the previous implementation with a new PoolFactory that creates a ContextWorkerPool based on the configured max\_workers setting. This change introduces SerializedClosureTask to handle task serialization and execution within the new Amp-based worker context, enabling the runner to leverage Amp v3's concurrency model for parallel task processing.
src/Runner/Parallel · high confidence
Refactored PHP parser to use a visitor-based architecture with strict typing
The PHP parser implementation has been rewritten to use a modular visitor pattern, introducing new classes for configuration (TraverserConfigurator), context management (ParserContext), and factory creation (ParserFactory, TraverserFactory). This change enforces strict types across the parser and provides specific visitors to detect issues such as missing strict type declarations, forbidden function or method calls, and the use of 'else' or 'exit' statements. Additionally, a custom VisitorContainer is used to ensure visitor instances are cloned between runs to prevent state leakage.
src/Parser/Php · high confidence
Refactored entry point to use dependency injection container
The bin/grumphp script has been rewritten to bootstrap the application via a ContainerFactory instead of direct instantiation. It now loads the project's autoloader from the current working directory first, followed by GrumPHP's autoloader from various possible locations, and finally resolves the Console Application from the built dependency injection container.
bin · high confidence
Refactored path resolution and introduced new utility classes
The path resolution logic has been restructured to support git worktrees and submodules by introducing a new Paths utility that delegates to a GuessedPaths service, ensuring files are read from the correct worktree git directory. A new ComposerFile utility now explicitly parses composer.json to determine bin and config paths, while a new Filesystem utility provides robust path guessing and cross-platform slash normalization. Additionally, new helper classes (Str, Regex, PhpVersion, Platform) have been added to standardize string operations, regex handling, PHP version checks, and platform detection.
src/Util · high confidence
Refactored reporting into dedicated middleware and added CI detection
The reporting logic has been moved from inline task helpers into dedicated middleware classes: \RunnerReporter\ now handles high-level start/finish messages (including the new 'Aborted' message when \stopOnFailure\ triggers) and \TaskResultsReporter\ manages per-task progress updates. A new \CiDetector\ wrapper was added to detect CI environments, which disables interactive output overwrites in CI to prevent broken console sections. Additionally, the \TaskResultsReporter\ now uses \write\ instead of \overwrite\ for CI outputs and improves no-ansi reporting by only rendering at start and completion.
src/Runner/Reporting · high confidence
Refactored task runner with middleware stack and stop-on-failure support
The task execution engine in src/Runner has been restructured to use a middleware-based architecture. A new MiddlewareStack allows processing task results through a chain of handlers, while the TaskRunner now delegates execution to this stack. A new StopOnFailure mechanism enables the runner to cancel ongoing tasks immediately when a blocking failure occurs. Additionally, new result types like FixableTaskResult and MemoizedTaskResultMap have been introduced to support fixer logic and result caching, and the TaskResult model now explicitly distinguishes between blocking and non-blocking failures.
src/Runner · high confidence
Update PHP Spec template for modern PHP standards
The .phpspec/specification.tpl file has been updated to reflect modern PHP practices. The template now uses the fully qualified class name syntax (%subject\_class%::class) instead of string literals for type checking, aligning with PHP 5.5+ standards. This change supports the project's decision to drop PHP 5.4 support, ensuring that generated spec files are compatible with current PHP versions and utilize modern language features for better static analysis and readability.
.phpspec · high confidence
Vagrant git hooks now support commit-msg validation and POSIX compatibility
The Vagrant integration for GrumPHP has been updated to include a new \commit-msg\ hook alongside the existing \pre-commit\ hook, enabling commit message validation within the Vagrant environment. Both hooks have been rewritten to use POSIX-compliant \sh\ instead of \bash\, ensuring broader shell compatibility. The implementation now explicitly transfers the commit message and the raw git diff (using \--raw\ format) to the Vagrant guest via heredocs, allowing GrumPHP to analyze both staged changes and commit messages directly from the virtual machine.
resources/hooks/vagrant · high confidence
YAML linter now supports custom tags and PHP constants
The YAML linter has been updated to allow configuration of parsing behaviors for advanced YAML features. Users can now enable the parsing of custom YAML tags and PHP constants via new options, which control how the underlying Symfony YAML parser handles these elements during linting.
src/Linter/Yaml · high confidence
Test coverage
Added FilesystemTestCase for Symfony integration tests; Added PhpSpec test coverage for Event classes and StashUnstagedChangesSubscriber; Added PhpSpec test coverage for Util classes; Added PhpSpec test coverage for the Locator components; Added PhpSpec test suites for Collection classes; Added PhpSpec tests for GrumPHP exception classes; Added PhpSpec tests for ProcessBuilder and ProcessFactory; Added PhpSpec tests for Runner components; Added PhpSpec tests for configuration models and resolvers; Added PhpSpec tests for linter and composer plugin components; Added PhpSpec tests for task configuration and context classes; Added PhpSpec unit tests for the PHP parser subsystem; Added XML linter test fixtures for DTD, XSD, and XInclude validation; Added e2e test fixtures for task and extension validation; Added end-to-end test suite for GrumPHP configuration and execution; Added test bootstrap configuration; Added test coverage for Formatter components; Added test helper traits for mocking context and task objects; Added test infrastructure for runner middleware; Added tests for ConsoleIO; Added tests for GitRepository lazy loading and diff parsing; Added unit tests for ASCII configuration handling; Added unit tests for Fixer components; Added unit tests for Git blacklist, branch name, and commit message tasks; Added unit tests for Git worktree and path locator components; Added unit tests for GrumPHP utility classes; Added unit tests for IOFactory CI environment detection; Added unit tests for JSON, XML, and YAML linters; Added unit tests for PHP parser visitors and task integrations; Added unit tests for the CI detector runner; Added unit tests for the task runner middleware stack; New base test classes for task testing.
Dependencies
GrumPHP v2 major release: PHP 8.2+ requirement and Symfony 6.4+ ecosystem
This update introduces a major version bump that significantly raises the baseline requirements for GrumPHP. Users must now use PHP 8.2 or higher (supporting up to PHP 8.5), and the project has migrated to the Composer Plugin API v2. The dependency tree has been modernized to require Symfony components v6.4, v7.0, or v8.0, and has adopted the Amp v3 concurrency framework. Additionally, the package name has changed from \grumphp/grumphp\ to \phpro/grumphp\, and the license has been updated to MIT.
(dependencies) · high confidence
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 68.3 → 66.7 (-1.6)
- Rubric changed (rubric-2026.11.2 → rubric-2026.11.4) — scores are not directly comparable.
Lenses
- Code Health 97.1 → 95.4 (-1.7)
- Architecture 82.0 → 65.2 (-16.8)
- Maturity 56.2 → 60.1 (+3.9)
- Readiness 69.7 → 66.8 (-2.9)
- Security 96.0 → 96.0 (0.0)
Resolved (32)
- Coverage read from a committed report
- Duplicated block (10 lines × 2) (src/Task/FileSize.php)
- Duplicated block (12 lines × 2) (src/Task/Php7cc.php)
- Duplicated block (13 lines × 2) (src/Task/Codeception.php)
- Duplicated block (13 lines × 2) (src/Task/ESLint.php)
- Duplicated block (13–14 lines × 2) (src/Task/Ecs.php)
- Duplicated block (13–15 lines × 2) (src/Task/SecurityChecker.php)
- Duplicated block (5 lines × 2) (src/Task/Behat.php)
- Duplicated block (5 lines × 2) (src/Task/Tester.php)
- Duplicated block (5 lines × 6) (src/Task/Codeception.php)
- Duplicated block (6–13 lines × 2) (src/Task/Kahlan.php)
- Duplicated block (6–7 lines × 5) (src/Task/Codeception.php)
- Duplicated block (7 lines × 2) (src/Task/Codeception.php)
- Duplicated block (7 lines × 2) (src/Task/Infection.php)
- Duplicated block (7 lines × 2) (src/Task/PhpCsFixer.php)
- Duplicated block (7 lines × 3) (src/Task/PhpStan.php)
- Duplicated block (7 lines × 3) (src/Task/Psalm.php)
- Duplicated block (7 lines × 3) (src/Task/SecurityCheckerComposeraudit.php)
- Duplicated block (7 lines × 4) (src/Task/ComposerRequireChecker.php)
- Duplicated block (8 lines × 2) (src/Task/SecurityCheckerComposeraudit.php)
- …and 12 more
New (18)
- Circular dependency (src/Collection/ProcessArgumentsCollection.php)
- Duplicated block (7 lines × 3) (src/Task/SecurityCheckerComposeraudit.php)
- Edited copy of a member (12 corresponding lines) (src/Runner/TaskHandler/TaskHandler.php)
- Edited copy of a member (14 corresponding lines) (src/Task/AbstractLinterTask.php)
- Edited copy of a member (16 corresponding lines) (src/Parser/Php/Visitor/ForbiddenClassMethodCallsVisitor.php)
- Edited copy of a member (17 corresponding lines) (src/Task/PhpMd.php)
- Edited copy of a member (22 corresponding lines) (src/Task/XmlLint.php)
- Edited copy of a member (33 corresponding lines) (src/Task/MagoAnalyzer.php)
- Edited copy of a member (9 corresponding lines) (src/Runner/TaskHandler/Middleware/ReportingTaskHandlerMiddleware.php)
- Members sharing a duplicated core (8 members, 50+ identical tokens) (src/Task/ComposerNormalize.php)
- No ADRs found (composer.json)
- Off the main sequence: src/Collection
- Off the main sequence: src/Git
- Off the main sequence: src/Util
- Off-boarding risk: anonymized user #1
- Orphaned file (src/Task/PhpMd.php)
- Orphaned file (src/Task/PhpStan.php)
- Unstable project src/Event
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
phpro/grumphp was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.
About this page
- The score is its most recent published measurement, taken on 17 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit c469dc05dcb81d6893bda31ff87eb48512c30fc7 — the exact code this score is about.
- Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.85+preprod-eba6548ac50f.