Repository: dereuromark/cakephp-ide-helper
Branch: master
Commit: 2844e5a12782
Files: 478
Total size: 935.6 KB

Directory structure:
gitextract_wbx2q4tc/

├── .editorconfig
├── .gitattributes
├── .github/
│   ├── FUNDING.yml
│   ├── dependabot.yml
│   └── workflows/
│       ├── ci.yml
│       └── deploy-docs.yml
├── .gitignore
├── LICENSE
├── README.md
├── annotate-watcher.cjs
├── composer.json
├── config/
│   └── app.example.php
├── docs/
│   ├── .vitepress/
│   │   ├── config.ts
│   │   └── theme/
│   │       ├── custom.css
│   │       └── index.ts
│   ├── annotations/
│   │   ├── callbacks.md
│   │   ├── classes.md
│   │   ├── commands.md
│   │   ├── controllers.md
│   │   ├── custom-class-annotator.md
│   │   ├── index.md
│   │   ├── models.md
│   │   ├── operations.md
│   │   ├── templates.md
│   │   └── view.md
│   ├── code-completion/
│   │   └── index.md
│   ├── generator/
│   │   ├── custom-tasks.md
│   │   ├── index.md
│   │   ├── operations.md
│   │   └── tasks.md
│   ├── guide/
│   │   ├── ide-support.md
│   │   ├── index.md
│   │   ├── installation.md
│   │   ├── migration.md
│   │   └── usage.md
│   ├── illuminator/
│   │   └── index.md
│   ├── index.md
│   ├── package.json
│   └── reference/
│       ├── configuration.md
│       └── contributing.md
├── phpcs.xml
├── phpstan.neon
├── phpunit.xml.dist
├── src/
│   ├── Annotation/
│   │   ├── AbstractAnnotation.php
│   │   ├── AnnotationFactory.php
│   │   ├── AnnotationInterface.php
│   │   ├── ExtendsAnnotation.php
│   │   ├── LinkAnnotation.php
│   │   ├── MethodAnnotation.php
│   │   ├── MixinAnnotation.php
│   │   ├── ParamAnnotation.php
│   │   ├── PropertyAnnotation.php
│   │   ├── PropertyReadAnnotation.php
│   │   ├── ReplacableAnnotationInterface.php
│   │   ├── SeeAnnotation.php
│   │   ├── UsesAnnotation.php
│   │   └── VariableAnnotation.php
│   ├── Annotator/
│   │   ├── AbstractAnnotator.php
│   │   ├── CallbackAnnotator.php
│   │   ├── CallbackAnnotatorTask/
│   │   │   ├── AbstractCallbackAnnotatorTask.php
│   │   │   ├── CallbackAnnotatorTaskInterface.php
│   │   │   ├── TableCallbackAnnotatorTask.php
│   │   │   └── VirtualFieldCallbackAnnotatorTask.php
│   │   ├── CallbackAnnotatorTaskCollection.php
│   │   ├── ClassAnnotator.php
│   │   ├── ClassAnnotatorTask/
│   │   │   ├── AbstractClassAnnotatorTask.php
│   │   │   ├── ClassAnnotatorTaskInterface.php
│   │   │   ├── FormClassAnnotatorTask.php
│   │   │   ├── MailerClassAnnotatorTask.php
│   │   │   ├── ModelAwareClassAnnotatorTask.php
│   │   │   ├── PathAwareClassAnnotatorTaskInterface.php
│   │   │   ├── TableFindAnnotatorTask.php
│   │   │   ├── TableFindNodeVisitor.php
│   │   │   └── TestClassAnnotatorTask.php
│   │   ├── ClassAnnotatorTaskCollection.php
│   │   ├── CommandAnnotator.php
│   │   ├── ComponentAnnotator.php
│   │   ├── ControllerAnnotator.php
│   │   ├── EntityAnnotator.php
│   │   ├── HelperAnnotator.php
│   │   ├── ModelAnnotator.php
│   │   ├── Template/
│   │   │   └── VariableExtractor.php
│   │   ├── TemplateAnnotator.php
│   │   ├── Traits/
│   │   │   ├── ComponentTrait.php
│   │   │   ├── DocBlockTrait.php
│   │   │   ├── FileTrait.php
│   │   │   ├── HelperTrait.php
│   │   │   ├── ModelTrait.php
│   │   │   └── UseStatementsTrait.php
│   │   └── ViewAnnotator.php
│   ├── CodeCompletion/
│   │   ├── CodeCompletionGenerator.php
│   │   ├── Task/
│   │   │   ├── BehaviorTask.php
│   │   │   ├── ControllerEventsTask.php
│   │   │   ├── ModelEventsTask.php
│   │   │   ├── SelectQueryTask.php
│   │   │   ├── TaskInterface.php
│   │   │   └── ViewEventsTask.php
│   │   └── TaskCollection.php
│   ├── Command/
│   │   ├── Annotate/
│   │   │   ├── AllCommand.php
│   │   │   ├── CallbacksCommand.php
│   │   │   ├── ClassesCommand.php
│   │   │   ├── CommandsCommand.php
│   │   │   ├── ComponentsCommand.php
│   │   │   ├── ControllersCommand.php
│   │   │   ├── HelpersCommand.php
│   │   │   ├── ModelsCommand.php
│   │   │   ├── TemplatesCommand.php
│   │   │   └── ViewCommand.php
│   │   ├── AnnotateCommand.php
│   │   ├── Command.php
│   │   ├── GenerateCodeCompletionCommand.php
│   │   ├── GeneratePhpStormMetaCommand.php
│   │   └── IlluminateCommand.php
│   ├── Console/
│   │   └── Io.php
│   ├── Filesystem/
│   │   └── Folder.php
│   ├── Generator/
│   │   ├── Directive/
│   │   │   ├── BaseDirective.php
│   │   │   ├── ExitPoint.php
│   │   │   ├── ExpectedArguments.php
│   │   │   ├── ExpectedReturnValues.php
│   │   │   ├── Override.php
│   │   │   └── RegisterArgumentsSet.php
│   │   ├── GeneratorInterface.php
│   │   ├── PhpstormGenerator.php
│   │   ├── Task/
│   │   │   ├── BehaviorTask.php
│   │   │   ├── CacheTask.php
│   │   │   ├── CellTask.php
│   │   │   ├── ComponentTask.php
│   │   │   ├── ConfigureTask.php
│   │   │   ├── ConnectionTask.php
│   │   │   ├── ConsoleHelperTask.php
│   │   │   ├── ConsoleTask.php
│   │   │   ├── DatabaseTableColumnNameTask.php
│   │   │   ├── DatabaseTableColumnTypeTask.php
│   │   │   ├── DatabaseTableTask.php
│   │   │   ├── DatabaseTypeTask.php
│   │   │   ├── ElementTask.php
│   │   │   ├── EntityTask.php
│   │   │   ├── EnvTask.php
│   │   │   ├── FixtureTask.php
│   │   │   ├── FormHelperTask.php
│   │   │   ├── HelperTask.php
│   │   │   ├── LayoutTask.php
│   │   │   ├── MailerTask.php
│   │   │   ├── ModelTask.php
│   │   │   ├── PluginTask.php
│   │   │   ├── RequestTask.php
│   │   │   ├── RoutePathTask.php
│   │   │   ├── TableAssociationTask.php
│   │   │   ├── TableFinderTask.php
│   │   │   ├── TaskInterface.php
│   │   │   ├── TranslationKeyTask.php
│   │   │   └── ValidationTask.php
│   │   └── TaskCollection.php
│   ├── IdeHelperPlugin.php
│   ├── Illuminator/
│   │   ├── Illuminator.php
│   │   ├── Task/
│   │   │   ├── AbstractTask.php
│   │   │   ├── ControllerDefaultTableTask.php
│   │   │   ├── EntityFieldTask.php
│   │   │   └── TableValidationLinkTask.php
│   │   └── TaskCollection.php
│   ├── Utility/
│   │   ├── App.php
│   │   ├── AppPath.php
│   │   ├── CollectionClass.php
│   │   ├── ControllerActionParser.php
│   │   ├── GenericString.php
│   │   ├── Plugin.php
│   │   ├── PluginPath.php
│   │   └── TranslationParser.php
│   ├── ValueObject/
│   │   ├── ArgumentsSet.php
│   │   ├── ClassName.php
│   │   ├── KeyValue.php
│   │   ├── LiteralName.php
│   │   ├── StringName.php
│   │   └── ValueObjectInterface.php
│   └── View/
│       └── Helper/
│           └── DocBlockHelper.php
└── tests/
    ├── Fixture/
    │   ├── BarBarsFixture.php
    │   ├── CarsFixture.php
    │   ├── FoosFixture.php
    │   ├── HousesFixture.php
    │   ├── WheelsFixture.php
    │   └── WindowsFixture.php
    ├── TestCase/
    │   ├── Annotation/
    │   │   ├── AnnotationFactoryTest.php
    │   │   ├── ExtendsAnnotationTest.php
    │   │   ├── MethodAnnotationTest.php
    │   │   ├── MixinAnnotationTest.php
    │   │   ├── ParamAnnotationTest.php
    │   │   ├── PropertyAnnotationTest.php
    │   │   ├── UsesAnnotationTest.php
    │   │   └── VariableAnnotationTest.php
    │   ├── Annotator/
    │   │   ├── CallbackAnnotatorTask/
    │   │   │   └── VirtualFieldCallbackAnnotatorTaskTest.php
    │   │   ├── CallbackAnnotatorTest.php
    │   │   ├── ClassAnnotatorTask/
    │   │   │   ├── FormClassAnnotatorTaskTest.php
    │   │   │   ├── MailerClassAnnotatorTaskTest.php
    │   │   │   ├── TableFindAnnotatorTaskTest.php
    │   │   │   └── TestClassAnnotatorTaskTest.php
    │   │   ├── ClassAnnotatorTest.php
    │   │   ├── CommandAnnotatorTest.php
    │   │   ├── ComponentAnnotatorTest.php
    │   │   ├── ControllerAnnotatorTest.php
    │   │   ├── DiffHelperTrait.php
    │   │   ├── EntityAnnotatorTest.php
    │   │   ├── HelperAnnotatorTest.php
    │   │   ├── ModelAnnotatorSpecificTest.php
    │   │   ├── ModelAnnotatorTest.php
    │   │   ├── Template/
    │   │   │   └── VariableExtractorTest.php
    │   │   ├── TemplateAnnotatorTest.php
    │   │   └── ViewAnnotatorTest.php
    │   ├── CodeCompletion/
    │   │   ├── CodeCompletionGeneratorTest.php
    │   │   ├── Task/
    │   │   │   ├── BehaviorTaskTest.php
    │   │   │   ├── ControllerEventsTaskTest.php
    │   │   │   ├── ModelEventsTaskTest.php
    │   │   │   └── ViewEventsTaskTest.php
    │   │   └── TaskCollectionTest.php
    │   ├── Command/
    │   │   ├── Annotate/
    │   │   │   ├── ClassesCommandPathAwareTest.php
    │   │   │   ├── ClassesCommandTestCaseWalkTest.php
    │   │   │   └── Fixture/
    │   │   │       ├── SecondTestPathAwareAnnotatorTask.php
    │   │   │       └── TestPathAwareAnnotatorTask.php
    │   │   ├── AnnotateCommandTest.php
    │   │   ├── GenerateCodeCompletionCommandTest.php
    │   │   ├── GeneratePhpstormMetaCommandTest.php
    │   │   └── IlluminateCommandTest.php
    │   ├── Console/
    │   │   └── IoTest.php
    │   ├── Generator/
    │   │   ├── Directive/
    │   │   │   ├── ExitPointTest.php
    │   │   │   ├── ExpectedArgumentsTest.php
    │   │   │   ├── ExpectedReturnValuesTest.php
    │   │   │   ├── OverrideTest.php
    │   │   │   └── RegisterArgumentsSetTest.php
    │   │   ├── PhpstormGeneratorTest.php
    │   │   ├── Task/
    │   │   │   ├── BehaviorTaskTest.php
    │   │   │   ├── CacheTaskTest.php
    │   │   │   ├── CellTaskTest.php
    │   │   │   ├── ComponentTaskTest.php
    │   │   │   ├── ConfigureTaskTest.php
    │   │   │   ├── ConnectionTaskTest.php
    │   │   │   ├── ConsoleHelperTaskTest.php
    │   │   │   ├── ConsoleTaskTest.php
    │   │   │   ├── DatabaseTableColumnNameTaskTest.php
    │   │   │   ├── DatabaseTableColumnTypeTaskTest.php
    │   │   │   ├── DatabaseTableTaskTest.php
    │   │   │   ├── DatabaseTypeTaskTest.php
    │   │   │   ├── ElementTaskTest.php
    │   │   │   ├── EntityTaskTest.php
    │   │   │   ├── EnvTaskTest.php
    │   │   │   ├── FixtureTaskTest.php
    │   │   │   ├── FormHelperTaskTest.php
    │   │   │   ├── HelperTaskTest.php
    │   │   │   ├── LayoutTaskTest.php
    │   │   │   ├── MailerTaskTest.php
    │   │   │   ├── ModelTaskTest.php
    │   │   │   ├── PluginTaskTest.php
    │   │   │   ├── RequestTaskTest.php
    │   │   │   ├── RoutePathTaskTest.php
    │   │   │   ├── TableAssociationTaskTest.php
    │   │   │   ├── TableFinderTaskTest.php
    │   │   │   ├── TranslationKeyTaskTest.php
    │   │   │   └── ValidationTaskTest.php
    │   │   └── TaskCollectionTest.php
    │   ├── Illuminator/
    │   │   ├── IlluminatorTest.php
    │   │   └── Task/
    │   │       ├── ControllerDefaultTableTaskTest.php
    │   │       ├── EntityFieldTaskTest.php
    │   │       └── TableValidationLinkTaskTest.php
    │   ├── Utility/
    │   │   ├── AppPathTest.php
    │   │   ├── AppTest.php
    │   │   ├── GenericStringTest.php
    │   │   ├── PluginPathTest.php
    │   │   ├── PluginTest.php
    │   │   └── TranslationParserTest.php
    │   ├── ValueObject/
    │   │   ├── ClassNameTest.php
    │   │   ├── DoubleQuoteStringNameTest.php
    │   │   ├── KeyValueTest.php
    │   │   ├── LiteralNameTest.php
    │   │   └── StringNameTest.php
    │   └── View/
    │       └── Helper/
    │           └── DocBlockHelperTest.php
    ├── bootstrap.php
    ├── phpstan.neon
    ├── schema.php
    ├── shim.php
    ├── test_app/
    │   ├── locales/
    │   │   ├── de/
    │   │   │   ├── default.po
    │   │   │   └── my_plugin.po
    │   │   └── en/
    │   │       └── default.po
    │   ├── plugins/
    │   │   ├── Awesome/
    │   │   │   ├── src/
    │   │   │   │   ├── AwesomePlugin.php
    │   │   │   │   ├── Controller/
    │   │   │   │   │   └── Admin/
    │   │   │   │   │       └── AwesomeHousesController.php
    │   │   │   │   └── Model/
    │   │   │   │       └── Table/
    │   │   │   │           ├── HousesTable.php
    │   │   │   │           └── WindowsTable.php
    │   │   │   └── templates/
    │   │   │       └── element/
    │   │   │           └── pagination.php
    │   │   ├── Controllers/
    │   │   │   └── src/
    │   │   │       ├── Controller/
    │   │   │       │   ├── GenericController.php
    │   │   │       │   ├── HousesController.php
    │   │   │       │   └── WindowsController.php
    │   │   │       ├── ControllersPlugin.php
    │   │   │       └── Model/
    │   │   │           └── Table/
    │   │   │               └── HousesTable.php
    │   │   ├── MyNamespace/
    │   │   │   └── MyPlugin/
    │   │   │       ├── src/
    │   │   │       │   ├── Controller/
    │   │   │       │   │   └── Component/
    │   │   │       │   │       └── MyComponent.php
    │   │   │       │   ├── Model/
    │   │   │       │   │   ├── Behavior/
    │   │   │       │   │   │   └── MyBehavior.php
    │   │   │       │   │   └── Table/
    │   │   │       │   │       └── MyTable.php
    │   │   │       │   └── MyPluginPlugin.php
    │   │   │       └── tests/
    │   │   │           └── Fixture/
    │   │   │               └── Sub/
    │   │   │                   └── MyFixture.php
    │   │   └── Relations/
    │   │       └── src/
    │   │           ├── Model/
    │   │           │   ├── Entity/
    │   │           │   │   ├── Bar.php
    │   │           │   │   ├── Foo.php
    │   │           │   │   └── User.php
    │   │           │   └── Table/
    │   │           │       ├── BarsTable.php
    │   │           │       ├── FoosTable.php
    │   │           │       └── UsersTable.php
    │   │           └── RelationsPlugin.php
    │   ├── src/
    │   │   ├── Application.php
    │   │   ├── Command/
    │   │   │   └── MyCommand.php
    │   │   ├── Controller/
    │   │   │   ├── AppController.php
    │   │   │   ├── BarController.php
    │   │   │   ├── Component/
    │   │   │   │   ├── CheckHttpCacheComponent.php
    │   │   │   │   ├── MyComponent.php
    │   │   │   │   ├── MyControllerComponent.php
    │   │   │   │   └── MyOtherComponent.php
    │   │   │   ├── DynamicPropertiesController.php
    │   │   │   ├── DynamicPropertiesExistingDocblockController.php
    │   │   │   └── FoosController.php
    │   │   ├── Custom/
    │   │   │   ├── CustomClass.php
    │   │   │   └── Nested/
    │   │   │       └── NestedClass.php
    │   │   ├── Database/
    │   │   │   └── Type/
    │   │   │       └── UuidType.php
    │   │   ├── Generator/
    │   │   │   └── Task/
    │   │   │       ├── TestDatabaseTableColumnTypeTask.php
    │   │   │       ├── TestEnvTask.php
    │   │   │       └── TestFixtureTask.php
    │   │   ├── Mailer/
    │   │   │   └── UserMailer.php
    │   │   ├── Model/
    │   │   │   ├── Entity/
    │   │   │   │   ├── BarBar.php
    │   │   │   │   ├── BarBarsAbstract.php
    │   │   │   │   ├── Callback.php
    │   │   │   │   ├── Car.php
    │   │   │   │   ├── Complex/
    │   │   │   │   │   └── Wheel.php
    │   │   │   │   ├── Complex2/
    │   │   │   │   │   └── Wheel.php
    │   │   │   │   ├── Foo.php
    │   │   │   │   ├── PHP/
    │   │   │   │   │   ├── ComplexType.php
    │   │   │   │   │   ├── Duplicates.php
    │   │   │   │   │   └── Generics.php
    │   │   │   │   ├── PHP7/
    │   │   │   │   │   └── Virtual.php
    │   │   │   │   ├── Virtual.php
    │   │   │   │   └── Wheel.php
    │   │   │   ├── Enum/
    │   │   │   │   └── CarStatus.php
    │   │   │   └── Table/
    │   │   │       ├── AbstractTable.php
    │   │   │       ├── BarBarsAbstractTable.php
    │   │   │       ├── BarBarsTable.php
    │   │   │       ├── CallbacksTable.php
    │   │   │       ├── CarsTable.php
    │   │   │       ├── CustomFinderTable.php
    │   │   │       ├── ExceptionsTable.php
    │   │   │       ├── FoosTable.php
    │   │   │       ├── SkipMeTable.php
    │   │   │       ├── SkipSomeTable.php
    │   │   │       ├── Specific/
    │   │   │       │   ├── AbstractTable.php
    │   │   │       │   ├── BarBarsAbstractTable.php
    │   │   │       │   ├── BarBarsTable.php
    │   │   │       │   ├── CallbacksTable.php
    │   │   │       │   ├── CarsTable.php
    │   │   │       │   ├── CustomFinderTable.php
    │   │   │       │   ├── ExceptionsTable.php
    │   │   │       │   ├── FoosTable.php
    │   │   │       │   ├── SkipMeTable.php
    │   │   │       │   ├── SkipSomeTable.php
    │   │   │       │   ├── WheelsExtraTable.php
    │   │   │       │   └── WheelsTable.php
    │   │   │       ├── WheelsExtraTable.php
    │   │   │       └── WheelsTable.php
    │   │   ├── ValueObject/
    │   │   │   └── DoubleQuoteStringName.php
    │   │   └── View/
    │   │       ├── AppView.php
    │   │       ├── Cell/
    │   │       │   └── TestCell.php
    │   │       ├── CustomView.php
    │   │       └── Helper/
    │   │           ├── HtmlHelper.php
    │   │           ├── MyHelper.php
    │   │           └── MyMethodHelper.php
    │   ├── templates/
    │   │   ├── Foos/
    │   │   │   ├── anonymous.php
    │   │   │   ├── array.php
    │   │   │   ├── custom_view.php
    │   │   │   ├── edit.php
    │   │   │   ├── empty.php
    │   │   │   ├── existing.php
    │   │   │   ├── existing_strict.php
    │   │   │   ├── following_inline.php
    │   │   │   ├── inline.php
    │   │   │   ├── loop.php
    │   │   │   ├── multiline.php
    │   │   │   ├── outdated.php
    │   │   │   ├── phpline.php
    │   │   │   ├── string_interpolation.php
    │   │   │   └── vars.php
    │   │   ├── Helpers/
    │   │   │   └── helpers.php
    │   │   ├── View/
    │   │   │   └── view.php
    │   │   ├── element/
    │   │   │   ├── deeply/
    │   │   │   │   └── nested.php
    │   │   │   └── example.php
    │   │   └── layout/
    │   │       └── ajax.php
    │   ├── tests/
    │   │   └── Fixture/
    │   │       └── SmallWindowsFixture.php
    │   └── vendor/
    │       └── cakephp/
    │           └── cakephp/
    │               └── tests/
    │                   └── Fixture/
    │                       └── PostsFixture.php
    └── test_files/
        ├── ClassAnnotation/
        │   └── TableFind/
        │       └── before.php
        ├── Command/
        │   └── MyCommand.php
        ├── Controller/
        │   ├── AppController.php
        │   ├── BarController.php
        │   ├── Component/
        │   │   ├── MyComponent.php
        │   │   ├── MyControllerComponent.php
        │   │   └── MyOtherComponent.php
        │   ├── DynamicPropertiesController.php
        │   ├── DynamicPropertiesExistingDocblockController.php
        │   ├── FoosController.php
        │   ├── HousesController.php
        │   └── WindowsController.php
        ├── Custom/
        │   ├── CustomClass.php
        │   └── Nested/
        │       └── NestedClass.php
        ├── FormAnnotation/
        │   ├── FormAnnotation.existing.php
        │   └── FormAnnotation.missing.php
        ├── MailerAnnotation/
        │   ├── MailerAnnotation.existing.php
        │   ├── MailerAnnotation.invalid.php
        │   ├── MailerAnnotation.missing.php
        │   ├── MailerAnnotation.missing2.php
        │   └── MailerAnnotation.missing3.php
        ├── Model/
        │   ├── Entity/
        │   │   ├── Car.php
        │   │   ├── Complex/
        │   │   │   └── Wheel.php
        │   │   ├── Constants/
        │   │   │   ├── Wheel.php
        │   │   │   └── WheelComplex.php
        │   │   ├── ConstantsPartial/
        │   │   │   └── Wheel.php
        │   │   ├── ConstantsPartialResult/
        │   │   │   └── Wheel.php
        │   │   ├── Foo.php
        │   │   ├── PHP/
        │   │   │   ├── ComplexType.php
        │   │   │   ├── Duplicates.php
        │   │   │   └── Generics.php
        │   │   ├── PHP7/
        │   │   │   └── Virtual.php
        │   │   ├── Relations/
        │   │   │   ├── Bar.php
        │   │   │   ├── Foo.php
        │   │   │   └── User.php
        │   │   ├── Virtual.php
        │   │   └── Wheel.php
        │   └── Table/
        │       ├── BarBarsAbstractTable.php
        │       ├── BarBarsDetailedTable.php
        │       ├── BarBarsEntityTemplateTable.php
        │       ├── BarBarsTable.php
        │       ├── CallbacksTable.php
        │       ├── FooTable.php
        │       ├── SkipMeTable.php
        │       ├── SkipSomeTable.php
        │       ├── Specific/
        │       │   ├── BarBarsAbstractTable.php
        │       │   ├── BarBarsDetailedTable.php
        │       │   ├── BarBarsTable.php
        │       │   ├── CallbacksTable.php
        │       │   ├── FooTable.php
        │       │   ├── SkipMeTable.php
        │       │   ├── SkipSomeTable.php
        │       │   ├── WheelsExtraTable.php
        │       │   └── WheelsTable.php
        │       ├── Validation/
        │       │   └── IpRulesTable.php
        │       ├── ValidationResult/
        │       │   └── IpRulesTable.php
        │       ├── WheelsExtraTable.php
        │       └── WheelsTable.php
        ├── View/
        │   ├── AppView.php
        │   └── Helper/
        │       ├── MyHelper.php
        │       └── MyMethodHelper.php
        ├── VirtualFieldAnnotation/
        │   ├── VirtualFieldAnnotation.existing.php
        │   └── VirtualFieldAnnotation.missing.php
        ├── locales/
        │   └── default.po
        ├── meta/
        │   └── phpstorm/
        │       ├── .meta.php
        │       ├── .meta_52.php
        │       └── .meta_lowest.php
        ├── routes/
        │   ├── after/
        │   │   ├── empty.php
        │   │   ├── existing.php
        │   │   └── outdated.php
        │   └── before/
        │       ├── empty.php
        │       ├── existing.php
        │       └── outdated.php
        ├── templates/
        │   ├── array.php
        │   ├── custom_view.php
        │   ├── edit.php
        │   ├── empty.php
        │   ├── existing.php
        │   ├── existing_strict.php
        │   ├── following_inline.php
        │   ├── inline.php
        │   ├── loop.php
        │   ├── multiline.php
        │   ├── outdated.php
        │   ├── phpline.php
        │   ├── string_interpolation.php
        │   └── vars.php
        └── tests/
            ├── BarControllerTest.attribute.php
            ├── BarControllerTest.existing.php
            ├── BarControllerTest.link.php
            └── BarControllerTest.missing.php

================================================
FILE CONTENTS
================================================

================================================
FILE: .editorconfig
================================================
; This file is for unifying the coding style for different editors and IDEs.
; More information at https://editorconfig.org
root = true

[*]
indent_style = tab
indent_size = 4
end_of_line = lf
insert_final_newline = true
trim_trailing_whitespace = true

[*.bat]
end_of_line = crlf

[*.yml]
indent_style = space
indent_size = 2

[*.md]
indent_style = space


================================================
FILE: .gitattributes
================================================
# Define the line ending behavior of the different file extensions
# Set default behavior, in case users don't have core.autocrlf set.
* text text=auto eol=lf

*.jpg binary
*.png binary

# Remove files for archives generated using `git archive`
phpunit.xml.dist export-ignore
.github export-ignore
.gitignore export-ignore
.gitattributes export-ignore
.editorconfig export-ignore
tests/test_app export-ignore
tests/test_files export-ignore
tests/TestCase.php export-ignore


================================================
FILE: .github/FUNDING.yml
================================================
# These are supported funding model platforms

github: dereuromark


================================================
FILE: .github/dependabot.yml
================================================
version: 2
updates:
  - package-ecosystem: "npm"
    directory: "/docs"
    schedule:
      interval: "weekly"
    ignore:
      # vite is a transitive dep of vitepress; vitepress 1.x pins vite ^5.4.x
      # and security fixes for vite require >= 6.4.2. Drop this ignore once
      # vitepress 2.x ships stable (currently alpha) and we can upgrade.
      - dependency-name: "vite"


================================================
FILE: .github/workflows/ci.yml
================================================
name: CI

on:
  push:
  pull_request:
  workflow_dispatch:

jobs:
  testsuite:
    runs-on: ubuntu-24.04
    strategy:
      fail-fast: false
      matrix:
        php-version: ['8.2', '8.5']
        db-type: [sqlite, mysql, pgsql]
        prefer-lowest: ['']
        include:
          - php-version: '8.2'
            db-type: 'sqlite'
            prefer-lowest: 'prefer-lowest'

    services:
      postgres:
        image: postgres
        ports:
          - 5432:5432
        env:
          POSTGRES_PASSWORD: postgres

    steps:
      - uses: actions/checkout@v5

      - name: Setup Service
        if: matrix.db-type == 'mysql'
        run: |
          sudo service mysql start
          mysql -h 127.0.0.1 -u root -proot -e 'CREATE DATABASE cakephp;'

      - name: Setup PHP
        uses: shivammathur/setup-php@v2
        with:
          php-version: ${{ matrix.php-version }}
          extensions: mbstring, intl, pdo_${{ matrix.db-type }}
          coverage: pcov

      - name: Get composer cache directory
        id: composercache
        run: echo "dir=$(composer config cache-files-dir)" >> $GITHUB_OUTPUT

      - name: Cache dependencies
        uses: actions/cache@v4
        with:
          path: ${{ steps.composercache.outputs.dir }}
          key: ${{ runner.os }}-composer-${{ hashFiles('**/composer.json') }}
          restore-keys: ${{ runner.os }}-composer-

      - name: Composer install
        run: |
          composer --version
          if ${{ matrix.prefer-lowest == 'prefer-lowest' }}
          then
            composer update --prefer-lowest --prefer-stable
            composer require --dev dereuromark/composer-prefer-lowest:dev-master
          else
            composer install --no-progress --prefer-dist --optimize-autoloader
          fi

      - name: Run PHPUnit
        run: |
          if [[ ${{ matrix.db-type }} == 'sqlite' ]]; then export DB_URL='sqlite:///:memory:'; fi
          if [[ ${{ matrix.db-type }} == 'mysql' ]]; then export DB_URL='mysql://root:root@127.0.0.1/cakephp'; fi
          if [[ ${{ matrix.db-type }} == 'pgsql' ]]; then export DB_URL='postgres://postgres:postgres@127.0.0.1/postgres'; fi
          if [[ ${{ matrix.php-version }} == '8.2' ]]; then
            vendor/bin/phpunit --coverage-clover=coverage.xml
          else
            vendor/bin/phpunit
          fi

      - name: Validate prefer-lowest
        if: matrix.prefer-lowest == 'prefer-lowest'
        run: vendor/bin/validate-prefer-lowest -m

      - name: Upload coverage reports to Codecov
        if: success() && matrix.php-version == '8.2'
        uses: codecov/codecov-action@v5
        with:
          token: ${{ secrets.CODECOV_TOKEN }}

  validation:
    name: Coding Standard & Static Analysis
    runs-on: ubuntu-24.04

    steps:
      - uses: actions/checkout@v5

      - name: Setup PHP
        uses: shivammathur/setup-php@v2
        with:
          php-version: '8.2'
          extensions: mbstring, intl
          coverage: none

      - name: Get composer cache directory
        id: composercache
        run: echo "dir=$(composer config cache-files-dir)" >> $GITHUB_OUTPUT

      - name: Cache dependencies
        uses: actions/cache@v4
        with:
          path: ${{ steps.composercache.outputs.dir }}
          key: ${{ runner.os }}-composer-${{ hashFiles('**/composer.json') }}
          restore-keys: ${{ runner.os }}-composer-

      - name: Composer Setup
        run: composer stan-setup

      - name: Run phpstan
        run: vendor/bin/phpstan analyse --error-format=github

      - name: Run phpcs
        run: composer cs-check


================================================
FILE: .github/workflows/deploy-docs.yml
================================================
name: Deploy Documentation

on:
  push:
    branches:
      - master
    paths:
      - 'docs/**'
      - '.github/workflows/deploy-docs.yml'
  workflow_dispatch:

permissions:
  contents: read
  pages: write
  id-token: write

concurrency:
  group: pages
  cancel-in-progress: false

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Setup Node
        uses: actions/setup-node@v4
        with:
          node-version: 20
          cache: npm
          cache-dependency-path: docs/package-lock.json

      - name: Setup Pages
        uses: actions/configure-pages@v5

      - name: Install dependencies
        run: npm ci
        working-directory: docs

      - name: Build with VitePress
        run: npm run docs:build
        working-directory: docs

      - name: Upload artifact
        uses: actions/upload-pages-artifact@v3
        with:
          path: docs/.vitepress/dist

  deploy:
    environment:
      name: github-pages
      url: ${{ steps.deployment.outputs.page_url }}
    needs: build
    runs-on: ubuntu-latest
    steps:
      - name: Deploy to GitHub Pages
        id: deployment
        uses: actions/deploy-pages@v4


================================================
FILE: .gitignore
================================================
/phpunit.phar
/.phpunit.result.cache
/.phpunit.cache/
/vendor/
/tmp/
/composer.lock
/composer.phar
# IDE and editor specific files #
#################################
/nbproject/
/.idea/
/.phpstorm.meta.php
/tests/test_app/.phpstorm.meta.php/.ide-helper.meta.php
.phpcs.cache

# Docs
/docs/node_modules/
/docs/.vitepress/dist/
/docs/.vitepress/cache/


================================================
FILE: LICENSE
================================================
MIT License

Copyright (c) 2017 Mark Sch.

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.


================================================
FILE: README.md
================================================
#  CakePHP IdeHelper Plugin

[![CI](https://github.com/dereuromark/cakephp-ide-helper/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/dereuromark/cakephp-ide-helper/actions/workflows/ci.yml?query=branch%3Amaster)
[![Coverage Status](https://img.shields.io/codecov/c/github/dereuromark/cakephp-ide-helper/master.svg)](https://app.codecov.io/github/dereuromark/cakephp-ide-helper/tree/master)
[![PHPStan](https://img.shields.io/badge/PHPStan-level%208-brightgreen.svg?style=flat)](https://phpstan.org/)
[![Latest Stable Version](https://poser.pugx.org/dereuromark/cakephp-ide-helper/v/stable.svg)](https://packagist.org/packages/dereuromark/cakephp-ide-helper)
[![Minimum PHP Version](https://img.shields.io/badge/php-%3E%3D%208.2-8892BF.svg)](https://php.net/)
[![License](https://poser.pugx.org/dereuromark/cakephp-ide-helper/license.svg)](LICENSE)
[![Total Downloads](https://poser.pugx.org/dereuromark/cakephp-ide-helper/d/total.svg)](https://packagist.org/packages/dereuromark/cakephp-ide-helper)

IdeHelper plugin for CakePHP applications.

> Boost your productivity. Avoid mistakes.

This branch is for use with **CakePHP 5.1+**. For details see [version map](https://github.com/dereuromark/cakephp-ide-helper/wiki#cakephp-version-map).

## Features

The main idea is to improve IDE compatibility and use annotations to make the IDE understand the
"magic" of CakePHP, so you can click through the class methods and object chains as well as spot obvious issues and mistakes easier. The IDE will usually mark problematic code yellow (missing, wrong method etc).

This also improves compatibility with tools like [PHPStan](https://github.com/phpstan/phpstan).
Those can then follow the code easier and provide more valuable help.

- Add annotations to existing code (e.g. when upgrading an application) just like baking would to new code.
- Can run multiple times without adding the annotations again.
- It can also replace or remove outdated annotations.
- Works with your application as well as any loaded plugin.
- CI check support, hook it up just like the coding standards check.
- Set up as watcher and have live in-real-time annotations added/updated.

Supports annotations for:
- Models (Tables and Entities)
- Controllers (including prefixes like `Admin`) and Components
- View (AppView) and Helpers
- Templates (`.php` PHP template files including elements)
- Commands and Tasks
- ... and more

![Screenshot](docs/public/screenshot.jpg)

Supports code completion help for:
- Behaviors (property access on the BehaviorRegistry)

Supports IDE autocomplete/typehinting of (magic)strings as well as return types/values for:
- Plugins, Components, Behaviors, Helpers, Mailers
- Associations, Validation
- I18n Translation, Cache
- Elements and layouts
- Tables and their fields
- Route paths, Request/ENV, Connection
- ... and more (using PhpStorm meta file)

Supports better IDE usage with Illuminator tasks to enhance existing code:
- EntityFieldTask adds all entity fields as class constants for easier usage in IDEs

### IDE support
This plugin is supposed to work with ANY IDE that supports annotations and code completion.
IDEs tested so far for 100% compatibility:
- **[PhpStorm](https://github.com/dereuromark/cakephp-ide-helper/wiki/PHPStorm)** (incl. meta file generator)
- IntelliJ
- Atom
- **[VS Code](https://github.com/dereuromark/cakephp-ide-helper/wiki/Visual-Studio-Code)**
- ... [Report or PR your IDE of choice here to confirm its full compatibility]

See [Wiki](https://github.com/dereuromark/cakephp-ide-helper/wiki) for details and tips/settings.

### Plugin with Annotator tasks
- [CakephpFixtureFactories](https://github.com/dereuromark/cakephp-fixture-factories) for Factory class usage through `@extends`.

### Plugins with meta file generator tasks
The following plugins use this plugin to improve IDE compatibility around factory and magic string usage:
- [Migrations](https://github.com/cakephp/migrations) for migration file writing (included in IdeHelper directly).
- [Queue](https://github.com/dereuromark/cakephp-queue) for `QueuedJobsTable::createJob()` usage.
- [Burzum/CakeServiceLayer](https://github.com/burzum/cakephp-service-layer) for `loadService()` usage.
- ... (add yours here)

### Plugins with Illuminator tasks
- [StateMachine](https://github.com/spryker/cakephp-statemachine) for syncing states from XML into PHP.
- ... (add yours here)

### More
More collections of useful tasks can be found in the [IdeHelperExtra plugin](https://github.com/dereuromark/cakephp-ide-helper-extra).

### Install, Setup, Usage
See the **[Documentation](https://dereuromark.github.io/cakephp-ide-helper/)** for details.


### Powered by
[![PhpStorm logo.](https://resources.jetbrains.com/storage/products/company/brand/logos/PhpStorm.svg)](https://jb.gg/OpenSourceSupport)

They are sponsoring my IDE for my FOSS work on this repository and beyond.


================================================
FILE: annotate-watcher.cjs
================================================
// watcher.js
const chokidar = require('chokidar');
const { exec } = require('child_process');

// Helper to parse CLI arguments
function getPathsFromArgs() {
	const arg = process.argv.find(arg => arg.startsWith('--path='));
	if (!arg) return ['src/', 'templates/']; // default path
	const value = arg.split('=')[1];
	return value.split(',').map(p => p.trim()).filter(Boolean);
}

const watchPaths = getPathsFromArgs();
console.log(`🔍 Watching: ${watchPaths.join(', ')}`);

// Initialize watcher
chokidar.watch(watchPaths, {
	ignored: /(^|[\/\\])\../, // ignore dotfiles
	persistent: true,
})
	.on('change', path => {
		if (!path.endsWith('.php')) return; // skip non-PHP files

		console.log(`📝 File changed: ${path}`);

		// Run CakePHP command
		exec('bin/cake annotate all --file ' + `${path}`, (error, stdout, stderr) => {
			if (error) {
				console.error(`❌ Error executing CakePHP command: ${error.message}`);
				return;
			}
			if (stderr) {
				console.error(`⚠️ STDERR: ${stderr}`);
			}
			console.log(`✅ Output:\n${stdout}`);
		});
	});


================================================
FILE: composer.json
================================================
{
	"name": "dereuromark/cakephp-ide-helper",
	"description": "CakePHP IdeHelper Plugin to improve auto-completion",
	"license": "MIT",
	"type": "cakephp-plugin",
	"keywords": [
		"cakephp",
		"IDE",
		"autocomplete",
		"annotations",
		"phpstorm",
		"phpdoc",
		"dev",
		"cli"
	],
	"authors": [
		{
			"name": "Mark Scherer",
			"homepage": "https://www.dereuromark.de",
			"role": "Maintainer"
		},
		{
			"name": "Other contributors",
			"homepage": "https://github.com/dereuromark/cakephp-ide-helper/graphs/contributors",
			"role": "Developer"
		}
	],
	"homepage": "https://github.com/dereuromark/cakephp-ide-helper/",
	"support": {
		"issues": "https://github.com/dereuromark/cakephp-ide-helper/issues",
		"source": "https://github.com/dereuromark/cakephp-ide-helper/"
	},
	"require": {
		"php": ">=8.2",
		"cakephp/bake": "^3.2.0",
		"cakephp/cakephp": "^5.1.5",
		"nikic/php-parser": "^5.7",
		"phpstan/phpdoc-parser": "^2.1.0",
		"sebastian/diff": "^6.0 || ^7.0 || ^8.0",
		"squizlabs/php_codesniffer": "^3.13 || ^4.0"
	},
	"require-dev": {
		"dereuromark/cakephp-shim": "^3.3.0",
		"cakephp/migrations": "^4.5.1 || ^5.0",
		"cakephp/plugin-installer": "^2.0.1",
		"fig-r/psr2r-sniffer": "@stable",
		"phpunit/phpunit": "^11.5 || ^12.1 || ^13.0",
		"phpstan/phpstan": "^2.0"
	},
	"minimum-stability": "stable",
	"prefer-stable": true,
	"autoload": {
		"psr-4": {
			"IdeHelper\\": "src/",
			"IdeHelper\\Test\\Fixture\\": "tests/Fixture/"
		}
	},
	"autoload-dev": {
		"psr-4": {
			"Awesome\\": "tests/test_app/plugins/Awesome/src/",
			"Cake\\Test\\": "vendor/cakephp/cakephp/tests/",
			"Controllers\\": "tests/test_app/plugins/Controllers/src/",
			"IdeHelper\\PHPStan\\": "tests/PHPStan/",
			"IdeHelper\\Test\\": "tests/",
			"MyNamespace\\MyPlugin\\": "tests/test_app/plugins/MyNamespace/MyPlugin/src/",
			"MyNamespace\\MyPlugin\\Test\\Fixture\\": "tests/test_app/plugins/MyNamespace/MyPlugin/tests/Fixture/",
			"Relations\\": "tests/test_app/plugins/Relations/src/",
			"TestApp\\": "tests/test_app/src/"
		}
	},
	"config": {
		"allow-plugins": {
			"cakephp/plugin-installer": true,
			"dealerdirect/phpcodesniffer-composer-installer": true
		}
	},
	"scripts": {
		"cs-check": "phpcs --colors --parallel=16",
		"cs-fix": "phpcbf --colors --parallel=16",
		"lowest": "validate-prefer-lowest",
		"lowest-setup": "composer update --prefer-lowest --prefer-stable --prefer-dist --no-interaction && cp composer.json composer.backup && composer require --dev dereuromark/composer-prefer-lowest && mv composer.backup composer.json",
		"lowest-setup-debug": "cp composer.json composer.backup && composer require --dev phpunit/phpunit:^11.5 -W && composer update --prefer-lowest --prefer-stable --prefer-dist --no-interaction && composer require --dev dereuromark/composer-prefer-lowest && mv composer.backup composer.json",
		"stan": "phpstan analyze",
		"stan-setup": "cp composer.json composer.backup && composer require --dev phpstan/phpstan:^2.0.0 && mv composer.backup composer.json",
		"stan-tests": "phpstan analyze -c tests/phpstan.neon",
		"test": "phpunit",
		"test-coverage": "phpunit --log-junit tmp/coverage/unitreport.xml --coverage-html tmp/coverage --coverage-clover tmp/coverage/coverage.xml"
	}
}


================================================
FILE: config/app.example.php
================================================
<?php

return [
	// Copy the following over to your project one in ROOT/config/
	'IdeHelper' => [
		// Additional plugins that are not loaded, but should be included, use `-` prefix to exclude
		'plugins' => [],
		// Controller prefixes to check for
		'prefixes' => [
			'Admin',
		],
		// Template paths to skip
		'skipTemplatePaths' => [
			'/templates/Bake/',
		],
		'templateExtensions' => [
			'php',
		],
		// How behaviors are annotated into tables: ['mixin', 'extends', true, false, null]
		'tableBehaviors' => null, // null auto-detects based CakePHP version (>= 5.2.2 for extends) and always adds mixins.
		'arrayAsGenerics' => false, // Enable to have modern generics syntax (recommended) in doc blocks
		'objectAsGenerics' => false, // Enable to have modern generics syntax (recommended) in doc blocks
		'assocsAsGenerics' => false, // Enable to have modern generics syntax (NOT recommended yet) in doc blocks
		'genericsInParam' => false, // true for basic generics, 'detailed' for fully detailed types (array<string, mixed>, ResultSetInterface<int, TEntity>, ...)
		'concreteEntitiesInParam' => false, // Enable to have specific entities in generated method param doc blocks (NOT recommended)
		'tableEntityQuery' => false, // Enable to annotate `Table::find()` as returning `SelectQuery<TEntity>` for IDEs
		// Set to `false` to disable, or string if you have a custom FQCN to be used
		'templateCollectionObject' => true,
		// Set to `false` to disable, defaults to `mixed` if enabled, you can also pass callable for logic
		'autoCollect' => true,
		// Can be strings or `/regex/` (e.g. `'/^\_.+$/i'` for underscore prefixed variables)
		'autoCollectBlacklist' => [],
		'preferLinkOverUsesInTests' => true, // Prefer `@link` annotations over `@uses` in test files, prevents PHPUnit/Rector to replace them with attributes.
		// Custom Entity field type mapping
		'typeMap' => [],
		// Default View class to use
		'viewClass' => null,
		// Plugins to include for View annotations
		'includedPlugins' => [],
		// Always add annotations/meta even if not yet needed
		'preemptive' => false,
		// Annotator task customization
		'annotators' => [],
		// For meta file generator
		'generatorTasks' => [],
		// A regex pattern - for Migrations plugin DatabaseTableTask generator task
		'ignoreDatabaseTables' => null,
		// A list of tables - for Migrations plugin DatabaseTableTask generator task
		'skipDatabaseTables' => null,
		// For Illuminator tasks
		'illuminatorTasks' => [],
		'illuminatorIndentation' => "\t",
		// For code completion file generator
		'codeCompletionTasks' => [],
		// If a custom directory should be used, defaults to TMP otherwise
		'codeCompletionPath' => null,
		'codeCompletionReturnType' => null, // Auto-detect based on controller/component, set to true/false to force one mode.
	],
];


================================================
FILE: docs/.vitepress/config.ts
================================================
import { defineConfig } from 'vitepress'

export default defineConfig({
  title: 'cakephp-ide-helper',
  description: 'Annotations, meta files, code-completion, and Illuminator tasks for CakePHP — boost IDE and static analyzer support.',
  base: '/cakephp-ide-helper/',
  head: [
    ['link', { rel: 'icon', href: '/cakephp-ide-helper/favicon.svg', type: 'image/svg+xml' }],
  ],
  themeConfig: {
    logo: '/logo.svg',
    nav: [
      { text: 'Guide', link: '/guide/', activeMatch: '/guide/' },
      { text: 'Annotations', link: '/annotations/', activeMatch: '/annotations/' },
      { text: 'Code Completion', link: '/code-completion/', activeMatch: '/code-completion/' },
      { text: 'Generator', link: '/generator/', activeMatch: '/generator/' },
      { text: 'Illuminator', link: '/illuminator/', activeMatch: '/illuminator/' },
      { text: 'Reference', link: '/reference/configuration', activeMatch: '/reference/' },
      {
        text: 'Links',
        items: [
          { text: 'GitHub', link: 'https://github.com/dereuromark/cakephp-ide-helper' },
          { text: 'Packagist', link: 'https://packagist.org/packages/dereuromark/cakephp-ide-helper' },
          { text: 'Issues', link: 'https://github.com/dereuromark/cakephp-ide-helper/issues' },
          { text: 'Wiki', link: 'https://github.com/dereuromark/cakephp-ide-helper/wiki' },
          { text: 'IdeHelperExtra', link: 'https://github.com/dereuromark/cakephp-ide-helper-extra' },
        ],
      },
    ],
    sidebar: {
      '/guide/': [
        {
          text: 'Guide',
          items: [
            { text: 'Introduction', link: '/guide/' },
            { text: 'Installation', link: '/guide/installation' },
            { text: 'Usage', link: '/guide/usage' },
            { text: 'IDE Support', link: '/guide/ide-support' },
            { text: 'Migrating from 4.x', link: '/guide/migration' },
          ],
        },
      ],
      '/annotations/': [
        {
          text: 'Annotations',
          items: [
            { text: 'Overview', link: '/annotations/' },
            { text: 'Controllers', link: '/annotations/controllers' },
            { text: 'Models', link: '/annotations/models' },
            { text: 'View, Components, Helpers', link: '/annotations/view' },
            { text: 'Templates', link: '/annotations/templates' },
            { text: 'Commands and Routes', link: '/annotations/commands' },
            { text: 'Classes', link: '/annotations/classes' },
            { text: 'Callbacks', link: '/annotations/callbacks' },
            { text: 'Operations', link: '/annotations/operations' },
            { text: 'Custom Class Annotators', link: '/annotations/custom-class-annotator' },
          ],
        },
      ],
      '/code-completion/': [
        {
          text: 'Code Completion',
          items: [
            { text: 'Overview', link: '/code-completion/' },
          ],
        },
      ],
      '/generator/': [
        {
          text: 'Generator',
          items: [
            { text: 'Overview', link: '/generator/' },
            { text: 'Available Tasks', link: '/generator/tasks' },
            { text: 'Custom Tasks and Directives', link: '/generator/custom-tasks' },
            { text: 'Operations', link: '/generator/operations' },
          ],
        },
      ],
      '/illuminator/': [
        {
          text: 'Illuminator',
          items: [
            { text: 'Overview', link: '/illuminator/' },
          ],
        },
      ],
      '/reference/': [
        {
          text: 'Reference',
          items: [
            { text: 'Configuration', link: '/reference/configuration' },
            { text: 'Contributing', link: '/reference/contributing' },
          ],
        },
      ],
    },
    socialLinks: [
      { icon: 'github', link: 'https://github.com/dereuromark/cakephp-ide-helper' },
    ],
    search: {
      provider: 'local',
    },
    editLink: {
      pattern: 'https://github.com/dereuromark/cakephp-ide-helper/edit/master/docs/:path',
      text: 'Edit this page on GitHub',
    },
    footer: {
      message: 'Released under the MIT License.',
      copyright: 'Copyright Mark Scherer',
    },
  },
})


================================================
FILE: docs/.vitepress/theme/custom.css
================================================
:root {
  --vp-c-brand-1: #6d28d9;
  --vp-c-brand-2: #7c3aed;
  --vp-c-brand-3: #a78bfa;
  --vp-c-brand-soft: rgba(167, 139, 250, 0.14);

  --vp-home-hero-name-color: transparent;
  --vp-home-hero-name-background: linear-gradient(135deg, #6d28d9 0%, #0284c7 100%);
  --vp-home-hero-image-background-image: linear-gradient(135deg, #6d28d9 0%, #0284c7 100%);
  --vp-home-hero-image-filter: blur(42px);
}

.dark {
  --vp-c-brand-1: #a78bfa;
  --vp-c-brand-2: #8b5cf6;
  --vp-c-brand-3: #7c3aed;
}

.vp-doc table code,
.vp-doc p code,
.vp-doc li code {
  white-space: nowrap;
}

.vp-doc .custom-block.tip {
  border-color: var(--vp-c-brand-1);
}


================================================
FILE: docs/.vitepress/theme/index.ts
================================================
import DefaultTheme from 'vitepress/theme'
import './custom.css'

export default DefaultTheme


================================================
FILE: docs/annotations/callbacks.md
================================================
# Callbacks and CallbackAnnotationTasks

This is a separate annotations tool that focuses on **methods** and their doc
blocks instead of classes. By default it ships with:

- `TableCallbackAnnotatorTask`

## Table Callback Annotations

Behaviors and generic code use the following signature:

```php
/**
 * @param \Cake\Event\EventInterface $event Event
 * @param \Cake\Datasource\EntityInterface $entity Entity
 * @param \ArrayObject $options Options
 * @return void
 */
public function beforeSave(EventInterface $event, EntityInterface $entity, ArrayObject $options): void
```

As long as you only use methods and attributes of the `EntityInterface`
contract, this is fine.

But in specific Table-class code, you usually also access the entity's
concrete properties. There the type hint is somewhat a lie. To please the IDE
and tooling like PHPStan we can at least fix up the doc block — and that is
what this task does, declaring the `Post` entity to be available and used
inside.

Inside the concrete `PostsTable` after running the `callbacks` command:

```php
/**
 * @param \Cake\Event\EventInterface $event Event
 * @param \App\Model\Entity\Post $entity Entity
 * @param \ArrayObject $options Options
 * @return void
 */
public function beforeSave(EventInterface $event, EntityInterface $entity, ArrayObject $options): void
```

## Entity Virtual Field Setter/Getter Annotations

A virtual field will be "linked" to the property it handles:

```php
/**
 * @see \App\Model\Entity\MyEntity::$expected_type
 *
 * @return int|null
 */
protected function _getExpectedType(): ?int
```

This way you can quick-jump from the property to the getter and vice versa
within your IDE.

## Custom Tasks

Create your own task class:

```php
namespace App\Annotator\CallbackAnnotatorTask;

use IdeHelper\Annotator\CallbackAnnotatorTask\AbstractCallbackAnnotatorTask;
use IdeHelper\Annotator\CallbackAnnotatorTask\CallbackAnnotatorTaskInterface;

class MyCallbackAnnotatorTask extends AbstractCallbackAnnotatorTask implements CallbackAnnotatorTaskInterface {

    /**
     * @param string $path
     * @return bool
     */
    public function shouldRun(string $path): bool {
        // ...
    }

    /**
     * @param string $path
     * @return bool
     */
    public function annotate(string $path): bool {
        // ...
    }

}
```

Then add it to the config:

```php
'IdeHelper' => [
    'CallbackAnnotatorTasks' => [
        'MyCallbackAnnotatorTask' => \App\Annotator\CallbackAnnotatorTask\MyCallbackAnnotatorTask::class,
    ],
],
```

The key `'MyCallbackAnnotatorTask'` can be any string.

Replacing existing tasks works the same way as for classes: use the native
class name as key, your replacement as value, or `null` to disable.


================================================
FILE: docs/annotations/classes.md
================================================
# Classes and ClassAnnotationTasks

In order to run certain "fixers" over all classes, class annotations and their
tasks are available. Out of the box the following tasks are run.

## ModelAware

Any `use ModelAwareTrait` together with `$this->loadModel(...)` calls will add
the required annotation on top of the class.

## `Form::execute()`

Adds a convenience inline annotation so you can quickly jump to the actual
business logic:

```php
use App\Form\ReleaseForm;

$releaseForm = new ReleaseForm();

/** @uses \App\Form\ReleaseForm::_execute() */
$releaseForm->execute($data);
```

## `Mailer::send()`

Adds a convenience inline annotation so you can quickly jump to the actual
business logic:

```php
use App\Mailer\NotificationMailer;
// or
$notificationMailer = $this->getMailer('Notification');

/** @uses \App\Mailer\NotificationMailer::notify() */
$notificationMailer->send('notify', [$user, $details]);
```

## Test

Test classes of specific types can be annotated with the corresponding class
they test. This is mainly useful for the following types, which are invoked
indirectly via the integration test harness:

- Controller
- Command

The `@link` statement helps to quick-jump to the class if needed. If your test
class already has a `#[UsesClass(...)]` attribute, no annotation will be
added.

::: tip Use `@uses` instead of `@link`
Set the `IdeHelper.preferLinkOverUsesInTests` config key to `false` to use
`@uses` instead of `@link`.
:::

## Custom Tasks

Create your own task class:

```php
namespace App\Annotator\ClassAnnotatorTask;

use IdeHelper\Annotator\ClassAnnotatorTask\AbstractClassAnnotatorTask;
use IdeHelper\Annotator\ClassAnnotatorTask\ClassAnnotatorTaskInterface;

class MyClassAnnotatorTask extends AbstractClassAnnotatorTask implements ClassAnnotatorTaskInterface {

    /**
     * @param string $path
     * @param string $content
     * @return bool
     */
    public function shouldRun(string $path, string $content): bool {
        // ...
    }

    /**
     * @param string $path
     * @return bool
     */
    public function annotate(string $path): bool {
        // ...
    }

}
```

Then add it to the config:

```php
'IdeHelper' => [
    'classAnnotatorTasks' => [
        'MyClassAnnotatorTask' => \App\Annotator\ClassAnnotatorTask\MyClassAnnotatorTask::class,
    ],
],
```

The key `'MyClassAnnotatorTask'` can be any string.

For a fully worked PHP-AST example, see [Custom Class Annotators](./custom-class-annotator).

## Targeting Custom Directories

By default `bin/cake annotate classes` walks `src/` (app + plugin classpaths)
and `tests/TestCase/` (when `TestClassAnnotatorTask` is registered). A custom
task whose subjects live elsewhere — for example test-fixture factories under
`tests/Factory/`, scenario classes, or generated stubs — can opt into having
those directories walked by also implementing
`PathAwareClassAnnotatorTaskInterface`:

```php
namespace App\Annotator\ClassAnnotatorTask;

use IdeHelper\Annotator\ClassAnnotatorTask\AbstractClassAnnotatorTask;
use IdeHelper\Annotator\ClassAnnotatorTask\PathAwareClassAnnotatorTaskInterface;

class MyClassAnnotatorTask extends AbstractClassAnnotatorTask implements PathAwareClassAnnotatorTaskInterface {

    /**
     * @return array<string>
     */
    public static function scanPaths(): array {
        return ['tests/Factory/'];
    }

    public function shouldRun(string $path, string $content): bool { /* ... */ }
    public function annotate(string $path): bool { /* ... */ }

}
```

Paths are project-root relative for app context, plugin-root relative when
run with `-p`. They are walked recursively. Paths that do not exist on disk
are silently skipped, and a path declared by multiple tasks is walked only
once.

::: tip Path convention
Return paths with forward slashes and a trailing slash (e.g.
`'tests/Factory/'`), independent of OS. The command normalizes to the
OS-native separator before walking, so the dedup key stays stable across
Windows / \*nix and across tasks that disagree on style.
:::

The interface is optional and additive — existing tasks that do not implement
it behave unchanged. The feature is opt-in: a path-aware task is only
consulted when it is registered in `IdeHelper.classAnnotatorTasks`.

## Replacing Native Tasks

Using associative arrays you can swap any native task with your own
implementation:

```php
'IdeHelper' => [
    'classAnnotatorTasks' => [
        \IdeHelper\Annotator\ClassAnnotatorTask\ModelAwareTask::class => \App\Annotator\ClassAnnotatorTask\MyEnhancedModelAwareTask::class,
    ],
],
```

The native class name is the key, your replacement the value. Setting the
value to `null` disables a native task entirely.


================================================
FILE: docs/annotations/commands.md
================================================
# Commands and Routes

## Commands

Commands should annotate their primary model as well as all manually loaded
models.

```bash
bin/cake annotate commands
```

```php
    /**
     * @var string|null
     */
    protected ?string $defaultTable = 'Cars';

    /**
     * @return int
     */
    public function execute(Arguments $args, ConsoleIo $io): int {
        $this->fetchTable('MyPlugin.Wheels');

        return static::CODE_SUCCESS;
    }
```

results in:

```php
/**
 * @property \MyPlugin\Model\Table\WheelsTable $Wheels
 * @property \App\Model\Table\CarsTable $Cars
 */
```

## Routes

Route files in 4.x are no longer required to be static. The
`config/routes.php` file gets the following annotation so the `$routes` object
is type-hinted for editors and analyzers:

```php
/**
 * @var \Cake\Routing\RouteBuilder $routes
 */
```


================================================
FILE: docs/annotations/controllers.md
================================================
# Controllers

All controllers should at least annotate their primary model. They should also
annotate the other loaded models as well as the loaded components.

```bash
bin/cake annotate controllers
```

## Primary Model via Convention

```php
<?php
namespace App\Controller;

class ApplesController extends AppController {
}
```

becomes:

```php
<?php
namespace App\Controller;

/**
 * @property \App\Model\Table\ApplesTable $Apples
 */
class ApplesController extends AppController {
}
```

You get autocompletion on any `$this->Apples->...()` usage in your controllers.

Use `-p PluginName` to annotate inside a plugin.

::: tip Plugin wildcards
Use `*` to refer to a group of plugins, e.g. `-p SomePrefix/*` for everything
under your own `plugins/` directory. You can also use `all` for all app
plugins.

For more than one plugin the command will not run into `vendor/` plugins, to
avoid accidental modification there.
:::

## Primary Model via `$defaultTable`

When defining `$defaultTable` it will be used instead:

```php
<?php
namespace App\Controller;

/**
 * @property \App\Model\Table\MyApplesTable $MyApples
 */
class ApplesController extends AppController {

    protected ?string $defaultTable = 'MyApples';

}
```

## Custom Prefixes

By default, the annotator supports any prefix for your controllers (as a
subfolder). Using the Configure key `'IdeHelper.prefixes'` you can configure a
prefix whitelist.


================================================
FILE: docs/annotations/custom-class-annotator.md
================================================
# Custom Class Annotators

Worked examples of writing custom class annotators in your CakePHP application.

## `getByUuid()` — Concrete Entity Inline Annotation

Imagine you have a method `getByUuid()` for all your tables to look up records
by their UUID instead of the AIID. The returned result would be "known" by
the IDE / PHPStan as `EntityInterface`.

You can create a custom annotator to add a concrete entity annotation
automatically. It adds an inline `@var` annotation above each `getByUuid()`
method assignment.

The example below uses PHP-AST to parse the class files and find the relevant
method calls. This is more exact than using a regex or PHPCS tokenizing, with
fewer false positives.

It then uses the existing IdeHelper code modifier that leverages PHPCS
tokenizing to add the inline annotation to the class file via
`annotateInlineContent()`.

```php
<?php

namespace App\Annotator\ClassAnnotatorTask;

use Cake\ORM\TableRegistry;
use IdeHelper\Annotation\AnnotationFactory;
use IdeHelper\Annotation\VariableAnnotation;
use IdeHelper\Annotator\ClassAnnotatorTask\AbstractClassAnnotatorTask;
use IdeHelper\Annotator\ClassAnnotatorTask\ClassAnnotatorTaskInterface;
use PhpParser\Node;
use PhpParser\Node\Expr\Assign;
use PhpParser\Node\Expr\MethodCall;
use PhpParser\Node\Expr\PropertyFetch;
use PhpParser\Node\Expr\Variable;
use PhpParser\Node\Identifier;
use PhpParser\NodeTraverser;
use PhpParser\NodeVisitorAbstract;
use PhpParser\ParserFactory;

/**
 * Usage of getByUuid() should have inline annotations added.
 */
class TableGetAnnotatorTask extends AbstractClassAnnotatorTask implements ClassAnnotatorTaskInterface
{
    /**
     * @param string $path
     * @param string $content
     *
     * @return bool
     */
    public function shouldRun(string $path, string $content): bool
    {
        if (!str_contains($path, DS . 'src' . DS)) {
            return false;
        }

        return true;
    }

    /**
     * @param string $path
     *
     * @return bool
     */
    public function annotate(string $path): bool
    {
        $found = $this->findGetByUuidCalls();

        $result = true;
        foreach ($found as $row) {
            $annotations = [
                AnnotationFactory::createOrFail(
                    VariableAnnotation::TAG,
                    $row['entity'],
                    $row['var'],
                ),
            ];
            $result &= $this->annotateInlineContent($path, $this->content, $annotations, $row['line']);
        }

        return $result;
    }

    protected function findGetByUuidCalls(): array
    {
        $parser = (new ParserFactory())->createForNewestSupportedVersion();
        $ast = $parser->parse($this->content);

        $found = [];

        $traverser = new NodeTraverser();

        $traverser->addVisitor(new class ($found) extends NodeVisitorAbstract {
            protected array $found;

            /**
             * @param array $found
             */
            public function __construct(array &$found)
            {
                $this->found = &$found;
            }

            /**
             * @param \PhpParser\Node $node
             *
             * @return null
             */
            public function enterNode(Node $node): null
            {
                if (
                    $node instanceof Assign &&
                    $node->expr instanceof MethodCall &&
                    $node->expr->name instanceof Identifier &&
                    $node->expr->name->toString() === 'getByUuid'
                ) {
                    $varName = $node->var instanceof Variable ? $node->var->name : null;

                    $caller = $node->expr->var;
                    if (
                        $caller instanceof PropertyFetch &&
                        $caller->var instanceof Variable &&
                        $caller->var->name === 'this' &&
                        $caller->name instanceof Identifier
                    ) {
                        $modelName = $caller->name->toString();
                        $entityClass = TableRegistry::getTableLocator()->get($modelName)->getEntityClass();

                        $this->found[] = [
                            'line' => $node->getStartLine(),
                            'var' => '$' . $varName,
                            'entity' => '\\' . $entityClass,
                        ];
                    }
                }

                return null;
            }
        });

        $traverser->traverse($ast);

        return $found;
    }
}
```


================================================
FILE: docs/annotations/index.md
================================================
# Annotations Updater

The Annotator keeps doc blocks and annotations in sync with your code without
modifying functional code.

Note that freshly [baking](https://github.com/cakephp/bake) your code produces
similar results, but most projects already have existing code where re-baking
is not an option. The annotator also keeps manually added or modified code
annotated.

## Important Options to Start With

The following are defined under the `IdeHelper` key in `app.php`:

- `arrayAsGenerics`: Set to `true` to use modern generics syntax (`array<type>`
  instead of legacy `type[]`).

See the [Configuration reference](/reference/configuration) for the full list.

## Per-Class-Type Reference

Each class type has its own page covering the dedicated subcommand and the
options that apply only to that type:

- [Controllers](./controllers) — `bin/cake annotate controllers`
- [Models](./models) — `bin/cake annotate models` (Tables and Entities)
- [View, Components, Helpers](./view) — `annotate view`, `annotate components`, `annotate helpers`
- [Templates](./templates) — `bin/cake annotate templates`
- [Commands and Routes](./commands) — `bin/cake annotate commands`
- [Classes](./classes) — class-level annotators (`ModelAware`, `Form::execute()`, `Mailer::send()`, `Test`, custom)
- [Callbacks](./callbacks) — method-level annotators (`TableCallbackAnnotatorTask`, custom)

## Cross-Cutting

- [Operations](./operations) — running all commands, dry-run, filters, removal, file watcher, CI
- [Custom Class Annotators](./custom-class-annotator) — full PHP-AST example

## Replacing Native Tasks

Using associative arrays you can swap any native task with your own
implementation:

```php
'IdeHelper' => [
    'annotators' => [
        \IdeHelper\Annotator\EntityAnnotator::class => \App\Annotator\MyEnhancedEntityAnnotator::class,
    ],
],
```

The native class name is the key, your replacement the value. Setting the
value to `null` disables a native task entirely.


================================================
FILE: docs/annotations/models.md
================================================
# Models

Annotate Tables and their Entities:

```bash
bin/cake annotate models
```

## Tables

Tables annotate their entity-related methods, their relations, and behavior
mixins.

A `LocationsTable` class would gain the following doc-block annotations if not
already present:

```php
/**
 * @method \App\Model\Entity\Location newEmptyEntity()
 * @method \App\Model\Entity\Location newEntity(array $data, array $options = [])
 * @method array<\App\Model\Entity\Location> newEntities(array $data, array $options = [])
 * @method \App\Model\Entity\Location get(mixed $primaryKey, array|string $finder = 'all', \Psr\SimpleCache\CacheInterface|string|null $cache = null, \Closure|string|null $cacheKey = null, mixed ...$args)
 * @method \Cake\ORM\Query\SelectQuery<\App\Model\Entity\Location> find(string $type = 'all', mixed ...$args)
 * @method \App\Model\Entity\Location|false save(\Cake\Datasource\EntityInterface $entity, array $options = [])
 * @method \App\Model\Entity\Location saveOrFail(\Cake\Datasource\EntityInterface $entity, array $options = [])
 * @method \App\Model\Entity\Location patchEntity(\Cake\Datasource\EntityInterface $entity, array $data, array $options = [])
 * @method array<\App\Model\Entity\Location> patchEntities(iterable $entities, array $data, array $options = [])
 * @method \App\Model\Entity\Location findOrCreate(\Cake\ORM\Query\SelectQuery|callable|array $search, ?callable $callback = null, array $options = [])
 * @method \Cake\Datasource\ResultSetInterface<\App\Model\Entity\Location>|false saveMany(iterable $entities, array $options = [])
 * @method \Cake\Datasource\ResultSetInterface<\App\Model\Entity\Location> saveManyOrFail(iterable $entities, array $options = [])
 * @method \Cake\Datasource\ResultSetInterface<\App\Model\Entity\Location>|false deleteMany(iterable $entities, array $options = [])
 * @method \Cake\Datasource\ResultSetInterface<\App\Model\Entity\Location> deleteManyOrFail(iterable $entities, array $options = [])
 *
 * @property \Cake\ORM\Association\HasMany<\App\Model\Table\ImagesTable> $Images
 * @property \Cake\ORM\Association\BelongsTo<\App\Model\Table\UsersTable> $Users
 *
 * @mixin \Cake\ORM\Behavior\TimestampBehavior
 */
```

### Entity-aware `find()` return type

If you want the table annotations to also expose the entity-aware `find()`
return type for IDEs, enable:

```php
'IdeHelper' => [
    'tableEntityQuery' => true,
],
```

This is intentionally optional, because finder result shapes can still widen
beyond plain entities.

### Detailed param types

The `IdeHelper.genericsInParam` option is tri-state:

- `false` (default) — bare `array` params, legacy behavior.
- `true` — basic generics: `array<mixed>` / `array<string, mixed>` / `iterable<TEntity>`.
- `'detailed'` — fully detailed types throughout, matching the richer form PHPStan and Psalm understand best.

With `'detailed'`, the generated method annotations look like:

```php
 * @method \App\Model\Entity\User newEntity(array<string, mixed> $data, array<string, mixed> $options = [])
 * @method array<\App\Model\Entity\User> newEntities(array<array<string, mixed>> $data, array<string, mixed> $options = [])
 * @method \App\Model\Entity\User get(mixed $primaryKey, array<string, mixed>|string $finder = 'all', \Psr\SimpleCache\CacheInterface|string|null $cache = null, \Closure|string|null $cacheKey = null, mixed ...$args)
 * @method \App\Model\Entity\User findOrCreate(\Cake\ORM\Query\SelectQuery<\App\Model\Entity\User>|callable|array<string, mixed> $search, ?callable $callback = null, array<string, mixed> $options = [])
 * @method \Cake\Datasource\ResultSetInterface<int, \App\Model\Entity\User>|false saveMany(iterable<\App\Model\Entity\User> $entities, array<string, mixed> $options = [])
```

Switching the value is additive — existing `true` users keep their current
output, and the new `'detailed'` opt-in can be enabled at any time.

## Entities

Entities annotate their properties and relations.

A `Location` entity could look like this afterward:

```php
/**
 * @property int $id
 * @property int $user_id
 * @property \App\Model\Entity\User $user
 * @property string $location
 * @property string $details
 * @property \Cake\I18n\DateTime $created
 * @property \Cake\I18n\DateTime $modified
 * @property string|null $virtual_property
 *
 * @property \App\Model\Entity\Image[] $images
 * @property \App\Model\Entity\User $user
 */
class Location extends Entity {
}
```

### Custom type maps

Using the Configure key `'IdeHelper.typeMap'` you can set a custom array of
types to be used for the field mapping. Overwriting the defaults of this
plugin is also possible — to skip (reset) just set the value to `null`:

```php
'IdeHelper' => [
    'typeMap' => [
        'custom' => 'array',
        'longtext' => null,
        // ...
    ],
],
```

Using the Configure key `'IdeHelper.nullableMap'` you can set a custom array
of types and whether they can be nullable:

```php
'IdeHelper' => [
    'nullableMap' => [
        'custom' => false,
        'longtext' => true,
        // ...
    ],
],
```

### Virtual properties

For virtual properties the annotator looks up the respective `_get...()`
methods (e.g. `_getVirtualProperty()` for `$virtual_property`). It first checks
the documented type in the doc block's `@return`, otherwise (given PHP 7.0+)
tries to read it from the return type hint (e.g. `: ?string`). Only if that is
also not present does it fall back to `mixed`.

Note: You can also use the `@property-read` tag if it is a pure virtual field
getter.


================================================
FILE: docs/annotations/operations.md
================================================
# Operations

Cross-cutting flags and workflows that apply to every annotator subcommand.

## Running All Commands

```bash
bin/cake annotate all
```

By default it runs interactively, asking you for each class type whether to
continue. You can use `-i` (interactive) to enable interactive mode. It is
also recommended to make the output more verbose:

```bash
bin/cake annotate all -i -v
```

::: warning Backup first
Make sure you have committed or backed up all project files before running
the annotator across the whole project.
:::

## Dry-Run and Diff

If you want to check whether the annotator would modify any files, run it
with `-d` (dry-run):

```bash
bin/cake annotate all -d
```

It will output a small diff for each modification:

```
templates/Tickets
-> view
   | +<?php
   | +/**
   | + * @var \App\View\AppView $this
   | + * @var \App\Model\Entity\Ticket $ticket
   | + */
   | +?>
   |  <nav class="large-3 medium-4 columns" id="actions-sidebar">
```

::: tip Verbose dry-runs
Use `-v` together with `-d` to get more information on which files were
processed.
:::

## Quick-Filter Files

With `-f` / `--filter` you can quickly annotate only specific files. The
filter is applied to the file name. For templates it also looks at the folder
name.

## Specific Files Only

With `--file` and a comma-separated list of ROOT-relative or absolute paths,
you can limit the run to those specific files. This is useful for programmatic
tooling-based runs or file watchers.

If `--file` is set, it takes precedence over `--filter` (which is ignored).

Example:

```bash
bin/cake annotate all --file src/View/AppView.php,plugins/My/src/View/Helper/MyHelper.php
```

## Removing Outdated Annotations

With `-r` / `--remove` there is basic support for finding and removing
outdated annotations.

::: warning Alpha-quality feature
Only use this after running the normal annotation flow and committing the
result, so you can review and verify the changes. This feature is still in a
very alpha phase.
:::

You can prevent removal (just like updating) by adding a comment to your
annotation. That will skip any attempt to remove it:

```php
    @property array|null $data !
```

or:

```php
    @property array|null $data ! A manual field for testing only
```

## Skipping Annotations for a Class

Sometimes you are extending another class. In that case you can use the
`@inherit` tag in the class doc block to skip annotating:

```php
/**
 * @inheritdoc
 */
class CustomImagesTable extends ImagesTable ...
```

In this case `CustomImagesTable` extends `ImagesTable` but uses the same
`protected $_entityClass = Image::class;`, so we skip annotating.

## File Watcher Setup

You can set up a file watcher to run the annotation tool on every file
change, giving you live annotation updates while coding.

### Using Node and Chokidar

Install in your project root:

```bash
npm init -y
npm install chokidar --save
```

Run:

```bash
node vendor/dereuromark/cakephp-ide-helper/annotate-watcher.cjs
```

If necessary, you can customize the paths via `--path=src/,templates/`, for
example. You can also copy `annotate-watcher.cjs` to your app and customize it
there.

Since this is cross-platform, this is the recommended approach. It is also
the most performant — only files directly modified are touched. The trade-off
is that it might miss a few related templates that are not modified but would
get updates.

### Using watchexec

See [github.com/watchexec/watchexec](https://github.com/watchexec/watchexec).

```bash
watchexec -e php 'bin/cake annotate all'
```

Here you would run the annotator over all files. Still usually quite
performant.

## Continuous Integration

The tool can be run like the coding standards check in your CI. This way no
annotation can be forgotten when making PRs.

Use the `--ci` option along with `-d` (dry run):

```bash
bin/cake annotate all -d --ci
```

It will return error code `2` if any modification has to be done.

::: info Database setup
This needs some additional setup, like running migrations prior to the call.
The database must exist and replicate the actual DB.
:::

You can also add this into a pre-commit hook for local development. Your VCS
will then refuse to commit until annotations are all in line.

## Writing Your Own Annotators

Extend `IdeHelper\Command\AnnotateCommand` at the application level, register
your command, and create your own `Annotator` class:

```php
class MyAnnotator extends AbstractAnnotator {

    /**
     * @param string $path
     * @return bool
     */
    public function annotate(string $path): bool {
        // ...
    }
}
```

Then read a folder, iterate over it, and invoke your annotator from the
command with a specific path.

## Configure Options

For the full list of possible Configure options, see the `app.example.php`
file in the plugin's `/config/` directory. The content can be directly copied
into your project config.


================================================
FILE: docs/annotations/templates.md
================================================
# Templates

Annotate view templates and elements:

```bash
bin/cake annotate templates
```

Templates should have a `/** @var \App\View\AppView $this */` added on top if
they use any helper or access the request object. They should also annotate
entities they use.

A template such as:

```php
<h2>Some header</h2>
<?php echo $this->Form->create($user); ?>
<?php foreach ($groups as $group): ?>
<?php endforeach; ?>
<li><?= $this->Html->link(__('Edit Email'), ['action' => 'edit', $email->id]) ?> </li>
```

would get the following added on top:

```php
<?php
/**
 * @var \App\View\AppView $this
 * @var \App\Model\Entity\Email $email
 * @var \App\Model\Entity\Group[] $groups
 * @var \App\Model\Entity\User $user
 */
?>
```

## Extensions

To adjust which template extensions are processed, set
`IdeHelper.templateExtensions` via Configure. By default, all files of type
`'ctp'` and `'php'` will be checked.

::: info Twig templates
All template annotating is around PHP templates. Twig templates are not
supported. Twig usually has its own tooling — but it has serious drawbacks on
what this plugin provides: auto-complete and type-hinting as well as IDE
introspection of variable types.
:::

## Skipping Folders

Certain template folders, like Bake template generation, should be skipped.
This is done by default for `/templates/Bake/` in your app or your plugin.

If you want to adjust this, set `IdeHelper.skipTemplatePaths` via Configure:

```php
'IdeHelper' => [
    'skipTemplatePaths' => [
        // ...
    ],
],
```

## Skipping Variables

In some cases existing annotations might match different entities (e.g.
plugin vs. app namespace). To prevent them from being replaced incorrectly,
mark them to be ignored by adding any comment description:

```php
<?php
/**
 * @var \App\View\AppView $this
 * @var \My\Custom\Entity $car !
 */
?>
```

The `!` prevents the entity annotation from being replaced.

## Auto-Collecting Variables

The IdeHelper can auto-collect template variables and add them to the list
above. Set `'IdeHelper.autoCollect'` to `false` to disable this. It defaults
to `'mixed'` where the type cannot be guessed/detected.

If you need more control, configure a callable to detect or guess:

```php
'IdeHelper.autoCollect', function(array $variable) {
    if ($variable['name'] === 'date') {
        return 'Cake\I18n\DateTime';
    }
    return null;
});
```

::: tip Unique variables
For the best experience of auto-collecting, use unique variable names inside
the template(s). If you pass down a `$user` variable from the controller,
make sure you are not overwriting it in some local scope.

```php
// This will skip the other $user annotation
foreach ($role->users as $user) {}

// Use a better name instead to keep $user annotation
foreach ($role->users as $rolUser) {}
```
:::

You can use the `'IdeHelper.autoCollectBlacklist'` config to exclude certain
variables. The array accepts both strings and regexp patterns like
`'/^\_.+$/i'` for underscore-prefixed variables.

## Entity Collections

Usually, all collections (pagination, find) are object collections when passed
to the view layer. The template annotations added for them are e.g.:

```
// objectAsGenerics false
@var \App\Model\Entity\Article[]|\Cake\Collection\CollectionInterface $articles

// objectAsGenerics true
@var \Cake\Collection\CollectionInterface<\App\Model\Entity\Article> $articles
```

The config `IdeHelper.templateCollectionObject` can be set to a FQCN string if
you want to display a custom class (e.g. `\Cake\Datasource\ResultSetInterface`).
You can also set it to `iterable` (recommended) if you don't use any of the
specific interface methods (just iterating over them):

```
// templateCollectionObject set to 'iterable'
@var iterable<\App\Model\Entity\Article> $articles
```

If you always pass arrays, you can set `IdeHelper.templateCollectionObject` to
`false` to reflect this in the annotations:

```
// arrayAsGenerics false
@var \App\Model\Entity\Article[] $articles

// arrayAsGenerics true
@var array<\App\Model\Entity\Article> $articles
```

## Preemptive Annotating

Using Configure key `'IdeHelper.preemptive'` set to `true` you can be a bit
more preemptive in annotations. E.g. `@var \App\View\AppView $this` will then
always be added to view templates, even if not currently needed. This allows
immediate type-hinting once actually needed; it is recommended to enable this
setting.

## Custom View Class

Using Configure key `'IdeHelper.viewClass'` a custom class name can be set to
use instead of the default. E.g. `'App\View\MyCustomAppView'` or
`MyCustomAppView::class` (incl. `use` statement).


================================================
FILE: docs/annotations/view.md
================================================
# View, Components, Helpers

## View

The `AppView` class should annotate the helpers of the plugins and the app.

```bash
bin/cake annotate view
```

With template content like:

```php
<?php echo $this->My->foo($bar); ?>
<?php if ($this->Configure->baz()) {} ?>
```

the following would be annotated (if the `My` and `Shim.Configure` helpers are
loaded correctly):

```php
/**
 * @property \App\View\Helper\MyHelper $My
 * @property \Shim\View\Helper\ConfigureHelper $Configure
 */
class AppView extends View {
}
```

### Include plugins

Using the Configure key `'IdeHelper.includedPlugins'` you can set an array of
(loaded!) plugins to include. Those will then also be parsed and all found
helpers added to the `AppView` annotations. Setting this to `true` will
auto-include all loaded plugins.

## Components

Components should annotate any component they use.

```bash
bin/cake annotate components
```

A component containing:

```php
    /**
     * @var array
     */
    protected $components = [
        'RequestHandler',
        'Flash.Flash',
    ];
```

would get the following annotations:

```php
/**
 * @property \App\Controller\Component\CheckHttpCacheComponent $CheckHttpCache
 * @property \Flash\Controller\Component\FlashComponent $Flash
 */
```

## Helpers

Helpers should annotate any helper they use.

```bash
bin/cake annotate helpers
```

A helper containing:

```php
    /**
     * @var array
     */
    protected $helpers = [
        'Form',
    ];

    /**
     * @param \Cake\View\View $View
     * @param array $config
     */
    public function __construct(View $View, array $config = []) {
        parent::__construct($View, $config);
        $this->_View->loadHelper('Template');
    }
```

would get the following annotations:

```php
/**
 * @property \Cake\View\Helper\FormHelper $Form
 * @property \App\View\Helper\TemplateHelper $Template
 */
```


================================================
FILE: docs/code-completion/index.md
================================================
# Code Completion File Generator

In contrast to the [PhpStorm meta file generator](/generator/), this tool is
intentionally generic and IDE agnostic.

![Behavior Code Completion](/img/code_completion.png)

## Usage

This command will generate the CodeCompletion `php` files into your app's
`TMP/` directory:

```bash
bin/cake generate code_completion
```

The files should not be persisted — they will always be regenerated or
updated locally if needed.

::: tip composer hook
Set up a `post-install-cmd` hook for composer to keep them up to date
automatically.
:::

## Behaviors

```php
/** @var \Search\Manager $searchManager */
$searchManager = $this->behaviors()->Search->searchManager();
```

So far `$searchManager` required the annotation above to be type-hinted and
clickable, because the magic property access is not resolvable on its own.

With the generated code completion file this is no longer necessary. The
property `Search` is detected as `\Search\Model\Behavior\SearchBehavior`,
making `searchManager()` available in the IDE for method argument checking
and following.

## SelectQuery generics

The code completion generator also ships a `Cake\ORM\Query\SelectQuery`
helper stub for fluent query chains. This is especially useful together with
the model annotation option:

```php
'IdeHelper' => [
    'tableEntityQuery' => true,
],
```

That combination lets IDEs preserve the concrete entity type through calls
such as:

```php
$query = $this->Users->find();
$query->where(['active' => true])->all();
```

The generated stub intentionally focuses on methods where the subject type is
stable or where Cake already has a clear subject transition:

| Flow | Semantic result | ide-helper support |
| --- | --- | --- |
| `$this->Users->find()->where(...)->all()` | `User` entities | Covered via `tableEntityQuery` + `SelectQuery<TSubject>` stub |
| `$this->Users->find('active')->matching('Roles')->contain('Profiles')->all()` | `User` entities | Covered; these fluent methods preserve `TSubject` |
| `$this->Users->find()->disableHydration()->all()` | `array<string, mixed>` rows | Covered; `disableHydration()` switches the query stub to array results |
| `$this->Users->find('list')->all()` | non-entity shaped result | Not forced by default; keep this outside the entity-query assumption |
| `$this->Users->find()->formatResults(...)` | depends on formatter | Not modeled; formatter callbacks can reshape results arbitrarily |
| `$this->Users->find()->mapReduce(...)` | depends on mapper/reducer | Not modeled; map/reduce can reshape results arbitrarily |

This keeps the default helper honest: preserve the type where the query
stays subject-compatible, and avoid pretending that formatter-driven or
list-style flows are still plain entity queries.

For PhpStorm projects you can point the generated code completion files into
`.phpstorm.meta.php/` so they are indexed as local project helpers:

```php
'IdeHelper' => [
    'codeCompletionPath' => ROOT . DS . '.phpstorm.meta.php' . DS,
],
```

Then regenerate the files with:

```bash
bin/cake generate code_completion
```

## Adding Your Own Tasks

Create your own task class:

```php
namespace App\CodeCompletion\Task;

use IdeHelper\CodeCompletion\Task\TaskInterface;

class MyTask implements TaskInterface {

    const TYPE_NAMESPACE = 'Some\Namespace';

    /**
     * @return string
     */
    public function type(): string {
        return static::TYPE_NAMESPACE;
    }

    /**
     * @return string
     */
    public function create(): string {
        // ...
    }

}
```

Then add it to the config:

```php
'IdeHelper' => [
    'codeCompletionTasks' => [
        'MyTask' => \App\CodeCompletion\Task\MyTask::class,
    ],
],
```

The key `'MyTask'` can be any string.

### Replacing native tasks

Using associative arrays you can swap any native task with your own
implementation:

```php
'IdeHelper' => [
    'codeCompletionTasks' => [
        \IdeHelper\CodeCompletion\Task\BehaviorTask::class => \App\CodeCompletion\Task\MyEnhancedBehaviorTask::class,
    ],
],
```

The native class name is the key, your replacement the value. Setting the
value to `null` disables a native task entirely.

### Property example

So let's imagine you have the following magic properties you want to annotate:

```php
$alpha = $someObject->Alpha; // Returns \My\Cool\Alpha class
$beta = $someObject->Beta; // Returns \My\Cool\Beta class
```

Then make sure your task's `create()` method returns something like:

```php
abstract class SomeObject extends SomeObjectInterface {

    /**
     * Alpha class.
     *
     * @var \My\Cool\Alpha
     */
    public $Alpha;

    /**
     * Beta class.
     *
     * @var \My\Cool\Beta
     */
    public $Beta;

}
```

We use the `abstract` keyword to avoid direct implementation hinting.

### Method example

Let's imagine you have the following magic methods you want to annotate:

```php
$alpha = $someObject->alpha(); // Returns \My\Cool\Alpha class
$beta = $someObject->beta(); // Returns \My\Cool\Beta class
```

Then make sure your task's `create()` method returns something like:

```php
abstract class SomeObject extends SomeObjectInterface {

    /**
     * Alpha class.
     *
     * @var \My\Cool\Alpha
     */
    protected $alpha;

    // ...

    /**
     * @return \My\Cool\Alpha
     */
    public function search(): Alpha {
        return $this->alpha;
    }

    // ...

}
```

## Custom Path for Files

Using the Configure key `'IdeHelper.codeCompletionPath'` you can use a custom
path in your project. This way the files can be added to version control.


================================================
FILE: docs/generator/custom-tasks.md
================================================
# Custom Tasks and Directives

## Adding Your Own Tasks

Create your own task class:

```php
namespace App\Generator\Task;

use IdeHelper\Generator\Task\TaskInterface;

class MyTask implements TaskInterface {

    /**
     * @return array<\IdeHelper\Generator\Directive\BaseDirective>
     */
    public function collect(): array {
        // ...
    }

}
```

Then add it to the config:

```php
'IdeHelper' => [
    'generatorTasks' => [
        'MyTask' => \App\Generator\Task\MyTask::class,
    ],
],
```

The key `'MyTask'` can be any string, but it must be unique across all
existing tasks.

## Replacing Native Tasks

Using associative arrays you can swap any native task with your own
implementation:

```php
'IdeHelper' => [
    'generatorTasks' => [
        \IdeHelper\Generator\Task\ModelTask::class => \App\Generator\Task\MyEnhancedModelTask::class,
    ],
],
```

The native class name is the key, your replacement the value. Setting the
value to `null` disables a native task entirely.

## Available Directives

### Override

Most directives used by the built-in tasks are `Override`. They are also the
ones supported the longest. For a specific string method argument, an
`Override` returns a specific object — that covers a lot of CakePHP's
internal magic.

```php
$method = '\Namespace\PackageName\MyFactory::create(0)';
$map = [
    'alpha' => '\My\Cool\Alpha::class',
    'beta' => '\My\Cool\Beta::class',
];
$directive = new Override($method, $map);
```

You can also use the `ClassName` value object together with real `::class`
usage and imports:

```php
use IdeHelper\ValueObject\ClassName;
use My\Cool\Alpha;
use My\Cool\Beta;

$map = [
    'alpha' => ClassName::create(Alpha::class),
    'beta' => ClassName::create(Beta::class),
];
```

### ExpectedArguments

With this you can set default values to choose from for method arguments.
Specify the parameter count as a 0-based value.

```php
$method = '\Namespace\PackageName\MyFactory::create()';
$position = 0;
$list = [
    '\'alpha\'',
    '\'beta\'',
];
$directive = new ExpectedArguments($method, $position, $list);
```

Note the escaped quotes around literal string values. To make it cleaner,
use the `StringName` value object — it auto-quotes on output:

```php
use IdeHelper\ValueObject\StringName;

$list = [
    StringName::create('alpha'),
    StringName::create('beta'),
];
```

### ExpectedReturnValues

You can also set expected return types for a method:

```php
$method = '\Namespace\PackageName\MyFactory::create()';
$list = [
    '\My\Cool\Alpha::class',
    '\My\Cool\Beta::class',
];
$directive = new ExpectedReturnValues($method, $list);
```

### RegisterArgumentsSet

If you reuse the same lists for both arguments and return values, you can
register a set and reuse it in the directives above.

```php
$set = 'mySet';
$list = [
    '\My\Cool\Executer::SUCCESS',
    '\My\Cool\Executer::ERROR',
];
$directive = new RegisterArgumentsSet($set, $list);
```

Now you can use it as the list value `argumentsSet('mySet')` inside the
others. For this just pass the `$directive` object itself to the list, which
then contains only this one element.

You can also use the `LiteralName` value object for constants and anything
that does not need to be output as a string:

```php
use IdeHelper\ValueObject\LiteralName;

$list = [
    LiteralName::create('\My\Cool\Executer::SUCCESS'),
    LiteralName::create('\My\Cool\Executer::ERROR'),
];
```

If you want to reuse existing argument sets from other tasks, use the
`ArgumentsSet` value object referencing them:

```php
use IdeHelper\Generator\Directive\ExpectedArguments;
use IdeHelper\ValueObject\ArgumentsSet;

$method = '\\' . static::CLASS_FORMAT_HELPER . '::sidebarLink()';
$list = [
    ArgumentsSet::create(FormatIconFontAwesome5Task::SET_ICONS_FONTAWESOME),
];
$directive = new ExpectedArguments($method, 1, $list);
```

Just make sure those argument sets are actually available — this is not
checked for you.

### ExitPoint

This directive lets the IDE know what methods abort the current code flow.
The IDE shows an "Unreachable statement" warning and usually highlights the
following code in yellow to inform you.

```php
$directive = new ExitPoint('\My\Class::method()');
```

## Worked Example

Imagine you have the following methods you want to annotate:

```php
$alpha = MyFactory::create('alpha'); // Returns \My\Cool\Alpha class
$beta = MyFactory::create('beta'); // Returns \My\Cool\Beta class
```

Create an `Override` to get the correct class instance returned:

```php
$method = '\Namespace\PackageName\MyFactory::create(0)';
$map = [
    'alpha' => '\My\Cool\Alpha::class',
    'beta' => '\My\Cool\Beta::class',
];
$override = new Override($method, $map);
```

Note that map keys are usually always strings and output auto-quoted by
default. So you can treat them as simple/literal strings.

Now imagine you have multiple class methods that return the same set of
constants. First create the reusable set:

```php
$list = [
    '\My\Cool\Executer::SUCCESS',
    '\My\Cool\Executer::ERROR',
];
$argumentsSet = new RegisterArgumentsSet('mySet', $list);
```

Now you can use it for all methods:

```php
$method = '\My\Cool\Executer::execute()';
$list = [
    $argumentsSet,
];
$expectedReturnValues = new ExpectedReturnValues($method, $list);
```

Make sure your task's `collect()` method returns all of them:

```php
return [
    $override->key() => $override,
    $argumentsSet->key() => $argumentsSet,
    $expectedReturnValues->key() => $expectedReturnValues,
    // ...
];
```

As the key for directive values, always use their `->key()` string.

For more examples and details, see the [PhpStorm Advanced Metadata documentation](https://confluence.jetbrains.com/display/PhpStorm/PhpStorm+Advanced+Metadata).

## Literal Keys

If you really need literal string keys (no auto-quoting), use the `KeyValue`
value object:

```php
$key = ClassName::create(Bar::class);
$value = ClassName::create(Bar::class);
$keyValue = KeyValue::create($key, $value);

// Now use it as any other value
$map = [
    'thisKeyIsOnlyForSortingNow' => $keyValue,
    // ...
];
$directive = new Override('\\' . Table::class . '::returnMy(0)', $map);
```

It allows you to control the quoting of both key and value. The map key here
is only used for sorting.

::: info Override-only
This value object can only be used for the `Override` directive — that's the
one that actually makes use of associative keys.
:::


================================================
FILE: docs/generator/index.md
================================================
# Meta File Generator

![Model Typehinting](/img/model_typehinting.png)

![Model Autocomplete](/img/model_autocomplete.png)

The meta file generator produces `.phpstorm.meta.php` files that PhpStorm and
VS Code (with PHP Intelephense) use to understand factories, magic strings,
and return types throughout the CakePHP code base.

## PhpStorm

This command generates `.ide-helper.meta.php` in your app's
`ROOT/.phpstorm.meta.php/` directory:

```bash
bin/cake generate phpstorm
```

Make sure it is indexed (a restart of PhpStorm may be required).

::: info Why a directory?
We use a directory here to allow custom and manually created meta files
alongside this generated file. Any file inside this directory will be parsed
and used. Prefixing the file with a `.` is recommended so PHPCS skips it
automatically.
:::

## What's Next

- [Available Tasks](./tasks) — every built-in task and what it covers
- [Custom Tasks and Directives](./custom-tasks) — add your own tasks, available directives, examples
- [Operations](./operations) — include/exclude plugins, CI checks, reusing argument sets


================================================
FILE: docs/generator/operations.md
================================================
# Operations

Cross-cutting flags and workflows for the meta file generator.

## Include/Exclude Plugins

Many plugins do not need to be "loaded" — those would normally not be
included in the generator tasks. If you want to add some not-loaded plugins
into the list of plugins to process, use:

```php
'IdeHelper' => [
    'plugins' => [
        'MyNotLoadedPlugin',
        '-BlacklistedLoadedPlugin',
    ],
],
```

With the `-` prefix you can even exclude loaded plugins from being processed.

## CI or Pre-Commit Check

Using `-d` (dry run) you will get error code `2` if the file would need
updating:

```bash
bin/cake generate phpstorm -d
```

This way you can automate the check for CI tooling or commit hooks.

## Reusing Argument Sets

You can reuse argument sets that are present from any of the built-in or your
custom tasks.

In verbose mode the console gives you the available sets for re-use:

```bash
bin/cake generate phpstorm -v
```

You can then directly make use of them in any matching directive (for such
lists):

- `ExpectedArguments`
- `ExpectedReturnValues`


================================================
FILE: docs/generator/tasks.md
================================================
# Available Tasks

The list of built-in tasks shipped with the meta file generator.

## Plugins

In your `Application.php` you can — after composer-requiring (and refreshing
the meta file) — auto-complete the available plugins for your `addPlugin()`
calls:

```php
    public function bootstrap(): void {
        // ...
        $this->addPlugin('TypeHere');
    }
```

This is especially useful for more complex and possibly vendor-prefixed
names (e.g. `'Cake/TwigView'`, note the forward slash).

## Models

```php
/** @var \App\Model\Table\UsersTable $users */
$users = TableRegistry::getTableLocator()->get('Users');
$users->doSomething();
```

So far `$users` required the annotation above to be type-hinted and
clickable. With the generated meta file this is no longer necessary. The
static factory call is detected and `$users` is hinted as
`\App\Model\Table\UsersTable`, making `doSomething()` available in the IDE
for method argument checking and following.

This task also annotates dynamic model factory calls (e.g.
`$this->getTableLocator()->get('Users')`) and `loadModel()` usage.

![Model Autocomplete loadModel](/img/model_autocomplete_loadmodel.png)

If you prefer FQCN as the argument, you still get the benefit for the return
type:

```php
use App\Model\Table\UsersTable;

$users = TableRegistry::getTableLocator()->get(UsersTable::class);
$users->doSomething();
```

It now knows the concrete object of `$users` and can autocomplete the method
call right away. You will not be able to quickly select from a list of input
options in this form, however.

## Entities

The following are auto-completed, for example:

```php
$user->setDirty('field_name');
$user->setError('field_name');
$user->getOriginal('field_name');
// ...
```

## TableAssociations

The following are auto-completed, for example:

```php
$this->belongsTo('Authors');
$this->hasOne('Book');
$this->hasMany('Articles');
$this->belongsToMany('Tags.Tags');
```

## TableFinders

The `'threaded'` string is now auto-completed, for example:

```php
$this->Posts->find('threaded');
```

::: tip Preemptive finders
Using Configure key `'IdeHelper.preemptive'` set to `true`, you can be a bit
more verbose and include all possible custom finders, including those from
behaviors.
:::

![Model Autocomplete finder](/img/model_autocomplete_finder.png)

## Behaviors

The following are auto-completed, for example:

```php
$this->addBehavior('Tools.Slugged');
$this->removeBehavior('Slugged'); // Note the alias without plugin prefix
```

## Components

The following are auto-completed, for example:

```php
$this->loadComponent('My.Useful');
$this->components()->unload('Useful'); // Note the alias without plugin prefix
```

## Helpers

The following are auto-completed, for example:

```php
$this->loadHelper('Tools.Tree');
```

And so is `addHelper()` (added in CakePHP 4.1) on the `ViewBuilder`:

```php
$this->viewBuilder()
    ->addHelper('TinyAuth.AuthUser')
    ->addHelper('Tools.Tree');
```

## Mailers

The following is auto-completed and returns the corresponding Mailer class:

```php
$userMailer = $this->getMailer('User');
```

## Types

In your bootstrap (app or plugin) you might add additional database `Type`
classes, or reconfigure existing ones:

```php
Type::build('date')->useLocaleParser()->setLocaleFormat('d.m.Y');
Type::build('datetime')->useLocaleParser()->setLocaleFormat('d.m.Y H:i');
```

The IDE recognizes the returned type of class and allows auto-complete here,
too. Same for `Type::map()` and type strings like `integer`, `string`, etc.:

```php
Type::map('decimal', ...);
```

## Elements

Heavy users of elements in templates: tired of typing the full template name
in `$this->element('...')` calls? PhpStorm auto-completes this, including all
elements from plugins.

## Layouts

`$this->viewBuilder->setLayout(...)` is auto-completed.

## Cache

`Cache::write()`, `Cache::read()` and other methods are auto-completed for
the cache engine(s) available.

## FormHelper

`$this->Form->control()` is auto-completed for the model fields available.

## Validation

### `Validator::requirePresence()`

![Validation Autocomplete Validator::requirePresence()](/img/validation_autocomplete_validator_require_presence.png)

Now not just `bool`, but also the possible "magic strings" are type-hinted
and usable as single click/enter.

## Request params

`$this->request->getParam()` auto-completes for `prefix`, `controller` and
other common keys.

## Configure keys

![Configure Autocomplete](/img/configure_autocomplete.png)

`Configure::read()` and the other methods are auto-completed for currently
existing keys. Numeric keys are excluded as they are usually not part of an
associative array config.

## ENV keys

`env()` is auto-completed for most common and used keys.

## Translation keys

Using `__()` and `__d()` can be auto-completed based on your project's `.po`
files.

::: info Quoting limitation
PhpStorm is [not smart enough yet](https://youtrack.jetbrains.com/issue/WI-52508)
to auto-adjust any (escaped or not) quotes in your strings. So in those cases
you must use `'` as delimiters for your strings if you want auto-complete:

```php
<?php echo __('A "quoted" string'); ?>
<?php echo __('A \'literally quoted\' string'); ?>
<?php echo __('A variable \'\'{0}\'\' be replaced.', __('will')); ?>
```

Any further `'` inside will be escaped for you.
:::

## ConnectionManager

`ConnectionManager::get()` is auto-completed for the currently configured
connection aliases.

## Fixtures

`TestCase::addFixture()` is auto-completed for the currently available
fixtures from app, core, and plugins.

## Migrations plugin database tables

When using the Migrations plugin, this task comes in handy to quickly
autocomplete existing tables, their column names, and possible column types.

It excludes CakePHP internal tables and all `phinxlog` ones by default. You
can use a regex blacklist to further exclude certain tables:

```php
'IdeHelper' => [
    'skipDatabaseTables' => [
        '/customRegexPattern/',
        // ...
    ],
],
```


================================================
FILE: docs/guide/ide-support.md
================================================
# IDE Support

This plugin is intended to work with **any IDE** that supports annotations and
code completion. Below is the current state of testing and integration.

## Tested IDEs

IDEs tested for full compatibility:

- **[PhpStorm](https://github.com/dereuromark/cakephp-ide-helper/wiki/PHPStorm)** — also supports the meta file generator
- IntelliJ IDEA
- Atom
- **[VS Code](https://github.com/dereuromark/cakephp-ide-helper/wiki/Visual-Studio-Code)** — meta file works via the PHP Intelephense plugin
- Report or open a PR for your IDE on the [wiki](https://github.com/dereuromark/cakephp-ide-helper/wiki) to confirm full compatibility.

## Plugins With Meta File Generator Tasks

The following plugins ship Generator tasks that build on top of this plugin:

- [Migrations](https://github.com/cakephp/migrations) — migration file writing (included in IdeHelper directly).
- [Queue](https://github.com/dereuromark/cakephp-queue) — `QueuedJobsTable::createJob()` usage.
- [Burzum/CakeServiceLayer](https://github.com/burzum/cakephp-service-layer) — `loadService()` usage.
- [CakephpFixtureFactories](https://github.com/vierge-noire/cakephp-fixture-factories) — factory class autocomplete.

Add yours via PR.

## Plugins With Annotator Tasks

- See the [IdeHelperExtra](https://github.com/dereuromark/cakephp-ide-helper-extra) plugin for a curated collection of additional annotator tasks.

## Plugins With Illuminator Tasks

- [StateMachine](https://github.com/spryker/cakephp-statemachine) — syncs states from XML into PHP.

## Sponsorship

[![PhpStorm logo.](https://resources.jetbrains.com/storage/products/company/brand/logos/PhpStorm.svg)](https://jb.gg/OpenSourceSupport)

JetBrains sponsors PhpStorm for the FOSS work on this repository and beyond.


================================================
FILE: docs/guide/index.md
================================================
# Introduction

`cakephp-ide-helper` improves IDE compatibility and uses annotations to make
your IDE understand the "magic" of CakePHP, so you can click through class
methods and object chains and spot obvious issues and mistakes earlier. It
also improves compatibility with tools like [PHPStan](https://github.com/phpstan/phpstan).

> Boost your productivity. Avoid mistakes.

This branch is for use with **CakePHP 5.1+**. For older versions see the
[version map](https://github.com/dereuromark/cakephp-ide-helper/wiki#cakephp-version-map).

## Two Tools, One Plugin

There are two main tools for keeping your code up to date:

| Tool | Modifies | When to use |
|------|----------|-------------|
| **Annotator** | Doc blocks and annotations only — never functional code | Keep type hints in sync as the codebase evolves |
| **Illuminator** | Functional code itself (constants, methods, etc.) | One-shot rewrites — for example, add entity field constants |

On top of those there are two stub-file generators:

| Generator | Output | Audience |
|-----------|--------|----------|
| **Meta File Generator** | `.phpstorm.meta.php/.ide-helper.meta.php` | PhpStorm and VS Code (Intelephense) |
| **Code Completion Generator** | Generic PHP stubs in `TMP/` | Any IDE that indexes PHP files |

Annotations are needed for static analyzers to understand the code; the meta
file and code completion stubs are mainly IDE autocomplete helpers.

## What's Next

1. [Installation](./installation) — Get the plugin set up
2. [Usage](./usage) — High-level commands and recommended composer scripts
3. [IDE Support](./ide-support) — Tested IDEs and plugins-of-this-plugin
4. [Annotations](/annotations/) — Per-class-type annotation reference
5. [Code Completion](/code-completion/), [Generator](/generator/), [Illuminator](/illuminator/)

If you are upgrading from 4.x see [Migrating from 4.x](./migration).


================================================
FILE: docs/guide/installation.md
================================================
# Installation

## Composer

Install as a `require-dev` dependency:

```bash
composer require --dev dereuromark/cakephp-ide-helper
```

## Plugin Loading

Enable the plugin in your `Application.php` or call:

```bash
bin/cake plugin load IdeHelper
```

::: tip Local-only loading
As a `require-dev` dependency, the plugin should only load for local
development. Wrap the registration with a check or `try`/`catch`, and ideally
also restrict it to CLI mode (`if (PHP_SAPI === 'cli')`).
:::

## Verifying the Install

Once the plugin is loaded, the following commands become available:

```bash
bin/cake annotate --help
bin/cake generate --help
bin/cake illuminate --help
```

If those resolve, you are ready to move on to [Usage](./usage).


================================================
FILE: docs/guide/migration.md
================================================
# Migrating from 4.x

A few commands were renamed when moving to 5.x:

| 4.x | 5.x |
|-----|-----|
| `bin/cake code_completion generate` | `bin/cake generate code_completion` |
| `bin/cake phpstorm generate` | `bin/cake generate phpstorm` |
| `bin/cake illuminator` | `bin/cake illuminate code` |

If you have composer scripts or CI jobs referencing the old commands, update
them accordingly.


================================================
FILE: docs/guide/usage.md
================================================
# Usage

A short tour of the high-level commands. Each section has a dedicated guide
with the full set of options.

## Annotations

Run on your app:

```bash
bin/cake annotate [type]
```

By default it prints a diff of the changes plus the number of modified lines.

Run on a loaded plugin:

```bash
bin/cake annotate [type] -p FooBar
```

The plugin is autoloaded if needed (when not manually loaded already).

Use `-v` for verbose output:

```bash
bin/cake annotate [type] -v
```

Add `-d` (`--dry-run`) to simulate the output without modifying files.

See [Annotations](/annotations/) for the full reference.

## Code Completion

The code completion file aims to be generic and to work with all IDEs.

Generate the code completion files into `TMP/`:

```bash
bin/cake generate code_completion
```

See [Code Completion](/code-completion/).

## Meta File Generator

The meta file is supported by:

- PhpStorm (2016.2+)
- VS Code with the [PHP Intelephense](https://marketplace.visualstudio.com/items?itemName=bmewburn.vscode-intelephense-client) plugin

Generate the app-level `.phpstorm.meta.php` file:

```bash
bin/cake generate phpstorm
```

See [Generator](/generator/).

## Illuminator

Rewrite PHP files using configured Illuminator tasks:

```bash
bin/cake illuminate code <path>
```

Use `-v` for verbose output and `-t` (`--task`) with a comma-separated list to
limit the run to specific tasks. Add `-d` (`--dry-run`) to simulate.

See [Illuminator](/illuminator/).

## Recommended composer Scripts

Group commands so they are easy to remember and easy to wire into hooks or CI:

```json
"scripts": {
    "setup": "bin/cake generate code_completion && bin/cake generate phpstorm",
    "annotate": "bin/cake annotate all && bin/cake annotate all -p Sandbox",
    "illuminate": "bin/cake illuminate code"
}
```

That way you only have to remember the wrapper commands:

- `composer setup` — also useful as a Git hook after checkout/pull
- `composer annotate` — include all your `/plugins/` (the non-vendor ones)
- `composer illuminate` — include all your `/plugins/` (the non-vendor ones)


================================================
FILE: docs/illuminator/index.md
================================================
# PHP File Illuminator

The Illuminator can modify your PHP files based on Illuminator rule sets. You
can use the pre-set tasks, or create your own to enhance your PHP files and
classes.

::: warning Modifies functional code
Unlike the [Annotator](/annotations/), which only updates doc blocks and
annotations, the Illuminator actually modifies existing code. Make sure to
back up or commit your changes before running it.
:::

Each task has its own scope defined, based on path or filename. If a task's
scope does not match a file, it is skipped.

Use `-p PluginName` to run inside a plugin.

::: tip Plugin wildcards
Use `*` to refer to a group of plugins, e.g. `-p SomePrefix/*` for everything
under your own `plugins/` directory. You can also use `all` for all app
plugins.

For more than one plugin the command will not run into `vendor/` plugins, to
avoid accidental modification there.
:::

## Available Tasks

### EntityField

Your entities expose their fields either via `get()`/`set()` or as class
properties. Especially when using them through methods, you have no
type-hinting/autocomplete on those magic strings. In these cases, having
class constants is the solution.

This task adds them based on the defined property annotations in the doc
block:

```php
/**
 * @property int $id
 * @property string $brand_name
 * @property \Cake\I18n\DateTime $created
 * @property \Cake\I18n\DateTime|null $retired
 * @property \App\Model\Entity\Wheel[] $wheels
 */
class Car extends Entity {

    public const FIELD_ID = 'id';
    public const FIELD_BRAND_NAME = 'brand_name';
    // ...

}
```

This is especially useful for code like:

```php
// old
$carEntity->setDirty('wheels');

// new
$carEntity->setDirty($carEntity::FIELD_WHEELS);
```

or:

```php
// old
$query->orderByDesc('publish_date');

// new
$query->orderByDesc(Post::FIELD_PUBLISH_DATE);
```

This allows for less typing as autocomplete finds it immediately — and for
usage display (IDE → right-click → get usage). That also means refactoring is
much easier this way (via the IDE, usually a clean
one-modification-refactor across the whole project).

::: info Visibility flag
Since PHP 7.1+ this task adds the `public` visibility flag if you don't
configure it otherwise.

This task does not clean out removed or renamed fields. You should quickly
check for usage of the constant — if unused it can be safely removed.
:::

![Fields Autocomplete](/img/fields_autocomplete.png)

## Adding Your Own Tasks

Create your own task class:

```php
namespace App\Illuminator\Task;

use IdeHelper\Illuminator\Task\TaskInterface;

class MyTask implements TaskInterface {

    /**
     * @param string $path
     * @return bool
     */
    public function shouldRun(string $path): bool {
        // ...
    }

    /**
     * @param string $content
     * @param string $path
     * @return string
     */
    public function run(string $content, string $path): string {
        // ...
    }

}
```

Then add it to the config:

```php
'IdeHelper' => [
    'IlluminatorTasks' => [
        'MyTask' => \App\Illuminator\Task\MyTask::class,
    ],
],
```

The key `'MyTask'` can be any string, but it must be unique across all
existing tasks.

### Replacing native tasks

Using associative arrays you can swap any native task with your own
implementation:

```php
'IdeHelper' => [
    'IlluminatorTasks' => [
        \IdeHelper\Illuminator\Task\FooBarTask::class => \App\Illuminator\Task\MyEnhancedFooBarTask::class,
    ],
],
```

The native class name is the key, your replacement the value. Setting the
value to `null` disables a native task entirely.

## Configuration

You can specify specific settings via `app.php` config:

- `'IdeHelper.illuminatorIndentation'` as `'    '` to use spaces as indentation
  whitespace; defaults to `"\t"`.

## Important Constraint

Some tasks may be based on the results of the Annotator. Make sure to run the
Annotator first, e.g.:

```bash
bin/cake annotate all && bin/cake illuminate code <path>
```

## CI or Pre-Commit Check

Using `-d` (dry run) you will get error code `2` if the file would need
updating. This way you can automate the check for CI tooling or commit hooks.


================================================
FILE: docs/index.md
================================================
---
layout: home

hero:
  name: cakephp-ide-helper
  text: IDE Helper for CakePHP
  tagline: Annotations, meta files, code-completion stubs, and Illuminator tasks — boost IDE and static analyzer support, avoid mistakes.
  image:
    src: /logo.svg
    alt: cakephp-ide-helper
  actions:
    - theme: brand
      text: Get Started
      link: /guide/
    - theme: alt
      text: Annotations
      link: /annotations/
    - theme: alt
      text: View on GitHub
      link: https://github.com/dereuromark/cakephp-ide-helper

features:
  - icon: 📝
    title: Annotations Updater
    details: Keep doc blocks and annotations on controllers, models, entities, templates, commands, and more in sync as your code evolves.
  - icon: 🧠
    title: Meta File Generator
    details: Produce `.phpstorm.meta.php` files so PhpStorm and VS Code understand factories, magic strings, and return types.
  - icon: 💡
    title: Code Completion Stubs
    details: IDE-agnostic stub generation for behaviors and SelectQuery generics, so chained ORM calls keep their types.
  - icon: ⚙️
    title: Illuminator Tasks
    details: Rewrite source files where annotations are not enough — for example, generate entity field constants automatically.
  - icon: 🔁
    title: CI and Watcher Friendly
    details: Run as a CI check (`-d --ci`), pre-commit hook, or live file watcher with chokidar or watchexec.
  - icon: 🧱
    title: Extensible
    details: Plug in your own annotators, callback tasks, generator tasks, and Illuminator tasks — replace built-ins or add new ones.
---


================================================
FILE: docs/package.json
================================================
{
  "name": "cakephp-ide-helper-docs",
  "private": true,
  "type": "module",
  "scripts": {
    "docs:dev": "vitepress dev",
    "docs:build": "vitepress build",
    "docs:preview": "vitepress preview"
  },
  "devDependencies": {
    "vitepress": "^1.6.3",
    "vue": "^3.5.13"
  }
}


================================================
FILE: docs/reference/configuration.md
================================================
# Configuration Reference

All Configure options live under the `IdeHelper` key in `app.php`. The
canonical reference with defaults is the `app.example.php` file in the
plugin's `/config/` directory — that file is the source of truth and can be
copy-pasted into your project config.

## Common Keys at a Glance

The list below highlights the keys mentioned across this documentation. For
the full set, defaults, and the most up-to-date options, see
[`config/app.example.php`](https://github.com/dereuromark/cakephp-ide-helper/blob/master/config/app.example.php).

### Annotator

| Key | Type | Notes |
|-----|------|-------|
| `arrayAsGenerics` | `bool` | Use modern `array<type>` instead of legacy `type[]`. |
| `genericsInParam` | `false \| true \| 'detailed'` | Tri-state for table method param types. See [Models](/annotations/models). |
| `tableEntityQuery` | `bool` | Expose entity-aware `find()` return type on tables. |
| `prefixes` | `array` | Whitelist of controller subfolder prefixes. |
| `typeMap` | `array` | Map DB types → PHP types for entity property annotations. |
| `nullableMap` | `array` | Map DB types → nullability flag. |
| `includedPlugins` | `array \| true` | Plugins to include when annotating helpers in `AppView`. |
| `templateExtensions` | `array` | File extensions processed by the templates annotator. Defaults to `['ctp', 'php']`. |
| `skipTemplatePaths` | `array` | Template folders the annotator should skip. `/templates/Bake/` is skipped by default. |
| `templateCollectionObject` | `string \| false` | FQCN (or `iterable`/`false`) used for template collection annotations. |
| `autoCollect` | `bool \| callable` | Auto-collect template variables. |
| `autoCollectBlacklist` | `array` | Strings or regex patterns of variables to exclude from auto-collection. |
| `preemptive` | `bool` | Preemptive annotations (e.g. always add `@var \App\View\AppView $this` to templates). |
| `viewClass` | `string` | Custom AppView FQCN. |
| `preferLinkOverUsesInTests` | `bool` | Use `@link` (default) vs. `@uses` in test class annotations. |
| `annotators` | `array` | Replace or disable native annotators. |
| `classAnnotatorTasks` | `array` | Register or replace class-annotator tasks. |
| `CallbackAnnotatorTasks` | `array` | Register or replace callback-annotator tasks. |

### Generator

| Key | Type | Notes |
|-----|------|-------|
| `plugins` | `array` | Include not-loaded plugins or exclude loaded ones (`-` prefix). |
| `generatorTasks` | `array` | Register or replace generator tasks. |
| `skipDatabaseTables` | `array` | Regex blacklist for the Migrations-tables generator task. |

### Code Completion

| Key | Type | Notes |
|-----|------|-------|
| `codeCompletionPath` | `string` | Custom output path for code completion files (e.g. `ROOT . DS . '.phpstorm.meta.php' . DS`). |
| `codeCompletionTasks` | `array` | Register or replace code completion tasks. |

### Illuminator

| Key | Type | Notes |
|-----|------|-------|
| `illuminatorIndentation` | `string` | Indentation whitespace; defaults to `"\t"`. Use `'    '` for spaces. |
| `IlluminatorTasks` | `array` | Register or replace Illuminator tasks. |

## Replacing or Disabling Native Tasks

For each task type, the registration array uses `'CustomKey' => ClassName`
to add a task, or the native class name as the key to replace one:

```php
'IdeHelper' => [
    'annotators' => [
        // Replace a native annotator
        \IdeHelper\Annotator\EntityAnnotator::class => \App\Annotator\MyEnhancedEntityAnnotator::class,
        // Disable a native annotator
        \IdeHelper\Annotator\HelperAnnotator::class => null,
        // Add a custom annotator
        'MyCustomAnnotator' => \App\Annotator\MyCustomAnnotator::class,
    ],
],
```

The same pattern applies to `classAnnotatorTasks`, `CallbackAnnotatorTasks`,
`generatorTasks`, `codeCompletionTasks`, and `IlluminatorTasks`.


================================================
FILE: docs/reference/contributing.md
================================================
# Contributing

## Basics

See the composer scripts:

```bash
composer cs-check
composer cs-fix
composer test-setup
composer test
```

## Generator

### New meta file

Run the test with the `--debug` option to generate a new `TMP/.meta.php`:

```bash
php phpunit.phar tests/TestCase/Generator/PhpstormGeneratorTest.php --debug
```

You can then easily copy it over into the `test_files/` directory and replace
the existing one.


================================================
FILE: phpcs.xml
================================================
<?xml version="1.0"?>
<ruleset name="plugin">
	<arg name="cache" value=".phpcs.cache"/>
	<rule ref="PSR2R"/>

    <arg value="nps"/>

    <file>config/</file>
    <file>src/</file>
    <file>tests/</file>

    <exclude-pattern>/tests/test_files/</exclude-pattern>
    <exclude-pattern>/tests/test_app/</exclude-pattern>
</ruleset>


================================================
FILE: phpstan.neon
================================================
parameters:
	level: 8
	paths:
		- src/

	treatPhpDocTypesAsCertain: false
	bootstrapFiles:
		- tests/bootstrap.php
		- tests/shim.php
	ignoreErrors:
		- '#Unsafe usage of new static\(\).+#'
		- '#Parameter \#1 \$object of function get_class expects object, object\|string given.#'
		-
			message: '#(unknown class Phinx\\|invalid return type Phinx\\|undefined method Migrations\\Migrations)#'
			path: src/Generator/Task/DatabaseTableColumnTypeTask.php


================================================
FILE: phpunit.xml.dist
================================================
<?xml version="1.0" encoding="UTF-8"?>
<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
		 colors="true"
		 bootstrap="tests/bootstrap.php"
		 xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/10.2/phpunit.xsd">
	<php>
		<ini name="memory_limit" value="-1"/>
		<!-- E_ALL => 32767 -->
		<!-- E_ALL & ~E_USER_DEPRECATED => 16383 -->
		<ini name="error_reporting" value="32767"/>

		<env name="FIXTURE_SCHEMA_METADATA" value="tests/schema.php"/>
	</php>

	<testsuites>
		<testsuite name="ide-helper">
			<directory>tests/TestCase/</directory>
		</testsuite>
	</testsuites>

	<extensions>
		<bootstrap class="Cake\TestSuite\Fixture\Extension\PHPUnitExtension"/>
	</extensions>

	<source>
		<include>
			<directory suffix=".php">src/</directory>
		</include>
	</source>
</phpunit>


================================================
FILE: src/Annotation/AbstractAnnotation.php
================================================
<?php

namespace IdeHelper\Annotation;

use RuntimeException;

abstract class AbstractAnnotation implements AnnotationInterface, ReplacableAnnotationInterface {

	/**
	 * @var string
	 */
	public const TAG = '';

	protected string $type;

	protected ?int $index;

	/**
	 * Needed for removing annotations
	 */
	protected bool $isInUse = false;

	/**
	 * @param string $type
	 * @param int|null $index
	 */
	public function __construct(string $type, ?int $index = null) {
		$this->type = $type;
		$this->index = $index;
	}

	/**
	 * @return string
	 */
	public function __toString(): string {
		return static::TAG . ' ' . $this->build();
	}

	/**
	 * @return string
	 */
	public function getType(): string {
		return $this->type;
	}

	/**
	 * @return bool
	 */
	public function hasIndex(): bool {
		return $this->index !== null;
	}

	/**
	 * @throws \RuntimeException
	 * @return int
	 */
	public function getIndex(): int {
		$index = $this->index;
		if ($index === null) {
			throw new RuntimeException('You cannot get an non-defined index. You can check with hasIndex() before calling this method.');
		}

		return $index;
	}

	/**
	 * @param bool $inUse
	 *
	 * @return void
	 */
	public function setInUse(bool $inUse = true): void {
		$this->isInUse = $inUse;
	}

	/**
	 * @return bool
	 */
	public function isInUse(): bool {
		return $this->isInUse;
	}

}


================================================
FILE: src/Annotation/AnnotationFactory.php
================================================
<?php

namespace IdeHelper\Annotation;

use RuntimeException;

class AnnotationFactory {

	protected string $property;

	/**
	 * @param string $tag
	 * @param string $type
	 * @param string|null $content
	 * @param int|null $index
	 * @return \IdeHelper\Annotation\AbstractAnnotation|null
	 */
	public static function create($tag, $type, $content = null, $index = null) {
		switch ($tag) {
			case PropertyAnnotation::TAG:
				return new PropertyAnnotation($type, (string)$content, $index);
			case PropertyReadAnnotation::TAG:
				return new PropertyReadAnnotation($type, (string)$content, $index);
			case MethodAnnotation::TAG:
				return new MethodAnnotation($type, (string)$content, $index);
			case VariableAnnotation::TAG:
				return new VariableAnnotation($type, (string)$content, $index);
			case MixinAnnotation::TAG:
				if ($content) {
					$type .= ' ' . $content;
				}

				return new MixinAnnotation($type, $index);
			case ParamAnnotation::TAG:
				return new ParamAnnotation($type, (string)$content, $index);
			case UsesAnnotation::TAG:
				if ($content) {
					$type .= ' ' . $content;
				}

				return new UsesAnnotation($type, $index);
			case ExtendsAnnotation::TAG:
				if ($content) {
					$type .= ' ' . $content;
				}

				return new ExtendsAnnotation($type, $index);
			case LinkAnnotation::TAG:
				if ($content) {
					$type .= ' ' . $content;
				}

				return new LinkAnnotation($type, $index);
			case SeeAnnotation::TAG:
				if ($content) {
					$type .= ' ' . $content;
				}

				return new SeeAnnotation($type, $index);
		}

		return null;
	}

	/**
	 * @param string $annotation (e.g. `@method \Foo\Bar myMethod($x, $y)`)
	 *
	 * @return \IdeHelper\Annotation\AbstractAnnotation|null
	 */
	public static function createFromString($annotation) {
		preg_match('/^@mixin (.+)\s*(.+)?$/', $annotation, $matches);
		if ($matches) {
			return static::create(MixinAnnotation::TAG, $matches[1]);
		}
		preg_match('/^@uses (.+)\s*(.+)?$/', $annotation, $matches);
		if ($matches) {
			return static::create(UsesAnnotation::TAG, $matches[1]);
		}
		preg_match('/^@extends ([^\s!]+<.*?>)(?:\s*([!]))?/', $annotation, $matches);
		if ($matches) {
			$string = implode(' ', $matches);

			return static::create(ExtendsAnnotation::TAG, $string);
		}

		// Split `@tag <type> <rest>`: the type may contain spaces inside generic
		// brackets (e.g. `Foo<int, Bar>`), so naive `[^ ]+` would cut it short.
		// Walk the type char-by-char, tracking `<>` depth, and stop at the first
		// top-level space.
		if (preg_match('/^(@property|@property-read|@method|@var|@param) (.+)$/', $annotation, $matches)) {
			$tag = $matches[1];
			$rest = $matches[2];
			$depth = 0;
			$len = strlen($rest);
			$split = -1;
			for ($i = 0; $i < $len; $i++) {
				$c = $rest[$i];
				if ($c === '<') {
					$depth++;
				} elseif ($c === '>') {
					$depth = max(0, $depth - 1);
				} elseif ($c === ' ' && $depth === 0) {
					$split = $i;

					break;
				}
			}
			if ($split <= 0) {
				return null;
			}
			$type = substr($rest, 0, $split);
			$content = substr($rest, $split + 1);

			return static::create($tag, $type, $content);
		}

		return null;
	}

	/**
	 * @param string $tag
	 * @param string $type
	 * @param string|null $content
	 * @param int|null $index
	 * @throws \RuntimeException
	 * @return \IdeHelper\Annotation\AbstractAnnotation
	 */
	public static function createOrFail($tag, $type, $content = null, $index = null) {
		$annotation = static::create($tag, $type, $content, $index);
		if (!$annotation) {
			throw new RuntimeException('Cannot create annotation for tag ' . $tag . ', type ' . $type);
		}

		return $annotation;
	}

}


================================================
FILE: src/Annotation/AnnotationInterface.php
================================================
<?php

namespace IdeHelper\Annotation;

interface AnnotationInterface {

	/**
	 * @return string
	 */
	public function getDescription(): string;

	/**
	 * @return string
	 */
	public function build(): string;

}


================================================
FILE: src/Annotation/ExtendsAnnotation.php
================================================
<?php

namespace IdeHelper\Annotation;

class ExtendsAnnotation extends AbstractAnnotation {

	/**
	 * @var string
	 */
	public const TAG = '@extends';

	protected string $description;

	/**
	 * @param string $type
	 * @param int|null $index
	 */
	public function __construct(string $type, ?int $index = null) {
		$description = '';

		$closingBracket = strrpos($type, '>');
		if ($closingBracket) {
			$description = substr($type, $closingBracket + 1);
			$description = trim($description);
			$type = substr($type, 0, $closingBracket + 1);
		}

		parent::__construct($type, $index);

		$this->description = $description;
	}

	/**
	 * @return string
	 */
	public function getDescription(): string {
		return $this->description;
	}

	/**
	 * @return string
	 */
	public function build(): string {
		$description = $this->description !== '' ? (' ' . $this->description) : '';

		return $this->type . $description;
	}

	/**
	 * @param \IdeHelper\Annotation\AbstractAnnotation|\IdeHelper\Annotation\ExtendsAnnotation $annotation
	 *
	 * @return bool
	 */
	public function matches(AbstractAnnotation $annotation): bool {
		if (!$annotation instanceof self) {
			return false;
		}

		// Always matches as there can only be one per docblock
		return true;
	}

	/**
	 * @param \IdeHelper\Annotation\AbstractAnnotation|\IdeHelper\Annotation\ExtendsAnnotation $annotation
	 * @return void
	 */
	public function replaceWith(AbstractAnnotation $annotation): void {
		$this->type = $annotation->getType();
	}

}


================================================
FILE: src/Annotation/LinkAnnotation.php
================================================
<?php

namespace IdeHelper\Annotation;

class LinkAnnotation extends AbstractAnnotation {

	/**
	 * @var string
	 */
	public const TAG = '@link';

	protected string $description;

	/**
	 * @param string $type
	 * @param int|null $index
	 */
	public function __construct($type, $index = null) {
		$description = '';
		if (str_contains($type, ' ')) {
			[$type, $description] = explode(' ', $type, 2);
		}

		parent::__construct($type, $index);

		if (preg_match('/^(http|https):/', $type)) {
			$this->isInUse = true;
		}

		$this->description = $description;
	}

	/**
	 * @return string
	 */
	public function getDescription(): string {
		return $this->description;
	}

	/**
	 * @return string
	 */
	public function build(): string {
		$description = $this->description !== '' ? (' ' . $this->description) : '';

		return $this->type . $description;
	}

	/**
	 * @param \IdeHelper\Annotation\AbstractAnnotation|\IdeHelper\Annotation\MixinAnnotation $annotation
	 *
	 * @return bool
	 */
	public function matches(AbstractAnnotation $annotation): bool {
		if (!$annotation instanceof self) {
			return false;
		}
		if ($annotation->getType() !== $this->type) {
			return false;
		}

		return true;
	}

	/**
	 * @param \IdeHelper\Annotation\AbstractAnnotation|\IdeHelper\Annotation\MixinAnnotation $annotation
	 * @return void
	 */
	public function replaceWith(AbstractAnnotation $annotation): void {
		$this->type = $annotation->getType();
	}

}


================================================
FILE: src/Annotation/MethodAnnotation.php
================================================
<?php

namespace IdeHelper\Annotation;

class MethodAnnotation extends AbstractAnnotation {

	/**
	 * @var string
	 */
	public const TAG = '@method';

	protected string $method;

	protected string $description;

	/**
	 * @param string $type
	 * @param string $method
	 * @param int|null $index
	 */
	public function __construct($type, $method, $index = null) {
		parent::__construct($type, $index);

		$description = '';
		$closingBrace = strrpos($method, ') ');
		if ($closingBrace !== false && $closingBrace !== strlen($method) - 1) {
			$description = substr($method, $closingBrace + 2);
			$method = substr($method, 0, $closingBrace + 1);
		}

		$this->method = $method;
		$this->description = $description;
	}

	/**
	 * @return string
	 */
	public function getMethod(): string {
		return $this->method;
	}

	/**
	 * @return string
	 */
	public function getDescription(): string {
		return $this->description;
	}

	/**
	 * @return string
	 */
	public function build(): string {
		$description = $this->description !== '' ? (' ' . $this->description) : '';

		return $this->type . ' ' . $this->method . $description;
	}

	/**
	 * @param \IdeHelper\Annotation\AbstractAnnotation|\IdeHelper\Annotation\MethodAnnotation $annotation
	 *
	 * @return bool
	 */
	public function matches(AbstractAnnotation $annotation): bool {
		if (!$annotation instanceof self) {
			return false;
		}
		$methodName = substr($annotation->getMethod(), 0, strpos($annotation->getMethod(), '(') ?: 0);
		if ($methodName !== substr($this->method, 0, strpos($this->method, '(') ?: 0)) {
			return false;
		}

		return true;
	}

	/**
	 * @param \IdeHelper\Annotation\MethodAnnotation $annotation
	 * @return void
	 */
	public function replaceWith(AbstractAnnotation $annotation): void {
		$this->type = $annotation->getType();
		$this->method = $annotation->getMethod();
	}

}


================================================
FILE: src/Annotation/MixinAnnotation.php
================================================
<?php

namespace IdeHelper\Annotation;

class MixinAnnotation extends AbstractAnnotation {

	/**
	 * @var string
	 */
	public const TAG = '@mixin';

	protected string $description;

	/**
	 * @param string $type
	 * @param int|null $index
	 */
	public function __construct($type, $index = null) {
		$description = '';
		if (str_contains($type, ' ')) {
			[$type, $description] = explode(' ', $type, 2);
		}

		parent::__construct($type, $index);

		$this->description = $description;
	}

	/**
	 * @return string
	 */
	public function getDescription(): string {
		return $this->description;
	}

	/**
	 * @return string
	 */
	public function build(): string {
		$description = $this->description !== '' ? (' ' . $this->description) : '';

		return $this->type . $description;
	}

	/**
	 * @param \IdeHelper\Annotation\AbstractAnnotation|\IdeHelper\Annotation\MixinAnnotation $annotation
	 *
	 * @return bool
	 */
	public function matches(AbstractAnnotation $annotation): bool {
		if (!$annotation instanceof self) {
			return false;
		}
		if ($annotation->getType() !== $this->type) {
			return false;
		}

		return true;
	}

	/**
	 * @param \IdeHelper\Annotation\AbstractAnnotation|\IdeHelper\Annotation\MixinAnnotation $annotation
	 * @return void
	 */
	public function replaceWith(AbstractAnnotation $annotation): void {
		$this->type = $annotation->getType();
	}

}


================================================
FILE: src/Annotation/ParamAnnotation.php
================================================
<?php

namespace IdeHelper\Annotation;

class ParamAnnotation extends AbstractAnnotation {

	/**
	 * @var string
	 */
	public const TAG = '@param';

	protected string $variable;

	protected string $description;

	/**
	 * @param string $type
	 * @param string $variable
	 * @param int|null $index
	 */
	public function __construct($type, $variable, $index = null) {
		parent::__construct($type, $index);

		$description = '';
		if (str_contains($variable, ' ')) {
			[$variable, $description] = explode(' ', $variable, 2);
		}

		$this->variable = $variable;
		$this->description = $description;
	}

	/**
	 * @return string
	 */
	public function getVariable(): string {
		return $this->variable;
	}

	/**
	 * @return string
	 */
	public function getDescription(): string {
		return $this->description;
	}

	/**
	 * @return string
	 */
	public function build(): string {
		$description = $this->description !== '' ? (' ' . $this->description) : '';

		return $this->type . ' ' . $this->variable . $description;
	}

	/**
	 * @param \IdeHelper\Annotation\AbstractAnnotation|\IdeHelper\Annotation\ParamAnnotation $annotation
	 *
	 * @return bool
	 */
	public function matches(AbstractAnnotation $annotation): bool {
		if (!$annotation instanceof self) {
			return false;
		}
		if ($annotation->getVariable() !== $this->variable) {
			return false;
		}

		return true;
	}

	/**
	 * @param \IdeHelper\Annotation\ParamAnnotation $annotation
	 * @return void
	 */
	public function replaceWith(AbstractAnnotation $annotation): void {
		$this->type = $annotation->getType();
		$this->variable = $annotation->getVariable();
	}

}


================================================
FILE: src/Annotation/PropertyAnnotation.php
================================================
<?php

namespace IdeHelper\Annotation;

class PropertyAnnotation extends AbstractAnnotation {

	/**
	 * @var string
	 */
	public const TAG = '@property';

	protected string $property;

	protected string $description;

	/**
	 * @param string $type
	 * @param string $property
	 * @param int|null $index
	 */
	public function __construct($type, $property, $index = null) {
		parent::__construct($type, $index);

		$description = '';
		if (str_contains($property, ' ')) {
			[$property, $description] = explode(' ', $property, 2);
		}
		if (!str_starts_with($property, '$')) {
			$property = '$' . $property;
		}

		$this->property = $property;
		$this->description = $description;
	}

	/**
	 * @return string
	 */
	public function getProperty(): string {
		return $this->property;
	}

	/**
	 * @return string
	 */
	public function getDescription(): string {
		return $this->description;
	}

	/**
	 * @return string
	 */
	public function build(): string {
		$description = $this->description !== '' ? (' ' . $this->description) : '';

		return $this->type . ' ' . $this->property . $description;
	}

	/**
	 * @param \IdeHelper\Annotation\AbstractAnnotation|\IdeHelper\Annotation\PropertyAnnotation $annotation
	 *
	 * @return bool
	 */
	public function matches(AbstractAnnotation $annotation): bool {
		if (!$annotation instanceof self) {
			return false;
		}
		if ($annotation->getProperty() !== $this->property) {
			return false;
		}

		return true;
	}

	/**
	 * @param \IdeHelper\Annotation\PropertyAnnotation $annotation
	 * @return void
	 */
	public function replaceWith(AbstractAnnotation $annotation): void {
		$this->type = $annotation->getType();
		$this->property = $annotation->getProperty();
	}

}


================================================
FILE: src/Annotation/PropertyReadAnnotation.php
================================================
<?php

namespace IdeHelper\Annotation;

class PropertyReadAnnotation extends PropertyAnnotation {

	/**
	 * @var string
	 */
	public const TAG = '@property-read';

}


================================================
FILE: src/Annotation/ReplacableAnnotationInterface.php
================================================
<?php

namespace IdeHelper\Annotation;

interface ReplacableAnnotationInterface {

	/**
	 * @param \IdeHelper\Annotation\AbstractAnnotation $annotation
	 *
	 * @return bool
	 */
	public function matches(AbstractAnnotation $annotation): bool;

	/**
	 * @param \IdeHelper\Annotation\AbstractAnnotation $annotation
	 *
	 * @return void
	 */
	public function replaceWith(AbstractAnnotation $annotation): void;

}


================================================
FILE: src/Annotation/SeeAnnotation.php
================================================
<?php

namespace IdeHelper\Annotation;

class SeeAnnotation extends AbstractAnnotation {

	/**
	 * @var string
	 */
	public const TAG = '@see';

	protected string $description;

	/**
	 * @param string $type
	 * @param int|null $index
	 */
	public function __construct($type, $index = null) {
		$description = '';
		if (str_contains($type, ' ')) {
			[$type, $description] = explode(' ', $type, 2);
		}

		parent::__construct($type, $index);

		$this->description = $description;
	}

	/**
	 * @return string
	 */
	public function getDescription(): string {
		return $this->description;
	}

	/**
	 * @return string
	 */
	public function build(): string {
		$description = $this->description !== '' ? (' ' . $this->description) : '';

		return $this->type . $description;
	}

	/**
	 * @param \IdeHelper\Annotation\AbstractAnnotation|\IdeHelper\Annotation\MixinAnnotation $annotation
	 *
	 * @return bool
	 */
	public function matches(AbstractAnnotation $annotation): bool {
		if (!$annotation instanceof self) {
			return false;
		}
		if ($annotation->getType() !== $this->type) {
			return false;
		}

		return true;
	}

	/**
	 * @param \IdeHelper\Annotation\AbstractAnnotation|\IdeHelper\Annotation\MixinAnnotation $annotation
	 * @return void
	 */
	public function replaceWith(AbstractAnnotation $annotation): void {
		$this->type = $annotation->getType();
	}

}


================================================
FILE: src/Annotation/UsesAnnotation.php
================================================
<?php

namespace IdeHelper\Annotation;

class UsesAnnotation extends AbstractAnnotation {

	/**
	 * @var string
	 */
	public const TAG = '@uses';

	protected string $description;

	/**
	 * @param string $type
	 * @param int|null $index
	 */
	public function __construct($type, $index = null) {
		$description = '';
		if (str_contains($type, ' ')) {
			[$type, $description] = explode(' ', $type, 2);
		}

		parent::__construct($type, $index);

		$this->description = $description;
	}

	/**
	 * @return string
	 */
	public function getDescription(): string {
		return $this->description;
	}

	/**
	 * @return string
	 */
	public function build(): string {
		$description = $this->description !== '' ? (' ' . $this->description) : '';

		return $this->type . $description;
	}

	/**
	 * @param \IdeHelper\Annotation\AbstractAnnotation|\IdeHelper\Annotation\MixinAnnotation $annotation
	 *
	 * @return bool
	 */
	public function matches(AbstractAnnotation $annotation): bool {
		if (!$annotation instanceof self) {
			return false;
		}
		if ($annotation->getType() !== $this->type) {
			return false;
		}

		return true;
	}

	/**
	 * @param \IdeHelper\Annotation\AbstractAnnotation|\IdeHelper\Annotation\MixinAnnotation $annotation
	 * @return void
	 */
	public function replaceWith(AbstractAnnotation $annotation): void {
		$this->type = $annotation->getType();
	}

}


================================================
FILE: src/Annotation/VariableAnnotation.php
================================================
<?php

namespace IdeHelper\Annotation;

class VariableAnnotation extends AbstractAnnotation {

	/**
	 * @var string
	 */
	public const TAG = '@var';

	protected string $variable;

	protected string $description;

	protected bool $guessed = false;

	/**
	 * @param string $type
	 * @param string $variable
	 * @param int|null $index
	 */
	public function __construct($type, $variable, $index = null) {
		parent::__construct($type, $index);

		$description = '';
		if (str_contains($variable, ' ')) {
			[$variable, $description] = explode(' ', $variable, 2);
		}
		$this->variable = $variable;
		$this->description = $description;
	}

	/**
	 * @return string
	 */
	public function getVariable(): string {
		return $this->variable;
	}

	/**
	 * @return string
	 */
	public function getDescription(): string {
		return $this->description;
	}

	/**
	 * @param bool $value
	 *
	 * @return $this
	 */
	public function setGuessed($value) {
		$this->guessed = $value;

		return $this;
	}

	/**
	 * @return bool
	 */
	public function getGuessed() {
		return $this->guessed;
	}

	/**
	 * @return string
	 */
	public function build(): string {
		$description = $this->description !== '' ? (' ' . $this->description) : '';

		return $this->type . ' ' . $this->variable . $description;
	}

	/**
	 * @param \IdeHelper\Annotation\AbstractAnnotation|\IdeHelper\Annotation\VariableAnnotation $annotation
	 *
	 * @return bool
	 */
	public function matches(AbstractAnnotation $annotation): bool {
		if (!$annotation instanceof self) {
			return false;
		}
		if ($annotation->getVariable() !== $this->variable) {
			return false;
		}

		return true;
	}

	/**
	 * @param \IdeHelper\Annotation\VariableAnnotation $annotation
	 * @return void
	 */
	public function replaceWith(AbstractAnnotation $annotation): void {
		$newType = $annotation->getType();

		// Preserve |null from existing type when the new type doesn't have it
		if ($this->hasNull() && !$this->typeHasNull($newType)) {
			$newType .= '|null';
		}

		$this->type = $newType;
		$this->variable = $annotation->getVariable();
	}

	/**
	 * @return bool
	 */
	protected function hasNull(): bool {
		return $this->typeHasNull($this->type);
	}

	/**
	 * @param string $type
	 * @return bool
	 */
	protected function typeHasNull(string $type): bool {
		return str_contains($type, '|null') || str_contains($type, 'null|') || $type === 'null';
	}

}


================================================
FILE: src/Annotator/AbstractAnnotator.php
================================================
<?php

namespace IdeHelper\Annotator;

use Bake\View\Helper\DocBlockHelper;
use Cake\Core\Configure;
use Cake\Core\InstanceConfigTrait;
use Cake\View\View;
use IdeHelper\Annotation\AbstractAnnotation;
use IdeHelper\Annotation\AnnotationFactory;
use IdeHelper\Annotation\ExtendsAnnotation;
use IdeHelper\Annotation\LinkAnnotation;
use IdeHelper\Annotation\MethodAnnotation;
use IdeHelper\Annotation\MixinAnnotation;
use IdeHelper\Annotation\PropertyAnnotation;
use IdeHelper\Annotation\PropertyReadAnnotation;
use IdeHelper\Annotation\UsesAnnotation;
use IdeHelper\Annotation\VariableAnnotation;
use IdeHelper\Annotator\Traits\DocBlockTrait;
use IdeHelper\Annotator\Traits\FileTrait;
use IdeHelper\Console\Io;
use IdeHelper\Utility\App;
use PHP_CodeSniffer\Config;
use PHP_CodeSniffer\Files\File;
use PHP_CodeSniffer\Util\Tokens;
use PHPStan\PhpDocParser\Ast\PhpDoc\InvalidTagValueNode;
use ReflectionClass;
use RuntimeException;
use SebastianBergmann\Diff\Differ;
use SebastianBergmann\Diff\Output\DiffOnlyOutputBuilder;

$composerVendorDir = getcwd() . DS . 'vendor';
$codesnifferDir = 'squizlabs' . DS . 'php_codesniffer';
if (!is_dir($composerVendorDir . DS . $codesnifferDir)) {
	$ideHelperDir = substr(__DIR__, 0, strpos(__DIR__, DS . 'cakephp-ide-helper') ?: 0);
	$composerVendorDir = dirname($ideHelperDir);
}
$manualAutoload = $composerVendorDir . DS . $codesnifferDir . DS . 'autoload.php';
if (!class_exists(Config::class) && file_exists($manualAutoload)) {
	require $manualAutoload;
}

abstract class AbstractAnnotator {

	use FileTrait;
	use InstanceConfigTrait;
	use DocBlockTrait;

	/**
	 * @var string
	 */
	public const CONFIG_DRY_RUN = 'dry-run';

	/**
	 * @var string
	 */
	public const CONFIG_PLUGIN = 'plugin';

	/**
	 * @var string
	 */
	public const CONFIG_NAMESPACE = 'namespace';

	/**
	 * @var string
	 */
	public const CONFIG_VERBOSE = 'verbose';

	/**
	 * @var string
	 */
	public const CONFIG_REMOVE = 'remove';

	/**
	 * @var string
	 */
	public const COUNT_REMOVED = 'removed';

	/**
	 * @var string
	 */
	public const COUNT_UPDATED = 'updated';

	/**
	 * @var string
	 */
	public const COUNT_ADDED = 'added';

	/**
	 * @var string
	 */
	public const COUNT_SKIPPED = 'skipped';

	/**
	 * @var array<string>
	 */
	public const TYPES = [
		PropertyAnnotation::TAG,
		PropertyReadAnnotation::TAG,
		VariableAnnotation::TAG,
		MethodAnnotation::TAG,
		MixinAnnotation::TAG,
		UsesAnnotation::TAG,
		LinkAnnotation::TAG,
		ExtendsAnnotation::TAG,
	];

	public static bool $output = false;

	protected Io $_io;

	/**
	 * @var array<string, mixed>
	 */
	protected array $_defaultConfig = [
		self::CONFIG_PLUGIN => null,
	];

	/**
	 * @param \IdeHelper\Console\Io $io
	 * @param array<string, mixed> $config
	 */
	public function __construct(Io $io, array $config) {
		$this->_io = $io;
		$this->setConfig($config);

		$appNamespace = Configure::read('App.namespace', 'App');
		$namespace = $this->getConfig(static::CONFIG_PLUGIN) ?: $appNamespace;
		$namespace = str_replace('/', '\\', $namespace);
		$this->setConfig(static::CONFIG_NAMESPACE, $namespace);
	}

	/**
	 * @param string $path Path to file.
	 * @return bool
	 */
	abstract public function annotate(string $path): bool;

	/**
	 * @param string $oldContent
	 * @param string $newContent
	 * @return void
	 */
	protected function displayDiff(string $oldContent, string $newContent): void {
		$differ = new Differ(new DiffOnlyOutputBuilder());
		$array = $differ->diffToArray($oldContent, $newContent);

		$begin = null;
		$end = null;
		/**
		 * @var int $key
		 */
		foreach ($array as $key => $row) {
			if ($row[1] === 0) {
				continue;
			}

			if ($begin === null) {
				$begin = $key;
			}
			$end = $key;
		}
		if ($begin === null) {
			return;
		}
		$firstLineOfOutput = $begin > 0 ? $begin - 1 : 0;
		$lastLineOfOutput = count($array) - 1 > $end ? $end + 1 : $end;

		for ($i = $firstLineOfOutput; $i <= $lastLineOfOutput; $i++) {
			$row = $array[$i];

			$char = ' ';
			$output = trim($row[0], "\n\r\0\x0B");

			if ($row[1] === 1) {
				$char = '+';
				$this->_io->info('   | ' . $char . $output);
			} elseif ($row[1] === 2) {
				$char = '-';
				$this->_io->out('<warning>' . '   | ' . $char . $output . '</warning>');
			} else {
				$this->_io->out('   | ' . $char . $output);
			}
		}
	}

	/**
	 * @param string $path
	 * @param string $contents
	 * @throws \RuntimeException When the file cannot be written.
	 * @return void
	 */
	protected function storeFile(string $path, string $contents): void {
		static::$output = true;

		if ($this->getConfig(static::CONFIG_DRY_RUN)) {
			return;
		}

		if (file_exists($path) && md5_file($path) === md5($contents)) {
			return;
		}

		if (file_put_contents($path, $contents) === false) {
			throw new RuntimeException(sprintf('Failed to write file `%s`.', $path));
		}
	}

	/**
	 * @var array<string, int>
	 */
	protected array $_counter = [];

	/**
	 * @param string $path
	 * @param string $content
	 * @param array<\IdeHelper\Annotation\AbstractAnnotation> $annotations
	 *
	 * @return bool
	 */
	protected function annotateContent(string $path, string $content, array $annotations): bool {
		if (!count($annotations)) {
			return false;
		}

		$file = $this->getFile($path);

		$classOrTraitIndex = $file->findNext([T_CLASS, T_TRAIT], 0);
		if (!$classOrTraitIndex) {
			return false;
		}
		$beginningOfLineIndex = $this->beginningOfLine($file, $classOrTraitIndex);
		$beginningOfLineIndex = $this->skipOverAttributes($file, $beginningOfLineIndex);

		$closeTagIndex = $this->findDocBlockCloseTagIndex($file, $beginningOfLineIndex);
		$this->resetCounter();
		if ($closeTagIndex && $this->shouldSkip($file, $closeTagIndex)) {
			return false;
		}

		if ($closeTagIndex && !$this->isInlineDocBlock($file, $closeTagIndex)) {
			$newContent = $this->appendToExistingDocBlock($file, $closeTagIndex, $annotations);
		} else {
			$newContent = $this->addNewDocBlock($file, $beginningOfLineIndex, $annotations);
		}

		if ($newContent === $content) {
			$this->reportSkipped($path);

			return false;
		}

		if (!$this->getConfig('verbose')) {
			$this->_io->out('-> ' . str_replace(ROOT . DS, '', $path));
		}

		$this->displayDiff($content, $newContent);
		$this->storeFile($path, $newContent);

		$this->report();

		return true;
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param int $index First functional code after docblock
	 *
	 * @return int|null
	 */
	protected function findDocBlockCloseTagIndex(File $file, int $index): ?int {
		$prevCode = $file->findPrevious(Tokens::$emptyTokens, $index - 1, null, true);
		if (!$prevCode) {
			return null;
		}

		return $file->findPrevious(T_DOC_COMMENT_CLOSE_TAG, $index - 1, $prevCode) ?: null;
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param int $docBlockCloseIndex
	 * @param array<\IdeHelper\Annotation\AbstractAnnotation> $annotations
	 *
	 * @throws \RuntimeException
	 *
	 * @return string
	 */
	protected function appendToExistingDocBlock(File $file, int $docBlockCloseIndex, array &$annotations): string {
		$existingAnnotations = $this->parseExistingAnnotations($file, $docBlockCloseIndex);

		$generatedTags = array_unique(array_map(static function ($annotation) {
			return $annotation::TAG;
		}, $annotations));

		$replacingAnnotations = [];
		$addingAnnotations = [];
		foreach ($annotations as $key => $annotation) {
			if (!is_object($annotation)) {
				throw new RuntimeException('Must be object: ' . print_r($annotation, true));
			}
			if ($this->exists($annotation, $existingAnnotations)) {
				unset($annotations[$key]);

				continue;
			}

			if (!$this->allowsReplacing($annotation, $existingAnnotations)) {
				unset($annotations[$key]);
				$this->_counter[static::COUNT_SKIPPED]++;

				continue;
			}

			$toBeReplaced = $this->needsReplacing($annotation, $existingAnnotations);
			if (!$toBeReplaced) {
				$addingAnnotations[] = $annotation;

				continue;
			}

			$replacingAnnotations[] = $toBeReplaced;
		}

		$tokens = $file->getTokens();
		$lastTagIndexOfPreviousLine = $docBlockCloseIndex;
		while ($tokens[$lastTagIndexOfPreviousLine]['line'] === $tokens[$docBlockCloseIndex]['line']) {
			$lastTagIndexOfPreviousLine--;
		}

		$needsNewline = $this->needsNewLineInDocBlock($file, $lastTagIndexOfPreviousLine);

		$fixer = $this->getFixer($file);

		$fixer->beginChangeset();

		foreach ($replacingAnnotations as $annotation) {
			$fixer->replaceToken($annotation->getIndex(), $annotation->build());
			$this->_counter[static::COUNT_UPDATED]++;
		}

		if (count($addingAnnotations)) {
			$annotationString = $needsNewline ? ' *' . "\n" : '';
			foreach ($addingAnnotations as $annotation) {
				$annotationString .= ' * ' . $annotation . "\n";
				$this->_counter[static::COUNT_ADDED]++;
			}

			$fixer->addContent($lastTagIndexOfPreviousLine, $annotationString);
		}

		if ($this->getConfig(static::CONFIG_REMOVE)) {
			foreach ($existingAnnotations as $key => $existingAnnotation) {
				if ($existingAnnotation->isInUse()) {
					unset($existingAnnotations[$key]);

					continue;
				}

				if ($existingAnnotation->getDescription() !== '') {
					$this->_counter[static::COUNT_SKIPPED]++;
					unset($existingAnnotations[$key]);

					continue;
				}

				if ($generatedTags && !in_array($existingAnnotation::TAG, $generatedTags, true)) {
					unset($existingAnnotations[$key]);
				}
			}

			$removingAnnotations = $existingAnnotations;
			foreach ($removingAnnotations as $annotation) {
				$lastWhitespaceOfPreviousLine = $this->getLastWhitespaceOfPreviousLine($tokens, $annotation->getIndex());
				$index = $annotation->getIndex();
				for ($i = $lastWhitespaceOfPreviousLine; $i <= $index; $i++) {
					$fixer->replaceToken($i, '');
				}
				$this->_counter[static::COUNT_REMOVED]++;
			}
		}

		$fixer->endChangeset();

		return $fixer->getContents();
	}

	/**
	 * @param array<array<string, mixed>> $tokens
	 * @param int $index
	 *
	 * @return int
	 */
	protected function getLastWhitespaceOfPreviousLine(array $tokens, int $index): int {
		$currentLine = $tokens[$index]['line'];
		$index--;
		while ($tokens[$index]['line'] === $currentLine) {
			$index--;
		}

		return $index;
	}

	/**
	 * @param \IdeHelper\Annotation\AbstractAnnotation $annotation
	 * @param array<\IdeHelper\Annotation\AbstractAnnotation> $existingAnnotations
	 * @return bool
	 */
	protected function exists(AbstractAnnotation $annotation, array &$existingAnnotations): bool {
		foreach ($existingAnnotations as $key => $existingAnnotation) {
			if ($existingAnnotation->build() === $annotation->build()) {
				unset($existingAnnotations[$key]);

				return true;
			}

			if ($annotation instanceof PropertyAnnotation && $existingAnnotation instanceof PropertyAnnotation) {
				if ($annotation->getProperty() === $existingAnnotation->getProperty() && $annotation->getType() === $existingAnnotation->getType()) {
					unset($existingAnnotations[$key]);

					return true;
				}
			}

			// Let's skip on existing ones that are only guessed.
			if ($annotation instanceof VariableAnnotation && $existingAnnotation instanceof VariableAnnotation) {
				if ($annotation->getVariable() === $existingAnnotation->getVariable() && $annotation->getGuessed()) {
					unset($existingAnnotations[$key]);

					return true;
				}
				// Special case: $this variable should not be duplicated if types also match
				if ($annotation->getVariable() === '$this' && $existingAnnotation->getVariable() === '$this' && $annotation->getType() === $existingAnnotation->getType()) {
					unset($existingAnnotations[$key]);

					return true;
				}
			}
		}

		return false;
	}

	/**
	 * @param \IdeHelper\Annotation\AbstractAnnotation $annotation
	 * @param array<\IdeHelper\Annotation\AbstractAnnotation> $existingAnnotations
	 * @return \IdeHelper\Annotation\AbstractAnnotation|null
	 */
	protected function needsReplacing(AbstractAnnotation $annotation, array &$existingAnnotations) {
		foreach ($existingAnnotations as $key => $existingAnnotation) {
			if ($existingAnnotation->matches($annotation)) {
				$newAnnotation = clone $existingAnnotation;
				$newAnnotation->replaceWith($annotation);

				unset($existingAnnotations[$key]);

				return $newAnnotation;
			}
		}

		return null;
	}

	/**
	 * @param \IdeHelper\Annotation\AbstractAnnotation $annotation
	 * @param array<\IdeHelper\Annotation\AbstractAnnotation> $existingAnnotations
	 * @return bool
	 */
	protected function allowsReplacing(AbstractAnnotation $annotation, array &$existingAnnotations): bool {
		foreach ($existingAnnotations as $key => $existingAnnotation) {
			if ($existingAnnotation->matches($annotation) && $existingAnnotation->getDescription() !== '') {
				unset($existingAnnotations[$key]);

				return false;
			}
		}

		return true;
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param int $closeTagIndex
	 * @param array<string> $types
	 *
	 * @return array<\IdeHelper\Annotation\AbstractAnnotation>
	 */
	protected function parseExistingAnnotations(File $file, int $closeTagIndex, array $types = self::TYPES): array {
		$tokens = $file->getTokens();

		/** @var int $startTagIndex */
		$startTagIndex = $tokens[$closeTagIndex]['comment_opener'];

		$annotations = [];
		for ($i = $startTagIndex + 1; $i < $closeTagIndex; $i++) {
			if ($tokens[$i]['type'] !== 'T_DOC_COMMENT_TAG') {
				continue;
			}
			if (!in_array($tokens[$i]['content'], $types, true)) {
				continue;
			}

			$classNameIndex = $i + 2;

			if ($tokens[$classNameIndex]['type'] !== 'T_DOC_COMMENT_STRING') {
				continue;
			}

			$content = $tokens[$classNameIndex]['content'];

			/** @var \PHPStan\PhpDocParser\Ast\PhpDoc\InvalidTagValueNode|\PHPStan\PhpDocParser\Ast\PhpDoc\ReturnTagValueNode $valueNode */
			$valueNode = static::getValueNode($tokens[$i]['content'], $content);
			if ($valueNode instanceof InvalidTagValueNode) {
				$multilineFixed = false;
				for ($p = $i + 3; $p < $closeTagIndex; $p++) {
					if ($tokens[$p]['type'] === 'T_DOC_COMMENT_TAG') {
						break;
					}

					if ($tokens[$p]['type'] !== 'T_DOC_COMMENT_STRING') {
						continue;
					}

					$content .= $tokens[$p]['content'];
					/** @var \PHPStan\PhpDocParser\Ast\PhpDoc\InvalidTagValueNode|\PHPStan\PhpDocParser\Ast\PhpDoc\ReturnTagValueNode $valueNode */
					$valueNode = static::getValueNode($tokens[$i]['content'], $content);
					if (!($valueNode instanceof InvalidTagValueNode)) {
						$multilineFixed = true;

						break;
					}
				}

				if (!$multilineFixed || $valueNode instanceof InvalidTagValueNode) {
					continue;
				}
			}

			$returnTypes = $this->valueNodeParts($valueNode);
			$typeString = $this->renderUnionTypes($returnTypes);

			$tag = $tokens[$i]['content'];
			$variablePos = strpos($content, ' $');
			if (in_array($tag, [VariableAnnotation::TAG, PropertyAnnotation::TAG]) && $variablePos) {
				$content = mb_substr($content, $variablePos + 1);
			} else {
				$content = mb_substr($content, mb_strlen($typeString) + 1);
			}

			$annotation = AnnotationFactory::createOrFail($tag, $typeString, $content, $classNameIndex);
			if ($this->getConfig(static::CONFIG_REMOVE) && $tag === VariableAnnotation::TAG && $this->varInUse($tokens, $closeTagIndex, $content)) {
				$annotation->setInUse();
			}
			if ($this->getConfig(static::CONFIG_REMOVE) && $tag === PropertyAnnotation::TAG && $this->propertyInUse($tokens, $closeTagIndex, $content)) {
				$annotation->setInUse();
			}
			if ($this->getConfig(static::CONFIG_REMOVE) && $tag === PropertyReadAnnotation::TAG && $this->propertyInUse($tokens, $closeTagIndex, $content)) {
				$annotation->setInUse();
			}
			if ($this->getConfig(static::CONFIG_REMOVE) && $tag === MethodAnnotation::TAG && $this->methodInUse($tokens, $closeTagIndex, $content)) {
				$annotation->setInUse();
			}

			$annotations[] = $annotation;
		}

		return $annotations;
	}

	/**
	 * Checks the var token for existence.
	 *
	 * T_VARIABLE ..., content=`$variable`
	 *
	 * @param array<array<string, mixed>> $tokens
	 * @param int $closeTagIndex
	 * @param string $variable
	 *
	 * @return bool
	 */
	protected function varInUse(array $tokens, int $closeTagIndex, string $variable): bool {
		if ($variable === '$this') {
			return false;
		}

		$i = $closeTagIndex + 1;
		while (isset($tokens[$i])) {
			if ($tokens[$i]['code'] === T_VARIABLE && $tokens[$i]['content'] === $variable) {
				return true;
			}
			$i++;
		}

		return false;
	}

	/**
	 * Checks the property token chain for existence.
	 *
	 * T_VARIABLE ..., content=`$this`
	 * T_OBJECT_OPERATOR ..., content=`->`
	 * T_STRING ..., content=`PropertyName`
	 * T_OBJECT_OPERATOR ..., content=`->`
	 *
	 * @param array<array<string, mixed>> $tokens
	 * @param int $closeTagIndex
	 * @param string $variable
	 *
	 * @return bool
	 */
	protected function propertyInUse(array $tokens, int $closeTagIndex, string $variable): bool {
		$property = substr($variable, 1);

		$i = $closeTagIndex + 1;
		while (isset($tokens[$i])) {
			if ($tokens[$i]['code'] !== T_VARIABLE || $tokens[$i]['content'] !== '$this') {
				$i++;

				continue;
			}
			$i++;
			if (!isset($tokens[$i])) {
				break;
			}
			if ($tokens[$i]['code'] !== T_OBJECT_OPERATOR) {
				$i++;

				continue;
			}
			$i++;
			if (!isset($tokens[$i])) {
				break;
			}
			if ($tokens[$i]['code'] !== T_STRING || $tokens[$i]['content'] !== $property) {
				$i++;

				continue;
			}
			$i++;
			if (!isset($tokens[$i])) {
				break;
			}
			if ($tokens[$i]['code'] !== T_OBJECT_OPERATOR) {
				$i++;

				continue;
			}

			return true;
		}

		return false;
	}

	/**
	 * Checks the property token chain for existence.
	 *
	 * T_VARIABLE ..., content=`$this`
	 * T_OBJECT_OPERATOR ..., content=`->`
	 * T_STRING ..., content=`method`
	 * T_OPEN_PARENTHESIS ..., content=`(`
	 *
	 * @param array<array<string, mixed>> $tokens
	 * @param int $closeTagIndex
	 * @param string $method
	 *
	 * @return bool
	 */
	protected function methodInUse(array $tokens, int $closeTagIndex, string $method): bool {
		if (!preg_match('#^(\w+)\(#', $method, $matches)) {
			return false;
		}
		$method = $matches[1];

		$i = $closeTagIndex + 1;
		while (isset($tokens[$i])) {
			if ($tokens[$i]['code'] !== T_VARIABLE || $tokens[$i]['content'] !== '$this') {
				$i++;

				continue;
			}
			$i++;
			if (!isset($tokens[$i])) {
				break;
			}
			if ($tokens[$i]['code'] !== T_OBJECT_OPERATOR) {
				$i++;

				continue;
			}
			$i++;
			if (!isset($tokens[$i])) {
				break;
			}
			if ($tokens[$i]['code'] !== T_STRING || $tokens[$i]['content'] !== $method) {
				$i++;

				continue;
			}
			$i++;
			if (!isset($tokens[$i])) {
				break;
			}
			if ($tokens[$i]['code'] !== T_OPEN_PARENTHESIS) {
				$i++;

				continue;
			}

			return true;
		}

		return false;
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param int $lastTagIndexOfPreviousLine
	 *
	 * @return bool
	 */
	protected function needsNewLineInDocBlock(File $file, int $lastTagIndexOfPreviousLine): bool {
		$tokens = $file->getTokens();

		$line = $tokens[$lastTagIndexOfPreviousLine]['line'];
		$index = $lastTagIndexOfPreviousLine - 1;

		while ($tokens[$index]['line'] === $line) {
			if ($tokens[$index]['code'] === T_DOC_COMMENT_TAG || $tokens[$index]['code'] === T_DOC_COMMENT_OPEN_TAG) {
				return false;
			}
			$index--;
		}

		return true;
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param int $index
	 * @param array<\IdeHelper\Annotation\AbstractAnnotation>|array<string> $annotations
	 *
	 * @return string
	 */
	protected function addNewDocBlock(File $file, int $index, array $annotations) {
		$tokens = $file->getTokens();

		foreach ($annotations as $key => $annotation) {
			if (is_string($annotation)) {
				continue;
			}
			$annotations[$key] = (string)$annotation;
		}

		$helper = new DocBlockHelper(new View());
		$annotationString = $helper->classDescription('', '', $annotations);
		if (PHP_EOL !== "\n") {
			$annotationString = str_replace("\n", PHP_EOL, $annotationString);
		}

		$fixer = $this->getFixer($file);

		$docBlock = $annotationString . PHP_EOL;
		$fixer->replaceToken($index, $docBlock . $tokens[$index]['content']);

		$contents = $fixer->getContents();

		$this->_counter[static::COUNT_ADDED] = count($annotations);

		return $contents;
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param int $docBlockCloseIndex
	 *
	 * @return bool
	 */
	protected function isInlineDocBlock(File $file, int $docBlockCloseIndex): bool {
		$tokens = $file->getTokens();

		$docBlockOpenIndex = $tokens[$docBlockCloseIndex]['comment_opener'];

		return $tokens[$docBlockCloseIndex]['line'] === $tokens[$docBlockOpenIndex]['line'];
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param int $docBlockCloseIndex
	 * @return bool
	 */
	protected function shouldSkip(File $file, int $docBlockCloseIndex): bool {
		$tokens = $file->getTokens();
		$docBlockOpenIndex = $tokens[$docBlockCloseIndex]['comment_opener'];

		for ($i = $docBlockOpenIndex + 1; $i < $docBlockCloseIndex; $i++) {
			if ($tokens[$i]['code'] !== T_DOC_COMMENT_TAG) {
				continue;
			}
			if (mb_strtolower($tokens[$i]['content']) === '@inheritdoc') {
				return true;
			}
		}

		return false;
	}

	/**
	 * @param array<string> $usedModels
	 * @param string $content
	 * @return array<\IdeHelper\Annotation\AbstractAnnotation>
	 */
	protected function getModelAnnotations(array $usedModels, string $content): array {
		$annotations = [];

		foreach ($usedModels as $usedModel) {
			$className = App::className($usedModel, 'Model/Table', 'Table');
			if (!$className) {
				$className = 'Cake\ORM\Table';
			}
			[, $name] = pluginSplit($usedModel);

			$annotations[] = AnnotationFactory::createOrFail(PropertyAnnotation::TAG, '\\' . $className, '$' . $name);
		}

		return $annotations;
	}

	/**
	 * Gets protected/private property of a class.
	 *
	 * So
	 *   $this->invokeProperty($object, '_foo');
	 * is equal to
	 *   $object->_foo
	 * (assuming the property was directly publicly accessible)
	 *
	 * @param object $object Instantiated object that we want the property off.
	 * @param string $name Property name to fetch.
	 *
	 * @return mixed Property value.
	 */
	protected function invokeProperty(&$object, string $name) {
		$reflection = new ReflectionClass(get_class($object));
		if (!$reflection->hasProperty($name)) {
			return null;
		}
		$property = $reflection->getProperty($name);

		return $property->getValue($object);
	}

	/**
	 * @return void
	 */
	protected function report(): void {
		$out = [];

		$added = !empty($this->_counter[static::COUNT_ADDED]) ? $this->_counter[static::COUNT_ADDED] : 0;
		if ($added) {
			$out[] = $added . ' ' . ($added === 1 ? 'annotation' : 'annotations') . ' added';
		}
		$updated = !empty($this->_counter[static::COUNT_UPDATED]) ? $this->_counter[static::COUNT_UPDATED] : 0;
		if ($updated) {
			$out[] = $updated . ' ' . ($updated === 1 ? 'annotation' : 'annotations') . ' updated';
		}
		$removed = !empty($this->_counter[static::COUNT_REMOVED]) ? $this->_counter[static::COUNT_REMOVED] : 0;
		if ($removed) {
			$out[] = $removed . ' ' . ($removed === 1 ? 'annotation' : 'annotations') . ' removed';
		}
		$skipped = !empty($this->_counter[static::COUNT_SKIPPED]) ? $this->_counter[static::COUNT_SKIPPED] : 0;
		if ($skipped) {
			$out[] = $skipped . ' ' . ($skipped === 1 ? 'annotation' : 'annotations') . ' skipped';
		}

		if (!$out) {
			return;
		}

		$this->_io->success('   -> ' . implode(', ', $out) . '.');
	}

	/**
	 * @param string $path
	 * @return void
	 */
	protected function reportSkipped(string $path): void {
		$out = [];

		$skipped = !empty($this->_counter[static::COUNT_SKIPPED]) ? $this->_counter[static::COUNT_SKIPPED] : 0;
		if ($skipped) {
			$out[] = $skipped . ' ' . ($skipped === 1 ? 'annotation' : 'annotations') . ' skipped';
		}

		if (!$out) {
			return;
		}

		if (!$this->getConfig('verbose')) {
			$this->_io->out('-> ' . str_replace(ROOT . DS, '', $path));
		}

		$this->_io->out('   -> ' . implode(', ', $out));
	}

	/**
	 * @return void
	 */
	protected function resetCounter(): void {
		$this->_counter = [
			static::COUNT_ADDED => 0,
			static::COUNT_UPDATED => 0,
			static::COUNT_REMOVED => 0,
			static::COUNT_SKIPPED => 0,
		];
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param int $classOrTraitIndex
	 *
	 * @return int
	 */
	protected function beginningOfLine(File $file, $classOrTraitIndex) {
		$tokens = $file->getTokens();

		$line = $tokens[$classOrTraitIndex]['line'];
		$beginningOfLineIndex = $classOrTraitIndex;
		while ($tokens[$beginningOfLineIndex - 1]['line'] === $line) {
			$beginningOfLineIndex--;
		}

		return $beginningOfLineIndex;
	}

	/**
	 * @param class-string<object> $className
	 *
	 * @return bool
	 */
	protected function _isAbstract($className) {
		$reflection = new ReflectionClass($className);

		return $reflection->isAbstract();
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param int $index
	 *
	 * @return int
	 */
	protected function skipOverAttributes(File $file, int $index): int {
		$prevCode = $file->findPrevious(Tokens::$emptyTokens, $index - 1, null, true);
		if (!$prevCode) {
			return $index;
		}

		$tokens = $file->getTokens();
		while ($prevCode && $tokens[$prevCode]['code'] === T_ATTRIBUTE_END) {
			$beginningOfLine = $this->beginningOfLine($file, $prevCode);
			$prevCode = $file->findPrevious(Tokens::$emptyTokens, $beginningOfLine - 1, null, true);
		}

		return $beginningOfLine ?? $index;
	}

}


================================================
FILE: src/Annotator/CallbackAnnotator.php
================================================
<?php

namespace IdeHelper\Annotator;

use RuntimeException;

class CallbackAnnotator extends AbstractAnnotator {

	/**
	 * @param string $path Path to file.
	 * @return bool
	 */
	public function annotate(string $path): bool {
		$content = file_get_contents($path);
		if ($content === false) {
			throw new RuntimeException('Cannot read file');
		}

		$this->invokeTasks($path, $content);

		return true;
	}

	/**
	 * @param string $path
	 * @param string $content
	 *
	 * @return void
	 */
	protected function invokeTasks(string $path, string $content): void {
		$tasks = $this->getTasks($path, $content);

		foreach ($tasks as $task) {
			if (!$task->shouldRun($path)) {
				continue;
			}

			$task->annotate($path);
		}
	}

	/**
	 * @param string $path
	 * @param string $content
	 * @return array<\IdeHelper\Annotator\CallbackAnnotatorTask\CallbackAnnotatorTaskInterface>
	 */
	protected function getTasks(string $path, string $content): array {
		$taskCollection = new CallbackAnnotatorTaskCollection();

		return $taskCollection->tasks($this->_io, $this->_config, $path, $content);
	}

}


================================================
FILE: src/Annotator/CallbackAnnotatorTask/AbstractCallbackAnnotatorTask.php
================================================
<?php

namespace IdeHelper\Annotator\CallbackAnnotatorTask;

use IdeHelper\Annotator\AbstractAnnotator;
use IdeHelper\Console\Io;
use PHP_CodeSniffer\Files\File;
use PHP_CodeSniffer\Util\Tokens;

abstract class AbstractCallbackAnnotatorTask extends AbstractAnnotator {

	protected string $path;

	protected string $content;

	/**
	 * @param \IdeHelper\Console\Io $io
	 * @param array<string, mixed> $config
	 * @param string $path
	 * @param string $content
	 */
	public function __construct(Io $io, array $config, $path, $content) {
		parent::__construct($io, $config);

		$this->path = $path;
		$this->content = $content;
	}

	/**
	 * For testing only
	 *
	 * @return string
	 */
	public function getContent(): string {
		return $this->content;
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 *
	 * @return array<array<string, mixed>>
	 */
	protected function getMethods(File $file) {
		$methods = [];
		$currentIndex = 0;
		while (true) {
			$methodIndex = $file->findNext(T_FUNCTION, $currentIndex);
			if (!$methodIndex) {
				break;
			}
			$methods[$methodIndex] = $this->parseMethod($file, $methodIndex);

			$currentIndex = $methodIndex + 1;
		}

		return $methods;
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param int $index
	 * @return array<string, mixed>
	 */
	protected function parseMethod(File $file, int $index) {
		$tokens = $file->getTokens();
		$nameIndex = $file->findNext(Tokens::$emptyTokens, $index + 1, null, true);

		$closeTagIndex = $this->findCloseTagIndex($file, $index);

		$result = [
			'name' => $tokens[$nameIndex]['content'],
			'docBlockStart' => $closeTagIndex ? $tokens[$closeTagIndex]['comment_opener'] : null,
			'docBlockEnd' => $closeTagIndex ?: null,
		];

		return $result;
	}

	/**
	 * @param string $path
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param array<array<string, mixed>> $methods
	 * @return bool
	 */
	protected function annotateMethods(string $path, File $file, array $methods): bool {
		$this->resetCounter();

		$fixer = $this->getFixer($file);

		$fixer->beginChangeset();

		foreach ($methods as $method) {
			/** @var array<\IdeHelper\Annotation\ParamAnnotation> $replacingAnnotations */
			$replacingAnnotations = $method['annotations'];
			foreach ($replacingAnnotations as $annotation) {
				$fixer->replaceToken($annotation->getIndex(), $annotation->build());
				$this->_counter[static::COUNT_UPDATED]++;
			}
		}

		$fixer->endChangeset();

		$newContent = $fixer->getContents();

		if ($newContent === $this->content) {
			$this->reportSkipped($path);

			return false;
		}

		$this->displayDiff($this->content, $newContent);
		$this->storeFile($path, $newContent);
		$this->content = $newContent;

		$this->report();

		return true;
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param int $index
	 * @return int|null
	 */
	protected function findCloseTagIndex(File $file, int $index): ?int {
		$tokens = $file->getTokens();

		$beginningOfLineIndex = $index;
		while ($tokens[$beginningOfLineIndex - 1]['line'] === $tokens[$index]['line']) {
			$beginningOfLineIndex--;
		}

		$prevCodeIndex = $file->findPrevious(Tokens::$emptyTokens, $beginningOfLineIndex - 1, null, true);
		$closeTagIndex = $file->findPrevious(T_DOC_COMMENT_CLOSE_TAG, $index - 1, $prevCodeIndex ?: null);

		return $closeTagIndex ?: null;
	}

}


================================================
FILE: src/Annotator/CallbackAnnotatorTask/CallbackAnnotatorTaskInterface.php
================================================
<?php

namespace IdeHelper\Annotator\CallbackAnnotatorTask;

interface CallbackAnnotatorTaskInterface {

	/**
	 * @param string $path Path to file.
	 * @return bool
	 */
	public function shouldRun(string $path): bool;

	/**
	 * @param string $path Path to file.
	 * @return bool
	 */
	public function annotate(string $path): bool;

}


================================================
FILE: src/Annotator/CallbackAnnotatorTask/TableCallbackAnnotatorTask.php
================================================
<?php

namespace IdeHelper\Annotator\CallbackAnnotatorTask;

use Cake\ORM\TableRegistry;
use IdeHelper\Annotation\ParamAnnotation;
use PHP_CodeSniffer\Files\File;
use Throwable;

/**
 * Fix up generic *(EventInterface $event, EntityInterface $entity, ...) hook methods to have at least the $entity documented as concrete class.
 */
class TableCallbackAnnotatorTask extends AbstractCallbackAnnotatorTask implements CallbackAnnotatorTaskInterface {

	/**
	 * @var array<string, string>
	 */
	protected array $callbacks = [
		'afterMarshal' => 'afterMarshal',
		'beforeRules' => 'beforeRules',
		'afterRules' => 'afterRules',
		'beforeSave' => 'beforeSave',
		'afterSave' => 'afterSave',
		'afterSaveCommit' => 'afterSaveCommit',
		'beforeDelete' => 'beforeDelete',
		'afterDelete' => 'afterDelete',
		'afterDeleteCommit' => 'afterDeleteCommit',
	];

	/**
	 * @var string|null
	 */
	protected $entityClassName;

	/**
	 * @param string $path
	 * @return bool
	 */
	public function shouldRun(string $path): bool {
		$className = pathinfo($path, PATHINFO_FILENAME);
		if ($className === 'Table' || !str_ends_with($className, 'Table')) {
			return false;
		}

		$modelName = substr($className, 0, -5);
		$plugin = $this->getConfig(static::CONFIG_PLUGIN);

		try {
			$table = TableRegistry::getTableLocator()->get($plugin ? ($plugin . '.' . $modelName) : $modelName);
		} catch (Throwable $e) {
			if ($this->getConfig(static::CONFIG_VERBOSE)) {
				$this->_io->warn('   Skipping table: ' . $e->getMessage());
			}

			return false;
		}

		$entityClassName = $table->getEntityClass();
		$this->entityClassName = $entityClassName;

		if (!preg_match('#\bfunction (' . $this->generatePattern() . ')\b#', $this->content)) {
			return false;
		}

		return true;
	}

	/**
	 * @param string $path
	 * @return bool
	 */
	public function annotate(string $path): bool {
		$file = $this->getFile($path, $this->content);

		$methods = $this->getMethods($file);

		foreach ($methods as $index => $method) {
			if (!in_array($method['name'], $this->callbacks, true)) {
				unset($methods[$index]);

				continue;
			}

			if (!$this->needsUpdate($file, $index, $method)) {
				unset($methods[$index]);

				continue;
			}

			$methods[$index] = $method;
		}

		return $this->annotateMethods($path, $file, $methods);
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param int $index
	 * @param array<string, mixed> $method
	 * @return bool
	 */
	protected function needsUpdate(File $file, int $index, array &$method): bool {
		if (empty($method['docBlockStart']) || empty($method['docBlockEnd'])) {
			return false;
		}

		$annotations = $this->parseExistingAnnotations($file, $method['docBlockEnd'], ['@param']);

		if (empty($annotations[1])) {
			return false;
		}

		/** @var \IdeHelper\Annotation\ParamAnnotation $currentAnnotation */
		$currentAnnotation = $annotations[1];
		$expectedAnnotation = new ParamAnnotation('\\' . $this->entityClassName, $currentAnnotation->getVariable());

		if ($currentAnnotation->getType() === $expectedAnnotation->getType()) {
			return false;
		}

		$currentAnnotation->replaceWith($expectedAnnotation);

		$method['annotations'] = [
			$currentAnnotation,
		];

		return true;
	}

	/**
	 * @return string
	 */
	protected function generatePattern(): string {
		$pattern = [];
		foreach ($this->callbacks as $key => $v) {
			$pattern[] = preg_quote($key . '(');
		}

		return implode('|', $pattern);
	}

}


================================================
FILE: src/Annotator/CallbackAnnotatorTask/VirtualFieldCallbackAnnotatorTask.php
================================================
<?php

namespace IdeHelper\Annotator\CallbackAnnotatorTask;

use Cake\Core\Exception\CakeException;
use Cake\Utility\Inflector;
use IdeHelper\Annotation\SeeAnnotation;
use PHP_CodeSniffer\Files\File;

/**
 * Fix up entity virtual field methods to have at least the $property linked.
 */
class VirtualFieldCallbackAnnotatorTask extends AbstractCallbackAnnotatorTask implements CallbackAnnotatorTaskInterface {

	/**
	 * @var array<string, string>
	 */
	protected array $methods = [
		'_get' => '#_get[A-Z]\w+#',
		'_set' => '#_set[A-Z]\w+#',
	];

	/**
	 * @param string $path
	 * @return bool
	 */
	public function shouldRun(string $path): bool {
		if (!preg_match('#/Model/Entity/\w+\.php$#', $path)) {
			return false;
		}

		return true;
	}

	/**
	 * @param string $path
	 * @return bool
	 */
	public function annotate(string $path): bool {
		$file = $this->getFile($path, $this->content);

		$methods = $this->getMethods($file);
		$namespace = $this->getNamespace($file);
		$class = $this->getClass($file);

		foreach ($methods as $index => $method) {
			if (!$this->isVirtualField($method)) {
				unset($methods[$index]);

				continue;
			}

			$method['see'] = $namespace . '\\' . $class . '::$' . Inflector::underscore(substr($method['name'], 4));

			if (!$this->needsUpdate($file, $index, $method)) {
				unset($methods[$index]);

				continue;
			}

			$methods[$index] = $method;
		}

		if (!$methods) {
			return false;
		}

		return $this->annotateMethods($path, $file, $methods);
	}

	/**
	 * @param string $path
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param array<array<string, mixed>> $methods
	 * @return bool
	 */
	protected function annotateMethods(string $path, File $file, array $methods): bool {
		$this->resetCounter();

		$fixer = $this->getFixer($file);

		$fixer->beginChangeset();

		foreach ($methods as $method) {
			/** @var array<\IdeHelper\Annotation\ParamAnnotation> $replacingAnnotations */
			$replacingAnnotations = $method['annotations'] ?? [];
			foreach ($replacingAnnotations as $annotation) {
				$fixer->replaceToken($annotation->getIndex(), $annotation->build());
				$this->_counter[static::COUNT_UPDATED]++;
			}

			/** @var \IdeHelper\Annotation\LinkAnnotation|null $addingAnnotation */
			$addingAnnotation = $method['annotation'] ?? null;
			if ($addingAnnotation) {
				$endIndex = $method['docBlockEnd'];

				$indentation = $this->indentation($file, $endIndex);
				$fixer->addContentBefore($endIndex, '* @see ' . $addingAnnotation->build() . PHP_EOL . $indentation);
			}
		}

		$fixer->endChangeset();

		$newContent = $fixer->getContents();

		if ($newContent === $this->content) {
			$this->reportSkipped($path);

			return false;
		}

		$this->displayDiff($this->content, $newContent);
		$this->storeFile($path, $newContent);
		$this->content = $newContent;

		$this->report();

		return true;
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param int $index
	 * @param array<string, mixed> $method
	 * @return bool
	 */
	protected function needsUpdate(File $file, int $index, array &$method): bool {
		if (empty($method['docBlockStart']) || empty($method['docBlockEnd'])) {
			return false;
		}

		$annotations = $this->parseExistingAnnotations($file, $method['docBlockEnd'], ['@see']);

		$expectedAnnotation = new SeeAnnotation($method['see']);
		if (!$annotations || $annotations[0]->getType() !== $method['see']) {
			$method['annotation'] = $expectedAnnotation;

			return true;
		}

		/** @var \IdeHelper\Annotation\LinkAnnotation $currentAnnotation */
		$currentAnnotation = $annotations[0];
		if ($currentAnnotation->getType() === $expectedAnnotation->getType()) {
			return false;
		}

		$currentAnnotation->replaceWith($expectedAnnotation);
		$currentAnnotation->setInUse();

		$method['annotations'] = [
			$currentAnnotation,
		];

		return true;
	}

	/**
	 * @param array<string, mixed> $method
	 *
	 * @return bool
	 */
	protected function isVirtualField(array $method): bool {
		foreach ($this->methods as $regex) {
			if (preg_match($regex, $method['name'])) {
				return true;
			}
		}

		return false;
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 *
	 * @return string
	 */
	protected function getNamespace(File $file): string {
		$namespaceIndex = $file->findNext(T_NAMESPACE, 0);
		$startIndex = $file->findNext(T_WHITESPACE, $namespaceIndex + 1, null, true);
		$endIndex = $file->findNext(T_SEMICOLON, $namespaceIndex + 1);

		if (!$namespaceIndex || !$startIndex || !$endIndex) {
			throw new CakeException('File does not seem to be a valid entity class');
		}

		$tokens = $file->getTokens();
		$elements = ['\\'];
		for ($i = $startIndex; $i < $endIndex; $i++) {
			$elements[] = $tokens[$i]['content'];
		}

		return implode('', $elements);
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 *
	 * @return string
	 */
	protected function getClass(File $file): string {
		$classIndex = $file->findNext(T_CLASS, 0);
		$classNameIndex = $file->findNext(T_WHITESPACE, $classIndex + 1, null, true);

		$tokens = $file->getTokens();
		if (!$classNameIndex || empty($tokens[$classNameIndex])) {
			throw new CakeException('File does not seem to be a valid entity class');
		}

		return $tokens[$classNameIndex]['content'];
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param int $endIndex
	 *
	 * @return string
	 */
	protected function indentation(File $file, int $endIndex): string {
		$tokens = $file->getTokens();
		$indentationElements = [];
		for ($i = $endIndex - 1; $i > 0; $i--) {
			if ($tokens[$i]['line'] !== $tokens[$endIndex]['line']) {
				break;
			}

			$indentationElements[] = $tokens[$i]['content'];
		}

		return implode('', $indentationElements);
	}

}


================================================
FILE: src/Annotator/CallbackAnnotatorTaskCollection.php
================================================
<?php

namespace IdeHelper\Annotator;

use Cake\Core\Configure;
use IdeHelper\Annotator\CallbackAnnotatorTask\TableCallbackAnnotatorTask;
use IdeHelper\Annotator\CallbackAnnotatorTask\VirtualFieldCallbackAnnotatorTask;
use IdeHelper\Console\Io;

class CallbackAnnotatorTaskCollection {

	/**
	 * @var array<class-string<\IdeHelper\Annotator\CallbackAnnotatorTask\CallbackAnnotatorTaskInterface>, class-string<\IdeHelper\Annotator\CallbackAnnotatorTask\CallbackAnnotatorTaskInterface>>
	 */
	protected array $defaultTasks = [
		TableCallbackAnnotatorTask::class => TableCallbackAnnotatorTask::class,
		VirtualFieldCallbackAnnotatorTask::class => VirtualFieldCallbackAnnotatorTask::class,
	];

	/**
	 * @var array<class-string<\IdeHelper\Annotator\CallbackAnnotatorTask\CallbackAnnotatorTaskInterface>>
	 */
	protected array $tasks;

	/**
	 * @param array<class-string<\IdeHelper\Annotator\CallbackAnnotatorTask\CallbackAnnotatorTaskInterface>> $tasks
	 */
	public function __construct(array $tasks = []) {
		$defaultTasks = $this->defaultTasks();
		$tasks += $defaultTasks;

		foreach ($tasks as $task) {
			if (!$task) {
				continue;
			}

			$this->tasks = $tasks;
		}
	}

	/**
	 * @return array<class-string<\IdeHelper\Annotator\CallbackAnnotatorTask\CallbackAnnotatorTaskInterface>>
	 */
	public function defaultTasks(): array {
		$tasks = (array)Configure::read('IdeHelper.callbackAnnotatorTasks') + $this->defaultTasks;

		foreach ($tasks as $k => $v) {
			if (is_numeric($k)) {
				$tasks[$v] = $v;
				unset($tasks[$k]);
			}
		}

		return $tasks;
	}

	/**
	 * @param \IdeHelper\Console\Io $io
	 * @param array<string, mixed> $config
	 * @param string $path
	 * @param string $content
	 * @return array<\IdeHelper\Annotator\CallbackAnnotatorTask\CallbackAnnotatorTaskInterface>
	 */
	public function tasks(Io $io, array $config, string $path, string $content): array {
		$tasks = $this->tasks;

		$collection = [];
		foreach ($tasks as $task) {
			/** @var \IdeHelper\Annotator\CallbackAnnotatorTask\CallbackAnnotatorTaskInterface $object */
			$object = new $task($io, $config, $path, $content);
			$collection[] = $object;
		}

		return $collection;
	}

}


================================================
FILE: src/Annotator/ClassAnnotator.php
================================================
<?php

namespace IdeHelper\Annotator;

use RuntimeException;

class ClassAnnotator extends AbstractAnnotator {

	/**
	 * @param string $path Path to file.
	 * @return bool
	 */
	public function annotate(string $path): bool {
		$content = file_get_contents($path);
		if ($content === false) {
			throw new RuntimeException('Cannot read file');
		}

		$this->invokeTasks($path, $content);

		return true;
	}

	/**
	 * @param string $path
	 * @param string $content
	 *
	 * @return void
	 */
	protected function invokeTasks(string $path, string $content): void {
		$tasks = $this->getTasks($content);

		foreach ($tasks as $task) {
			if (!$task->shouldRun($path, $content)) {
				continue;
			}

			$task->annotate($path);
		}
	}

	/**
	 * @param string $content
	 * @return array<\IdeHelper\Annotator\ClassAnnotatorTask\ClassAnnotatorTaskInterface>
	 */
	protected function getTasks(string $content): array {
		$taskCollection = new ClassAnnotatorTaskCollection();

		return $taskCollection->tasks($this->_io, $this->_config, $content);
	}

}


================================================
FILE: src/Annotator/ClassAnnotatorTask/AbstractClassAnnotatorTask.php
================================================
<?php

namespace IdeHelper\Annotator\ClassAnnotatorTask;

use IdeHelper\Annotator\AbstractAnnotator;
use IdeHelper\Console\Io;
use PHP_CodeSniffer\Files\File;
use PHP_CodeSniffer\Util\Tokens;
use RuntimeException;

abstract class AbstractClassAnnotatorTask extends AbstractAnnotator {

	protected string $content;

	/**
	 * @param \IdeHelper\Console\Io $io
	 * @param array<string, mixed> $config
	 * @param string $content
	 */
	public function __construct(Io $io, array $config, $content) {
		parent::__construct($io, $config);

		$this->content = $content;
	}

	/**
	 * For testing only
	 *
	 * @return string
	 */
	public function getContent(): string {
		return $this->content;
	}

	/**
	 * @param string $path
	 * @param string $content
	 * @param array<\IdeHelper\Annotation\AbstractAnnotation> $annotations
	 *
	 * @return bool
	 */
	protected function annotateContent(string $path, string $content, array $annotations): bool {
		if (!count($annotations)) {
			return false;
		}

		$file = $this->getFile($path, $content);

		$classOrTraitIndex = $file->findNext([T_CLASS, T_TRAIT], 0);
		if (!$classOrTraitIndex) {
			return false;
		}
		$beginningOfLineIndex = $this->beginningOfLine($file, $classOrTraitIndex);

		$attributeTokens = [
			T_ATTRIBUTE => T_ATTRIBUTE,
			T_ATTRIBUTE_END => T_ATTRIBUTE_END,
			T_NS_SEPARATOR => T_NS_SEPARATOR,
			T_STRING => T_STRING,
		];
		$prevCode = $file->findPrevious(Tokens::$emptyTokens + $attributeTokens, $beginningOfLineIndex - 1, null, true);
		if ($prevCode === false) {
			return false;
		}

		$closeTagIndex = $file->findPrevious(T_DOC_COMMENT_CLOSE_TAG, $beginningOfLineIndex - 1, $prevCode);
		$this->resetCounter();
		if ($closeTagIndex && $this->shouldSkip($file, $closeTagIndex)) {
			return false;
		}
		if ($closeTagIndex && !$this->isInlineDocBlock($file, $closeTagIndex)) {
			$newContent = $this->appendToExistingDocBlock($file, $closeTagIndex, $annotations);
		} else {
			$newContent = $this->addNewDocBlock($file, $beginningOfLineIndex, $annotations);
		}

		if ($newContent === $content) {
			$this->reportSkipped($path);

			return false;
		}

		$this->displayDiff($content, $newContent);
		$this->storeFile($path, $newContent);
		$this->content = $newContent;

		$this->report();

		return true;
	}

	/**
	 * @param string $path
	 * @param string $content
	 * @param array<\IdeHelper\Annotation\AbstractAnnotation> $annotations
	 * @param int $line
	 *
	 * @return bool
	 */
	protected function annotateInlineContent(string $path, string $content, array $annotations, int $line): bool {
		if (!count($annotations)) {
			return false;
		}

		$file = $this->getFile($path, $content);

		$beginningOfLineIndex = $this->findFirstTokenOfLine($file, $line);
		if (!$beginningOfLineIndex) {
			return false;
		}

		$prevCode = $file->findPrevious(Tokens::$emptyTokens, $beginningOfLineIndex - 1, null, true);
		if ($prevCode === false) {
			return false;
		}

		$closeTagIndex = $file->findPrevious(T_DOC_COMMENT_CLOSE_TAG, $beginningOfLineIndex - 1, $prevCode);
		$this->resetCounter();
		if ($closeTagIndex && $this->shouldSkip($file, $closeTagIndex)) {
			return false;
		}
		if ($closeTagIndex) {
			// Skip as there seems to be already one
			$newContent = $content;
		} else {
			$newContent = $this->addNewInlineDocBlock($file, $beginningOfLineIndex, $annotations);
		}

		if ($newContent === $content) {
			$this->reportSkipped($path);

			return false;
		}

		$this->displayDiff($content, $newContent);
		$this->storeFile($path, $newContent);
		$this->content = $newContent;

		$this->report();

		return true;
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param int $index
	 * @param array<\IdeHelper\Annotation\AbstractAnnotation>|array<string> $annotations
	 *
	 * @return string
	 */
	protected function addNewInlineDocBlock(File $file, int $index, array $annotations) {
		$tokens = $file->getTokens();

		if (count($annotations) !== 1) {
			throw new RuntimeException('Cannot work with annotation count != 1 right now');
		}

		$annotation = reset($annotations);
		$annotationString = '/** ' . (string)$annotation . ' */';
		if (PHP_EOL !== "\n") {
			$annotationString = str_replace("\n", PHP_EOL, $annotationString);
		}
		$indentation = $this->detectIndentation($file, $index);

		$fixer = $this->getFixer($file);

		$docBlock = $indentation . $annotationString . PHP_EOL;
		$fixer->replaceToken($index, $docBlock . $tokens[$index]['content']);

		$contents = $fixer->getContents();

		$this->_counter[static::COUNT_ADDED] = count($annotations);

		return $contents;
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param int $line
	 *
	 * @return int|null
	 */
	protected function findFirstTokenOfLine(File $file, int $line): ?int {
		$tokens = $file->getTokens();
		foreach ($tokens as $index => $token) {
			if ($token['line'] === $line) {
				return $index;
			}
		}

		return null;
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param int $index
	 *
	 * @return string
	 */
	protected function detectIndentation(File $file, int $index): string {
		$nextIndex = $file->findNext(T_WHITESPACE, $index + 1, null, true);
		if (!$nextIndex) {
			return '';
		}

		$tokens = $file->getTokens();
		$whitespace = '';
		for ($i = $index; $i < $nextIndex; $i++) {
			$whitespace .= $tokens[$i]['content'];
		}

		return $whitespace;
	}

}


================================================
FILE: src/Annotator/ClassAnnotatorTask/ClassAnnotatorTaskInterface.php
================================================
<?php

namespace IdeHelper\Annotator\ClassAnnotatorTask;

interface ClassAnnotatorTaskInterface {

	/**
	 * Deprecated: $content, use $this->content instead.
	 *
	 * @param string $path
	 * @param string $content
	 * @return bool
	 */
	public function shouldRun(string $path, string $content): bool;

	/**
	 * @param string $path Path to file.
	 * @return bool
	 */
	public function annotate(string $path): bool;

}


================================================
FILE: src/Annotator/ClassAnnotatorTask/FormClassAnnotatorTask.php
================================================
<?php

namespace IdeHelper\Annotator\ClassAnnotatorTask;

use Cake\Core\Configure;
use IdeHelper\Annotation\AnnotationFactory;
use IdeHelper\Annotation\UsesAnnotation;

/**
 * Form classes should automatically have `@uses` annotated for method invocation.
 */
class FormClassAnnotatorTask extends AbstractClassAnnotatorTask implements ClassAnnotatorTaskInterface {

	/**
	 * Deprecated: $content, use $this->content instead.
	 *
	 * @param string $path
	 * @param string $content
	 * @return bool
	 */
	public function shouldRun(string $path, string $content): bool {
		if (!str_contains($path, DS . 'src' . DS)) {
			return false;
		}

		$appNamespace = Configure::read('App.namespace') ?: 'App';
		if (!preg_match('#\buse (\w+)\\\\Form\\\\(.+)Form\b#', $content, $matches)) {
			return false;
		}

		$varName = lcfirst($matches[2]) . 'Form';
		if (!preg_match('#\$' . preg_quote($varName, '#') . '->execute\(#', $content)) {
			return false;
		}

		return true;
	}

	/**
	 * @param string $path
	 * @return bool
	 */
	public function annotate(string $path): bool {
		preg_match('#\buse (\w+)\\\\Form\\\\(.+)Form\b#', $this->content, $matches);
		if (empty($matches[1]) || empty($matches[2])) {
			return false;
		}

		$appNamespace = $matches[1];
		$name = $matches[2] . 'Form';

		$varName = lcfirst($name);
		$rows = explode(PHP_EOL, $this->content);
		$rowToAnnotate = null;
		foreach ($rows as $i => $row) {
			if (!preg_match('#\$' . preg_quote($varName, '#') . '->execute\(#', $row)) {
				continue;
			}
			$rowToAnnotate = $i + 1;

			break;
		}

		if (!$rowToAnnotate) {
			return false;
		}

		$method = $appNamespace . '\\Form\\' . $name . '::_execute()';
		$annotations = $this->buildUsesAnnotations([$method]);

		return $this->annotateInlineContent($path, $this->content, $annotations, $rowToAnnotate);
	}

	/**
	 * @param array<string> $classes
	 * @return array<\IdeHelper\Annotation\AbstractAnnotation>
	 */
	protected function buildUsesAnnotations(array $classes): array {
		$annotations = [];

		foreach ($classes as $className) {
			$annotations[] = AnnotationFactory::createOrFail(UsesAnnotation::TAG, '\\' . $className);
		}

		return $annotations;
	}

}


================================================
FILE: src/Annotator/ClassAnnotatorTask/MailerClassAnnotatorTask.php
================================================
<?php

namespace IdeHelper\Annotator\ClassAnnotatorTask;

use Cake\Core\Configure;
use IdeHelper\Annotation\AnnotationFactory;
use IdeHelper\Annotation\UsesAnnotation;

/**
 * Mailer classes should automatically have `@uses` annotated for method invocation.
 */
class MailerClassAnnotatorTask extends AbstractClassAnnotatorTask implements ClassAnnotatorTaskInterface {

	/**
	 * Deprecated: $content, use $this->content instead.
	 *
	 * @param string $path
	 * @param string $content
	 * @return bool
	 */
	public function shouldRun(string $path, string $content): bool {
		if (!str_contains($path, DS . 'src' . DS)) {
			return false;
		}

		if (preg_match('#namespace \w+\\\\Mailer;#', $content)) {
			return false;
		}

		preg_match('#\buse (\w+)\\\\Mailer\\\\(\w+)Mailer\b#', $content, $useMatches);
		preg_match('#\$\w+\s*=\s*\$this-\>getMailer\(\'([\w\.]+)\'\)#', $content, $callMatches);
		$singleLine = false;
		if (!$callMatches) {
			$singleLine = true;
			preg_match('#\$this->getMailer\(\s*\'([\w\.]+)\'\s*\)\s*->\s*send\(\s*\'([\w\.]+)\'#msu', $content, $callMatches);
		}
		if (!$useMatches && !$callMatches) {
			return false;
		}

		if ($useMatches) {
			$varName = lcfirst($useMatches[2]) . 'Mailer';
		} else {
			$class = $callMatches[1];
			[$plugin, $name] = pluginSplit($class);
			$varName = lcfirst($name) . 'Mailer';
		}

		if ($singleLine && !empty($callMatches)) {
			return true;
		}

		if (!preg_match('#\$' . preg_quote($varName, '#') . '->send\(\'\w+\'#', $content)) {
			return false;
		}

		return true;
	}

	/**
	 * @param string $path
	 * @return bool
	 */
	public function annotate(string $path): bool {
		preg_match('#\buse (\w+)\\\\Mailer\\\\(\w+)Mailer\b#', $this->content, $useMatches);

		$singleCall = false;
		$singleCallAction = null;
		if (!$useMatches) {
			preg_match('#\$\w+\s*=\s*\$this->getMailer\(\'([\w.]+)\'\)#', $this->content, $callMatches);
			if (!$callMatches) {
				preg_match('#\$this->getMailer\(\s*\'([\w\.]+)\'\s*\)\s*->\s*send\(\s*\'([\w\.]+)\'#msu', $this->content, $callMatches);
				if (!$callMatches) {
					return false;
				}

				$singleCall = true;
				$singleCallAction = $callMatches[2];
			}
		}

		if ($useMatches) {
			$appNamespace = $useMatches[1];
			$name = $useMatches[2] . 'Mailer';
		} else {
			[$plugin, $name] = pluginSplit($callMatches[1]);
			$appNamespace = $plugin ?: (Configure::read('App.namespace') ?: 'App');
			$name = $name . 'Mailer';
		}

		$action = null;
		if (!$singleCall) {
			$varName = lcfirst($name);
			$rows = explode(PHP_EOL, $this->content);
			$rowToAnnotate = null;
			$rowMatches = null;
			foreach ($rows as $i => $row) {
				if (!preg_match('#\$' . preg_quote($varName, '#') . '->send\(\'(\w+)\'#', $row, $rowMatches)) {
					continue;
				}
				$rowToAnnotate = $i + 1;
				$action = $rowMatches[1];

				break;
			}
		} else {
			assert($singleCallAction !== null);
			$rows = explode(PHP_EOL, $this->content);
			$rowToAnnotate = null;
			$rowMatches = null;
			$multiLine = str_contains($callMatches[0], PHP_EOL);
			foreach ($rows as $i => $row) {
				if (
					$multiLine
					&& preg_match('#\$this->getMailer\(\s*\'' . $callMatches[1] . '\'\s*\)#msu', $row, $rowMatches)
					&& !empty($rows[$i + 1])
					&& preg_match('#->\s*send\(\s*\'' . $singleCallAction . '\'#msu', $rows[$i + 1], $rowMatches)
				) {
					$rowToAnnotate = $i;
					$action = $singleCallAction;

					break;
				}

				if (!preg_match('#\$this->getMailer\(\s*\'' . $callMatches[1] . '\'\s*\)\s*->\s*send\(\s*\'' . $singleCallAction . '\'#msu', $row, $rowMatches)) {
					continue;
				}
				$rowToAnnotate = $i + 1;
				$action = $singleCallAction;

				break;
			}
		}

		if (!$rowToAnnotate) {
			return false;
		}

		$method = $appNamespace . '\\Mailer\\' . $name . '::' . $action . '()';
		$annotations = $this->buildUsesAnnotations([$method]);

		return $this->annotateInlineContent($path, $this->content, $annotations, $rowToAnnotate);
	}

	/**
	 * @param array<string> $classes
	 * @return array<\IdeHelper\Annotation\AbstractAnnotation>
	 */
	protected function buildUsesAnnotations(array $classes): array {
		$annotations = [];

		foreach ($classes as $className) {
			$annotations[] = AnnotationFactory::createOrFail(UsesAnnotation::TAG, '\\' . $className);
		}

		return $annotations;
	}

}


================================================
FILE: src/Annotator/ClassAnnotatorTask/ModelAwareClassAnnotatorTask.php
================================================
<?php

namespace IdeHelper\Annotator\ClassAnnotatorTask;

use ReflectionClass;
use Throwable;

/**
 * Classes that use ModelAwareTrait should automatically have used tables - via fetchModel() call - annotated.
 */
class ModelAwareClassAnnotatorTask extends AbstractClassAnnotatorTask implements ClassAnnotatorTaskInterface {

	/**
	 * Deprecated: $content, use $this->content instead.
	 *
	 * @param string $path
	 * @param string $content
	 * @return bool
	 */
	public function shouldRun(string $path, string $content): bool {
		if (!str_contains($path, DS . 'src' . DS)) {
			return false;
		}
		if (preg_match('#\buse ModelAwareTrait\b#', $content)) {
			return true;
		}

		/** @var class-string|null $className */
		$className = $this->getClassName($path, $content);
		if (!$className) {
			return false;
		}

		try {
			return (new ReflectionClass($className))->hasMethod('fetchModel');
		} catch (Throwable $exception) {
			return false;
		}
	}

	/**
	 * @param string $path
	 * @return bool
	 */
	public function annotate(string $path): bool {
		$models = $this->getUsedModels($this->content);

		$annotations = $this->getModelAnnotations($models, $this->content);

		return $this->annotateContent($path, $this->content, $annotations);
	}

	/**
	 * @param string $content
	 *
	 * @return array<string>
	 */
	protected function getUsedModels(string $content): array {
		preg_match_all('/\$this-\>fetchModel\(\'([a-z.]+)\'/i', $content, $matches);
		if (empty($matches[1])) {
			return [];
		}

		$models = $matches[1];

		return array_unique($models);
	}

	/**
	 * @param string $path
	 * @param string $content
	 *
	 * @return string|null
	 */
	protected function getClassName(string $path, string $content): ?string {
		preg_match('#^namespace (.+)\b#m', $content, $matches);
		if (!$matches) {
			return null;
		}

		$className = pathinfo($path, PATHINFO_FILENAME);

		return $matches[1] . '\\' . $className;
	}

}


================================================
FILE: src/Annotator/ClassAnnotatorTask/PathAwareClassAnnotatorTaskInterface.php
================================================
<?php

namespace IdeHelper\Annotator\ClassAnnotatorTask;

/**
 * Optional interface that a class annotator task can implement to declare
 * extra directories that the `bin/cake annotate classes` command should walk
 * in addition to its default `src/` (app + plugin classpaths) and
 * `tests/TestCase/` scans.
 *
 * The intended use is third-party packages whose subjects live outside the
 * conventional source tree — e.g. a test-fixture factory plugin whose
 * subclasses live under `tests/Factory/`. By declaring the path on the
 * task itself, the package does not need to ship its own bake/annotate
 * subcommand: registering the task in `IdeHelper.classAnnotatorTasks` is
 * enough for the existing command to reach the relevant files.
 *
 * `scanPaths()` is `static` so the command can query a task's paths
 * without first instantiating it with an `Io` and per-file content. Paths
 * are project-root relative for app context, and plugin-root relative
 * when the command is run with `-p <plugin>` (or `-p all`). Paths are
 * walked recursively.
 *
 * Convention: return paths with forward slashes and a trailing slash
 * (e.g. `'tests/Factory/'`), independent of OS. The command normalizes
 * to the OS-native separator before walking, so the dedup key is stable
 * when two tasks declare the same path.
 */
interface PathAwareClassAnnotatorTaskInterface extends ClassAnnotatorTaskInterface {

	/**
	 * @return array<string>
	 */
	public static function scanPaths(): array;

}


================================================
FILE: src/Annotator/ClassAnnotatorTask/TableFindAnnotatorTask.php
================================================
<?php

namespace IdeHelper\Annotator\ClassAnnotatorTask;

use Cake\Core\Configure;
use IdeHelper\Annotation\AnnotationFactory;
use IdeHelper\Annotation\VariableAnnotation;
use PhpParser\NodeTraverser;
use PhpParser\ParserFactory;
use Throwable;

/**
 * Usage of first() or firstOrFail() on table finders should have inline @var annotations added.
 *
 * Detects patterns like:
 * - $entity = $this->TableName->find()->first();
 * - $entity = $this->TableName->find()->firstOrFail();
 */
class TableFindAnnotatorTask extends AbstractClassAnnotatorTask implements ClassAnnotatorTaskInterface {

	/**
	 * Deprecated: $content, use $this->content instead.
	 *
	 * @param string $path
	 * @param string $content
	 * @return bool
	 */
	public function shouldRun(string $path, string $content): bool {
		if (!str_contains($path, DS . 'src' . DS)) {
			return false;
		}

		if (!preg_match('#->(first|firstOrFail)\(\)#', $content)) {
			return false;
		}

		return true;
	}

	/**
	 * @param string $path
	 * @return bool
	 */
	public function annotate(string $path): bool {
		$findings = $this->findTableFinderCalls();
		if (!$findings) {
			return false;
		}

		// Process from bottom to top to avoid line number shifts
		usort($findings, fn ($a, $b) => $b['line'] <=> $a['line']);

		$annotated = false;
		foreach ($findings as $finding) {
			$annotation = $this->buildVarAnnotation($finding['entityClass'], $finding['varName'], $finding['nullable']);
			$result = $this->annotateInlineContent($path, $this->content, [$annotation], $finding['line']);
			if ($result) {
				$annotated = true;
			}
		}

		return $annotated;
	}

	/**
	 * Find all table finder calls that end with first() or firstOrFail().
	 *
	 * @return array<array{line: int, varName: string, tableName: string, entityClass: string, nullable: bool}>
	 */
	protected function findTableFinderCalls(): array {
		$parser = (new ParserFactory())->createForHostVersion();
		try {
			$ast = $parser->parse($this->content);
		} catch (Throwable $e) {
			return [];
		}

		if ($ast === null) {
			return [];
		}

		$appNamespace = Configure::read('App.namespace') ?: 'App';

		$visitor = new TableFindNodeVisitor($appNamespace);
		$traverser = new NodeTraverser();
		$traverser->addVisitor($visitor);
		$traverser->traverse($ast);

		return $visitor->getFindings();
	}

	/**
	 * Build a @var annotation for the entity type.
	 *
	 * @param string $entityClass
	 * @param string $varName
	 * @param bool $nullable
	 * @return \IdeHelper\Annotation\VariableAnnotation
	 */
	protected function buildVarAnnotation(string $entityClass, string $varName, bool $nullable): VariableAnnotation {
		$type = $entityClass . ($nullable ? '|null' : '');

		/** @var \IdeHelper\Annotation\VariableAnnotation */
		return AnnotationFactory::createOrFail(VariableAnnotation::TAG, $type, '$' . $varName);
	}

}


================================================
FILE: src/Annotator/ClassAnnotatorTask/TableFindNodeVisitor.php
================================================
<?php

namespace IdeHelper\Annotator\ClassAnnotatorTask;

use Cake\Utility\Inflector;
use PhpParser\Node;
use PhpParser\Node\Expr\Assign;
use PhpParser\NodeVisitorAbstract;

/**
 * Node visitor that finds table finder calls ending with first() or firstOrFail().
 */
class TableFindNodeVisitor extends NodeVisitorAbstract {

	private string $appNamespace;

	/**
	 * @var array<array{line: int, varName: string, tableName: string, entityClass: string, nullable: bool}>
	 */
	private array $findings = [];

	/**
	 * @param string $appNamespace
	 */
	public function __construct(string $appNamespace) {
		$this->appNamespace = $appNamespace;
	}

	/**
	 * @return array<array{line: int, varName: string, tableName: string, entityClass: string, nullable: bool}>
	 */
	public function getFindings(): array {
		return $this->findings;
	}

	/**
	 * @param \PhpParser\Node $node
	 * @return int|null
	 */
	public function enterNode(Node $node): ?int {
		if (!$node instanceof Assign || !$node->expr instanceof Node\Expr\MethodCall) {
			return null;
		}

		$methodCall = $node->expr;

		// Check for ->first() or ->firstOrFail()
		if (
			!$methodCall->name instanceof Node\Identifier ||
			!in_array($methodCall->name->toString(), ['first', 'firstOrFail'], true)
		) {
			return null;
		}

		$method = $methodCall->name->toString();
		$nullable = $method === 'first';

		// Get the variable name being assigned
		if (!$node->var instanceof Node\Expr\Variable || !is_string($node->var->name)) {
			return null;
		}
		$varName = $node->var->name;

		// Traverse back through the method chain to find $this->TableName
		$tableName = $this->extractTableName($methodCall->var);
		if ($tableName === null) {
			return null;
		}

		$entityName = Inflector::singularize($tableName);
		$entityClass = '\\' . $this->appNamespace . '\\Model\\Entity\\' . $entityName;

		$this->findings[] = [
			'line' => $node->getStartLine(),
			'varName' => $varName,
			'tableName' => $tableName,
			'entityClass' => $entityClass,
			'nullable' => $nullable,
		];

		return null;
	}

	/**
	 * Extract table name from method chain like $this->TableName->find()->...
	 *
	 * @param \PhpParser\Node\Expr $expr
	 * @return string|null
	 */
	private function extractTableName(Node\Expr $expr): ?string {
		// Walk back through the method chain
		while ($expr instanceof Node\Expr\MethodCall) {
			$expr = $expr->var;
		}

		// Should now be at $this->TableName
		if (
			$expr instanceof Node\Expr\PropertyFetch &&
			$expr->var instanceof Node\Expr\Variable &&
			$expr->var->name === 'this' &&
			$expr->name instanceof Node\Identifier
		) {
			return $expr->name->toString();
		}

		return null;
	}

}


================================================
FILE: src/Annotator/ClassAnnotatorTask/TestClassAnnotatorTask.php
================================================
<?php

namespace IdeHelper\Annotator\ClassAnnotatorTask;

use Cake\Core\Configure;
use IdeHelper\Annotation\AnnotationFactory;
use IdeHelper\Annotation\LinkAnnotation;
use IdeHelper\Annotation\UsesAnnotation;

/**
 * Classes that test a class in a magic-call way should automatically have `@link` annotated.
 * By default:
 * - Controller tests
 * - Command tests
 *
 * Use Configure key `IdeHelper.testClassPatterns` to add more types and their regex pattern.
 */
class TestClassAnnotatorTask extends AbstractClassAnnotatorTask implements PathAwareClassAnnotatorTaskInterface {

	/**
	 * @return array<string>
	 */
	public static function scanPaths(): array {
		return ['tests/TestCase/'];
	}

	/**
	 * Deprecated: $content, use $this->content instead.
	 *
	 * @param string $path
	 * @param string $content
	 * @return bool
	 */
	public function shouldRun(string $path, string $content): bool {
		if (!str_contains($path, DS . 'tests' . DS . 'TestCase' . DS)) {
			return false;
		}

		$defaultTypes = (array)Configure::read('IdeHelper.testClassPatterns');
		$types = $defaultTypes + [
			'Controller' => '#\bclass .+ControllerTest extends\b#',
			'Command' => '#\bclass .+CommandTest extends\b#',
		];
		$typeList = implode('|', array_keys($types));

		if (!preg_match('#^namespace .+\\\\Test\\\\TestCase\\\\(' . $typeList . ')\b#m', $content)) {
			return false;
		}
		if (!$this->matchesType($content, $types)) {
			return false;
		}

		return true;
	}

	/**
	 * @param string $content
	 * @param array<string> $types
	 * @return bool
	 */
	protected function matchesType(string $content, array $types): bool {
		foreach ($types as $type => $pattern) {
			if (preg_match($pattern, $content)) {
				return true;
			}
		}

		return false;
	}

	/**
	 * @param string $path
	 * @return bool
	 */
	public function annotate(string $path): bool {
		$class = $this->getTestedClass($this->content);
		if (!$class) {
			return false;
		}

		if ($this->hasUsesClassAttribute($this->content, $class)) {
			return false;
		}

		if ($this->hasLinkAnnotation($this->content, $class)) {
			return false;
		}

		$annotations = $this->buildLinkAnnotations([$class]);

		return $this->annotateContent($path, $this->content, $annotations);
	}

	/**
	 * @param string $content
	 *
	 * @return string|null
	 */
	protected function getTestedClass(string $content): ?string {
		preg_match('#namespace (.+);#', $content, $matches);
		if (!$matches) {
			return null;
		}

		$namespace = str_replace('\\Test\\TestCase\\', '\\', $matches[1]);

		preg_match('#\bclass (.+)Test extends#', $content, $matches);
		if (!$matches) {
			return null;
		}
		$className = $matches[1];

		$fullClassName = $namespace . '\\' . $className;
		if (!class_exists($fullClassName)) {
			return null;
		}

		return $fullClassName;
	}

	/**
	 * @param array<string> $classes
	 * @return array<\IdeHelper\Annotation\AbstractAnnotation>
	 */
	protected function buildLinkAnnotations(array $classes): array {
		$annotations = [];

		$tag = UsesAnnotation::TAG;
		if (Configure::read('IdeHelper.preferLinkOverUsesInTests') ?? true) {
			$tag = LinkAnnotation::TAG;
		}

		foreach ($classes as $className) {
			$annotations[] = AnnotationFactory::createOrFail($tag, '\\' . $className);
		}

		return $annotations;
	}

	/**
	 * @param string $content
	 * @param string $class
	 * @return bool
	 */
	protected function hasUsesClassAttribute(string $content, string $class): bool {
		$shortClassName = substr(strrchr($class, '\\') ?: $class, 1);
		$full = preg_quote($class, '#');
		$short = preg_quote($shortClassName, '#');
		$pattern = '#\#\[UsesClass\(\s*\\\\?(?:' . $full . '|' . $short . ')::class\s*\)\]#';

		return (bool)preg_match($pattern, $content);
	}

	/**
	 * @param string $content
	 * @param string $class
	 * @return bool
	 */
	protected function hasLinkAnnotation(string $content, string $class): bool {
		$shortClassName = substr(strrchr($class, '\\') ?: $class, 1);
		$full = preg_quote($class, '#');
		$short = preg_quote($shortClassName, '#');
		$pattern = '#@(uses|link)\s+\\\\?(?:' . $full . '|' . $short . ')\b#';

		return (bool)preg_match($pattern, $content);
	}

}


================================================
FILE: src/Annotator/ClassAnnotatorTaskCollection.php
================================================
<?php

namespace IdeHelper\Annotator;

use Cake\Core\Configure;
use IdeHelper\Annotator\ClassAnnotatorTask\FormClassAnnotatorTask;
use IdeHelper\Annotator\ClassAnnotatorTask\MailerClassAnnotatorTask;
use IdeHelper\Annotator\ClassAnnotatorTask\ModelAwareClassAnnotatorTask;
use IdeHelper\Annotator\ClassAnnotatorTask\TestClassAnnotatorTask;
use IdeHelper\Console\Io;

class ClassAnnotatorTaskCollection {

	/**
	 * @var array<class-string<\IdeHelper\Annotator\ClassAnnotatorTask\ClassAnnotatorTaskInterface>, class-string<\IdeHelper\Annotator\ClassAnnotatorTask\ClassAnnotatorTaskInterface>>
	 */
	protected array $defaultTasks = [
		ModelAwareClassAnnotatorTask::class => ModelAwareClassAnnotatorTask::class,
		FormClassAnnotatorTask::class => FormClassAnnotatorTask::class,
		MailerClassAnnotatorTask::class => MailerClassAnnotatorTask::class,
		TestClassAnnotatorTask::class => TestClassAnnotatorTask::class,
	];

	/**
	 * @var array<class-string<\IdeHelper\Annotator\ClassAnnotatorTask\ClassAnnotatorTaskInterface>>
	 */
	protected array $tasks;

	/**
	 * @param array<class-string<\IdeHelper\Annotator\ClassAnnotatorTask\ClassAnnotatorTaskInterface>> $tasks
	 */
	public function __construct(array $tasks = []) {
		$defaultTasks = $this->defaultTasks();
		$tasks += $defaultTasks;
		$this->tasks = $tasks;
	}

	/**
	 * @return array<class-string<\IdeHelper\Annotator\ClassAnnotatorTask\ClassAnnotatorTaskInterface>>
	 */
	public function defaultTasks(): array {
		$tasks = (array)Configure::read('IdeHelper.classAnnotatorTasks') + $this->defaultTasks;

		foreach ($tasks as $k => $v) {
			if (is_numeric($k)) {
				$tasks[$v] = $v;
				unset($tasks[$k]);

				continue;
			}

			if (!$v) {
				unset($tasks[$k]);
			}
		}

		return $tasks;
	}

	/**
	 * @param \IdeHelper\Console\Io $io
	 * @param array<string, mixed> $config
	 * @param string $content
	 * @return array<\IdeHelper\Annotator\ClassAnnotatorTask\ClassAnnotatorTaskInterface>
	 */
	public function tasks(Io $io, array $config, string $content): array {
		$tasks = $this->tasks;

		$collection = [];
		foreach ($tasks as $task) {
			/** @var \IdeHelper\Annotator\ClassAnnotatorTask\ClassAnnotatorTaskInterface $object */
			$object = new $task($io, $config, $content);
			$collection[] = $object;
		}

		return $collection;
	}

}


================================================
FILE: src/Annotator/CommandAnnotator.php
================================================
<?php

namespace IdeHelper\Annotator;

use IdeHelper\Annotator\Traits\ModelTrait;
use RuntimeException;

class CommandAnnotator extends AbstractAnnotator {

	use ModelTrait;

	/**
	 * @param string $path Path to file.
	 * @return bool
	 */
	public function annotate(string $path): bool {
		$className = pathinfo($path, PATHINFO_FILENAME);
		if ($className === 'Command' || !str_ends_with($className, 'Command')) {
			return false;
		}

		$content = file_get_contents($path);
		if ($content === false) {
			throw new RuntimeException('Cannot read file');
		}
		$primaryModelClass = $this->getPrimaryModelClass($content);
		$usedModels = $this->getUsedModels($content);
		if ($primaryModelClass) {
			$usedModels[] = $primaryModelClass;
		}
		$usedModels = array_unique($usedModels);

		$annotations = $this->getModelAnnotations($usedModels, $content);

		return $this->annotateContent($path, $content, $annotations);
	}

	/**
	 * @param string $content
	 *
	 * @return string|null
	 */
	protected function getPrimaryModelClass(string $content): ?string {
		if (!preg_match('/\bprotected \?string \$defaultTable = \'([a-z.\/]+)\'/i', $content, $matches)) {
			return null;
		}

		$modelName = $matches[1];

		return $modelName;
	}

}


================================================
FILE: src/Annotator/ComponentAnnotator.php
================================================
<?php

namespace IdeHelper\Annotator;

use Cake\Controller\ComponentRegistry;
use Cake\Controller\Controller;
use Cake\Core\Configure;
use Cake\Http\ServerRequest;
use IdeHelper\Annotation\AnnotationFactory;
use IdeHelper\Annotation\MethodAnnotation;
use IdeHelper\Annotation\PropertyAnnotation;
use IdeHelper\Annotator\Traits\ComponentTrait;
use IdeHelper\Utility\App;
use RuntimeException;
use Throwable;

class ComponentAnnotator extends AbstractAnnotator {

	use ComponentTrait;

	/**
	 * @param string $path Path to file.
	 * @return bool
	 */
	public function annotate(string $path): bool {
		$name = pathinfo($path, PATHINFO_FILENAME);
		if (!str_ends_with($name, 'Component')) {
			return false;
		}

		$name = substr($name, 0, -9);
		$plugin = $this->getConfig(static::CONFIG_PLUGIN);
		/** @phpstan-var class-string<object>|null $className */
		$className = App::className(($plugin ? $plugin . '.' : '') . $name, 'Controller/Component', 'Component');
		if (!$className) {
			return false;
		}

		$content = file_get_contents($path);
		if ($content === false) {
			throw new RuntimeException('Cannot read file');
		}
		$annotations = $this->buildAnnotations($className);

		if ($this->hasControllerAnnotation($content)) {
			$appControllerClass = (Configure::read('App.namespace') ?: 'App') . '\Controller\AppController';
			$annotations[] = new MethodAnnotation('\\' . $appControllerClass, 'getController()');
		}

		return $this->annotateContent($path, $content, $annotations);
	}

	/**
	 * @param class-string<object> $className
	 *
	 * @return array<\IdeHelper\Annotation\AbstractAnnotation>
	 */
	protected function buildAnnotations(string $className): array {
		$annotations = [];

		$componentAnnotations = $this->getComponentAnnotations($className);
		foreach ($componentAnnotations as $componentAnnotation) {
			$annotations[] = $componentAnnotation;
		}

		return $annotations;
	}

	/**
	 * @param class-string<object> $className $className
	 *
	 * @return array<\IdeHelper\Annotation\AbstractAnnotation>
	 */
	protected function getComponentAnnotations(string $className) {
		if ($this->_isAbstract($className)) {
			return [];
		}

		$controller = new Controller(new ServerRequest());
		try {
			$object = new $className(new ComponentRegistry($controller));
		} catch (Throwable $e) {
			if ($this->getConfig(static::CONFIG_VERBOSE)) {
				$this->_io->warn('   Skipping component annotations: ' . $e->getMessage());
			}

			return [];
		}

		$map = $this->invokeProperty($object, 'components');

		if (!$map) {
			return [];
		}

		$annotations = [];
		foreach ($map as $name => $config) {
			$className = $this->findClassName($config['className'] ?? $name, !$this->getConfig(static::CONFIG_PLUGIN));
			if (!$className) {
				continue;
			}

			$annotations[] = AnnotationFactory::createOrFail(PropertyAnnotation::TAG, '\\' . $className, '$' . $name);
		}

		return $annotations;
	}

	/**
	 * @param string $content
	 *
	 * @return bool
	 */
	protected function hasControllerAnnotation(string $content): bool {
		return str_contains($content, '$this->getController()');
	}

}


================================================
FILE: src/Annotator/ControllerAnnotator.php
================================================
<?php

namespace IdeHelper\Annotator;

use Cake\Core\Configure;
use Cake\Datasource\ResultSetInterface;
use Cake\Http\ServerRequest;
use Cake\ORM\Entity;
use Cake\ORM\TableRegistry;
use Cake\Utility\Inflector;
use IdeHelper\Annotation\AnnotationFactory;
use IdeHelper\Annotation\MethodAnnotation;
use IdeHelper\Annotation\PropertyAnnotation;
use IdeHelper\Annotator\Traits\ComponentTrait;
use IdeHelper\Annotator\Traits\ModelTrait;
use IdeHelper\Utility\App;
use IdeHelper\Utility\GenericString;
use PHP_CodeSniffer\Files\File;
use RuntimeException;
use Throwable;

class ControllerAnnotator extends AbstractAnnotator {

	use ComponentTrait;
	use ModelTrait;

	/**
	 * @param string $path Path to file.
	 * @return bool
	 */
	public function annotate(string $path): bool {
		$className = pathinfo($path, PATHINFO_FILENAME);
		if (!str_ends_with($className, 'Controller')) {
			return false;
		}

		$content = file_get_contents($path);
		if ($content === false) {
			throw new RuntimeException('Cannot read file');
		}
		$primaryModelName = $this->getPrimaryModelClass($content, $className, $path);

		$usedModels = $this->getUsedModels($content);
		if ($primaryModelName) {
			$usedModels[] = $primaryModelName;
		}
		$usedModels = array_unique($usedModels);

		$annotations = $this->getModelAnnotations($usedModels, $content);

		$componentAnnotations = $this->getComponentAnnotations($className, $path);
		foreach ($componentAnnotations as $componentAnnotation) {
			$annotations[] = $componentAnnotation;
		}

		$paginationAnnotations = $this->getPaginationAnnotations($content, $primaryModelName);
		foreach ($paginationAnnotations as $paginationAnnotation) {
			$annotations[] = $paginationAnnotation;
		}

		$annotations = $this->filterByTypedProperties($annotations, $content);

		return $this->annotateContent($path, $content, $annotations);
	}

	/**
	 * Set annotations to be removable. Fixes false positives with PHPStan thinking it's all good.
	 *
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param int $closeTagIndex
	 * @param array<string> $types
	 * @return array<\IdeHelper\Annotation\AbstractAnnotation>
	 */
	protected function parseExistingAnnotations(File $file, int $closeTagIndex, array $types = self::TYPES): array {
		$annotations = parent::parseExistingAnnotations($file, $closeTagIndex, $types);

		foreach ($annotations as &$annotation) {
			if (!preg_match('#\\\\Model\\\\Table\\\\#', $annotation->getType()) && !preg_match('#\\\\Controller\\\\Component\\\\#', $annotation->getType())) {
				continue;
			}

			$annotation->setInUse(false);
		}

		return $annotations;
	}

	/**
	 * @param string $content
	 * @param string $className
	 * @param string $path
	 * @return string|null
	 */
	protected function getPrimaryModelClass(string $content, string $className, string $path): ?string {
		if ($className === 'AppController' || preg_match('#[a-z0-9]AppController$#', $className)) {
			return null;
		}

		$dynamicallyFoundModelClass = $this->findModelClass($className, $path);
		if ($dynamicallyFoundModelClass !== null) {
			return $dynamicallyFoundModelClass !== '' ? $dynamicallyFoundModelClass : null;
		}

		if (preg_match('/\bprotected \?string \$defaultTable = \'([a-z.\/]+)\'/i', $content, $matches)) {
			return $matches[1];
		}

		if (preg_match('/\bprotected \?string \$defaultTable = \'\';/i', $content, $matches)) {
			return null;
		}

		$plugin = $this->getConfig(static::CONFIG_PLUGIN);
		$modelName = substr($className, 0, -10);
		$modelClassName = ($plugin ?: Configure::read('App.namespace', 'App')) . '\\Model\\Table\\' . $modelName . 'Table';
		if (!class_exists($modelClassName)) {
			return null;
		}

		if ($modelName && $plugin) {
			$modelName = $plugin . '.' . $modelName;
		}

		return $modelName ?: null;
	}

	/**
	 * @param string $className
	 * @param string $path
	 *
	 * @return array<\IdeHelper\Annotation\AbstractAnnotation>
	 */
	protected function getComponentAnnotations(string $className, string $path): array {
		try {
			$map = $this->getUsedComponents($className, $path);
		} catch (Throwable $e) {
			if ($this->getConfig(static::CONFIG_VERBOSE)) {
				$this->_io->warn('   Skipping component annotations: ' . $e->getMessage());
			}
		}

		if (empty($map)) {
			return [];
		}

		$annotations = [];
		foreach ($map as $component => $className) {
			if (str_starts_with($className, 'Cake\\')) {
				continue;
			}

			$annotations[] = AnnotationFactory::createOrFail(PropertyAnnotation::TAG, '\\' . $className, '$' . $component);
		}

		return $annotations;
	}

	/**
	 * @param string $className
	 * @param string $path
	 *
	 * @return array<string>
	 */
	protected function getUsedComponents(string $className, string $path): array {
		$plugin = $className !== 'AppController' ? $this->getConfig(static::CONFIG_PLUGIN) : null;
		$prefix = $this->getPrefix($className, $path);

		/** @phpstan-var class-string<object>|null $fullClassName */
		$fullClassName = App::className(($plugin ? $plugin . '.' : '') . $className, 'Controller' . $prefix);
		if (!$fullClassName) {
			return [];
		}

		if ($this->_isAbstract($fullClassName)) {
			return [];
		}

		$request = new ServerRequest(['url' => 'justfortesting']);
		/** @var \App\Controller\AppController $controller */
		$controller = new $fullClassName($request);

		$components = [];
		foreach ($controller->components()->loaded() as $component) {
			$components[$component] = get_class($controller->components()->get($component));
		}

		if ($className === 'AppController') {
			return $components;
		}

		$appControllerComponents = $this->getUsedComponents('AppController', $path);
		$components = array_diff_key($components, $appControllerComponents);

		return $components;
	}

	/**
	 * @param string $content
	 * @param string|null $primaryModelName
	 *
	 * @return array<\IdeHelper\Annotation\AbstractAnnotation>
	 */
	protected function getPaginationAnnotations(string $content, ?string $primaryModelName): array {
		$entities = $this->extractPaginateEntities($content, $primaryModelName);
		if (!$entities) {
			return [];
		}

		$resultSetInterfaceCollection = GenericString::generate(implode('|', $entities), '\\' . ResultSetInterface::class);

		$settingsType = 'array';
		if (Configure::read('IdeHelper.genericsInParam')) {
			$settingsType = 'array<string, mixed>';
		}

		$annotations = [AnnotationFactory::createOrFail(MethodAnnotation::TAG, $resultSetInterfaceCollection, 'paginate(\Cake\Datasource\RepositoryInterface|\Cake\Datasource\QueryInterface|string|null $object = null, ' . $settingsType . ' $settings = [])')];

		return $annotations;
	}

	/**
	 * @param string $content
	 * @param string|null $primaryModelName
	 *
	 * @return array<string>
	 */
	protected function extractPaginateEntities(string $content, ?string $primaryModelName): array {
		$models = [];

		preg_match_all('/\$this->paginate\(\)/i', $content, $matches);
		if (!empty($matches[0]) && $primaryModelName) {
			$models[] = $primaryModelName;
		}

		preg_match_all('/\$this->paginate\(\$this->([a-z]+)\)/i', $content, $matches);
		if (!empty($matches[1])) {
			$models = array_merge($models, $matches[1]);
		}

		if (!$models) {
			return [];
		}

		$result = [];
		foreach ($models as $model) {
			$entityClassName = $this->getEntity($model, $primaryModelName);

			$fullClassName = '\\' . ltrim($entityClassName, '\\');
			if (in_array($fullClassName, $result, true)) {
				continue;
			}
			$result[] = $fullClassName;
		}

		return $result;
	}

	/**
	 * @param string $modelName
	 * @param string|null $primaryModelName Can be plugin dot syntaxed
	 *
	 * @return string
	 */
	protected function getEntity(string $modelName, ?string $primaryModelName): string {
		if ($this->getConfig(static::CONFIG_PLUGIN) && $modelName !== $primaryModelName && !strpos($modelName, '.')) {
			$modelName = $this->getConfig(static::CONFIG_PLUGIN) . '.' . $modelName;
		}

		try {
			$table = TableRegistry::getTableLocator()->get($modelName);
			$entityClassName = $table->getEntityClass();
		} catch (Throwable $exception) {
			$plugin = null;
			if (str_contains($modelName, '.')) {
				[$plugin, $modelName] = explode('.', $modelName, 2);
			}
			$entity = Inflector::singularize($modelName);
			$fullClassName = ($plugin ?: Configure::read('App.namespace', 'App')) . '\\Model\\Entity\\' . $entity;
			if (class_exists($fullClassName)) {
				return $fullClassName;
			}

			return Entity::class;
		}

		return $entityClassName;
	}

	/**
	 * @param string $className
	 * @param string $path
	 *
	 * @return string|null
	 */
	protected function findModelClass(string $className, string $path): ?string {
		$plugin = $this->getConfig(static::CONFIG_PLUGIN);
		$prefix = $this->getPrefix($className, $path);

		$fullClassName = App::className(($plugin ? $plugin . '.' : '') . $className, 'Controller' . $prefix);
		if (!$fullClassName) {
			return null;
		}

		try {
			/** @var \Cake\Controller\Controller $controller */
			$controller = new $fullClassName(new ServerRequest());
		} catch (Throwable $e) {
			$this->_io->warn('   Could not look up model class for ' . $fullClassName . ': ' . $e->getMessage());

			return null;
		}

		$modelClass = $this->invokeProperty($controller, 'defaultTable');
		if (!$modelClass) {
			return null;
		}

		if ($this->getConfig(static::CONFIG_PLUGIN) && !str_contains($modelClass, '.')) {
			$modelClass = $this->getConfig(static::CONFIG_PLUGIN) . '.' . $modelClass;
		}

		$fullClassName = App::className($modelClass, 'Model/Table', 'Table');
		if (!$fullClassName) {
			return null;
		}

		return $modelClass;
	}

	/**
	 * Namespace prefix for controllers.
	 *
	 * @param string $className
	 * @param string $path
	 *
	 * @return string
	 */
	protected function getPrefix(string $className, string $path): string {
		preg_match('#/Controller/(\w+)/' . $className . '\.php#', $path, $matches);
		$prefix = '';
		if ($matches) {
			$prefix = '/' . $matches[1];
		}

		return $prefix;
	}

	/**
	 * Filter out Table property annotations for properties that already have typed declarations.
	 *
	 * @param array<\IdeHelper\Annotation\AbstractAnnotation> $annotations
	 * @param string $content
	 * @return array<\IdeHelper\Annotation\AbstractAnnotation>
	 */
	protected function filterByTypedProperties(array $annotations, string $content): array {
		preg_match_all('/(?:protected|public|private)\s+\??[\w\\\\]+\s+\$(\w+)\s*[;=]/', $content, $matches);
		$typedProperties = $matches[1];
		if (!$typedProperties) {
			return $annotations;
		}

		return array_filter($annotations, function ($annotation) use ($typedProperties) {
			if (!$annotation instanceof PropertyAnnotation) {
				return true;
			}
			if (!preg_match('#\\\\Model\\\\Table\\\\#', $annotation->getType())) {
				return true;
			}

			$property = ltrim($annotation->getProperty(), '$');

			return !in_array($property, $typedProperties, true);
		});
	}

}


================================================
FILE: src/Annotator/EntityAnnotator.php
================================================
<?php

namespace IdeHelper\Annotator;

use Cake\Core\Configure;
use Cake\ORM\Association;
use Cake\ORM\Association\BelongsToMany;
use Cake\ORM\Entity;
use Cake\ORM\Table;
use Cake\ORM\TableRegistry;
use Cake\Utility\Inflector;
use Cake\View\View;
use IdeHelper\Annotation\AnnotationFactory;
use IdeHelper\Annotation\PropertyAnnotation;
use IdeHelper\Annotation\PropertyReadAnnotation;
use IdeHelper\Annotator\Traits\UseStatementsTrait;
use IdeHelper\Utility\App;
use IdeHelper\View\Helper\DocBlockHelper;
use PHP_CodeSniffer\Files\File;
use RuntimeException;
use Throwable;

class EntityAnnotator extends AbstractAnnotator {

	use UseStatementsTrait;

	/**
	 * @var array<string, string>|null
	 */
	protected static $typeMap;

	/**
	 * @var array<string, string>
	 */
	protected static array $typeMapDefaults = [
		'mediumtext' => 'string',
		'longtext' => 'string',
		'array' => 'array',
		'json' => 'array',
		'binaryuuid' => 'string',
	];

	/**
	 * @param string $path Path to file.
	 * @throws \RuntimeException
	 * @return bool
	 */
	public function annotate(string $path): bool {
		$name = pathinfo($path, PATHINFO_FILENAME);
		if ($name === 'Entity') {
			return false;
		}

		$content = file_get_contents($path);
		if ($content === false) {
			throw new RuntimeException('Cannot read file');
		}

		$helper = new DocBlockHelper(new View());
		$propertyHintMap = $this->propertyHintMap($content, $helper);

		$virtualFields = $this->virtualFields($name);
		// For BC reasons we cannot pass it as 3rd param, so we transport it on the helper as setter/getter
		$helper->setVirtualFields($virtualFields);
		$annotations = $this->buildAnnotations($propertyHintMap, $helper);

		return $this->annotateContent($path, $content, $annotations);
	}

	/**
	 * @param string $content
	 * @param \IdeHelper\View\Helper\DocBlockHelper $helper
	 * @return array<string>
	 */
	protected function propertyHintMap(string $content, DocBlockHelper $helper): array {
		/** @var \Cake\Database\Schema\TableSchemaInterface $tableSchema */
		$tableSchema = $this->getConfig('schema');
		$columns = $tableSchema->columns();

		$schema = [];
		foreach ($columns as $column) {
			$row = $tableSchema->getColumn($column);
			$row['kind'] = 'column';
			$schema[$column] = $row;
		}

		$schema = $this->hydrateSchemaFromAssoc($schema);

		$propertyHintMap = $helper->buildEntityPropertyHintTypeMap($schema);
		$propertyHintMap = $this->buildExtendedEntityPropertyHintTypeMap($schema, $helper) + $propertyHintMap;
		$propertyHintMap += $this->buildVirtualPropertyHintTypeMap($content);
		$propertyHintMap += $helper->buildEntityAssociationHintTypeMap($schema);

		return array_filter($propertyHintMap);
	}

	/**
	 * From Bake Plugin
	 *
	 * @param array<string, mixed> $schema
	 *
	 * @return array<string, array<string, mixed>>
	 */
	protected function hydrateSchemaFromAssoc(array $schema): array {
		/** @var \Cake\ORM\AssociationCollection<\Cake\ORM\Association> $associations */
		$associations = $this->getConfig('associations');

		/** @var \Cake\ORM\Association $association */
		foreach ($associations as $association) {
			try {
				$entityClass = '\\' . ltrim($association->getTarget()->getEntityClass(), '\\');

				if ($entityClass === '\\' . Entity::class) {
					$namespace = Configure::read('App.namespace');

					[$plugin] = pluginSplit($association->getTarget()->getRegistryAlias());
					if ($plugin !== null) {
						$namespace = $plugin;
					}
					$namespace = str_replace('/', '\\', trim($namespace, '\\'));

					$entityClass = $this->entityName($association->getTarget()->getAlias());
					$entityClass = '\\' . $namespace . '\Model\Entity\\' . $entityClass;

					if (!class_exists($entityClass)) {
						$entityClass = '\\' . Entity::class;
					}
				}

				$schema[$association->getProperty()] = [
					'kind' => 'association',
					'association' => $association,
					'type' => $entityClass,
					'null' => $this->nullable($association, $schema),
				];

				if ($association->type() !== 'manyToMany') {
					continue;
				}

				/** @var \Cake\ORM\Association\BelongsToMany<\Cake\ORM\Table> $association */
				$table = $this->getThrough($association);
				if (!$table) {
					$table = new Table();
				}

				try {
					$className = $table->getEntityClass();
				} catch (Throwable $e) {
					$className = Entity::class;
				}

				$entityClass = '\\' . ltrim($className, '\\');
				$alias = $association->getTarget()->getAlias() . 'Join';
				$table->addAssociations(['belongsTo' => [$alias]]);
				$schema['_joinData'] = [
					'kind' => 'association',
					'association' => $table->{$alias},
					'type' => $entityClass,
					'null' => false,
				];

			} catch (Throwable $exception) {
				if ($this->getConfig(static::CONFIG_VERBOSE)) {
					$this->_io->warn($exception->getMessage());
				}

				continue;
			}
		}

		return $schema;
	}

	/**
	 * @param \Cake\ORM\Association\BelongsToMany<\Cake\ORM\Table> $association
	 *
	 * @return \Cake\ORM\Table|null
	 */
	protected function getThrough(BelongsToMany $association): ?Table {
		try {
			$through = $association->getThrough();
		} catch (Throwable) {
			$through = null;
		}
		if ($through) {
			if (is_object($through)) {
				return $through;
			}

			return TableRegistry::getTableLocator()->get($through);
		}

		return null;
	}

	/**
	 * @uses \Cake\ORM\Association\BelongsToMany::_junctionTableName()
	 *
	 * @param \Cake\ORM\Association\BelongsToMany<\Cake\ORM\Table> $association
	 * @return string
	 */
	protected function junctionTableName(BelongsToMany $association): string {
		$tablesNames = array_map('Cake\Utility\Inflector::underscore', [
			$association->getSource()->getTable(),
			$association->getTarget()->getTable(),
		]);

		sort($tablesNames);

		return implode('_', $tablesNames);
	}

	/**
	 * @param \Cake\ORM\Association $association
	 * @param array<string, mixed> $schema
	 * @return bool
	 */
	protected function nullable(Association $association, array $schema): bool {
		if ($association->type() === Association::ONE_TO_ONE) {
			return true;
		}

		if ($association->type() === Association::MANY_TO_ONE) {
			/** @var array<string>|string $field */
			$field = $association->getForeignKey();
			if (is_array($field)) {
				return false;
			}
			if (!isset($schema[$field]['null'])) {
				return false;
			}

			return $schema[$field]['null'];
		}

		return false;
	}

	/**
	 * Creates the proper entity name (singular) for the specified name
	 *
	 * @param string $name Name
	 * @return string Camelized and plural model name
	 */
	protected function entityName(string $name): string {
		return Inflector::singularize(Inflector::camelize($name));
	}

	/**
	 * @param array<string, array<string, mixed>> $propertySchema
	 * @param \IdeHelper\View\Helper\DocBlockHelper $helper
	 *
	 * @return array<string, string>
	 */
	protected function buildExtendedEntityPropertyHintTypeMap(array $propertySchema, DocBlockHelper $helper): array {
		$propertyHintMap = [];

		foreach ($propertySchema as $property => $info) {
			if ($info['kind'] === 'column') {
				$type = $this->columnTypeToHintType($info['type']);
				if ($type === null) {
					continue;
				}

				$propertyHintMap[$property] = $helper->columnTypeNullable($info, $type);
			}
		}

		return $propertyHintMap;
	}

	/**
	 * Converts a column type to its DocBlock type counterpart.
	 *
	 * @see \Cake\Database\Type
	 *
	 * @param string $type The column type.
	 * @return string|null The DocBlock type, or `null` for unsupported column types.
	 */
	protected function columnTypeToHintType(string $type): ?string {
		if (static::$typeMap === null) {
			static::$typeMap = (array)Configure::read('IdeHelper.typeMap') + static::$typeMapDefaults;
		}

		if (isset(static::$typeMap[$type])) {
			return static::$typeMap[$type];
		}

		return null;
	}

	/**
	 * @param string $content
	 * @return array<string, string>
	 */
	protected function buildVirtualPropertyHintTypeMap(string $content): array {
		if (!preg_match('#\bfunction _get[A-Z][a-zA-Z0-9]+\(\)#', $content)) {
			return [];
		}

		$file = $this->getFile('', $content);

		$classIndex = $file->findNext(T_CLASS, 0);
		if ($classIndex === false) {
			return [];
		}

		$tokens = $file->getTokens();
		if (empty($tokens[$classIndex]['scope_closer'])) {
			return [];
		}

		$useStatements = null;

		$classEndIndex = $tokens[$classIndex]['scope_closer'];

		$properties = [];
		$startIndex = $classIndex;
		while ($startIndex < $classEndIndex) {
			$functionIndex = $file->findNext(T_FUNCTION, $startIndex + 1);
			if ($functionIndex === false) {
				break;
			}

			$methodNameIndex = $file->findNext(T_STRING, $functionIndex + 1);
			if ($methodNameIndex === false) {
				break;
			}

			$token = $tokens[$methodNameIndex];
			$methodName = $token['content'];

			$startIndex = $methodNameIndex + 1;

			if (!preg_match('#^_get([A-Z][a-zA-Z0-9]+)$#', $methodName, $matches)) {
				continue;
			}

			$property = Inflector::underscore($matches[1]);

			$type = $this->returnType($file, $tokens, $functionIndex);
			if ($useStatements === null) {
				$useStatements = $this->getUseStatements($file);
			}
			$type = $this->fqcnIfNeeded($type, $useStatements);

			$properties[$property] = $type;
		}

		return $properties;
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param array<array<string, mixed>> $tokens
	 * @param int $functionIndex
	 * @return string
	 */
	protected function returnType(File $file, array $tokens, int $functionIndex): string {
		$firstTokenInLineIndex = $functionIndex;

		$line = $tokens[$functionIndex]['line'];

		while ($tokens[$firstTokenInLineIndex - 1]['line'] === $line) {
			$firstTokenInLineIndex--;
		}

		$docBlockCloseTagIndex = $this->findDocBlockCloseTagIndex($file, $firstTokenInLineIndex);
		if (!$docBlockCloseTagIndex || empty($tokens[$docBlockCloseTagIndex]['comment_opener'])) {
			return $this->typeHint($file, $tokens, $functionIndex);
		}

		$docBlockOpenTagIndex = $tokens[$docBlockCloseTagIndex]['comment_opener'];

		return $this->extractReturnType($tokens, $docBlockOpenTagIndex, $docBlockCloseTagIndex);
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param array<array<string, mixed>> $tokens
	 * @param int $functionIndex
	 *
	 * @return string
	 */
	protected function typeHint(File $file, array $tokens, int $functionIndex): string {
		$parenthesisCloseTagIndex = $tokens[$functionIndex]['parenthesis_closer'];
		$scopeOpenTagIndex = $tokens[$functionIndex]['scope_opener'];

		$typehintIndex = $file->findNext(T_STRING, $parenthesisCloseTagIndex + 1, $scopeOpenTagIndex);
		if ($typehintIndex === false) {
			return 'mixed';
		}

		$returnType = $tokens[$typehintIndex]['content'];

		$nullableIndex = $file->findNext(T_NULLABLE, $parenthesisCloseTagIndex + 1, $typehintIndex);

		if ($nullableIndex) {
			$returnType .= '|null';
		}

		return $returnType;
	}

	/**
	 * @param array<array<string, mixed>> $tokens
	 * @param int $docBlockOpenTagIndex
	 * @param int $docBlockCloseTagIndex
	 *
	 * @return string
	 */
	protected function extractReturnType(array $tokens, int $docBlockOpenTagIndex, int $docBlockCloseTagIndex): string {
		for ($i = $docBlockOpenTagIndex + 1; $i < $docBlockCloseTagIndex; $i++) {

			if ($tokens[$i]['type'] !== 'T_DOC_COMMENT_TAG') {
				continue;
			}
			if ($tokens[$i]['content'] !== '@return') {
				continue;
			}

			$classNameIndex = $i + 2;

			if ($tokens[$classNameIndex]['type'] !== 'T_DOC_COMMENT_STRING') {
				continue;
			}

			$content = $tokens[$classNameIndex]['content'];

			// Find the end of the type, accounting for nested generics
			// Spaces inside <> brackets should not be treated as type boundaries
			$bracketDepth = 0;
			$typeEnd = null;
			$length = strlen($content);
			for ($j = 0; $j < $length; $j++) {
				$char = $content[$j];
				if ($char === '<') {
					$bracketDepth++;
				} elseif ($char === '>') {
					$bracketDepth--;
				} elseif ($char === ' ' && $bracketDepth === 0) {
					$typeEnd = $j;

					break;
				}
			}

			if ($typeEnd !== null) {
				$content = substr($content, 0, $typeEnd);
			}

			return $content;
		}

		return 'mixed';
	}

	/**
	 * @param array<string> $propertyHintMap
	 * @param \IdeHelper\View\Helper\DocBlockHelper $helper
	 *
	 * @throws \RuntimeException
	 *
	 * @return array<\IdeHelper\Annotation\AbstractAnnotation>
	 */
	protected function buildAnnotations(array $propertyHintMap, DocBlockHelper $helper): array {
		$virtualFields = $helper->getVirtualFields();

		$real = $virtual = [];
		foreach ($propertyHintMap as $name => $type) {
			$isVirtual = in_array($name, $virtualFields, true);
			$tag = $isVirtual ? PropertyReadAnnotation::TAG : PropertyAnnotation::TAG;
			$annotation = "$tag {$type}\${$name}";

			$annotationObject = AnnotationFactory::create($tag, $type, $name);
			if (!$annotationObject) {
				throw new RuntimeException('Cannot factorize annotation `' . $annotation . '`');
			}

			if ($isVirtual) {
				$virtual[$name] = $annotationObject;
			} else {
				$real[$name] = $annotationObject;
			}
		}

		return $real + $virtual;
	}

	/**
	 * Detect actual virtual fields by them being exposed as such.
	 *
	 * @param string $name
	 *
	 * @return array<string>
	 */
	protected function virtualFields(string $name): array {
		$plugin = $this->getConfig(static::CONFIG_PLUGIN);
		$className = App::className(($plugin ? $plugin . '.' : '') . $name, 'Model/Entity');
		if (!$className) {
			return [];
		}

		try {
			/** @var \Cake\Datasource\EntityInterface $entity */
			$entity = new $className();
		} catch (Throwable $exception) {
			return [];
		}

		return $entity->getVirtual();
	}

	/**
	 * @param string $type
	 * @param array<string, array<string, mixed>> $useStatements
	 * @return string
	 */
	protected function fqcnIfNeeded(string $type, array $useStatements): string {
		$types = explode('|', $type);
		foreach ($types as $key => $type) {
			$primitive = ['null', 'true', 'false', 'array', 'iterable', 'string', 'bool', 'float', 'int', 'object', 'callable', 'resource', 'mixed'];
			if (in_array($type, $primitive, true) || str_starts_with($type, '\\')) {
				continue;
			}

			if (!isset($useStatements[$type])) {
				continue;
			}

			$types[$key] = '\\' . $useStatements[$type]['fullName'];
		}

		return implode('|', $types);
	}

}


================================================
FILE: src/Annotator/HelperAnnotator.php
================================================
<?php

namespace IdeHelper\Annotator;

use Cake\View\View;
use IdeHelper\Annotation\AnnotationFactory;
use IdeHelper\Annotation\PropertyAnnotation;
use IdeHelper\Annotator\Traits\HelperTrait;
use IdeHelper\Utility\App;
use RuntimeException;
use Throwable;

class HelperAnnotator extends AbstractAnnotator {

	use HelperTrait;

	/**
	 * @param string $path Path to file.
	 * @return bool
	 */
	public function annotate(string $path): bool {
		$name = pathinfo($path, PATHINFO_FILENAME);
		if (!str_ends_with($name, 'Helper')) {
			return false;
		}

		$name = substr($name, 0, -6);
		$plugin = $this->getConfig(static::CONFIG_PLUGIN);

		/** @phpstan-var class-string<object>|null $className */
		$className = App::className(($plugin ? $plugin . '.' : '') . $name, 'View/Helper', 'Helper');
		if (!$className) {
			return false;
		}

		if ($this->_isAbstract($className)) {
			return false;
		}

		try {
			$helper = new $className(new View());
		} catch (Throwable $e) {
			if ($this->getConfig(static::CONFIG_VERBOSE)) {
				$this->_io->warn('   Skipping helper annotations: ' . $e->getMessage());
			}

			return false;
		}

		/** @uses \Cake\View\Helper::helpers */
		$helperMap = $this->invokeProperty($helper, 'helpers');

		$content = file_get_contents($path);
		if ($content === false) {
			throw new RuntimeException('Cannot read file');
		}

		$annotations = $this->getHelperAnnotations($helperMap);

		return $this->annotateContent($path, $content, $annotations);
	}

	/**
	 * @param array<string, array<string, mixed>> $helperMap
	 * @return array<\IdeHelper\Annotation\AbstractAnnotation>
	 */
	protected function getHelperAnnotations(array $helperMap): array {
		if (!$helperMap) {
			return [];
		}

		$helperAnnotations = [];
		foreach ($helperMap as $helper => $config) {
			$className = $this->findClassName($config['className'] ?? $helper, !$this->getConfig(static::CONFIG_PLUGIN));
			if (!$className) {
				continue;
			}

			$helperAnnotations[] = AnnotationFactory::createOrFail(PropertyAnnotation::TAG, '\\' . $className, '$' . $helper);
		}

		return $helperAnnotations;
	}

}


================================================
FILE: src/Annotator/ModelAnnotator.php
================================================
<?php

namespace IdeHelper\Annotator;

use Cake\Core\Configure;
use Cake\Database\Schema\TableSchemaInterface;
use Cake\Datasource\EntityInterface;
use Cake\Datasource\ResultSetInterface;
use Cake\ORM\AssociationCollection;
use Cake\ORM\Table;
use Cake\ORM\TableRegistry;
use IdeHelper\Annotation\AnnotationFactory;
use IdeHelper\Annotation\ExtendsAnnotation;
use IdeHelper\Annotation\MixinAnnotation;
use IdeHelper\Console\Io;
use IdeHelper\Utility\App;
use IdeHelper\Utility\AppPath;
use IdeHelper\Utility\GenericString;
use ReflectionClass;
use RuntimeException;
use Throwable;

class ModelAnnotator extends AbstractAnnotator {

	public const CLASS_TABLE = Table::class;

	/**
	 * @var string
	 */
	public const TABLE_BEHAVIORS = 'tableBehaviors';

	/**
	 * @var string
	 */
	public const BEHAVIOR_MIXIN = 'mixin';

	/**
	 * @var string
	 */
	public const BEHAVIOR_EXTENDS = 'extends';

	/**
	 * @var array<string, array<string, string>>
	 */
	protected array $_cache = [];

	/**
	 * @param \IdeHelper\Console\Io $io
	 * @param array<string, mixed> $config
	 */
	public function __construct(Io $io, array $config) {
		parent::__construct($io, $config);

		/** @var string|bool|null $tableBehaviors */
		$tableBehaviors = Configure::read('IdeHelper.tableBehaviors');
		if ($tableBehaviors === true) {
			$tableBehaviors = [
				static::BEHAVIOR_MIXIN,
				static::BEHAVIOR_EXTENDS,
			];
		} elseif ($tableBehaviors === false) {
			$tableBehaviors = [];
		} elseif ($tableBehaviors === null) {
			$tableBehaviors = [
				static::BEHAVIOR_MIXIN,
			];
			if (version_compare(Configure::version(), '5.2.3', '>=')) {
				$tableBehaviors[] = static::BEHAVIOR_EXTENDS;
			}
		}

		$this->setConfig(static::TABLE_BEHAVIORS, (array)$tableBehaviors);
	}

	/**
	 * @param string $path Path to file.
	 * @return bool
	 */
	public function annotate(string $path): bool {
		$className = pathinfo($path, PATHINFO_FILENAME);
		if ($className === 'Table' || !str_ends_with($className, 'Table')) {
			return false;
		}

		$modelName = substr($className, 0, -5);
		$plugin = $this->getConfig(static::CONFIG_PLUGIN);

		$tableName = $plugin ? ($plugin . '.' . $modelName) : $modelName;
		try {
			/** @phpstan-var class-string<object> $tableClass */
			$tableClass = App::classNameOrFail($tableName, 'Model/Table', 'Table');
		} catch (Throwable $e) {
			if ($this->getConfig(static::CONFIG_VERBOSE)) {
				$this->_io->warn('   Skipping table and entity: ' . $e->getMessage());
			}

			return false;
		}

		if ($this->_isAbstract($tableClass)) {
			if ($this->getConfig(static::CONFIG_VERBOSE)) {
				$this->_io->warn('   Skipping table and entity: Abstract class');
			}

			return false;
		}

		$tableReflection = new ReflectionClass($tableClass);
		if (!$tableReflection->isInstantiable()) {
			if ($this->getConfig(static::CONFIG_VERBOSE)) {
				$this->_io->warn('   Skipping table and entity: Not instantiable');
			}

			return false;
		}

		try {
			$table = TableRegistry::getTableLocator()->get($tableName);
			$schema = $table->getSchema();
			$behaviors = $this->getBehaviors($table);
		} catch (Throwable $e) {
			if ($this->getConfig(static::CONFIG_VERBOSE)) {
				$this->_io->warn('   Skipping table and entity: ' . $e->getMessage());
			}

			return false;
		}

		$tableAssociations = $table->associations();
		try {
			$associations = $this->getAssociations($tableAssociations);
		} catch (Throwable $e) {
			if ($this->getConfig(static::CONFIG_VERBOSE)) {
				$this->_io->warn('   Skipping associations: ' . $e->getMessage());
			}
			$associations = [];
		}

		$entityClassName = $table->getEntityClass();
		$entityName = substr($entityClassName, strrpos($entityClassName, '\\') + 1);

		$parentClass = (string)get_parent_class($table);
		$resTable = $this->table($path, $entityName, $associations, $behaviors, $parentClass, $entityClassName);
		$resEntity = $this->entity($entityClassName, $entityName, $schema, $tableAssociations);

		return $resTable || $resEntity;
	}

	/**
	 * @param string $path
	 * @param string $entityName
	 * @param array<string, mixed> $associations
	 * @param array<string> $behaviors
	 * @param string $parentClass
	 * @param string $entityClass
	 * @return bool
	 */
	protected function table(string $path, string $entityName, array $associations, array $behaviors, string $parentClass, string $entityClass = ''): bool {
		$content = file_get_contents($path);
		if ($content === false) {
			throw new RuntimeException('Cannot read file');
		}

		$behaviors += $this->parseLoadedBehaviors($content);
		$annotations = $this->buildAnnotations($associations, $entityName, $behaviors, $parentClass, $entityClass);

		return $this->annotateContent($path, $content, $annotations);
	}

	/**
	 * @param array<string, mixed> $associations
	 * @param string $entity
	 * @param array<string> $behaviors
	 * @param string $parentClass
	 * @param string $entityClass
	 * @return array<\IdeHelper\Annotation\AbstractAnnotation>
	 */
	protected function buildAnnotations(array $associations, string $entity, array $behaviors, string $parentClass, string $entityClass = ''): array {
		$namespace = $this->getConfig(static::CONFIG_NAMESPACE);
		$annotations = [];
		foreach ($associations as $type => $assocs) {
			foreach ($assocs as $name => $className) {
				if (Configure::read('IdeHelper.assocsAsGenerics') === true) {
					$annotations[] = "@property \\{$type}<\\{$className}> \${$name}";
				} else {
					$annotations[] = "@property \\{$className}&\\{$type} \${$name}";
				}
			}
		}

		$fullClassName = "$namespace\\Model\\Entity\\$entity";
		if (class_exists($fullClassName)) {
			$fullClassName = '\\' . $fullClassName;
			$fullClassNameCollection = GenericString::generate($fullClassName);
			$entityInterface = '\\' . EntityInterface::class;
			$resultSetInterfaceCollection = GenericString::generate($fullClassName, '\\' . ResultSetInterface::class);

			if (Configure::read('IdeHelper.concreteEntitiesInParam')) {
				$entityInterface = $fullClassName;
			}

			$generics = Configure::read('IdeHelper.genericsInParam');
			$detailed = $generics === 'detailed';
			$dataType = 'array';
			$dataListType = 'array';
			$optionsType = 'array';
			$iterable = 'iterable';
			$finderType = 'array|string';
			$findOrCreateSearchType = '\Cake\ORM\Query\SelectQuery|callable|array';
			if ($generics) {
				$dataType = $detailed ? 'array<string, mixed>' : 'array<mixed>';
				$dataListType = $detailed ? 'array<array<string, mixed>>' : 'array<mixed>';
				$optionsType = 'array<string, mixed>';
				// Detailed mode always narrows iterables to the concrete entity — a UsersTable only ever handles User entities.
				$iterableEntity = $detailed ? $fullClassName : $entityInterface;
				$iterable = "iterable<{$iterableEntity}>";
			}
			if ($detailed) {
				$finderType = 'array<string, mixed>|string';
				$findOrCreateSearchType = "\Cake\ORM\Query\SelectQuery<{$fullClassName}>|callable|array<string, mixed>";
			}

			/**
			 * Copied from Bake plugin's DocBlockHelper
			 *
			 * @link \Bake\View\Helper\DocBlockHelper::buildTableAnnotations()
			 */
			$annotations[] = "@method {$fullClassName} newEmptyEntity()";
			$annotations[] = "@method {$fullClassName} newEntity({$dataType} \$data, {$optionsType} \$options = [])";
			$annotations[] = "@method {$fullClassNameCollection} newEntities({$dataListType} \$data, {$optionsType} \$options = [])";

			$annotations[] = "@method {$fullClassName} get(mixed \$primaryKey, {$finderType} \$finder = 'all', \Psr\SimpleCache\CacheInterface|string|null \$cache = null, \Closure|string|null \$cacheKey = null, mixed ...\$args)";
			if (Configure::read('IdeHelper.tableEntityQuery')) {
				$annotations[] = "@method \Cake\ORM\Query\SelectQuery<{$fullClassName}> find(string \$type = 'all', mixed ...\$args)";
			}
			$annotations[] = "@method {$fullClassName} findOrCreate({$findOrCreateSearchType} \$search, ?callable \$callback = null, {$optionsType} \$options = [])";

			$annotations[] = "@method {$fullClassName} patchEntity({$entityInterface} \$entity, {$dataType} \$data, {$optionsType} \$options = [])";
			$annotations[] = "@method {$fullClassNameCollection} patchEntities({$iterable} \$entities, {$dataListType} \$data, {$optionsType} \$options = [])";

			$annotations[] = "@method {$fullClassName}|false save({$entityInterface} \$entity, {$optionsType} \$options = [])";
			$annotations[] = "@method {$fullClassName} saveOrFail({$entityInterface} \$entity, {$optionsType} \$options = [])";

			$annotations[] = "@method {$resultSetInterfaceCollection}|false saveMany({$iterable} \$entities, {$optionsType} \$options = [])";
			$annotations[] = "@method {$resultSetInterfaceCollection} saveManyOrFail({$iterable} \$entities, {$optionsType} \$options = [])";

			$annotations[] = "@method {$resultSetInterfaceCollection}|false deleteMany({$iterable} \$entities, {$optionsType} \$options = [])";
			$annotations[] = "@method {$resultSetInterfaceCollection} deleteManyOrFail({$iterable} \$entities, {$optionsType} \$options = [])";
		}

		// Make replaceable via parsed object
		$result = [];
		foreach ($annotations as $annotation) {
			$annotationObject = AnnotationFactory::createFromString($annotation);
			if (!$annotationObject) {
				throw new RuntimeException('Cannot factorize annotation ' . $annotation);
			}

			$result[] = $annotationObject;
		}

		$result = $this->addBehaviorMixins($result, $behaviors);
		$result = $this->addBehaviorExtends($result, $behaviors, $parentClass, $entityClass);

		return $result;
	}

	/**
	 * @param string $entityClass
	 * @param string $entityName
	 * @param \Cake\Database\Schema\TableSchemaInterface $schema
	 * @param \Cake\ORM\AssociationCollection $associations
	 *
	 * @return bool
	 */
	protected function entity(string $entityClass, string $entityName, TableSchemaInterface $schema, AssociationCollection $associations): bool {
		$plugin = $this->getConfig(static::CONFIG_PLUGIN);
		$entityPaths = AppPath::get('Model/Entity', $plugin);
		$entityPath = null;
		while ($entityPaths) {
			$pathTmp = array_shift($entityPaths);
			$pathTmp = str_replace('\\', DS, $pathTmp);
			if (file_exists($pathTmp . $entityName . '.php')) {
				$entityPath = $pathTmp . $entityName . '.php';

				break;
			}
		}
		if (!$entityPath) {
			return false;
		}

		$file = pathinfo($entityPath, PATHINFO_BASENAME);
		$this->_io->verbose('   ' . $file);

		$annotator = $this->getEntityAnnotator($entityClass, $schema, $associations);
		$annotator->annotate($entityPath);

		return true;
	}

	/**
	 * @param string $content
	 * @return array<string>
	 */
	protected function parseLoadedBehaviors(string $content): array {
		preg_match_all('/\$this->addBehavior\(\'([a-z.\/]+)\'/i', $content, $matches);
		if (empty($matches[1])) {
			return [];
		}

		$behaviors = array_unique($matches[1]);

		$result = [];
		foreach ($behaviors as $behavior) {
			[, $behaviorName] = pluginSplit($behavior);
			$result[$behaviorName] = $behavior;
		}

		return $result;
	}

	/**
	 * @param \Cake\ORM\AssociationCollection $tableAssociations
	 * @return array<string, array<string, string>>
	 */
	protected function getAssociations(AssociationCollection $tableAssociations): array {
		$associations = [];
		foreach ($tableAssociations->keys() as $key) {
			$association = $tableAssociations->get($key);
			if (!$association) {
				continue;
			}
			$type = get_class($association);

			[, $name] = pluginSplit($association->getAlias());
			$table = $association->getClassName() ?: $association->getAlias();
			$className = App::className($table, 'Model/Table', 'Table') ?: static::CLASS_TABLE;

			$associations[$type][$name] = $className;
		}

		return $associations;
	}

	/**
	 * @param \Cake\ORM\Table $table
	 * @return array<string>
	 */
	protected function getBehaviors($table): array {
		$object = $table->behaviors();
		$map = $this->invokeProperty($object, '_loaded');

		$behaviors = $this->extractBehaviors($map);
		/** @phpstan-var class-string<object>|false $parentClass */
		$parentClass = get_parent_class($table);
		if (!$parentClass) {
			return [];
		}

		if (isset($this->_cache[$parentClass])) {
			$parentBehaviors = $this->_cache[$parentClass];
		} else {
			$parentReflection = new ReflectionClass($parentClass);
			if (!$parentReflection->isInstantiable()) {
				return $behaviors;
			}

			/** @var \Cake\ORM\Table $parent */
			$parent = new $parentClass();

			$object = $parent->behaviors();
			$map = $this->invokeProperty($object, '_loaded');
			$this->_cache[$parentClass] = $parentBehaviors = $this->extractBehaviors($map);
		}

		return array_diff_key($behaviors, $parentBehaviors);
	}

	/**
	 * @param array<string> $map
	 * @return array<string>
	 */
	protected function extractBehaviors(array $map): array {
		$result = [];
		/** @var object|string $behavior */
		foreach ($map as $name => $behavior) {
			$behaviorClassName = get_class($behavior) ?: '';
			$behaviorName = $this->resolveBehaviorName($behaviorClassName, $name);
			$pluginName = $this->resolvePluginName($behaviorClassName, $name);
			if ($pluginName) {
				$pluginName .= '.';
			}
			$result[$name] = $pluginName . $behaviorName;
		}

		return $result;
	}

	/**
	 * @param string $className
	 * @param string $name
	 * @return string|null
	 */
	protected function resolveBehaviorName(string $className, string $name): ?string {
		preg_match('#\\\\(?:Model|ORM)\\\\Behavior\\\\(.+)Behavior$#', $className, $matches);
		if (!$matches) {
			return null;
		}

		return str_replace('\\', '/', $matches[1]);
	}

	/**
	 * @param string $className
	 * @param string $name
	 *
	 * @return string|null
	 */
	protected function resolvePluginName(string $className, string $name): ?string {
		if (str_starts_with($className, 'Cake\\ORM')) {
			return '';
		}
		if (str_starts_with($className, 'App\\Model\\')) {
			return '';
		}

		if (str_contains($name, '\\')) {
			preg_match('#^(.+?)\\\\Model\\\\Behavior\\\\#', $className, $matches);
			if (!$matches) {
				return null;
			}
		} else {
			preg_match('#^(.+?)\\\\Model\\\\Behavior\\\\(.+)Behavior$#', $className, $matches);
			if (!$matches) {
				return null;
			}
		}

		return str_replace('\\', '/', $matches[1]);
	}

	/**
	 * @param string $entityClass
	 * @param \Cake\Database\Schema\TableSchemaInterface $schema
	 * @param \Cake\ORM\AssociationCollection $associations
	 * @return \IdeHelper\Annotator\AbstractAnnotator
	 */
	protected function getEntityAnnotator(string $entityClass, TableSchemaInterface $schema, AssociationCollection $associations): AbstractAnnotator {
		$class = EntityAnnotator::class;
		/** @phpstan-var array<class-string<\IdeHelper\Annotator\AbstractAnnotator>> $tasks */
		$tasks = (array)Configure::read('IdeHelper.annotators');
		if (isset($tasks[$class])) {
			$class = $tasks[$class];
		}

		return new $class($this->_io, ['class' => $entityClass, 'schema' => $schema, 'associations' => $associations] + $this->getConfig());
	}

	/**
	 * @param array<\IdeHelper\Annotation\AbstractAnnotation> $result
	 * @param array<string> $behaviors
	 * @return array<\IdeHelper\Annotation\AbstractAnnotation>
	 */
	protected function addBehaviorMixins(array $result, array $behaviors): array {
		if (!in_array(static::BEHAVIOR_MIXIN, $this->_config[static::TABLE_BEHAVIORS], true)) {
			return $result;
		}

		foreach ($behaviors as $behavior) {
			$className = App::className($behavior, 'Model/Behavior', 'Behavior');
			if (!$className) {
				$className = App::className($behavior, 'ORM/Behavior', 'Behavior');
			}
			if (!$className) {
				continue;
			}

			$result[] = AnnotationFactory::createOrFail(MixinAnnotation::TAG, "\\{$className}");
		}

		return $result;
	}

	/**
	 * @param array<\IdeHelper\Annotation\AbstractAnnotation> $result
	 * @param array<string> $behaviors
	 * @param string $parentClass
	 * @param string $entityClass
	 * @return array<\IdeHelper\Annotation\AbstractAnnotation>
	 */
	protected function addBehaviorExtends(array $result, array $behaviors, string $parentClass, string $entityClass = ''): array {
		if (!in_array(static::BEHAVIOR_EXTENDS, $this->_config[static::TABLE_BEHAVIORS], true)) {
			return $result;
		}

		$list = [];
		foreach ($behaviors as $name => $fullName) {
			$className = App::className($fullName, 'Model/Behavior', 'Behavior');
			if (!$className) {
				$className = App::className($fullName, 'ORM/Behavior', 'Behavior');
			}
			if (!$className) {
				continue;
			}

			$list[] = $name . ': \\' . $className;
		}

		$entityTemplate = $this->supportsEntityTemplate() && $entityClass ? ', \\' . ltrim($entityClass, '\\') : '';

		if (!$list && !$entityTemplate) {
			return $result;
		}

		sort($list);

		$list = implode(', ', $list);

		if (!$parentClass) {
			$parentClass = '\\Cake\\ORM\\Table';
		}
		$result[] = AnnotationFactory::createOrFail(ExtendsAnnotation::TAG, '\\' . $parentClass . '<array{' . $list . '}' . $entityTemplate . '>');

		return $result;
	}

	/**
	 * Whether `\Cake\ORM\Table` declares a second `TEntity` template parameter (CakePHP 5.4+).
	 *
	 * @return bool
	 */
	protected function supportsEntityTemplate(): bool {
		return version_compare(Configure::version(), '5.4.0', '>=');
	}

}


================================================
FILE: src/Annotator/Template/VariableExtractor.php
================================================
<?php

namespace IdeHelper\Annotator\Template;

use PHP_CodeSniffer\Files\File;
use PHP_CodeSniffer\Util\Tokens;

/**
 * Extracts variables from CakePHP PHP templates using token list of CS File object.
 */
class VariableExtractor {

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @return array<string, mixed>
	 */
	public function extract(File $file): array {
		$vars = $this->collect($file);

		$result = [];
		foreach ($vars as $var) {
			/** @var string $name */
			$name = $var['name'];
			if (!isset($result[$name])) {
				$result[$name] = $var;
				$result[$name]['vars'][] = $var;
			}

			if ($var['excludeReason']) {
				$result[$name]['excludeReason'] = $var['excludeReason'];
			}
			if ($var['type'] && empty($result[$name]['type'])) {
				$result[$name]['type'] = $var['type'];
			}
			if ($var['type'] && !empty($result[$name]['type']) && $var['type'] !== $result[$name]['type']) {
				$result[$name]['type'] = 'mixed';
			}
		}

		ksort($result);

		return $result;
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 *
	 * @return array<array<string, mixed>>
	 */
	protected function collect(File $file): array {
		$tokens = $file->getTokens();

		$vars = [];
		foreach ($tokens as $i => $token) {
			if ($token['code'] !== T_VARIABLE) {
				continue;
			}
			if ($token['content'] === '$this') {
				continue;
			}

			$var = $this->getVar($file, $token, $i);
			if (!$var) {
				continue;
			}

			$vars[$i] = $var;
		}

		foreach ($tokens as $i => $token) {
			if ($token['code'] !== T_DOUBLE_QUOTED_STRING) {
				continue;
			}

			$varsFound = $this->getVarsFromString($file, $token, $i);
			foreach ($varsFound as $var) {
				$vars[] = $var;
			}
		}

		foreach ($tokens as $i => $token) {
			if ($token['code'] !== T_STRING || strtolower($token['content']) !== 'compact') {
				continue;
			}

			// Skip method calls like $obj->compact() or Class::compact()
			$prevIndex = $file->findPrevious(Tokens::$emptyTokens, $i - 1, null, true, null, true);
			if ($prevIndex !== false && in_array($tokens[$prevIndex]['code'], [T_OBJECT_OPERATOR, T_DOUBLE_COLON], true)) {
				continue;
			}

			$varsFound = $this->getVarsFromCompact($file, $i);
			foreach ($varsFound as $var) {
				$vars[] = $var;
			}
		}

		return $vars;
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param array<string, mixed> $token
	 * @param int $index
	 * @return array<string, mixed>
	 */
	protected function getVar(File $file, array $token, int $index): array {
		$variable = substr($token['content'], 1);

		$result = [
			'name' => $variable,
			'index' => $index,
			'type' => null,
			'excludeReason' => null,
			'context' => $token,
		];
		$type = $this->getVarType($file, $result);
		$result['type'] = $type;
		$excludeReason = $this->getExcludeReason($file, $result);
		$result['excludeReason'] = $excludeReason;

		return $result;
	}

	/**
	 * Guesses the variable type based on PHP token elements before or after.
	 *
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param array<string, mixed> $result
	 * @return string|null
	 */
	protected function getVarType(File $file, array $result): ?string {
		$tokens = $file->getTokens();

		$nextIndex = $file->findNext(Tokens::$emptyTokens, $result['index'] + 1, $result['index'] + 3, true, null, true);
		if ($nextIndex && $tokens[$nextIndex]['code'] === T_OBJECT_OPERATOR) {
			return 'object';
		}

		if ($nextIndex && $tokens[$nextIndex]['code'] === T_OPEN_SQUARE_BRACKET) {
			return 'array';
		}

		$prevIndex = $file->findPrevious(Tokens::$emptyTokens, $result['index'] - 1, $result['index'] - 3, true, null, true);
		if ($prevIndex && in_array($tokens[$prevIndex]['code'], [T_ECHO, T_OPEN_TAG_WITH_ECHO, T_STRING_CONCAT], true)) {
			if ($nextIndex && in_array($tokens[$nextIndex]['code'], [T_SEMICOLON, T_STRING_CONCAT, T_CLOSE_TAG], true)) {
				return 'string';
			}
		}

		return null;
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param array<string, mixed> $result
	 * @return string|null
	 */
	protected function getExcludeReason(File $file, array $result): ?string {
		if ($this->isLoopVar($file, $result)) {
			return 'Declared in loop';
		}
		if ($this->isTryCatchVar($file, $result)) {
			return 'Try catch';
		}
		if ($this->isAnonymousFunctionParameter($file, $result)) {
			return 'Anonymous function parameter';
		}

		if ($this->isAssignment($file, $result)) {
			return 'Assignment';
		}

		return null;
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param array<string, mixed> $result
	 * @return bool
	 */
	protected function isLoopVar(File $file, array $result): bool {
		$tokens = $file->getTokens();

		$prevIndex = $file->findPrevious(Tokens::$emptyTokens, $result['index'] - 1, $result['index'] - 3, true, null, true);
		if ($prevIndex && $tokens[$prevIndex]['code'] === T_AS) {
			return true;
		}

		if ($prevIndex && $tokens[$prevIndex]['code'] === T_DOUBLE_ARROW && $this->isInLoop($file, $result, $prevIndex)) {
			return true;
		}

		return false;
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param array<string, mixed> $result
	 * @param int $assignmentIndex
	 *
	 * @return bool
	 */
	protected function isInLoop(File $file, array $result, int $assignmentIndex): bool {
		if (empty($result['context']['nested_parenthesis'])) {
			return false;
		}

		$startIndex = null;
		foreach ($result['context']['nested_parenthesis'] as $key => $unused) {
			$startIndex = $key;

			break;
		}

		return (bool)$file->findPrevious(T_FOREACH, $startIndex - 1, $startIndex - 3);
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param array<string, mixed> $result
	 * @return bool
	 */
	protected function isTryCatchVar(File $file, array $result): bool {
		if (empty($result['context']['nested_parenthesis'])) {
			return false;
		}

		$startIndex = null;
		foreach ($result['context']['nested_parenthesis'] as $key => $unused) {
			$startIndex = $key;

			break;
		}

		if ($startIndex === null || $startIndex <= 1) {
			return false;
		}

		return (bool)$file->findPrevious(T_CATCH, $startIndex - 1, $startIndex - 3);
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param array<string, mixed> $result
	 * @return bool
	 */
	protected function isAnonymousFunctionParameter(File $file, array $result): bool {
		if (empty($result['context']['nested_parenthesis'])) {
			return false;
		}

		$tokens = $file->getTokens();

		// Check each level of nested parenthesis
		foreach ($result['context']['nested_parenthesis'] as $openParen => $closeParen) {
			// Check if this is immediately preceded by 'function' or 'fn' keyword
			if ($openParen > 0) {
				$prevToken = $file->findPrevious(T_WHITESPACE, $openParen - 1, (int)max(0, $openParen - 2), true);
				if ($prevToken !== false && in_array($tokens[$prevToken]['code'], [T_CLOSURE, T_FN], true)) {
					// This variable is inside an anonymous function's parameter list
					return true;
				}
			}
		}

		return false;
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param array<string, mixed> $result
	 * @return bool
	 */
	protected function isAssignment(File $file, array $result): bool {
		$tokens = $file->getTokens();

		$nextIndex = $file->findNext(Tokens::$emptyTokens, $result['index'] + 1, $result['index'] + 3, true, null, true);
		if ($nextIndex && $tokens[$nextIndex]['code'] === T_EQUAL) {
			return true;
		}

		if ($nextIndex && $tokens[$nextIndex]['code'] === T_CLOSE_SHORT_ARRAY) {
			$equalIndex = $file->findNext(Tokens::$emptyTokens, $nextIndex + 1, $nextIndex + 3, true, null, true);
			if ($equalIndex && $tokens[$equalIndex]['code'] === T_EQUAL) {
				return true;
			}
		}

		$prevIndex = $file->findPrevious(Tokens::$emptyTokens, $result['index'] - 1, $result['index'] - 3, true, null, true);
		if ($prevIndex === false) {
			return false;
		}

		for ($i = $prevIndex; $i > 0; $i--) {
			$testIndex = $file->findPrevious(Tokens::$emptyTokens, $i, $i - 2, true, null, true);
			if (!$testIndex) {
				break;
			}
			if ($tokens[$testIndex]['code'] !== T_COMMA && $tokens[$testIndex]['code'] !== T_VARIABLE) {
				$prevIndex = $testIndex;

				break;
			}
		}

		if ($prevIndex && $tokens[$prevIndex]['code'] === T_OPEN_SHORT_ARRAY) {
			$closerIndex = $tokens[$prevIndex]['bracket_closer'];
			$nextIndex = $file->findNext(Tokens::$emptyTokens, $closerIndex + 1, $closerIndex + 3, true, null, true);
			if ($nextIndex && $tokens[$nextIndex]['code'] === T_EQUAL) {
				return true;
			}
		}

		return false;
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param array<string, mixed> $token
	 * @param int $i
	 * @return array<array<string, mixed>>
	 */
	protected function getVarsFromString(File $file, array $token, int $i): array {

		preg_match_all('/\$(\{)?([a-zA-Z_][a-zA-Z0-9_]*)\}?/', $token['content'], $matches);
		if (empty($matches[2])) {
			return [];
		}

		$result = [];
		foreach ($matches[2] as $variable) {
			// Skip $this variable as it's handled separately
			if ($variable === 'this') {
				continue;
			}

			$result[] = [
				'name' => $variable,
				'index' => $i,
				'type' => null,
				'excludeReason' => null,
				'context' => $token,
			];
		}

		return $result;
	}

	/**
	 * Extracts variable names from compact() function calls.
	 *
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param int $index
	 * @return array<array<string, mixed>>
	 */
	protected function getVarsFromCompact(File $file, int $index): array {
		$tokens = $file->getTokens();

		// Find the opening parenthesis
		$openParen = $file->findNext(Tokens::$emptyTokens, $index + 1, null, true, null, true);
		if ($openParen === false || $tokens[$openParen]['code'] !== T_OPEN_PARENTHESIS) {
			return [];
		}

		$closeParen = $tokens[$openParen]['parenthesis_closer'] ?? null;
		if ($closeParen === null) {
			return [];
		}

		$result = [];
		for ($i = $openParen + 1; $i < $closeParen; $i++) {
			if ($tokens[$i]['code'] !== T_CONSTANT_ENCAPSED_STRING) {
				continue;
			}

			// Skip array keys (string followed by =>)
			$nextIndex = $file->findNext(Tokens::$emptyTokens, $i + 1, $closeParen, true, null, true);
			if ($nextIndex !== false && $tokens[$nextIndex]['code'] === T_DOUBLE_ARROW) {
				continue;
			}

			// Skip strings in concatenation (preceded or followed by .)
			if ($nextIndex !== false && $tokens[$nextIndex]['code'] === T_STRING_CONCAT) {
				continue;
			}
			$prevIndex = $file->findPrevious(Tokens::$emptyTokens, $i - 1, $openParen, true, null, true);
			if ($prevIndex !== false && $tokens[$prevIndex]['code'] === T_STRING_CONCAT) {
				continue;
			}

			// Strip quotes from the string
			$variable = trim($tokens[$i]['content'], '\'"');
			if ($variable === '' || $variable === 'this') {
				continue;
			}

			$result[] = [
				'name' => $variable,
				'index' => $i,
				'type' => null,
				'excludeReason' => null,
				'context' => $tokens[$i],
			];
		}

		return $result;
	}

}


================================================
FILE: src/Annotator/TemplateAnnotator.php
================================================
<?php

namespace IdeHelper\Annotator;

use Bake\View\Helper\DocBlockHelper;
use Cake\Collection\CollectionInterface;
use Cake\Core\Configure;
use Cake\Utility\Inflector;
use Cake\View\View;
use IdeHelper\Annotation\AbstractAnnotation;
use IdeHelper\Annotation\AnnotationFactory;
use IdeHelper\Annotation\VariableAnnotation;
use IdeHelper\Annotator\Template\VariableExtractor;
use IdeHelper\Utility\App;
use IdeHelper\Utility\CollectionClass;
use IdeHelper\Utility\GenericString;
use PHP_CodeSniffer\Config;
use PHP_CodeSniffer\Files\File;
use RuntimeException;

class TemplateAnnotator extends AbstractAnnotator {

	/**
	 * @param string $path Path to file.
	 * @return bool
	 */
	public function annotate(string $path): bool {
		$content = file_get_contents($path);
		if ($content === false) {
			throw new RuntimeException('Cannot read file');
		}

		$annotations = $this->buildAnnotations($path, $content);

		return $this->annotateContent($path, $content, $annotations);
	}

	/**
	 * @param string $path
	 * @param string $content
	 * @param array<\IdeHelper\Annotation\AbstractAnnotation> $annotations
	 *
	 * @return bool
	 */
	protected function annotateContent(string $path, string $content, array $annotations): bool {
		if (!count($annotations)) {
			return false;
		}

		$file = $this->getFile($path, $content);

		$phpOpenTagIndex = $file->findNext(T_OPEN_TAG, 0);
		if ($phpOpenTagIndex === false) {
			$phpOpenTagIndex = null;
		}

		$needsPhpTag = $phpOpenTagIndex === null || $this->needsPhpTag($file, $phpOpenTagIndex);

		// Adjust position after declare statement for searching and adding new content
		$phpOpenTagIndexAdjusted = $this->checkForDeclareStatement($file, $phpOpenTagIndex);

		$docBlockCloseTagIndex = null;
		if ($needsPhpTag) {
			$phpOpenTagIndexForSearch = null;
		} else {
			$phpOpenTagIndexForSearch = $phpOpenTagIndexAdjusted;
		}
		if ($phpOpenTagIndexForSearch !== null) {
			$docBlockCloseTagIndex = $this->findExistingDocBlock($file, $phpOpenTagIndexForSearch);
		}

		$phpOpenTagIndex = $phpOpenTagIndexAdjusted;
		if ($needsPhpTag) {
			$phpOpenTagIndex = null;
		}

		$this->resetCounter();
		if ($docBlockCloseTagIndex && !$this->isInlineDocBlock($file, $docBlockCloseTagIndex)) {
			$newContent = $this->appendToExistingDocBlock($file, $docBlockCloseTagIndex, $annotations);
		} else {
			$newContent = $this->addNewTemplateDocBlock($file, $annotations, $phpOpenTagIndex, $docBlockCloseTagIndex);
		}

		if ($newContent === $content) {
			$this->reportSkipped($path);

			return false;
		}

		if (!$this->getConfig('verbose')) {
			$this->_io->out('-> ' . str_replace(ROOT . DS, '', $path));
		}

		$this->displayDiff($content, $newContent);
		$this->storeFile($path, $newContent);

		$this->report();

		return true;
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param int $phpOpenTagIndex
	 * @return int|null
	 */
	protected function findExistingDocBlock(File $file, int $phpOpenTagIndex): ?int {
		$tokens = $file->getTokens();

		$nextIndex = $file->findNext(T_WHITESPACE, $phpOpenTagIndex + 1, null, true);
		if ($tokens[$nextIndex]['type'] !== 'T_DOC_COMMENT_OPEN_TAG') {
			return null;
		}

		$commentCloseIndex = $tokens[$nextIndex]['comment_closer'];

		$tagIndex = $file->findNext(T_DOC_COMMENT_TAG, $phpOpenTagIndex + 1, $commentCloseIndex);
		if (!$tagIndex || $tokens[$tagIndex]['content'] === '@var') {
			return $commentCloseIndex;
		}

		// Assume the first doc block is the license file doc block
		while ($closeIndex = $this->findExistingDocBlock($file, $commentCloseIndex)) {
			$line = $tokens[$closeIndex]['line'];
			$openIndex = $tokens[$closeIndex]['comment_opener'];
			$nextContentIndex = $file->findNext(T_WHITESPACE, $closeIndex + 1, null, true);
			// This must be an inline docblock, so we need to bail
			if (
				$nextContentIndex
				&& $tokens[$nextContentIndex]['line'] === $line + 1
				&& $tokens[$openIndex]['line'] === $tokens[$closeIndex]['line']
			) {
				break;
			}

			$commentCloseIndex = $closeIndex;
		}

		return $commentCloseIndex;
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param array<\IdeHelper\Annotation\AbstractAnnotation> $annotations
	 * @param int|null $phpOpenTagIndex
	 * @param int|null $docBlockCloseIndex
	 *
	 * @throws \RuntimeException
	 *
	 * @return string
	 */
	protected function addNewTemplateDocBlock(File $file, array $annotations, ?int $phpOpenTagIndex, ?int $docBlockCloseIndex): string {
		$helper = new DocBlockHelper(new View());

		$annotationStrings = [];
		foreach ($annotations as $key => $annotation) {
			if (!is_object($annotation)) {
				throw new RuntimeException('Must be object: ' . print_r($annotation, true));
			}
			$annotationStrings[$key] = (string)$annotation;
		}

		$annotationString = $helper->classDescription('', '', $annotationStrings);
		if (PHP_EOL !== "\n") {
			$annotationString = str_replace("\n", PHP_EOL, $annotationString);
		}

		if ($phpOpenTagIndex === null) {
			$annotationString = '<?php' . PHP_EOL . $annotationString . PHP_EOL . '?>';
		}

		$docBlock = $annotationString . PHP_EOL;
		if (!$file->getTokens()) {
			$this->_counter[static::COUNT_ADDED] = count($annotations);

			return $docBlock;
		}

		$fixer = $this->getFixer($file);
		if ($phpOpenTagIndex === null) {
			$fixer->addContentBefore(0, $docBlock);
		} else {
			// PHPCS v4 requires a blank line after <?php tag for PSR12 compliance
			// PHPCS v3 does not have this requirement
			if ($this->isV4()) {
				$fixer->addContent($phpOpenTagIndex, PHP_EOL . $annotationString);
			} else {
				$fixer->addContent($phpOpenTagIndex, $docBlock);
			}
		}

		$this->_counter[static::COUNT_ADDED] = count($annotations);

		if ($docBlockCloseIndex && $this->isInlineDocBlockRedundant($file, $annotations, $docBlockCloseIndex)) {
			$tokens = $file->getTokens();
			$docBlockOpenIndex = $tokens[$docBlockCloseIndex]['comment_opener'];
			for ($i = $docBlockCloseIndex + 1; $i >= $docBlockOpenIndex; $i--) {
				$fixer->replaceToken($i, '');
			}

			$this->_counter[static::COUNT_ADDED]--;
		}

		return $fixer->getContents();
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param int $phpOpenTagIndex
	 * @return bool
	 */
	protected function needsPhpTag(File $file, int $phpOpenTagIndex): bool {
		$needsPhpTag = true;

		$tokens = $file->getTokens();

		if ($phpOpenTagIndex === 0 || ($phpOpenTagIndex > 0 && $this->isFirstContent($tokens, $phpOpenTagIndex))) {
			$needsPhpTag = false;
		}
		if ($needsPhpTag) {
			return true;
		}

		$nextIndex = $file->findNext(T_WHITESPACE, $phpOpenTagIndex + 1, null, true);
		if ($tokens[$nextIndex]['code'] === T_DECLARE) {
			return false;
		}

		if ($tokens[$nextIndex]['line'] === $tokens[$phpOpenTagIndex]['line']) {
			return true;
		}

		return $needsPhpTag;
	}

	/**
	 * @param string $content
	 *
	 * @return bool
	 */
	protected function needsViewAnnotation(string $content): bool {
		if (Configure::read('IdeHelper.preemptive')) {
			return true;
		}

		if (preg_match('/\$this->/', $content)) {
			return true;
		}

		if (preg_match('/<\?/', $content)) {
			return true;
		}

		return false;
	}

	/**
	 * @return \IdeHelper\Annotation\VariableAnnotation
	 */
	protected function getViewAnnotation() {
		$className = Configure::read('IdeHelper.viewClass');
		if (!$className) {
			$className = (Configure::read('App.namespace') ?: 'App') . '\View\AppView';
		}
		if (!class_exists($className)) {
			$className = 'Cake\View\View';
		}

		/** @var \IdeHelper\Annotation\VariableAnnotation $annotation */
		$annotation = AnnotationFactory::createOrFail(VariableAnnotation::TAG, '\\' . $className, '$this');

		return $annotation;
	}

	/**
	 * Preserves existing view annotations if they reference a valid View subclass.
	 *
	 * @param \IdeHelper\Annotation\AbstractAnnotation $annotation
	 * @param array<\IdeHelper\Annotation\AbstractAnnotation> $existingAnnotations
	 * @return bool
	 */
	protected function allowsReplacing(AbstractAnnotation $annotation, array &$existingAnnotations): bool {
		foreach ($existingAnnotations as $key => $existingAnnotation) {
			if (!$existingAnnotation->matches($annotation)) {
				continue;
			}

			// Check if this is a $this view annotation with a valid View class
			if (
				$existingAnnotation instanceof VariableAnnotation
				&& $existingAnnotation->getVariable() === '$this'
			) {
				$existingType = ltrim($existingAnnotation->getType(), '\\');
				if (class_exists($existingType) && is_subclass_of($existingType, View::class)) {
					unset($existingAnnotations[$key]);

					return false;
				}
			}

			// Fall back to parent behavior for description check
			if ($existingAnnotation->getDescription() !== '') {
				unset($existingAnnotations[$key]);

				return false;
			}
		}

		return true;
	}

	/**
	 * @param array<array<string, mixed>> $tokens
	 * @param int $phpOpenTagIndex
	 *
	 * @return bool
	 */
	protected function isFirstContent(array $tokens, int $phpOpenTagIndex): bool {
		for ($i = $phpOpenTagIndex - 1; $i >= 0; $i--) {
			if ($tokens[$i]['type'] !== T_INLINE_HTML) {
				return false;
			}
			if (trim($tokens[$i]['content']) !== '') {
				return false;
			}
		}

		return true;
	}

	/**
	 * @param string $content
	 * @param array<string, array<string, mixed>> $variables
	 *
	 * @return array<string, mixed>
	 */
	protected function getEntityAnnotations(string $content, array $variables): array {
		$loopEntityAnnotations = $this->parseLoopEntities($content);
		$formEntityAnnotations = $this->parseFormEntities($content);
		$entityAnnotations = $this->parseEntities($content);

		$entityAnnotations = $loopEntityAnnotations + $formEntityAnnotations + $entityAnnotations;

		foreach ($entityAnnotations as $name => $entityAnnotation) {
			if (!empty($variables[$name]) && $variables[$name]['excludeReason']) {
				unset($entityAnnotations[$name]);
			}
		}

		return $entityAnnotations;
	}

	/**
	 * @param string $content
	 *
	 * @return array<string, mixed>
	 */
	protected function parseFormEntities(string $content): array {
		preg_match_all('/\$this->Form->create\(\$(\w+)\W/i', $content, $matches);
		if (empty($matches[1])) {
			return [];
		}

		$result = [];

		/** @var array<string> $entities */
		$entities = array_unique($matches[1]);
		foreach ($entities as $entity) {
			$entityName = Inflector::camelize(Inflector::underscore($entity));

			$className = App::className(($this->getConfig(static::CONFIG_PLUGIN) ? $this->getConfig(static::CONFIG_PLUGIN) . '.' : '') . $entityName, 'Model/Entity');
			if (!$className) {
				continue;
			}

			$annotation = AnnotationFactory::createOrFail(VariableAnnotation::TAG, '\\' . $className, '$' . $entity);

			$result[$entity] = $annotation;
		}

		return $result;
	}

	/**
	 * @param string $content
	 *
	 * @return array<string, mixed>
	 */
	protected function parseLoopEntities(string $content): array {
		preg_match_all('/\bforeach \(\$([a-z]+) as \$([a-z]+)\)/i', $content, $matches);
		if (empty($matches[2])) {
			return [];
		}

		$result = [];

		$entities = $matches[2];
		foreach ($entities as $key => $entity) {
			if (Inflector::pluralize($entity) !== $matches[1][$key]) {
				continue;
			}

			$entityName = Inflector::camelize(Inflector::underscore($entity));

			$className = App::className(($this->getConfig(static::CONFIG_PLUGIN) ? $this->getConfig(static::CONFIG_PLUGIN) . '.' : '') . $entityName, 'Model/Entity');
			if (!$className) {
				continue;
			}

			$resultKey = $matches[1][$key];
			$annotation = GenericString::generate('\\' . $className);
			if (Configure::read('IdeHelper.templateCollectionObject') !== false) {
				$collectionClass = CollectionClass::name('\\' . CollectionInterface::class);
				$collectionType = Configure::read('IdeHelper.templateCollectionObject');
				if (Configure::read('IdeHelper.objectAsGenerics') === true && $collectionType !== 'iterable') {
					$annotation .= '|' . GenericString::generate('\\' . $className, $collectionClass);
				} else {
					$annotation = GenericString::generate('\\' . $className, $collectionClass);
				}
			}

			$result[$resultKey] = AnnotationFactory::createOrFail(VariableAnnotation::TAG, $annotation, '$' . $matches[1][$key]);
			// We do not need the singular then
			$result[$entity] = null;
		}

		return $result;
	}

	/**
	 * @param string $content
	 *
	 * @return array<string, mixed>
	 */
	protected function parseEntities(string $content): array {
		preg_match_all('/\$([a-z]+)->[a-z]+/i', $content, $matches);
		if (empty($matches[1])) {
			return [];
		}
		/** @var array<string> $variableNames */
		$variableNames = array_unique($matches[1]);

		$result = [];

		foreach ($variableNames as $entity) {
			if ($entity === 'this') {
				continue;
			}

			$entityName = Inflector::camelize(Inflector::underscore($entity));

			$className = App::className(($this->getConfig(static::CONFIG_PLUGIN) ? $this->getConfig(static::CONFIG_PLUGIN) . '.' : '') . $entityName, 'Model/Entity');
			if (!$className) {
				continue;
			}

			$result[$entity] = AnnotationFactory::createOrFail(VariableAnnotation::TAG, '\\' . $className, '$' . $entity);
		}

		return $result;
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param array<\IdeHelper\Annotation\AbstractAnnotation> $annotations
	 * @param int $docBlockCloseIndex
	 *
	 * @return bool
	 */
	protected function isInlineDocBlockRedundant(File $file, array $annotations, int $docBlockCloseIndex): bool {
		$existingAnnotations = $this->parseExistingAnnotations($file, $docBlockCloseIndex);

		foreach ($existingAnnotations as $existingAnnotation) {
			foreach ($annotations as $annotation) {
				if ($existingAnnotation->build() === $annotation->build()) {
					return true;
				}
			}
		}

		return false;
	}

	/**
	 * @param string $path
	 * @param string $content
	 *
	 * @return array<\IdeHelper\Annotation\AbstractAnnotation>
	 */
	protected function buildAnnotations(string $path, string $content): array {
		$annotations = [];

		$needsAnnotation = $this->needsViewAnnotation($content);
		if ($needsAnnotation) {
			$annotations[] = $this->getViewAnnotation();
		}

		$variables = $this->getTemplateVariables($path, $content);

		$entityAnnotations = $this->getEntityAnnotations($content, $variables);
		foreach ($variables as $name => $variable) {
			if ($variable['excludeReason'] || isset($entityAnnotations[$name])) {
				continue;
			}
			if (Configure::read('IdeHelper.autoCollect') === false) {
				continue;
			}

			$annotations[] = $this->getVariableAnnotation($variable);
		}

		/** @var \IdeHelper\Annotation\AbstractAnnotation|null $entityAnnotation */
		foreach ($entityAnnotations as $entityAnnotation) {
			if (!$entityAnnotation) {
				continue;
			}
			$annotations[] = $entityAnnotation;
		}

		return $annotations;
	}

	/**
	 * Gets all template variables and a bit about their scope/context
	 * - type (if detected, e.g. string, object)
	 * - excludeReason (if detected as excludable, e.g. inside local assignment/loop)
	 *
	 * @param string $path
	 * @param string $content
	 *
	 * @return array<string, mixed>
	 */
	protected function getTemplateVariables(string $path, string $content): array {
		$file = $this->getFile($path, $content);

		$class = Configure::read('IdeHelper.variableExtractor') ?: VariableExtractor::class;
		/** @var \IdeHelper\Annotator\Template\VariableExtractor $extractor */
		$extractor = new $class();

		$variables = $extractor->extract($file);
		/** @var array<string> $blacklist */
		$blacklist = (array)Configure::read('IdeHelper.autoCollectBlacklist');
		foreach ($blacklist as $value) {
			if (!str_contains($value, '/')) {
				unset($variables[$value]);

				continue;
			}

			foreach ($variables as $name => $variable) {
				if (preg_match($value, $name)) {
					unset($variables[$name]);
				}
			}
		}

		return $variables;
	}

	/**
	 * @param array<string, mixed> $variable
	 *
	 * @return \IdeHelper\Annotation\AbstractAnnotation
	 */
	protected function getVariableAnnotation(array $variable) {
		$defaultType = Configure::read('IdeHelper.autoCollect');
		$type = $variable['type'];
		if ($type === null) {
			$type = $defaultType;
		}

		if (is_callable($defaultType)) {
			$guessedType = $defaultType($variable);
			if ($guessedType) {
				$type = $guessedType;
			}
		}
		if (!$type || $type === true) {
			$type = 'mixed';
		}

		/** @var \IdeHelper\Annotation\VariableAnnotation $annotation */
		$annotation = AnnotationFactory::createOrFail(VariableAnnotation::TAG, $type, '$' . $variable['name']);
		$annotation->setGuessed(true);

		/** @return \IdeHelper\Annotator\AbstractAnnotator */
		return $annotation;
	}

	/**
	 * @return bool
	 */
	protected function isV4(): bool {
		static $isV4 = null;

		if ($isV4 !== null) {
			return $isV4;
		}

		// PHPCS v4+ requires blank line after <?php for PSR12 compliance
		// Check version from Config class constant
		if (class_exists(Config::class)) {
			$version = Config::VERSION;
			$isV4 = version_compare($version, '4.0.0', '>=');
		} else {
			// Fallback: assume v4+ if class doesn't exist
			$isV4 = true;
		}

		return $isV4;
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param int|null $phpOpenTagIndex
	 *
	 * @return int|null
	 */
	protected function checkForDeclareStatement(File $file, ?int $phpOpenTagIndex): ?int {
		if ($phpOpenTagIndex === null) {
			return $phpOpenTagIndex;
		}

		$tokens = $file->getTokens();

		// Check if there's a declare statement right after the php open tag (on same or next line)
		$nextNonWhitespace = $file->findNext(T_WHITESPACE, $phpOpenTagIndex + 1, null, true);
		if ($nextNonWhitespace === false || $tokens[$nextNonWhitespace]['code'] !== T_DECLARE) {
			return $phpOpenTagIndex;
		}

		// Check if declare is on the same line or immediately after php tag
		if ($tokens[$nextNonWhitespace]['line'] > $tokens[$phpOpenTagIndex]['line'] + 1) {
			return $phpOpenTagIndex;
		}

		$lastIndexOfRow = $tokens[$nextNonWhitespace]['parenthesis_closer'];
		while (!empty($tokens[$lastIndexOfRow + 1]) && $tokens[$lastIndexOfRow + 1]['line'] === $tokens[$lastIndexOfRow]['line']) {
			$lastIndexOfRow++;
		}

		return $lastIndexOfRow;
	}

}


================================================
FILE: src/Annotator/Traits/ComponentTrait.php
================================================
<?php

namespace IdeHelper\Annotator\Traits;

use IdeHelper\Utility\App;
use IdeHelper\Utility\Plugin;

/**
 * Handles component related things
 */
trait ComponentTrait {

	/**
	 * @param string $component
	 * @param bool $includeApp
	 *
	 * @return string|null
	 */
	protected function findClassName(string $component, bool $includeApp): ?string {
		$plugins = Plugin::all();
		if (class_exists($component)) {
			return $component;
		}

		$className = App::className($component, 'Controller/Component', 'Component', $includeApp);
		if ($className) {
			return $className;
		}

		foreach ($plugins as $plugin) {
			$className = App::className($plugin . '.' . $component, 'Controller/Component', 'Component');
			if ($className) {
				return $className;
			}
		}

		return null;
	}

}


================================================
FILE: src/Annotator/Traits/DocBlockTrait.php
================================================
<?php

/**
 * MIT License
 * For full license information, please view the LICENSE file that was distributed with this source code.
 */

namespace IdeHelper\Annotator\Traits;

use PHP_CodeSniffer\Files\File;
use PHPStan\PhpDocParser\Ast\PhpDoc\GenericTagValueNode;
use PHPStan\PhpDocParser\Ast\PhpDoc\MethodTagValueNode;
use PHPStan\PhpDocParser\Ast\PhpDoc\ParamTagValueNode;
use PHPStan\PhpDocParser\Ast\PhpDoc\PhpDocTagValueNode;
use PHPStan\PhpDocParser\Ast\PhpDoc\ReturnTagValueNode;
use PHPStan\PhpDocParser\Ast\PhpDoc\ThrowsTagValueNode;
use PHPStan\PhpDocParser\Ast\PhpDoc\VarTagValueNode;
use PHPStan\PhpDocParser\Ast\Type\UnionTypeNode;
use PHPStan\PhpDocParser\Lexer\Lexer;
use PHPStan\PhpDocParser\Parser\ConstExprParser;
use PHPStan\PhpDocParser\Parser\PhpDocParser;
use PHPStan\PhpDocParser\Parser\TokenIterator;
use PHPStan\PhpDocParser\Parser\TypeParser;
use PHPStan\PhpDocParser\ParserConfig;

/**
 * Common functionality around doc block parsing and writing.
 */
trait DocBlockTrait {

	/**
	 * @param string $tagName tag name
	 * @param string $tagComment tag comment
	 *
	 * @return \PHPStan\PhpDocParser\Ast\PhpDoc\PhpDocTagValueNode
	 */
	protected static function getValueNode(string $tagName, string $tagComment): PhpDocTagValueNode {
		static $phpDocParser;
		if (!$phpDocParser) {
			$config = new ParserConfig(usedAttributes: []);
			$constExprParser = new ConstExprParser($config);
			$phpDocParser = new PhpDocParser($config, new TypeParser($config, $constExprParser), $constExprParser);
		}

		static $phpDocLexer;
		if (!$phpDocLexer) {
			$config = new ParserConfig(usedAttributes: []);
			$phpDocLexer = new Lexer($config);
		}

		return $phpDocParser->parseTagValue(new TokenIterator($phpDocLexer->tokenize($tagComment)), $tagName);
	}

	/**
	 * @param \PHPStan\PhpDocParser\Ast\PhpDoc\MethodTagValueNode|\PHPStan\PhpDocParser\Ast\PhpDoc\PropertyTagValueNode|\PHPStan\PhpDocParser\Ast\PhpDoc\VarTagValueNode|\PHPStan\PhpDocParser\Ast\PhpDoc\ParamTagValueNode|\PHPStan\PhpDocParser\Ast\PhpDoc\ReturnTagValueNode|\PHPStan\PhpDocParser\Ast\PhpDoc\GenericTagValueNode $valueNode
	 *
	 * @return array<string>
	 */
	protected function valueNodeParts(PhpDocTagValueNode $valueNode): array {
		if ($valueNode instanceof MethodTagValueNode) {
			$types = [$valueNode->returnType];
		} elseif ($valueNode instanceof GenericTagValueNode) {
			$types = [$valueNode];
		} elseif ($valueNode->type instanceof UnionTypeNode) {
			$types = $valueNode->type->types;
		} else {
			$types = [$valueNode->type];
		}

		$result = [];
		foreach ($types as $type) {
			$result[] = (string)$type;
		}

		return $result;
	}

	/**
	 * @param array<string> $parts
	 * @param \PHPStan\PhpDocParser\Ast\PhpDoc\PhpDocTagValueNode $valueNode
	 *
	 * @return string
	 */
	protected function stringifyValueNode(array $parts, PhpDocTagValueNode $valueNode): string {
		if ($valueNode instanceof ParamTagValueNode) {
			return trim(sprintf(
				'%s %s%s %s',
				implode('|', $parts),
				$valueNode->isVariadic ? '...' : '',
				$valueNode->parameterName,
				$valueNode->description,
			));
		}
		if ($valueNode instanceof ReturnTagValueNode) {
			return trim(sprintf(
				'%s%s',
				implode('|', $parts),
				$valueNode->description,
			));
		}
		if ($valueNode instanceof MethodTagValueNode) {
			return trim(sprintf(
				'%s %s() %s',
				implode('|', $parts),
				$valueNode->methodName,
				$valueNode->description,
			));
		}
		if ($valueNode instanceof VarTagValueNode) {
			return trim(sprintf(
				'%s %s%s',
				implode('|', $parts),
				$valueNode->variableName,
				$valueNode->description,
			));
		}
		if ($valueNode instanceof ThrowsTagValueNode) {
			return trim(sprintf(
				'%s %s',
				implode('|', $parts),
				$valueNode->description,
			));
		}

		return trim(implode('|', $parts));
	}

	/**
	 * Looks for either `@inheritDoc` or `{@inheritDoc}`.
	 * Also allows `@inheritdoc` or `{@inheritdoc}` aliases.
	 *
	 * @param \PHP_CodeSniffer\Files\File $phpCsFile
	 * @param int $docBlockStartIndex
	 * @param int $docBlockEndIndex
	 * @param string $alias
	 *
	 * @return bool
	 */
	protected function hasInheritDoc(File $phpCsFile, int $docBlockStartIndex, int $docBlockEndIndex, string $alias = '@inheritDoc'): bool {
		$tokens = $phpCsFile->getTokens();

		for ($i = $docBlockStartIndex + 1; $i < $docBlockEndIndex; ++$i) {
			if (empty($tokens[$i]['content'])) {
				continue;
			}
			$content = $tokens[$i]['content'];
			$pos = stripos($content, $alias);
			if ($pos === false) {
				continue;
			}

			if ($pos && str_starts_with($alias, '@') && substr($content, $pos - 1, $pos) === '{') {
				return false;
			}

			return true;
		}

		return false;
	}

	/**
	 * Checks for ...<...>.
	 *
	 * @param array<string> $docBlockTypes
	 *
	 * @return bool
	 */
	protected function containsIterableSyntax(array $docBlockTypes): bool {
		foreach ($docBlockTypes as $docBlockType) {
			if (str_contains($docBlockType, '<')) {
				return true;
			}
		}

		return false;
	}

	/**
	 * @param array<\PHPStan\PhpDocParser\Ast\Type\TypeNode|string> $typeNodes type nodes
	 *
	 * @return string
	 */
	protected function renderUnionTypes(array $typeNodes): string {
		$string = (string)preg_replace(
			[
				'/ ([|&]) /', // Spaces around union types (int | string) -> (int|string)
				'/\(<([^()]+)>\)/', // Remove unnecessary parentheses around union types (int|string)
				'/<\(/', // Replaces `(<` with `<`
				'/\)>/', // Replaces `)>` with `>`
				'/\)}/', // Replaces `)}` with `}`
				'/\),/', // Replaces `), ` with `,`
				'/[:,] \(/', // Replaces `: (` with `: ` and `, (` with `, `
			],
			[
				'${1}',
				'${1}',
				'<',
				'>',
				'}',
				',',
				', ',
			],
			implode('|', $typeNodes),
		);

		if (str_starts_with($string, '(') && str_ends_with($string, ')')) {
			$string = substr($string, 1, -1);
		}

		return $string;
	}

}


================================================
FILE: src/Annotator/Traits/FileTrait.php
================================================
<?php

namespace IdeHelper\Annotator\Traits;

use PHP_CodeSniffer\Config;
use PHP_CodeSniffer\Files\File;
use PHP_CodeSniffer\Fixer;
use PHP_CodeSniffer\Ruleset;
use PHP_CodeSniffer\Runner;

trait FileTrait {

	/**
	 * @param string $file
	 * @param string|null $content
	 *
	 * @return \PHP_CodeSniffer\Files\File
	 */
	protected function getFile(string $file, ?string $content = null): File {
		$_SERVER['argv'] = [];

		$phpcs = new Runner();

		if (!defined('PHP_CODESNIFFER_CBF')) {
			define('PHP_CODESNIFFER_CBF', false);
		}
		// Explictly specifying standard prevents it from searching for phpcs.xml type files.
		$config = new Config(['--standard=PSR2']);
		$phpcs->config = $config;
		$phpcs->init();

		$ruleset = new Ruleset($config);

		$fileObject = new File($file, $ruleset, $config);
		$fileObject->setContent($content ?? (string)file_get_contents($file));
		$fileObject->parse();

		return $fileObject;
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 *
	 * @return \PHP_CodeSniffer\Fixer
	 */
	protected function getFixer(File $file): Fixer {
		$fixer = new Fixer();

		$fixer->startFile($file);

		return $fixer;
	}

}


================================================
FILE: src/Annotator/Traits/HelperTrait.php
================================================
<?php

namespace IdeHelper\Annotator\Traits;

use IdeHelper\Utility\App;
use IdeHelper\Utility\Plugin;

/**
 * Handles component related things
 */
trait HelperTrait {

	/**
	 * @param string $helper
	 * @param bool $includeApp
	 *
	 * @return string|null
	 */
	protected function findClassName(string $helper, bool $includeApp): ?string {
		$className = App::className($helper, 'View/Helper', 'Helper', $includeApp);
		if ($className) {
			return $className;
		}

		$plugins = Plugin::all();
		foreach ($plugins as $plugin) {
			$className = App::className($plugin . '.' . $helper, 'View/Helper', 'Helper');
			if ($className) {
				return $className;
			}
		}

		return null;
	}

}


================================================
FILE: src/Annotator/Traits/ModelTrait.php
================================================
<?php

namespace IdeHelper\Annotator\Traits;

/**
 * Handles model related things
 */
trait ModelTrait {

	/**
	 * @param string $content
	 *
	 * @return array<string>
	 */
	protected function getUsedModels(string $content): array {
		preg_match_all('/\$this->([a-z]+)\s*=\s*\$this->fetchTable\(\'([a-z.]+)\'/i', $content, $matches);
		if (empty($matches[1])) {
			return [];
		}

		$properties = $matches[1];
		$tables = $matches[2];
		$models = array_combine($properties, $tables);

		preg_match_all('/\b(public|protected|private) \$([a-z]+)\b/i', $content, $propertyMatches);
		$excluded = $propertyMatches[2];
		foreach ($excluded as $property) {
			if (isset($models[$property])) {
				unset($models[$property]);
			}
		}

		return $models;
	}

}


================================================
FILE: src/Annotator/Traits/UseStatementsTrait.php
================================================
<?php

/**
 * MIT License
 * For full license information, please view the LICENSE file that was distributed with this source code.
 */

namespace IdeHelper\Annotator\Traits;

use PHP_CodeSniffer\Files\File;
use PHP_CodeSniffer\Util\Tokens;

trait UseStatementsTrait {

	/**
	 * @param \PHP_CodeSniffer\Files\File $phpcsFile
	 *
	 * @return array<string, array<string, mixed>>
	 */
	protected function getUseStatements(File $phpcsFile): array {
		$tokens = $phpcsFile->getTokens();

		$statements = [];
		foreach ($tokens as $index => $token) {
			if ($token['code'] !== T_USE || $token['level'] > 0) {
				continue;
			}

			$useStatementStartIndex = $phpcsFile->findNext(Tokens::$emptyTokens, $index + 1, null, true);

			// Ignore function () use ($foo) {}
			if (!$useStatementStartIndex || $tokens[$useStatementStartIndex]['content'] === '(') {
				continue;
			}

			$semicolonIndex = $phpcsFile->findNext(T_SEMICOLON, $useStatementStartIndex + 1);
			$useStatementEndIndex = $phpcsFile->findPrevious(Tokens::$emptyTokens, $semicolonIndex - 1, null, true);
			if (!$useStatementEndIndex) {
				continue;
			}

			$statement = '';
			for ($i = $useStatementStartIndex; $i <= $useStatementEndIndex; $i++) {
				$statement .= $tokens[$i]['content'];
			}

			// Another sniff takes care of that, we just ignore then.
			if ($this->isMultipleUseStatement($statement)) {
				continue;
			}

			$statementParts = preg_split('/\s+as\s+/i', $statement) ?: [];

			if (count($statementParts) === 1) {
				$fullName = $statement;
				$statementParts = explode('\\', $fullName);
				$shortName = end($statementParts);
				$alias = null;
			} else {
				$fullName = $statementParts[0];
				$alias = $statementParts[1];
				$statementParts = explode('\\', $fullName);
				$shortName = end($statementParts);
			}

			$shortName = trim($shortName);
			$fullName = trim($fullName);
			$key = $alias ?: $shortName;

			$statements[$key] = [
				'alias' => $alias,
				'end' => $semicolonIndex,
				'statement' => $statement,
				'fullName' => ltrim($fullName, '\\'),
				'shortName' => $shortName,
				'start' => $index,
			];
		}

		return $statements;
	}

	/**
	 * @param string $statementContent
	 *
	 * @return bool
	 */
	protected function isMultipleUseStatement(string $statementContent): bool {
		if (str_contains($statementContent, ',')) {
			return true;
		}

		return false;
	}

}


================================================
FILE: src/Annotator/ViewAnnotator.php
================================================
<?php

namespace IdeHelper\Annotator;

use Cake\Core\Configure;
use Cake\Http\ServerRequest;
use IdeHelper\Annotation\AnnotationFactory;
use IdeHelper\Annotation\PropertyAnnotation;
use IdeHelper\Annotator\Traits\HelperTrait;
use IdeHelper\Filesystem\Folder;
use IdeHelper\Utility\App;
use IdeHelper\Utility\AppPath;
use IdeHelper\Utility\Plugin;
use RuntimeException;

class ViewAnnotator extends AbstractAnnotator {

	use HelperTrait;

	/**
	 * @var array<string>
	 */
	protected array $helpers = [];

	/**
	 * @param string $path Path to file.
	 * @return bool
	 */
	public function annotate(string $path): bool {
		$content = file_get_contents($path);
		if ($content === false) {
			throw new RuntimeException('Cannot read file');
		}

		$helpers = $this->getHelpers();
		$annotations = $this->buildAnnotations($helpers);

		return $this->annotateContent($path, $content, $annotations);
	}

	/**
	 * @return array<string>
	 */
	protected function getHelpers(): array {
		$helperArray = $this->parseViewClass();

		$helperArray = $this->addAppHelpers($helperArray);
		$helperArray = $this->addExtractedHelpers($helperArray);

		return $helperArray;
	}

	/**
	 * @param array<string, string> $helperArray
	 * @return array<string, string>
	 */
	protected function addExtractedHelpers(array $helperArray) {
		$folders = $this->getFolders();

		$this->helpers = [];
		foreach ($folders as $folder) {
			$this->checkTemplates($folder);
		}

		$helpers = array_unique($this->helpers);

		foreach ($helpers as $helper) {
			if (isset($helperArray[$helper])) {
				continue;
			}

			$className = $this->findClassName($helper, !$this->getConfig(static::CONFIG_PLUGIN));
			if (!$className || str_starts_with($className, 'Cake\\')) {
				continue;
			}

			$helperArray[$helper] = $className;
		}

		return $helperArray;
	}

	/**
	 * @param string $folder
	 * @return void
	 */
	protected function checkTemplates(string $folder) {
		$folderContent = (new Folder($folder))->read(Folder::SORT_NAME, false, true);

		foreach ($folderContent[1] as $file) {
			$content = file_get_contents($file);
			if ($content === false) {
				throw new RuntimeException('Cannot read file');
			}
			$helpers = $this->parseHelpersInContent($content);
			$this->helpers = array_merge($this->helpers, $helpers);
		}

		foreach ($folderContent[0] as $subFolder) {
			$this->checkTemplates($subFolder);
		}
	}

	/**
	 * @param string $content
	 *
	 * @return array<string>
	 */
	protected function parseHelpersInContent(string $content) {
		preg_match_all('/\$this->([A-Z][A-Za-z]+)->/', $content, $matches);
		if (empty($matches[1])) {
			return [];
		}

		$helpers = array_unique($matches[1]);

		return $helpers;
	}

	/**
	 * @return array<string>
	 */
	protected function parseViewClass(): array {
		$helpers = [];

		/** @phpstan-var class-string<object> $className */
		$className = App::classNameOrFail('App', 'Controller', 'Controller');
		if ($this->_isAbstract($className)) {
			return [];
		}

		/** @var \Cake\Controller\Controller $Controller */
		$Controller = new $className(new ServerRequest());
		$View = $Controller->createView();

		foreach ($View->helpers() as $alias => $helper) {
			$className = get_class($helper);
			if (str_starts_with($className, 'Cake\\')) {
				continue;
			}

			$helpers[$alias] = $className;
		}

		return $helpers;
	}

	/**
	 * @param array<string> $helperArray
	 *
	 * @return array<string>
	 */
	protected function addAppHelpers(array $helperArray): array {
		$paths = AppPath::get('View/Helper');
		foreach ($paths as $path) {
			$folderContent = (new Folder($path))->read(Folder::SORT_NAME, true);
			if (empty($folderContent[1])) {
				continue;
			}

			$helpers = $folderContent[1];
			foreach ($helpers as $helper) {
				if (!preg_match('/^(.+)Helper.php$/', $helper, $matches)) {
					continue;
				}

				$helper = $matches[1];
				if (isset($helperArray[$helper])) {
					continue;
				}

				$helperArray[$helper] = Configure::read('App.namespace') . '\\View\\Helper\\' . $helper . 'Helper';
			}
		}

		return $helperArray;
	}

	/**
	 * @param array<string> $helpers
	 *
	 * @return array<\IdeHelper\Annotation\AbstractAnnotation>
	 */
	protected function buildAnnotations(array $helpers): array {
		$annotations = [];
		foreach ($helpers as $alias => $className) {
			$annotations[] = AnnotationFactory::createOrFail(PropertyAnnotation::TAG, '\\' . $className, '$' . $alias);
		}

		return $annotations;
	}

	/**
	 * @return array<string>
	 */
	protected function getFolders(): array {
		$plugin = null;
		$folders = App::path('templates', $plugin);
		$plugins = Configure::read('IdeHelper.includedPlugins');
		if ($plugins === true) {
			$plugins = Plugin::loaded(); // We cannot use all() here
		} else {
			$plugins = (array)$plugins;
		}
		foreach ($plugins as $plugin) {
			$folders = array_merge($folders, App::path('templates', $plugin));
		}

		return $folders;
	}

}


================================================
FILE: src/CodeCompletion/CodeCompletionGenerator.php
================================================
<?php

namespace IdeHelper\CodeCompletion;

use Cake\Core\Configure;
use RuntimeException;

class CodeCompletionGenerator {

	protected TaskCollection $taskCollection;

	/**
	 * @param \IdeHelper\CodeCompletion\TaskCollection $taskCollection
	 */
	public function __construct(TaskCollection $taskCollection) {
		$this->taskCollection = $taskCollection;
	}

	/**
	 * @return array<string>
	 */
	public function generate(): array {
		$map = $this->taskCollection->getMap();

		foreach ($map as $namespace => $array) {
			$content = $this->buildContent($array);

			$template = <<<CODE
<?php
namespace $namespace;

/**
 * Only for code completion - regenerate using `bin/cake code_completion generate`.
 */
$content
CODE;

			$path = $this->path();
			$filename = $path . 'CodeCompletion' . $this->type($namespace) . '.php';

			if (!file_exists($filename) || md5_file($filename) !== md5($template)) {
				if (file_put_contents($filename, $template) === false) {
					throw new RuntimeException(sprintf('Failed to write file `%s`.', $filename));
				}
			}
		}

		return array_keys($map);
	}

	/**
	 * @param array<string> $array
	 *
	 * @return string
	 */
	protected function buildContent(array $array): string {
		return implode('', $array);
	}

	/**
	 * @param string $namespace
	 *
	 * @return string
	 */
	protected function type(string $namespace): string {
		return (string)preg_replace('/[^\da-z]/i', '', $namespace);
	}

	/**
	 * @throws \RuntimeException When the directory cannot be created.
	 * @return string
	 */
	protected function path(): string {
		$path = Configure::read('IdeHelper.codeCompletionPath') ?: TMP;
		if (!is_dir($path) && !mkdir($path, 0770, true) && !is_dir($path)) {
			throw new RuntimeException(sprintf('Cannot create directory `%s`.', $path));
		}

		return $path;
	}

}


================================================
FILE: src/CodeCompletion/Task/BehaviorTask.php
================================================
<?php

namespace IdeHelper\CodeCompletion\Task;

use IdeHelper\Filesystem\Folder;
use IdeHelper\Utility\App;
use IdeHelper\Utility\AppPath;
use IdeHelper\Utility\Plugin;

class BehaviorTask implements TaskInterface {

	/**
	 * @var string
	 */
	public const TYPE_NAMESPACE = 'Cake\ORM';

	/**
	 * @return string
	 */
	public function type(): string {
		return static::TYPE_NAMESPACE;
	}

	/**
	 * @return string
	 */
	public function create(): string {
		$behaviors = $this->collectBehaviors();
		if (!$behaviors) {
			return '';
		}

		$content = $this->build($behaviors);

		$content = <<<CODE
abstract class BehaviorRegistry extends \Cake\Core\ObjectRegistry {

$content

}

CODE;

		return $content;
	}

	/**
	 * @return array<string>
	 */
	protected function collectBehaviors(): array {
		$behaviors = [];

		$folders = array_merge(App::core('ORM/Behavior'), AppPath::get('Model/Behavior'));
		foreach ($folders as $folder) {
			$behaviors = $this->addBehaviors($behaviors, $folder);
		}

		$plugins = Plugin::all();
		foreach ($plugins as $plugin) {
			$folders = AppPath::get('Model/Behavior', $plugin);
			foreach ($folders as $folder) {
				$behaviors = $this->addBehaviors($behaviors, $folder, $plugin);
			}
		}

		return $behaviors;
	}

	/**
	 * @param array<string> $behaviors
	 * @param string $folder
	 * @param string|null $plugin
	 *
	 * @return array<string>
	 */
	protected function addBehaviors(array $behaviors, string $folder, ?string $plugin = null): array {
		$folderContent = (new Folder($folder))->read(Folder::SORT_NAME, true);

		foreach ($folderContent[1] as $file) {
			preg_match('/^(.+)Behavior\.php$/', $file, $matches);
			if (!$matches) {
				continue;
			}
			$name = $matches[1];
			if ($plugin) {
				$name = $plugin . '.' . $name;
			}

			$className = App::className($name, 'Model/Behavior', 'Behavior');
			if (!$className) {
				continue;
			}

			$behaviors[$name] = $className;
		}

		return $behaviors;
	}

	/**
	 * @param array<string> $behaviors
	 *
	 * @return string
	 */
	protected function build(array $behaviors): string {
		$result = [];

		foreach ($behaviors as $behavior => $className) {
			[$plugin, $name] = pluginSplit($behavior);

			$template = <<<CODE
	/**
	 * $behavior behavior.
	 *
	 * @var \\$className
	 */
	public \$$name;
CODE;
			$result[] = $template;
		}

		return implode(PHP_EOL . PHP_EOL, $result);
	}

}


================================================
FILE: src/CodeCompletion/Task/ControllerEventsTask.php
================================================
<?php

namespace IdeHelper\CodeCompletion\Task;

use Cake\Core\Configure;

class ControllerEventsTask implements TaskInterface {

	/**
	 * @var string
	 */
	public const TYPE_NAMESPACE = 'Cake\Controller';

	/**
	 * @return string
	 */
	public function type(): string {
		return static::TYPE_NAMESPACE;
	}

	/**
	 * @return string
	 */
	public function create(): string {
		/** @var bool|null $returnType */
		$returnType = Configure::read('IdeHelper.codeCompletionReturnType');

		$controllerEvents = $this->events($returnType ?? false);
		$componentEvents = $this->events($returnType ?? true);

		return <<<CODE

use Cake\Event\EventInterface;
use Cake\Http\Response;
use Psr\Http\Message\UriInterface;

if (false) {
	class Controller {
$controllerEvents
	}

	class Component {
$componentEvents
	}
}

CODE;
	}

	/**
	 * @param bool $returnType
	 *
	 * @return string
	 */
	protected function events(bool $returnType): string {
		$type = null;
		$docBlock = null;
		if ($returnType) {
			$type = ': ' . 'void';
		} else {
			$docBlock = <<<TXT
		/**
		 * @param \Cake\Event\EventInterface \$event
		 *
		 * @return void
		 */
TXT;
			$docBlock = trim($docBlock) . PHP_EOL . str_repeat("\t", 2);
		}
		$docBlockRedirect = <<<TXT
		/**
		 * @param \Cake\Event\EventInterface \$event
		 * @param \Psr\Http\Message\UriInterface|array|string \$url
		 * @param \Cake\Http\Response \$response
		 *
		 * @return void
		 */
TXT;
		$docBlockRedirect = trim($docBlockRedirect) . PHP_EOL . str_repeat("\t", 2);

		$events = <<<TXT
		{$docBlock}public function startup(EventInterface \$event)$type {
		}

		{$docBlock}public function beforeFilter(EventInterface \$event)$type {
		}

		{$docBlock}public function beforeRender(EventInterface \$event)$type {
		}

		{$docBlock}public function afterFilter(EventInterface \$event)$type {
		}

		{$docBlock}public function shutdown(EventInterface \$event)$type {
		}

		{$docBlockRedirect}public function beforeRedirect(EventInterface \$event, UriInterface|array|string \$url, Response \$response)$type {
		}
TXT;

		return $events;
	}

}


================================================
FILE: src/CodeCompletion/Task/ModelEventsTask.php
================================================
<?php

namespace IdeHelper\CodeCompletion\Task;

class ModelEventsTask implements TaskInterface {

	/**
	 * @var string
	 */
	public const TYPE_NAMESPACE = 'Cake\ORM';

	/**
	 * @return string
	 */
	public function type(): string {
		return static::TYPE_NAMESPACE;
	}

	/**
	 * @return string
	 */
	public function create(): string {
		$events = <<<'TXT'
		public function beforeMarshal(EventInterface $event, ArrayObject $data, ArrayObject $options): void {}
		public function afterMarshal(EventInterface $event, EntityInterface $entity, ArrayObject $options): void {}
		public function beforeFind(EventInterface $event, SelectQuery $query, ArrayObject $options, bool $primary): void {}
		public function buildValidator(EventInterface $event, Validator $validator, string $name): void {}
		public function buildRules(RulesChecker $rules): RulesChecker { return $rules; }
		public function beforeRules(EventInterface $event, EntityInterface $entity, ArrayObject $options, string $operation): void {}
		public function afterRules(EventInterface $event, EntityInterface $entity, ArrayObject $options, bool $result, string $operation): void {}
		public function beforeSave(EventInterface $event, EntityInterface $entity, ArrayObject $options): void {}
		public function afterSave(EventInterface $event, EntityInterface $entity, ArrayObject $options): void {}
		public function afterSaveCommit(EventInterface $event, EntityInterface $entity, ArrayObject $options): void {}
		public function beforeDelete(EventInterface $event, EntityInterface $entity, ArrayObject $options): void {}
		public function afterDelete(EventInterface $event, EntityInterface $entity, ArrayObject $options): void {}
		public function afterDeleteCommit(EventInterface $event, EntityInterface $entity, ArrayObject $options): void {}
TXT;

		return <<<CODE

use ArrayObject;
use Cake\Datasource\EntityInterface;
use Cake\Event\EventInterface;
use Cake\ORM\Query\SelectQuery;
use Cake\ORM\RulesChecker;
use Cake\Validation\Validator;

if (false) {
	class Table {
$events
	}

	class Behavior {
$events
	}
}

CODE;
	}

}


================================================
FILE: src/CodeCompletion/Task/SelectQueryTask.php
================================================
<?php

namespace IdeHelper\CodeCompletion\Task;

class SelectQueryTask implements TaskInterface {

	/**
	 * @var string
	 */
	public const TYPE_NAMESPACE = 'Cake\ORM\Query';

	/**
	 * @return string
	 */
	public function type(): string {
		return static::TYPE_NAMESPACE;
	}

	/**
	 * @return string
	 */
	public function create(): string {
		return <<<'CODE'
use Cake\Database\ExpressionInterface;
use Cake\Datasource\ResultSetInterface;
use Closure;
use Psr\SimpleCache\CacheInterface;

if (false) {
	/**
	 * @template TSubject
	 */
	class SelectQuery {
		/**
		 * @return static<TSubject>
		 */
		public function find(string $finder, mixed ...$args) {}

		/**
		 * @return static<TSubject>
		 */
		public function where(
			ExpressionInterface|Closure|array|string|null $conditions = null,
			array $types = [],
			bool $overwrite = false,
		) {}

		/**
		 * @return static<TSubject>
		 */
		public function andWhere($conditions, array $types = []) {}

		/**
		 * @return static<TSubject>
		 */
		public function matching(string $assoc, ?Closure $builder = null) {}

		/**
		 * @return static<TSubject>
		 */
		public function leftJoinWith(string $assoc, ?Closure $builder = null) {}

		/**
		 * @return static<TSubject>
		 */
		public function innerJoinWith(string $assoc, ?Closure $builder = null) {}

		/**
		 * @return static<TSubject>
		 */
		public function notMatching(string $assoc, ?Closure $builder = null) {}

		/**
		 * @return static<TSubject>
		 */
		public function contain(mixed $associations, Closure|bool $override = false) {}

		/**
		 * @return static<TSubject>
		 */
		public function clearContain() {}

		/**
		 * @return static<TSubject>
		 */
		public function cache(Closure|string|false $key, CacheInterface|string $config = 'default') {}

		/**
		 * @return static<TSubject>
		 */
		public function groupBy(ExpressionInterface|array|string $fields, bool $overwrite = false) {}

		/**
		 * @return static<TSubject>
		 */
		public function orderBy(ExpressionInterface|Closure|array|string $fields, bool $overwrite = false) {}

		/**
		 * @return static<TSubject>
		 */
		public function enableAutoFields(bool $value = true) {}

		/**
		 * @return static<TSubject>
		 */
		public function disableAutoFields() {}

		/**
		 * @return static<array<string,mixed>>
		 */
		public function disableHydration() {}

		/**
		 * @return ResultSetInterface<array-key, TSubject>
		 */
		public function all() {}

		/**
		 * @return TSubject|null
		 */
		public function first() {}

		/**
		 * @return TSubject
		 */
		public function firstOrFail() {}

		/**
		 * @return array<TSubject>
		 */
		public function toArray() {}
	}
}

CODE;
	}

}


================================================
FILE: src/CodeCompletion/Task/TaskInterface.php
================================================
<?php

namespace IdeHelper\CodeCompletion\Task;

interface TaskInterface {

	/**
	 * @return string
	 */
	public function type(): string;

	/**
	 * @return string
	 */
	public function create(): string;

}


================================================
FILE: src/CodeCompletion/Task/ViewEventsTask.php
================================================
<?php

namespace IdeHelper\CodeCompletion\Task;

class ViewEventsTask implements TaskInterface {

	/**
	 * @var string
	 */
	public const TYPE_NAMESPACE = 'Cake\View';

	/**
	 * @return string
	 */
	public function type(): string {
		return static::TYPE_NAMESPACE;
	}

	/**
	 * @return string
	 */
	public function create(): string {
		$events = <<<'TXT'
		public function beforeRenderFile(EventInterface $event): void {}
		public function afterRenderFile(EventInterface $event): void {}
		public function beforeRender(EventInterface $event): void {}
		public function afterRender(EventInterface $event): void {}
		public function beforeLayout(EventInterface $event): void {}
		public function afterLayout(EventInterface $event): void {}
TXT;

		return <<<CODE

use Cake\Event\EventInterface;

if (false) {
	class Helper {
$events
	}
}

CODE;
	}

}


================================================
FILE: src/CodeCompletion/TaskCollection.php
================================================
<?php

namespace IdeHelper\CodeCompletion;

use Cake\Core\Configure;
use IdeHelper\CodeCompletion\Task\BehaviorTask;
use IdeHelper\CodeCompletion\Task\ControllerEventsTask;
use IdeHelper\CodeCompletion\Task\ModelEventsTask;
use IdeHelper\CodeCompletion\Task\SelectQueryTask;
use IdeHelper\CodeCompletion\Task\TaskInterface;
use IdeHelper\CodeCompletion\Task\ViewEventsTask;
use InvalidArgumentException;

class TaskCollection {

	/**
	 * @var array<class-string<\IdeHelper\CodeCompletion\Task\TaskInterface>, class-string<\IdeHelper\CodeCompletion\Task\TaskInterface>>
	 */
	protected array $defaultTasks = [
		BehaviorTask::class => BehaviorTask::class,
		ModelEventsTask::class => ModelEventsTask::class,
		SelectQueryTask::class => SelectQueryTask::class,
		ControllerEventsTask::class => ControllerEventsTask::class,
		ViewEventsTask::class => ViewEventsTask::class,
	];

	/**
	 * @var array<\IdeHelper\CodeCompletion\Task\TaskInterface>
	 */
	protected array $tasks = [];

	/**
	 * @param array<class-string<\IdeHelper\CodeCompletion\Task\TaskInterface>|\IdeHelper\Generator\Task\TaskInterface> $tasks
	 */
	public function __construct(array $tasks = []) {
		$defaultTasks = (array)Configure::read('IdeHelper.codeCompletionTasks') + $this->defaultTasks;
		$tasks += $defaultTasks;

		foreach ($tasks as $task) {
			if (!$task) {
				continue;
			}

			$this->add($task);
		}
	}

	/**
	 * Adds a task to the collection.
	 *
	 * @param \IdeHelper\CodeCompletion\Task\TaskInterface|class-string<\IdeHelper\CodeCompletion\Task\TaskInterface> $task The task to map.
	 * @throws \InvalidArgumentException
	 * @return $this
	 */
	protected function add($task) {
		if (is_string($task)) {
			$task = new $task();
		}

		$class = get_class($task);
		if (!$task instanceof TaskInterface) {
			throw new InvalidArgumentException(
				sprintf('Cannot use `%s` as task, it is not implementing `%s`.', $class, TaskInterface::class),
			);
		}

		$this->tasks[$class] = $task;

		return $this;
	}

	/**
	 * @return array<\IdeHelper\CodeCompletion\Task\TaskInterface>
	 */
	public function tasks(): array {
		return $this->tasks;
	}

	/**
	 * @return array<string, array<string>>
	 */
	public function getMap(): array {
		$map = [];
		foreach ($this->tasks as $task) {
			$snippet = $task->create();
			if (!$snippet) {
				continue;
			}

			$map[$task->type()][] = $snippet;
		}

		ksort($map);

		return $map;
	}

}


================================================
FILE: src/Command/Annotate/AllCommand.php
================================================
<?php

namespace IdeHelper\Command\Annotate;

use Cake\Console\Arguments;
use Cake\Console\ConsoleIo;
use Cake\Core\App;
use IdeHelper\Command\AnnotateCommand;

class AllCommand extends AnnotateCommand {

	protected bool $interactive;

	/**
	 * @return string
	 */
	public static function getDescription(): string {
		return 'Annotate all supported classes.';
	}

	/**
	 * @param \Cake\Console\Arguments $args
	 * @param \Cake\Console\ConsoleIo $io
	 * @return int
	 */
	public function execute(Arguments $args, ConsoleIo $io): int {
		parent::execute($args, $io);

		$types = [
			ModelsCommand::class,
			ControllersCommand::class,
			CommandsCommand::class,
			ComponentsCommand::class,
			HelpersCommand::class,
			TemplatesCommand::class,
		];
		if (!$args->getOption('plugin') && !$args->getOption('filter')) {
			$types[] = ViewCommand::class;
		}

		if ($args->getOption('remove')) {
			$io->verbose('Skipping "classes" and "callbacks" annotations, they do not support removing.');
		} else {
			$types[] = ClassesCommand::class;
			$types[] = CallbacksCommand::class;
		}

		if (!$args->getOption('interactive')) {
			$this->interactive = false;
		}

		$changes = false;
		foreach ($types as $key => $type) {
			if ($key !== 0) {
				$io->out('');
			}
			$shortName = App::shortName($type, 'Command', 'Command');
			$shortName = str_replace('IdeHelper.Annotate/', '', $shortName);
			if (!$this->interactive) {
				$io->out('[' . $shortName . ']');
			} else {
				$in = $io->askChoice($shortName . '?', ['y', 'n', 'a'], 'y');
				if ($in === 'a') {
					$this->abort();
				}
				if ($in !== 'y') {
					continue;
				}
			}

			$commandInstance = new $type();
			$commandInstance->execute($args, $io);

			if ($this->_annotatorMadeChanges()) {
				$changes = true;
			}
		}

		if ($args->getOption('ci') && $changes) {
			return static::CODE_CHANGES;
		}

		return static::CODE_SUCCESS;
	}

}


================================================
FILE: src/Command/Annotate/CallbacksCommand.php
================================================
<?php

namespace IdeHelper\Command\Annotate;

use Cake\Console\Arguments;
use Cake\Console\ConsoleIo;
use Cake\Console\ConsoleOptionParser;
use Cake\Core\Configure;
use IdeHelper\Annotator\CallbackAnnotator;
use IdeHelper\Command\AnnotateCommand;

class CallbacksCommand extends AnnotateCommand {

	/**
	 * @return string
	 */
	public static function getDescription(): string {
		return 'Annotate callback methods using callback annotation tasks. This task is not part of `all` when `-r` is used.';
	}

	/**
	 * @param \Cake\Console\ConsoleOptionParser $parser
	 * @return \Cake\Console\ConsoleOptionParser
	 */
	protected function buildOptionParser(ConsoleOptionParser $parser): ConsoleOptionParser {
		$parser = parent::buildOptionParser($parser);
		$parser->removeOption('remove');

		return $parser;
	}

	/**
	 * @param \Cake\Console\Arguments $args
	 * @param \Cake\Console\ConsoleIo $io
	 * @return int
	 */
	public function execute(Arguments $args, ConsoleIo $io): int {
		parent::execute($args, $io);

		$paths = $this->getPaths('classes');
		foreach ($paths as $plugin => $pluginPaths) {
			$this->setPlugin($plugin);
			foreach ($pluginPaths as $path) {
				$folders = glob($path . '*', GLOB_ONLYDIR) ?: [];
				foreach ($folders as $folder) {
					$this->_callbacks($folder . DS);
				}
			}
		}

		if ($args->getOption('ci') && $this->_annotatorMadeChanges()) {
			return static::CODE_CHANGES;
		}

		return static::CODE_SUCCESS;
	}

	/**
	 * @param string $folder
	 * @return void
	 */
	protected function _callbacks(string $folder) {
		$this->io->out(str_replace(ROOT . DS, '', $folder), 1, ConsoleIo::VERBOSE);

		$folderContent = glob($folder . '*') ?: [];
		foreach ($folderContent as $path) {
			if (is_dir($path)) {
				$folderName = pathinfo($path, PATHINFO_BASENAME);
				$prefixes = (array)Configure::read('IdeHelper.prefixes') ?: null;

				if ($prefixes !== null && !in_array($folderName, $prefixes, true)) {
					continue;
				}

				$this->_callbacks($path . DS);
			} else {
				$extension = pathinfo($path, PATHINFO_EXTENSION);
				if ($extension !== 'php') {
					continue;
				}

				$name = pathinfo($path, PATHINFO_FILENAME);
				if ($this->_shouldSkip($name, $path)) {
					continue;
				}

				$this->io->out('-> ' . $name, 1, ConsoleIo::VERBOSE);

				$annotator = $this->getAnnotator(CallbackAnnotator::class);
				$annotator->annotate($path);
			}
		}
	}

}


================================================
FILE: src/Command/Annotate/ClassesCommand.php
================================================
<?php

namespace IdeHelper\Command\Annotate;

use Cake\Console\Arguments;
use Cake\Console\ConsoleIo;
use Cake\Console\ConsoleOptionParser;
use Cake\Core\Configure;
use IdeHelper\Annotator\ClassAnnotator;
use IdeHelper\Annotator\ClassAnnotatorTask\PathAwareClassAnnotatorTaskInterface;
use IdeHelper\Annotator\ClassAnnotatorTaskCollection;
use IdeHelper\Command\AnnotateCommand;

class ClassesCommand extends AnnotateCommand {

	/**
	 * @return string
	 */
	public static function getDescription(): string {
		return 'Annotate classes using class annotation tasks. This task is not part of "all" when "-r" is used.';
	}

	/**
	 * @param \Cake\Console\ConsoleOptionParser $parser
	 * @return \Cake\Console\ConsoleOptionParser
	 */
	protected function buildOptionParser(ConsoleOptionParser $parser): ConsoleOptionParser {
		$parser = parent::buildOptionParser($parser);
		$parser->removeOption('remove');

		return $parser;
	}

	/**
	 * @param \Cake\Console\Arguments $args
	 * @param \Cake\Console\ConsoleIo $io
	 * @return int
	 */
	public function execute(Arguments $args, ConsoleIo $io): int {
		parent::execute($args, $io);

		$paths = $this->getPaths('classes');
		foreach ($paths as $plugin => $pluginPaths) {
			$this->setPlugin($plugin);
			foreach ($pluginPaths as $path) {
				$folders = glob($path . '*', GLOB_ONLYDIR) ?: [];
				foreach ($folders as $folder) {
					$this->_classes($folder . DS);
				}
			}
		}

		$collection = new ClassAnnotatorTaskCollection();
		$tasks = $collection->defaultTasks();

		$this->_walkPathAwareTasks($tasks);

		if ($args->getOption('ci') && $this->_annotatorMadeChanges()) {
			return static::CODE_CHANGES;
		}

		return static::CODE_SUCCESS;
	}

	/**
	 * Walk every directory declared by a path-aware annotator task, in app
	 * context and (when `-p <plugin>` is used) per-plugin. The standard
	 * ClassAnnotator runs over each *.php it finds; tasks gate themselves
	 * via shouldRun(), so unrelated tasks self-skip these paths.
	 *
	 * @param array<class-string<\IdeHelper\Annotator\ClassAnnotatorTask\ClassAnnotatorTaskInterface>> $tasks
	 * @return void
	 */
	protected function _walkPathAwareTasks(array $tasks): void {
		$pathAware = array_filter(
			$tasks,
			fn (string $cls): bool => is_a($cls, PathAwareClassAnnotatorTaskInterface::class, true),
		);
		if (!$pathAware) {
			return;
		}

		$paths = $this->getPaths();
		$walked = [];
		foreach ($paths as $plugin => $pluginPaths) {
			$this->setPlugin($plugin);
			foreach ($pluginPaths as $rootPath) {
				foreach ($pathAware as $taskClass) {
					foreach ($taskClass::scanPaths() as $relPath) {
						$folder = $rootPath . $this->_normalizeScanPath($relPath);
						if (isset($walked[$folder]) || !is_dir($folder)) {
							continue;
						}
						$walked[$folder] = true;
						$this->_classes($folder);
					}
				}
			}
		}
	}

	/**
	 * Normalize a scan path declared by a path-aware task to the OS-native
	 * separator with exactly one trailing separator, regardless of whether
	 * the task author used forward slashes, backslashes, or no trailing
	 * separator. This keeps the `$walked[$folder]` dedup key stable across
	 * portability quirks.
	 *
	 * @param string $relPath
	 * @return string
	 */
	protected function _normalizeScanPath(string $relPath): string {
		$forward = str_replace('\\', '/', $relPath);
		$trimmed = rtrim($forward, '/');

		return str_replace('/', DS, $trimmed) . DS;
	}

	/**
	 * @param string $folder
	 * @return void
	 */
	protected function _classes(string $folder) {
		$this->io->out(str_replace(ROOT . DS, '', $folder), 1, ConsoleIo::VERBOSE);

		$folderContent = glob($folder . '*') ?: [];
		foreach ($folderContent as $path) {

			// Prevent infinite loop
			if ($folder === $path) {
				continue;
			}

			if (is_dir($path)) {
				$folderName = pathinfo($path, PATHINFO_BASENAME);
				$prefixes = (array)Configure::read('IdeHelper.prefixes') ?: null;

				if ($prefixes !== null && !in_array($folderName, $prefixes, true)) {
					continue;
				}

				$this->_classes($path . DS);
			} else {
				$extension = pathinfo($path, PATHINFO_EXTENSION);
				if ($extension !== 'php') {
					continue;
				}

				$name = pathinfo($path, PATHINFO_FILENAME);
				if ($this->_shouldSkip($name, $path)) {
					continue;
				}

				$this->io->out('-> ' . $name, 1, ConsoleIo::VERBOSE);

				$annotator = $this->getAnnotator(ClassAnnotator::class);
				$annotator->annotate($path);
			}
		}
	}

}


================================================
FILE: src/Command/Annotate/CommandsCommand.php
================================================
<?php

namespace IdeHelper\Command\Annotate;

use Cake\Console\Arguments;
use Cake\Console\ConsoleIo;
use IdeHelper\Annotator\CommandAnnotator;
use IdeHelper\Command\AnnotateCommand;

class CommandsCommand extends AnnotateCommand {

	/**
	 * @return string
	 */
	public static function getDescription(): string {
		return 'Annotate primary model as well as used models in commands.';
	}

	/**
	 * @param \Cake\Console\Arguments $args
	 * @param \Cake\Console\ConsoleIo $io
	 * @return int
	 */
	public function execute(Arguments $args, ConsoleIo $io): int {
		parent::execute($args, $io);

		$paths = $this->getPaths('Command');

		foreach ($paths as $plugin => $pluginPaths) {
			$this->setPlugin($plugin);
			foreach ($pluginPaths as $path) {
				$this->_commands($path);
			}
		}

		if ($args->getOption('ci') && $this->_annotatorMadeChanges()) {
			return static::CODE_CHANGES;
		}

		return static::CODE_SUCCESS;
	}

	/**
	 * @param string $folder
	 * @return void
	 */
	protected function _commands(string $folder) {
		$this->io->out(str_replace(ROOT . DS, '', $folder), 1, ConsoleIo::VERBOSE);

		$folderContent = glob($folder . '*') ?: [];
		foreach ($folderContent as $path) {
			if (is_dir($path)) {
				continue;
			}
			$name = pathinfo($path, PATHINFO_FILENAME);
			if ($this->_shouldSkip($name, $path)) {
				continue;
			}

			$this->io->out('-> ' . $name, 1, ConsoleIo::VERBOSE);
			$annotator = $this->getAnnotator(CommandAnnotator::class);
			$annotator->annotate($path);
		}
	}

}


================================================
FILE: src/Command/Annotate/ComponentsCommand.php
================================================
<?php

namespace IdeHelper\Command\Annotate;

use Cake\Console\Arguments;
use Cake\Console\ConsoleIo;
use IdeHelper\Annotator\ComponentAnnotator;
use IdeHelper\Command\AnnotateCommand;

class ComponentsCommand extends AnnotateCommand {

	/**
	 * @return string
	 */
	public static function getDescription(): string {
		return 'Annotate used components inside components.';
	}

	/**
	 * @param \Cake\Console\Arguments $args
	 * @param \Cake\Console\ConsoleIo $io
	 * @return int
	 */
	public function execute(Arguments $args, ConsoleIo $io): int {
		parent::execute($args, $io);

		$paths = $this->getPaths('Controller/Component');
		foreach ($paths as $plugin => $pluginPaths) {
			$this->setPlugin($plugin);
			foreach ($pluginPaths as $path) {
				$this->_components($path);
			}
		}

		if ($args->getOption('ci') && $this->_annotatorMadeChanges()) {
			return static::CODE_CHANGES;
		}

		return static::CODE_SUCCESS;
	}

	/**
	 * @param string $folder
	 * @return void
	 */
	protected function _components(string $folder) {
		$this->io->out(str_replace(ROOT . DS, '', $folder), 1, ConsoleIo::VERBOSE);

		$folderContent = glob($folder . '*') ?: [];
		foreach ($folderContent as $path) {
			if (is_dir($path)) {
				$this->_components($path);
			} else {
				$name = pathinfo($path, PATHINFO_FILENAME);
				if ($this->_shouldSkip($name, $path)) {
					continue;
				}

				$this->io->out('-> ' . $name, 1, ConsoleIo::VERBOSE);
				$annotator = $this->getAnnotator(ComponentAnnotator::class);
				$annotator->annotate($path);
			}
		}
	}

}


================================================
FILE: src/Command/Annotate/ControllersCommand.php
================================================
<?php

namespace IdeHelper\Command\Annotate;

use Cake\Console\Arguments;
use Cake\Console\ConsoleIo;
use Cake\Core\Configure;
use IdeHelper\Annotator\ControllerAnnotator;
use IdeHelper\Command\AnnotateCommand;

class ControllersCommand extends AnnotateCommand {

	/**
	 * @return string
	 */
	public static function getDescription(): string {
		return 'Annotate primary model as well as used models in controller class.';
	}

	/**
	 * @param \Cake\Console\Arguments $args
	 * @param \Cake\Console\ConsoleIo $io
	 * @return int
	 */
	public function execute(Arguments $args, ConsoleIo $io): int {
		parent::execute($args, $io);

		$paths = $this->getPaths('Controller');

		foreach ($paths as $plugin => $pluginPaths) {
			$this->setPlugin($plugin);
			foreach ($pluginPaths as $path) {
				$this->_controllers($path);
			}
		}

		if ($args->getOption('ci') && $this->_annotatorMadeChanges()) {
			return static::CODE_CHANGES;
		}

		return static::CODE_SUCCESS;
	}

	/**
	 * @param string $folder
	 * @return void
	 */
	protected function _controllers(string $folder) {
		$this->io->out(str_replace(ROOT . DS, '', $folder), 1, ConsoleIo::VERBOSE);

		$folderContent = glob($folder . '*') ?: [];
		foreach ($folderContent as $path) {

			if (is_dir($path)) {
				$subFolder = pathinfo($path, PATHINFO_BASENAME);
				if ($subFolder === 'Component') {
					continue;
				}

				$prefixes = (array)Configure::read('IdeHelper.prefixes') ?: null;

				if ($prefixes !== null && !in_array($subFolder, $prefixes, true)) {
					continue;
				}

				$this->_controllers($folder . $subFolder . DS);
			} else {
				$name = pathinfo($path, PATHINFO_FILENAME);
				if ($this->_shouldSkip($name, $path)) {
					continue;
				}

				$this->io->out('-> ' . $name, 1, ConsoleIo::VERBOSE);

				$annotator = $this->getAnnotator(ControllerAnnotator::class);
				$annotator->annotate($path);
			}

		}
	}

}


================================================
FILE: src/Command/Annotate/HelpersCommand.php
================================================
<?php

namespace IdeHelper\Command\Annotate;

use Cake\Console\Arguments;
use Cake\Console\ConsoleIo;
use IdeHelper\Annotator\HelperAnnotator;
use IdeHelper\Command\AnnotateCommand;

class HelpersCommand extends AnnotateCommand {

	/**
	 * @return string
	 */
	public static function getDescription(): string {
		return 'Annotate used helpers inside helpers.';
	}

	/**
	 * @param \Cake\Console\Arguments $args
	 * @param \Cake\Console\ConsoleIo $io
	 * @return int
	 */
	public function execute(Arguments $args, ConsoleIo $io): int {
		parent::execute($args, $io);

		$paths = $this->getPaths('View/Helper');
		foreach ($paths as $plugin => $pluginPaths) {
			$this->setPlugin($plugin);
			foreach ($pluginPaths as $path) {
				$this->_helpers($path);
			}
		}

		if ($args->getOption('ci') && $this->_annotatorMadeChanges()) {
			return static::CODE_CHANGES;
		}

		return static::CODE_SUCCESS;
	}

	/**
	 * @param string $folder
	 * @return void
	 */
	protected function _helpers($folder) {
		$this->io->out(str_replace(ROOT . DS, '', $folder), 1, ConsoleIo::VERBOSE);

		$folderContent = glob($folder . '*') ?: [];
		foreach ($folderContent as $path) {
			if (is_dir($path)) {
				$this->_helpers($path);
			} else {
				$name = pathinfo($path, PATHINFO_FILENAME);
				if ($this->_shouldSkip($name, $path)) {
					continue;
				}

				$this->io->out('-> ' . $name, 1, ConsoleIo::VERBOSE);
				$annotator = $this->getAnnotator(HelperAnnotator::class);
				$annotator->annotate($path);
			}
		}
	}

}


================================================
FILE: src/Command/Annotate/ModelsCommand.php
================================================
<?php

namespace IdeHelper\Command\Annotate;

use Cake\Console\Arguments;
use Cake\Console\ConsoleIo;
use IdeHelper\Annotator\ModelAnnotator;
use IdeHelper\Command\AnnotateCommand;

class ModelsCommand extends AnnotateCommand {

	/**
	 * @return string
	 */
	public static function getDescription(): string {
		return 'Annotate fields and relations in table and entity class.';
	}

	/**
	 * @param \Cake\Console\Arguments $args
	 * @param \Cake\Console\ConsoleIo $io
	 * @return int
	 */
	public function execute(Arguments $args, ConsoleIo $io): int {
		parent::execute($args, $io);

		$paths = $this->getPaths('Model/Table');
		foreach ($paths as $plugin => $pluginPaths) {
			foreach ($pluginPaths as $path) {
				$this->setPlugin($plugin);
				$this->_models($path);
			}
		}

		if ($args->getOption('ci') && $this->_annotatorMadeChanges()) {
			return static::CODE_CHANGES;
		}

		return static::CODE_SUCCESS;
	}

	/**
	 * @param string $folder
	 * @return void
	 */
	protected function _models(string $folder) {
		$this->io->out(str_replace(ROOT . DS, '', $folder), 1, ConsoleIo::VERBOSE);

		$folderContent = glob($folder . '*') ?: [];
		foreach ($folderContent as $path) {
			if (!is_file($path)) {
				continue;
			}
			$name = pathinfo($path, PATHINFO_FILENAME);
			if ($this->_shouldSkip($name, $path)) {
				continue;
			}

			$this->io->out('-> ' . $name, 1, ConsoleIo::VERBOSE);

			$annotator = $this->getAnnotator(ModelAnnotator::class);
			$annotator->annotate($path);
		}
	}

}


================================================
FILE: src/Command/Annotate/TemplatesCommand.php
================================================
<?php

namespace IdeHelper\Command\Annotate;

use Cake\Console\Arguments;
use Cake\Console\ConsoleIo;
use IdeHelper\Annotator\TemplateAnnotator;
use IdeHelper\Command\AnnotateCommand;

class TemplatesCommand extends AnnotateCommand {

	/**
	 * @return string
	 */
	public static function getDescription(): string {
		return 'Annotate helpers in view templates and elements.';
	}

	/**
	 * @param \Cake\Console\Arguments $args
	 * @param \Cake\Console\ConsoleIo $io
	 * @return int
	 */
	public function execute(Arguments $args, ConsoleIo $io): int {
		parent::execute($args, $io);

		$paths = $this->getPaths('templates');

		foreach ($paths as $plugin => $pluginPaths) {
			$this->setPlugin($plugin);
			foreach ($pluginPaths as $path) {
				$this->_templates($path);
			}
		}

		if ($args->getOption('ci') && $this->_annotatorMadeChanges()) {
			return static::CODE_CHANGES;
		}

		return static::CODE_SUCCESS;
	}

	/**
	 * @param string $folder
	 * @return void
	 */
	protected function _templates($folder) {
		$this->io->out(str_replace(ROOT . DS, '', $folder), 1, ConsoleIo::VERBOSE);

		$folderContent = glob($folder . '*') ?: [];
		foreach ($folderContent as $path) {

			// Prevent infinite loop
			if ($folder === $path) {
				continue;
			}

			if (is_dir($path)) {
				foreach ($this->_config['skipTemplatePaths'] as $skip) {
					$subFolder = pathinfo($path, PATHINFO_BASENAME);
					if (!str_contains($subFolder, $skip)) {
						continue;
					}

					if ($this->args->getOption('verbose')) {
						$this->io->warning(sprintf('Skipped template folder `%s`', str_replace(ROOT . DS, '', $subFolder)));
					}

					break;
				}
				$this->_templates($path . DS);
			} else {
				$extension = pathinfo($path, PATHINFO_EXTENSION);
				if ($this->_shouldSkipExtension($extension)) {
					continue;
				}

				$name = pathinfo($path, PATHINFO_FILENAME);
				$dir = $name;
				$templatePathPos = strpos($folder, DS . 'templates' . DS);
				if ($templatePathPos) {
					$dir = substr($folder, $templatePathPos + strlen(DS . 'templates' . DS)) . $name;
				}
				if ($this->_shouldSkip($dir, $path)) {
					continue;
				}

				$this->io->out('-> ' . $name, 1, ConsoleIo::VERBOSE);
				$annotator = $this->getAnnotator(TemplateAnnotator::class);
				$annotator->annotate($path);
			}
		}
	}

}


================================================
FILE: src/Command/Annotate/ViewCommand.php
================================================
<?php

namespace IdeHelper\Command\Annotate;

use Cake\Console\Arguments;
use Cake\Console\ConsoleIo;
use Cake\Core\App;
use IdeHelper\Annotator\ViewAnnotator;
use IdeHelper\Command\AnnotateCommand;

class ViewCommand extends AnnotateCommand {

	/**
	 * @return string
	 */
	public static function getDescription(): string {
		return 'Annotate used helpers in AppView.';
	}

	/**
	 * @param \Cake\Console\Arguments $args
	 * @param \Cake\Console\ConsoleIo $io
	 * @return int
	 */
	public function execute(Arguments $args, ConsoleIo $io): int {
		parent::execute($args, $io);

		if ($args->getOption('plugin') || $args->getOption('filter')) {
			$io->error('Plugin or filter option not supported for this command');
			$this->abort();
		}

		$className = App::className('App', 'View', 'View');
		$file = APP . 'View' . DS . 'AppView.php';
		if (!$className || !file_exists($file)) {
			$io->warning('You need to create `AppView.php` first in `' . APP_DIR . DS . 'View' . DS . '`.');

			return static::CODE_SUCCESS;
		}

		$folder = pathinfo($file, PATHINFO_DIRNAME);
		$io->out(str_replace(ROOT . DS, '', $folder));
		$io->out(' -> ' . pathinfo($file, PATHINFO_BASENAME));

		$annotator = $this->getAnnotator(ViewAnnotator::class);
		$annotator->annotate($file);

		if ($args->getOption('ci') && $this->_annotatorMadeChanges()) {
			return static::CODE_CHANGES;
		}

		return static::CODE_SUCCESS;
	}

}


================================================
FILE: src/Command/AnnotateCommand.php
================================================
<?php

namespace IdeHelper\Command;

use Cake\Console\Arguments;
use Cake\Console\ConsoleIo;
use Cake\Console\ConsoleOptionParser;
use Cake\Core\Configure;
use Cake\TestSuite\ConnectionHelper;
use IdeHelper\Annotator\AbstractAnnotator;
use IdeHelper\Console\Io;
use RuntimeException;

abstract class AnnotateCommand extends Command {

	/**
	 * @var int
	 */
	public const CODE_CHANGES = 2;

	/**
	 * @var array<string>
	 */
	public const TEMPLATE_EXTENSIONS = ['php'];

	/**
	 * @var array<string, mixed>
	 */
	protected array $_config = [
		'skipTemplatePaths' => [
			'/templates/Bake/',
		],
	];

	/**
	 * @return void
	 */
	public function initialize(): void {
		parent::initialize();

		$skip = (array)Configure::read('IdeHelper.skipTemplatePaths');
		if ($skip) {
			$this->_config['skipTemplatePaths'] = $skip;
		}
	}

	/**
	 * E.g.:
	 * bin/cake upgrade /path/to/app --level=cakephp40
	 *
	 * @param \Cake\Console\Arguments $args The command arguments.
	 * @param \Cake\Console\ConsoleIo $io The console io
	 *
	 * @throws \Cake\Console\Exception\StopException
	 * @return int|null|void The exit code or null for success
	 */
	public function execute(Arguments $args, ConsoleIo $io) {
		parent::execute($args, $io);

		if ($args->getOption('ci')) {
			if (!$args->getOption('dry-run') || $args->getOption('interactive')) {
				$io->error('Continuous Integration mode requires -d param as well as no -i param!');
				$this->abort();
			}
			ConnectionHelper::addTestAliases();
		}

		AbstractAnnotator::$output = false;
	}

	/**
	 * @param \Cake\Console\ConsoleOptionParser $parser The parser to be defined
	 *
	 * @return \Cake\Console\ConsoleOptionParser The built parser.
	 */
	protected function buildOptionParser(ConsoleOptionParser $parser): ConsoleOptionParser {
		$options = [
			'dry-run' => [
				'short' => 'd',
				'help' => 'Dry run the task(s). Don\'t modify any files.',
				'boolean' => true,
			],
			'plugin' => [
				'short' => 'p',
				'help' => 'The plugin(s) to run. Defaults to the application otherwise. Supports wildcard `*` for partial match, `all` for all app plugins.',
				'default' => null,
			],
			'remove' => [
				'short' => 'r',
				'help' => 'Remove outdated annotations. Make sure you commited first or have a backup!',
				'boolean' => true,
			],
			'filter' => [
				'short' => 'f',
				'help' => 'Filter by search string in file name. For templates also in path.',
				'default' => null,
			],
			'file' => [
				'help' => 'Pass file(s) to run for, comma separated. Can be absolute or ROOT relative.',
				'default' => null,
			],
			'ci' => [
				'help' => 'Enable CI mode (requires dry-run). This will return an error code ' . static::CODE_CHANGES . ' if changes are necessary.',
				'boolean' => true,
			],
			'interactive' => [
				'short' => 'i',
				'help' => 'Interactive mode (prompt before each type).',
				'boolean' => true,
			],
		];

		$parser->addOptions($options);

		return $parser->setDescription('Annotation Command for generating better IDE auto-complete/hinting.');
	}

	/**
	 * @return \IdeHelper\Console\Io
	 */
	protected function _io(): Io {
		return new Io($this->io);
	}

	/**
	 * @param string $fileName
	 * @param string|null $path
	 *
	 * @return bool
	 */
	protected function _shouldSkip(string $fileName, ?string $path = null): bool {
		$files = $this->_files();
		if ($files) {
			return !in_array($path, $files, true);
		}

		$filter = (string)$this->args->getOption('filter');
		if (!$filter) {
			return false;
		}

		return !preg_match('/' . preg_quote($filter, '/') . '/i', $fileName);
	}

	/**
	 * @return array<string>
	 */
	protected function _files(): array {
		$file = (string)$this->args->getOption('file');
		if (!$file) {
			return [];
		}

		$files = explode(',', $file);
		foreach ($files as $k => $file) {
			if (!str_starts_with($file, ROOT . DS)) {
				$file = ROOT . DS . $file;
			}

			if (!file_exists($file)) {
				throw new RuntimeException('Cannot find file: ' . $file);
			}

			$files[$k] = $file;
		}

		return $files;
	}

	/**
	 * Checks template extensions against whitelist.
	 *
	 * @param string $extension
	 * @return bool
	 */
	protected function _shouldSkipExtension(string $extension): bool {
		$whitelist = Configure::read('IdeHelper.templateExtensions') ?: static::TEMPLATE_EXTENSIONS;

		return !in_array($extension, $whitelist, true);
	}

	/**
	 * @param class-string<\IdeHelper\Annotator\AbstractAnnotator> $class
	 *
	 * @return \IdeHelper\Annotator\AbstractAnnotator
	 */
	protected function getAnnotator(string $class): AbstractAnnotator {
		/** @phpstan-var array<class-string<\IdeHelper\Annotator\AbstractAnnotator>> $tasks */
		$tasks = (array)Configure::read('IdeHelper.annotators');
		if (isset($tasks[$class])) {
			$class = $tasks[$class];
		}

		$options = $this->args->getOptions();
		$options['plugin'] = $this->plugin;

		return new $class($this->_io(), $options);
	}

	/**
	 * @return bool
	 */
	protected function _annotatorMadeChanges(): bool {
		return AbstractAnnotator::$output !== false;
	}

}


================================================
FILE: src/Command/Command.php
================================================
<?php

namespace IdeHelper\Command;

use Cake\Command\Command as CoreCommand;
use Cake\Console\Arguments;
use Cake\Console\ConsoleIo;
use IdeHelper\Utility\App;
use IdeHelper\Utility\AppPath;
use IdeHelper\Utility\Plugin;
use IdeHelper\Utility\PluginPath;

abstract class Command extends CoreCommand {

	/**
	 * @var \Cake\Console\Arguments
	 */
	protected Arguments $args;

	/**
	 * @var \Cake\Console\ConsoleIo
	 */
	protected ConsoleIo $io;

	protected ?string $plugin = null;

	/**
	 * @param \Cake\Console\Arguments $args The command arguments.
	 * @param \Cake\Console\ConsoleIo $io The console io
	 * @throws \Cake\Console\Exception\StopException
	 * @return int|null|void The exit code or null for success
	 */
	public function execute(Arguments $args, ConsoleIo $io) {
		$this->args = $args;
		$this->io = $io;

		parent::execute($args, $io);
	}

	/**
	 * @param string|null $type
	 * @return array<string, array<string>>
	 */
	protected function getPaths(?string $type = null): array {
		$plugin = (string)$this->args->getOption('plugin') ?: null;
		if (!$plugin) {
			if (!$type) {
				$paths = [ROOT . DS];
			} elseif ($type === 'classes') {
				$paths = [ROOT . DS . APP_DIR . DS];
			} else {
				$paths = $type === 'templates' ? App::path('templates') : AppPath::get($type);
			}

			return ['app' => $paths];
		}

		$plugins = $this->getPlugins($plugin);

		$paths = [];
		foreach ($plugins as $plugin) {
			if (!$type) {
				$pluginPaths = [Plugin::path($plugin)];
			} else {
				if ($type === 'classes') {
					$pluginPaths = [PluginPath::classPath($plugin)];
				} else {
					$pluginPaths = $type === 'templates' ? App::path('templates', $plugin) : AppPath::get($type, $plugin);
				}
			}

			$paths[$plugin] = $pluginPaths;
		}

		return $paths;
	}

	/**
	 * @param string $plugin
	 *
	 * @return array<string>
	 */
	protected function getPlugins(string $plugin): array {
		if ($plugin !== 'all' && !str_contains($plugin, '*')) {
			return [Plugin::path($plugin) => $plugin];
		}

		$loaded = Plugin::loaded();
		$plugins = [];
		foreach ($loaded as $name) {
			$path = Plugin::path($name);
			$rootPath = str_replace(ROOT . DS, '', $path);
			if (str_starts_with($rootPath, 'vendor' . DS)) {
				continue;
			}

			$plugins[$path] = $name;
		}

		if ($plugin === 'all') {
			return $plugins;
		}

		return $this->filterPlugins($plugins, $plugin);
	}

	/**
	 * @param array<string> $plugins
	 * @param string $pattern
	 * @return array<string>
	 */
	protected function filterPlugins(array $plugins, string $pattern): array {
		return array_filter($plugins, function($plugin) use ($pattern) {
			return fnmatch($pattern, $plugin);
		});
	}

	/**
	 * @param string $plugin
	 * @return void
	 */
	protected function setPlugin(string $plugin): void {
		if (!$plugin || $plugin === 'app') {
			$this->plugin = null;

			return;
		}

		$this->plugin = $plugin;
	}

}


================================================
FILE: src/Command/GenerateCodeCompletionCommand.php
================================================
<?php

namespace IdeHelper\Command;

use Cake\Command\Command;
use Cake\Console\Arguments;
use Cake\Console\ConsoleIo;
use Cake\Console\ConsoleOptionParser;
use IdeHelper\CodeCompletion\CodeCompletionGenerator;
use IdeHelper\CodeCompletion\TaskCollection;

class GenerateCodeCompletionCommand extends Command {

	/**
	 * @return string
	 */
	public static function getDescription(): string {
		return 'CodeCompletion File Generator for generating better IDE auto-complete/hinting.';
	}

	/**
	 * @param \Cake\Console\Arguments $args The command arguments.
	 * @param \Cake\Console\ConsoleIo $io The console io
	 *
	 * @throws \Cake\Console\Exception\StopException
	 * @return int The exit code or null for success
	 */
	public function execute(Arguments $args, ConsoleIo $io): int {
		$codeCompletionGenerator = $this->getGenerator();

		if ($args->getOption('dry-run')) {
			return static::CODE_SUCCESS;
		}

		$types = $codeCompletionGenerator->generate();

		$io->out('CodeCompletion files generated: ' . implode(', ', $types));

		return static::CODE_SUCCESS;
	}

	/**
	 * @param \Cake\Console\ConsoleOptionParser $parser The parser to be defined
	 *
	 * @return \Cake\Console\ConsoleOptionParser The built parser.
	 */
	protected function buildOptionParser(ConsoleOptionParser $parser): ConsoleOptionParser {
		$parser = parent::buildOptionParser($parser);
		$options = [
			'dry-run' => [
				'short' => 'd',
				'help' => 'Dry run the generation. This will not actually generate any files.',
				'boolean' => true,
			],
		];

		return $parser
			->setDescription(static::getDescription())
			->addOptions($options);
	}

	/**
	 * @return \IdeHelper\CodeCompletion\CodeCompletionGenerator
	 */
	protected function getGenerator(): CodeCompletionGenerator {
		$taskCollection = new TaskCollection();

		return new CodeCompletionGenerator($taskCollection);
	}

}


================================================
FILE: src/Command/GeneratePhpStormMetaCommand.php
================================================
<?php

namespace IdeHelper\Command;

use Cake\Command\Command;
use Cake\Console\Arguments;
use Cake\Console\ConsoleIo;
use Cake\Console\ConsoleOptionParser;
use IdeHelper\Console\Io;
use IdeHelper\Generator\PhpstormGenerator;
use IdeHelper\Generator\TaskCollection;
use RuntimeException;

class GeneratePhpStormMetaCommand extends Command {

	/**
	 * @var int
	 */
	public const CODE_CHANGES = 2;

	/**
	 * @var \Cake\Console\ConsoleIo
	 */
	protected ConsoleIo $io;

	/**
	 * @return string
	 */
	public static function getDescription(): string {
		return 'Meta File Generator for generating better IDE auto-complete/hinting in PhpStorm.';
	}

	/**
	 * @param \Cake\Console\Arguments $args The command arguments.
	 * @param \Cake\Console\ConsoleIo $io The console io
	 *
	 * @throws \Cake\Console\Exception\StopException
	 * @return int The exit code or null for success
	 */
	public function execute(Arguments $args, ConsoleIo $io): int {
		$this->io = $io;

		parent::execute($args, $io);

		$phpstormGenerator = $this->getGenerator();
		$content = $phpstormGenerator->generate();

		$filePath = $this->getMetaFilePath();

		$unchanged = file_exists($filePath) && md5_file($filePath) === md5($content);
		if ($unchanged) {
			$io->out('Meta file `/.phpstorm.meta.php/.ide-helper.meta.php` still up to date.');

			return parent::CODE_SUCCESS;
		}

		if ($args->getOption('dry-run')) {
			$io->out('Meta file `/.phpstorm.meta.php/.ide-helper.meta.php` needs updating.');

			return static::CODE_CHANGES;
		}

		$this->ensureDir();

		if (file_put_contents($filePath, $content) === false) {
			throw new RuntimeException(sprintf('Failed to write meta file `%s`.', $filePath));
		}

		$io->out('Meta file `/.phpstorm.meta.php/.ide-helper.meta.php` generated.');

		return static::CODE_SUCCESS;
	}

	/**
	 * @param \Cake\Console\ConsoleOptionParser $parser The parser to be defined
	 *
	 * @return \Cake\Console\ConsoleOptionParser The built parser.
	 */
	protected function buildOptionParser(ConsoleOptionParser $parser): ConsoleOptionParser {
		$subcommandParser = [
			'dry-run' => [
				'short' => 'd',
				'help' => 'Dry run the generation. This will output an error code ' . static::CODE_CHANGES . ' if file needs changing. Can be used for CI checking.',
				'boolean' => true,
			],
		];

		$details = 'Generate `/.phpstorm.meta.php/.ide-helper.meta.php` meta file.';

		$parser->addOptions($subcommandParser);

		return $parser
			->setDescription(static::getDescription() . PHP_EOL . $details);
	}

	/**
	 * @return \IdeHelper\Generator\PhpstormGenerator
	 */
	protected function getGenerator(): PhpstormGenerator {
		$taskCollection = new TaskCollection();

		return new PhpstormGenerator($taskCollection, $this->io());
	}

	/**
	 * @throws \RuntimeException
	 * @return string
	 */
	protected function getMetaFilePath(): string {
		if (is_file(ROOT . DS . '.phpstorm.meta.php')) {
			throw new RuntimeException('Please use a directory called `ROOT/.phpstorm.meta.php/` and store your custom files there. Remove any root file you still have.');
		}

		return ROOT . DS . '.phpstorm.meta.php' . DS . '.ide-helper.meta.php';
	}

	/**
	 * @throws \RuntimeException When the directory cannot be created.
	 * @return void
	 */
	protected function ensureDir(): void {
		$dir = dirname($this->getMetaFilePath());
		if (!is_dir($dir) && !mkdir($dir, 0775, true) && !is_dir($dir)) {
			throw new RuntimeException(sprintf('Cannot create directory `%s`.', $dir));
		}
	}

	/**
	 * @return \IdeHelper\Console\Io
	 */
	protected function io(): Io {
		return new Io($this->io);
	}

}


================================================
FILE: src/Command/IlluminateCommand.php
================================================
<?php

namespace IdeHelper\Command;

use Cake\Console\Arguments;
use Cake\Console\ConsoleIo;
use Cake\Console\ConsoleOptionParser;
use IdeHelper\Console\Io;
use IdeHelper\Illuminator\Illuminator;
use IdeHelper\Illuminator\TaskCollection;

class IlluminateCommand extends Command {

	/**
	 * @var int
	 */
	public const CODE_CHANGES = 2;

	/**
	 * @return string
	 */
	public static function getDescription(): string {
		return 'PHP file modifier.';
	}

	/**
	 * E.g.:
	 * bin/cake upgrade /path/to/app --level=cakephp40
	 *
	 * @param \Cake\Console\Arguments $args The command arguments.
	 * @param \Cake\Console\ConsoleIo $io The console io
	 *
	 * @throws \Cake\Console\Exception\StopException
	 * @return int The exit code or null for success
	 */
	public function execute(Arguments $args, ConsoleIo $io): int {
		parent::execute($args, $io);

		$paths = $this->getPaths();

		$pathElement = $args->getArgument('path');
		if (!$pathElement) {
			$pathElement = ($args->getOption('plugin') ? 'src' : APP_DIR) . DS;
		}

		$filesChanged = 0;
		foreach ($paths as $plugin => $pluginPaths) {
			$this->setPlugin($plugin);
			foreach ($pluginPaths as $path) {
				$path .= $pathElement;
				if (!is_dir($path)) {
					continue;
				}

				$illuminator = $this->getIlluminator($args);
				$filesChanged += $illuminator->illuminate($path, (string)$args->getOption('filter') ?: null);
			}
		}

		if (!$filesChanged) {
			return static::CODE_SUCCESS;
		}

		if ($args->getOption('dry-run')) {
			$io->out($filesChanged . ' files need(s) updating.');

			return static::CODE_CHANGES;
		}

		$io->out('Files updated: ' . $filesChanged);

		return static::CODE_SUCCESS;
	}

	/**
	 * @param \Cake\Console\ConsoleOptionParser $parser The parser to be defined
	 *
	 * @return \Cake\Console\ConsoleOptionParser The built parser.
	 */
	protected function buildOptionParser(ConsoleOptionParser $parser): ConsoleOptionParser {
		$tasks = $this->getTaskList();

		$subcommandParser = [
			'plugin' => [
				'short' => 'p',
				'help' => 'The plugin(s) to run. Defaults to the application otherwise. Supports wildcard `*` for partial match, `all` for all app plugins.',
				'default' => null,
			],
			'dry-run' => [
				'short' => 'd',
				'help' => 'Dry run the task(s). This will output an error code ' . static::CODE_CHANGES . ' if file needs changing. Can be used for CI checking.',
				'boolean' => true,
			],
			'task' => [
				'short' => 't',
				'help' => 'Run specific task(s). Can be comma separated list. Available: ' . implode(', ', $tasks),
				'default' => null,
			],
			'filter' => [
				'short' => 'f',
				'help' => 'Filter by search string in file name.',
				'default' => null,
			],
		];

		$parser->addOptions($subcommandParser);
		$parser->addArgument('path', [
			'name' => 'path',
			'help' => 'Path in your project or plugin. Defaults to src/',
			'required' => false,
		]);

		$taskList = 'Tasks: ' . implode(', ', $tasks);
		$descr = static::getDescription() . PHP_EOL . 'Run Illuminator tasks over your PHP files.' . PHP_EOL;

		return $parser->setDescription($descr . $taskList);
	}

	/**
	 * @param \Cake\Console\Arguments $args
	 *
	 * @return \IdeHelper\Illuminator\Illuminator
	 */
	protected function getIlluminator(Arguments $args): Illuminator {
		$tasks = $args->getOption('task') ? explode(',', (string)$args->getOption('task')) : [];

		$options = $args->getOptions();
		$options['plugin'] = $this->plugin;

		$taskCollection = new TaskCollection($this->io(), $options, $tasks);

		return new Illuminator($taskCollection);
	}

	/**
	 * @throws \RuntimeException
	 * @throws \InvalidArgumentException
	 * @return array<string>
	 */
	protected function getTaskList(): array {
		$taskCollection = new TaskCollection($this->io(), []);

		return $taskCollection->taskNames();
	}

	/**
	 * @return \IdeHelper\Console\Io
	 */
	protected function io(): Io {
		$io = $this->io ?? new ConsoleIo();

		return new Io($io);
	}

}


================================================
FILE: src/Console/Io.php
================================================
<?php

namespace IdeHelper\Console;

use Cake\Command\Command;
use Cake\Console\ConsoleIo;
use Cake\Console\Exception\StopException;

/**
 * Composition class as proxy towards ConsoleIO - basically a shell replacement for inside business logic.
 */
class Io {

	protected ConsoleIo $_io;

	/**
	 * Output at the verbose level.
	 *
	 * @param array<string>|string $message A string or an array of strings to output
	 * @param int $newlines Number of newlines to append
	 * @return int|null The number of bytes returned from writing to stdout.
	 */
	public function verbose(array|string $message, int $newlines = 1): ?int {
		return $this->_io->verbose($message, $newlines);
	}

	/**
	 * @param \Cake\Console\ConsoleIo $io
	 */
	public function __construct(ConsoleIo $io) {
		$this->_io = $io;
	}

	/**
	 * Output at all levels.
	 *
	 * @param array<string>|string $message A string or an array of strings to output
	 * @param int $newlines Number of newlines to append
	 * @return int|null The number of bytes returned from writing to stdout.
	 */
	public function quiet(array|string $message, int $newlines = 1): ?int {
		return $this->_io->quiet($message, $newlines);
	}

	/**
	 * Outputs a single or multiple messages to stdout. If no parameters
	 * are passed outputs just a newline.
	 *
	 * ### Output levels
	 *
	 * There are 3 built-in output levels: ConsoleIo::QUIET, ConsoleIo::NORMAL, ConsoleIo::VERBOSE.
	 * The verbose and quiet output levels, map to the `verbose` and `quiet` output switches
	 * present in most shells. Using ConsoleIo::QUIET for a message means it will always display.
	 * While using ConsoleIo::VERBOSE means it will only display when verbose output is toggled.
	 *
	 * @param array<string>|string $message A string or an array of strings to output
	 * @param int $newlines Number of newlines to append
	 * @param int $level The message's output level, see above.
	 * @return int|null The number of bytes returned from writing to stdout.
	 */
	public function out(array|string $message = '', int $newlines = 1, int $level = ConsoleIo::NORMAL): ?int {
		return $this->_io->out($message, $newlines, $level);
	}

	/**
	 * Outputs a single or multiple error messages to stderr. If no parameters
	 * are passed outputs just a newline.
	 *
	 * @param array<string>|string $message A string or an array of strings to output
	 * @param int $newlines Number of newlines to append
	 * @return int|null The number of bytes returned from writing to stderr.
	 */
	public function error(array|string $message = '', int $newlines = 1): ?int {
		return $this->_io->error($message, $newlines);
	}

	/**
	 * Outputs a single or multiple error messages to stderr. If no parameters
	 * are passed outputs just a newline.
	 *
	 * @deprecated Use error() instead.
	 * @param array<string>|string $message A string or an array of strings to output
	 * @param int $newlines Number of newlines to append
	 * @return int|null The number of bytes returned from writing to stderr.
	 */
	public function err(array|string $message = '', int $newlines = 1): ?int {
		return $this->_io->error($message, $newlines);
	}

	/**
	 * Convenience method for out() that wraps message between <info /> tag
	 *
	 * @see http://book.cakephp.org/3.0/en/console-and-shells.html#ConsoleIo::out
	 * @param array<string>|string $message A string or an array of strings to output
	 * @param int $newlines Number of newlines to append
	 * @param int $level The message's output level, see above.
	 * @return int|null The number of bytes returned from writing to stdout.
	 */
	public function info(array|string $message = '', int $newlines = 1, int $level = ConsoleIo::NORMAL): ?int {
		return $this->_io->info($message, $newlines, $level);
	}

	/**
	 * Convenience method for out() that wraps message between <comment /> tag
	 *
	 * @see http://book.cakephp.org/3.0/en/console-and-shells.html#ConsoleIo::out
	 * @param array<string>|string $message A string or an array of strings to output
	 * @param int $newlines Number of newlines to append
	 * @param int $level The message's output level, see above.
	 * @return int|null The number of bytes returned from writing to stdout.
	 */
	public function comment(array|string $message = '', int $newlines = 1, int $level = ConsoleIo::NORMAL): ?int {
		return $this->_io->comment($message, $newlines, $level);
	}

	/**
	 * Convenience method for err() that wraps message between <warning /> tag
	 *
	 * @see http://book.cakephp.org/3.0/en/console-and-shells.html#ConsoleIo::err
	 * @param array<string>|string $message A string or an array of strings to output
	 * @param int $newlines Number of newlines to append
	 * @return int|null The number of bytes returned from writing to stderr.
	 */
	public function warn(array|string $message = '', int $newlines = 1): ?int {
		return $this->_io->warning($message, $newlines);
	}

	/**
	 * Convenience method for out() that wraps message between <success /> tag
	 *
	 * @see http://book.cakephp.org/3.0/en/console-and-shells.html#ConsoleIo::out
	 * @param array<string>|string $message A string or an array of strings to output
	 * @param int $newlines Number of newlines to append
	 * @param int $level The message's output level, see above.
	 * @return int|null The number of bytes returned from writing to stdout.
	 */
	public function success(array|string $message = '', int $newlines = 1, int $level = ConsoleIo::NORMAL): ?int {
		return $this->_io->success($message, $newlines, $level);
	}

	/**
	 * Returns a single or multiple linefeeds sequences.
	 *
	 * @param int $multiplier Number of times the linefeed sequence should be repeated
	 * @return string
	 */
	public function nl(int $multiplier = 1): string {
		return $this->_io->nl($multiplier);
	}

	/**
	 * Outputs a series of minus characters to the standard output, acts as a visual separator.
	 *
	 * @param int $newlines Number of newlines to pre- and append
	 * @param int $width Width of the line, defaults to 63
	 * @return void
	 */
	public function hr(int $newlines = 0, int $width = 63): void {
		$this->_io->hr($newlines, $width);
	}

	/**
	 * Displays a formatted error message
	 * and exits the application with status code 1
	 *
	 * @param string $message The error message
	 * @param int $exitCode The exit code for the shell task.
	 * @throws \Cake\Console\Exception\StopException
	 * @return void
	 */
	public function abort(string $message, int $exitCode = Command::CODE_ERROR): void {
		$this->_io->error($message);

		throw new StopException($message, $exitCode);
	}

}


================================================
FILE: src/Filesystem/Folder.php
================================================
<?php
declare(strict_types=1);

/**
 * CakePHP(tm) : Rapid Development Framework (https://cakephp.org)
 * Copyright (c) Cake Software Foundation, Inc. (https://cakefoundation.org)
 *
 * Licensed under The MIT License
 * For full copyright and license information, please see the LICENSE.txt
 * Redistributions of files must retain the above copyright notice.
 *
 * @copyright Copyright (c) Cake Software Foundation, Inc. (https://cakefoundation.org)
 * @link https://cakephp.org CakePHP(tm) Project
 * @since 0.2.9
 * @license https://opensource.org/licenses/mit-license.php MIT License
 */

namespace IdeHelper\Filesystem;

use DirectoryIterator;
use Exception;
use InvalidArgumentException;
use RecursiveDirectoryIterator;
use RecursiveIteratorIterator;

/**
 * Folder structure browser, lists folders and files.
 * Provides an Object interface for Common directory related tasks.
 *
 * @internal
 */
class Folder {

	/**
	 * Default scheme for Folder::copy
	 * Recursively merges subfolders with the same name
	 *
	 * @var string
	 */
	public const MERGE = 'merge';

	/**
	 * Overwrite scheme for Folder::copy
	 * subfolders with the same name will be replaced
	 *
	 * @var string
	 */
	public const OVERWRITE = 'overwrite';

	/**
	 * Skip scheme for Folder::copy
	 * if a subfolder with the same name exists it will be skipped
	 *
	 * @var string
	 */
	public const SKIP = 'skip';

	/**
	 * Sort mode by name
	 *
	 * @var string
	 */
	public const SORT_NAME = 'name';

	/**
	 * Sort mode by time
	 *
	 * @var string
	 */
	public const SORT_TIME = 'time';

	/**
	 * Path to Folder.
	 */
	public ?string $path = null;

	/**
	 * Sortedness. Whether list results
	 * should be sorted by name.
	 */
	public bool $sort = false;

	/**
	 * Mode to be used on create. Does nothing on windows platforms.
	 */
	public int $mode = 0755;

	/**
	 * Functions array to be called depending on the sort type chosen.
	 *
	 * @var array<string>
	 */
	protected array $_fsorts = [
		self::SORT_NAME => 'getPathname',
		self::SORT_TIME => 'getCTime',
	];

	/**
	 * Holds messages from last method.
	 *
	 * @var array<string>
	 */
	protected array $_messages = [];

	/**
	 * Holds errors from last method.
	 *
	 * @var array<string>
	 */
	protected array $_errors = [];

	/**
	 * Constructor.
	 *
	 * @param string|null $path Path to folder
	 * @param bool $create Create folder if not found
	 * @param int|null $mode Mode (CHMOD) to apply to created folder, false to ignore
	 */
	public function __construct(?string $path = null, bool $create = false, ?int $mode = null) {
		if (!$path) {
			$path = TMP;
		}
		if ($mode) {
			$this->mode = $mode;
		}

		if (!file_exists($path) && $create === true) {
			$this->create($path, $this->mode);
		}
		if (!static::isAbsolute($path)) {
			$path = realpath($path);
		}
		if (!empty($path)) {
			$this->cd($path);
		}
	}

	/**
	 * Return current path.
	 *
	 * @return string|null Current path
	 */
	public function pwd(): ?string {
		return $this->path;
	}

	/**
	 * Change directory to $path.
	 *
	 * @param string $path Path to the directory to change to
	 * @return string|false The new path. Returns false on failure
	 */
	public function cd(string $path) {
		$path = $this->realpath($path);
		if ($path !== false && is_dir($path)) {
			return $this->path = $path;
		}

		return false;
	}

	/**
	 * Returns an array of the contents of the current directory.
	 * The returned array holds two arrays: One of directories and one of files.
	 *
	 * @param string|bool $sort Whether you want the results sorted, set this and the sort property
	 *   to `false` to get unsorted results.
	 * @param array<string>|bool $exceptions Either an array or boolean true will not grab dot files
	 * @param bool $fullPath True returns the full path
	 * @return array<array<string>> Contents of current directory as an array, an empty array on failure
	 */
	public function read($sort = self::SORT_NAME, $exceptions = false, bool $fullPath = false): array {
		$dirs = $files = [];

		if (!$this->pwd()) {
			return [$dirs, $files];
		}
		if (is_array($exceptions)) {
			$exceptions = array_flip($exceptions);
		}
		$skipHidden = isset($exceptions['.']) || $exceptions === true;

		try {
			$iterator = new DirectoryIterator((string)$this->path);
		} catch (Exception $e) {
			return [$dirs, $files];
		}

		if (!is_bool($sort) && isset($this->_fsorts[$sort])) {
			$methodName = $this->_fsorts[$sort];
		} else {
			$methodName = $this->_fsorts[static::SORT_NAME];
		}

		foreach ($iterator as $item) {
			if ($item->isDot()) {
				continue;
			}
			$name = $item->getFilename();
			if ($skipHidden && $name[0] === '.' || isset($exceptions[$name])) {
				continue;
			}
			if ($fullPath) {
				$name = $item->getPathname();
			}

			if ($item->isDir()) {
				$dirs[$item->{$methodName}()][] = $name;
			} else {
				$files[$item->{$methodName}()][] = $name;
			}
		}

		if ($sort || $this->sort) {
			ksort($dirs);
			ksort($files);
		}

		if ($dirs) {
			$dirs = array_merge(...array_values($dirs));
		}

		if ($files) {
			$files = array_merge(...array_values($files));
		}

		return [$dirs, $files];
	}

	/**
	 * Returns an array of all matching files in current directory.
	 *
	 * @param string $regexpPattern Preg_match pattern (Defaults to: .*)
	 * @param string|bool $sort Whether results should be sorted.
	 * @return array<string> Files that match given pattern
	 */
	public function find(string $regexpPattern = '.*', $sort = false): array {
		[, $files] = $this->read($sort);

		return array_values(preg_grep('/^' . $regexpPattern . '$/i', $files) ?: []);
	}

	/**
	 * Returns an array of all matching files in and below current directory.
	 *
	 * @param string $pattern Preg_match pattern (Defaults to: .*)
	 * @param bool $sort Whether results should be sorted.
	 * @return array<string> Files matching $pattern
	 */
	public function findRecursive(string $pattern = '.*', bool $sort = false): array {
		if (!$this->pwd()) {
			return [];
		}
		$startsOn = (string)$this->path;
		$out = $this->_findRecursive($pattern, $sort);
		$this->cd($startsOn);

		return $out;
	}

	/**
	 * Private helper function for findRecursive.
	 *
	 * @param string $pattern Pattern to match against
	 * @param bool $sort Whether results should be sorted.
	 * @return array<string> Files matching pattern
	 */
	protected function _findRecursive(string $pattern, bool $sort = false): array {
		[$dirs, $files] = $this->read($sort);
		$found = [];

		foreach ($files as $file) {
			if (preg_match('/^' . $pattern . '$/i', $file)) {
				$found[] = static::addPathElement((string)$this->path, $file);
			}
		}
		$start = (string)$this->path;

		foreach ($dirs as $dir) {
			$this->cd(static::addPathElement($start, $dir));
			$found = array_merge($found, $this->findRecursive($pattern, $sort));
		}

		return $found;
	}

	/**
	 * Returns true if given $path is a Windows path.
	 *
	 * @param string $path Path to check
	 * @return bool true if windows path, false otherwise
	 */
	public static function isWindowsPath(string $path): bool {
		return preg_match('/^[A-Z]:\\\\/i', $path) || str_starts_with($path, '\\\\');
	}

	/**
	 * Returns true if given $path is an absolute path.
	 *
	 * @param string $path Path to check
	 * @return bool true if path is absolute.
	 */
	public static function isAbsolute(string $path): bool {
		if (!$path) {
			return false;
		}

		return $path[0] === '/' ||
			preg_match('/^[A-Z]:\\\\/i', $path) ||
			str_starts_with($path, '\\\\') ||
			static::isRegisteredStreamWrapper($path);
	}

	/**
	 * Returns true if given $path is a registered stream wrapper.
	 *
	 * @param string $path Path to check
	 * @return bool True if path is registered stream wrapper.
	 */
	public static function isRegisteredStreamWrapper(string $path): bool {
		return preg_match('/^[^:\/]+?(?=:\/\/)/', $path, $matches) &&
			in_array($matches[0], stream_get_wrappers(), true);
	}

	/**
	 * Returns a correct set of slashes for given $path. (\\ for Windows paths and / for other paths.)
	 *
	 * @param string $path Path to transform
	 * @return string Path with the correct set of slashes ("\\" or "/")
	 */
	public static function normalizeFullPath(string $path): string {
		$to = static::correctSlashFor($path);
		$from = ($to === '/' ? '\\' : '/');

		return str_replace($from, $to, $path);
	}

	/**
	 * Returns a correct set of slashes for given $path. (\\ for Windows paths and / for other paths.)
	 *
	 * @param string $path Path to check
	 * @return string Set of slashes ("\\" or "/")
	 */
	public static function correctSlashFor(string $path): string {
		return static::isWindowsPath($path) ? '\\' : '/';
	}

	/**
	 * Returns $path with added terminating slash (corrected for Windows or other OS).
	 *
	 * @param string $path Path to check
	 * @return string Path with ending slash
	 */
	public static function slashTerm(string $path): string {
		if (static::isSlashTerm($path)) {
			return $path;
		}

		return $path . static::correctSlashFor($path);
	}

	/**
	 * Returns $path with $element added, with correct slash in-between.
	 *
	 * @param string $path Path
	 * @param array<string>|string $element Element to add at end of path
	 * @return string Combined path
	 */
	public static function addPathElement(string $path, $element): string {
		$element = (array)$element;
		array_unshift($element, rtrim($path, DIRECTORY_SEPARATOR));

		return implode(DIRECTORY_SEPARATOR, $element);
	}

	/**
	 * Returns true if the Folder is in the given path.
	 *
	 * @param string $path The absolute path to check that the current `pwd()` resides within.
	 * @param bool $reverse Reverse the search, check if the given `$path` resides within the current `pwd()`.
	 * @throws \InvalidArgumentException When the given `$path` argument is not an absolute path.
	 * @return bool
	 */
	public function inPath(string $path, bool $reverse = false): bool {
		if (!static::isAbsolute($path)) {
			throw new InvalidArgumentException('The $path argument is expected to be an absolute path.');
		}

		$dir = static::slashTerm($path);
		$current = static::slashTerm((string)$this->pwd());

		if (!$reverse) {
			$return = preg_match('/^' . preg_quote($dir, '/') . '(.*)/', $current);
		} else {
			$return = preg_match('/^' . preg_quote($current, '/') . '(.*)/', $dir);
		}

		return (bool)$return;
	}

	/**
	 * Change the mode on a directory structure recursively. This includes changing the mode on files as well.
	 *
	 * @param string $path The path to chmod.
	 * @param int|null $mode Octal value, e.g. 0755.
	 * @param bool $recursive Chmod recursively, set to false to only change the current directory.
	 * @param array<string> $exceptions Array of files, directories to skip.
	 * @return bool Success.
	 */
	public function chmod(string $path, ?int $mode = null, bool $recursive = true, array $exceptions = []): bool {
		if (!$mode) {
			$mode = $this->mode;
		}

		if ($recursive === false && is_dir($path)) {
			// phpcs:disable
			if (@chmod($path, intval($mode, 8))) {
				// phpcs:enable
				$this->_messages[] = sprintf('%s changed to %s', $path, $mode);

				return true;
			}

			$this->_errors[] = sprintf('%s NOT changed to %s', $path, $mode);

			return false;
		}

		if (is_dir($path)) {
			$paths = $this->tree($path);

			foreach ($paths as $type) {
				foreach ($type as $fullpath) {
					$check = explode(DIRECTORY_SEPARATOR, $fullpath);
					$count = count($check);

					if (in_array($check[$count - 1], $exceptions, true)) {
						continue;
					}

					// phpcs:disable
					if (@chmod($fullpath, intval($mode, 8))) {
						// phpcs:enable
						$this->_messages[] = sprintf('%s changed to %s', $fullpath, $mode);
					} else {
						$this->_errors[] = sprintf('%s NOT changed to %s', $fullpath, $mode);
					}
				}
			}

			if (!$this->_errors) {
				return true;
			}
		}

		return false;
	}

	/**
	 * Returns an array of subdirectories for the provided or current path.
	 *
	 * @param string|null $path The directory path to get subdirectories for.
	 * @param bool $fullPath Whether to return the full path or only the directory name.
	 * @return array<string> Array of subdirectories for the provided or current path.
	 */
	public function subdirectories(?string $path = null, bool $fullPath = true): array {
		if (!$path) {
			$path = (string)$this->path;
		}
		$subdirectories = [];

		try {
			$iterator = new DirectoryIterator($path);
		} catch (Exception $e) {
			return [];
		}

		/** @var \DirectoryIterator<\SplFileInfo> $item */
		foreach ($iterator as $item) {
			if (!$item->isDir() || $item->isDot()) {
				continue;
			}
			$subdirectories[] = $fullPath ? $item->getRealPath() : $item->getFilename();
		}

		return $subdirectories;
	}

	/**
	 * Returns an array of nested directories and files in each directory
	 *
	 * @param string|null $path the directory path to build the tree from
	 * @param array<string>|bool $exceptions Either an array of files/folder to exclude
	 *   or boolean true to not grab dot files/folders
	 * @param string|null $type either 'file' or 'dir'. Null returns both files and directories
	 * @return array<mixed> Array of nested directories and files in each directory
	 */
	public function tree(?string $path = null, $exceptions = false, ?string $type = null): array {
		if (!$path) {
			$path = (string)$this->path;
		}
		$files = [];
		$directories = [$path];

		if (is_array($exceptions)) {
			$exceptions = array_flip($exceptions);
		}
		$skipHidden = false;
		if ($exceptions === true) {
			$skipHidden = true;
		} elseif (isset($exceptions['.'])) {
			$skipHidden = true;
			unset($exceptions['.']);
		}

		$directory = $iterator = null;
		try {
			$directory = new RecursiveDirectoryIterator(
				$path,
				RecursiveDirectoryIterator::KEY_AS_PATHNAME | RecursiveDirectoryIterator::CURRENT_AS_SELF,
			);
			$iterator = new RecursiveIteratorIterator($directory, RecursiveIteratorIterator::SELF_FIRST);
		} catch (Exception $e) {
			unset($directory, $iterator);

			if ($type === null) {
				return [[], []];
			}

			return [];
		}

		/**
		 * @var string $itemPath
		 * @var \RecursiveDirectoryIterator $fsIterator
		 */
		foreach ($iterator as $itemPath => $fsIterator) {
			if ($skipHidden) {
				$subPathName = $fsIterator->getSubPathname();
				if ($subPathName[0] === '.' || str_contains($subPathName, DIRECTORY_SEPARATOR . '.')) {
					unset($fsIterator);

					continue;
				}
			}
			/** @var \FilesystemIterator $item */
			$item = $fsIterator->current();
			if (!empty($exceptions) && isset($exceptions[$item->getFilename()])) {
				unset($fsIterator, $item);

				continue;
			}

			if ($item->isFile()) {
				$files[] = $itemPath;
			} elseif ($item->isDir() && !$item->isDot()) {
				$directories[] = $itemPath;
			}

			// inner iterators need to be unset too in order for locks on parents to be released
			unset($fsIterator, $item);
		}

		// unsetting iterators helps releasing possible locks in certain environments,
		// which could otherwise make `rmdir()` fail
		unset($directory, $iterator);

		if ($type === null) {
			return [$directories, $files];
		}
		if ($type === 'dir') {
			return $directories;
		}

		return $files;
	}

	/**
	 * Create a directory structure recursively.
	 *
	 * Can be used to create deep path structures like `/foo/bar/baz/shoe/horn`
	 *
	 * @param string $pathname The directory structure to create. Either an absolute or relative
	 *   path. If the path is relative and exists in the process' cwd it will not be created.
	 *   Otherwise, relative paths will be prefixed with the current pwd().
	 * @param int|null $mode octal value 0755
	 * @return bool Returns TRUE on success, FALSE on failure
	 */
	public function create(string $pathname, ?int $mode = null): bool {
		if (is_dir($pathname) || empty($pathname)) {
			return true;
		}

		if (!static::isAbsolute($pathname)) {
			$pathname = static::addPathElement((string)$this->pwd(), $pathname);
		}

		if (!$mode) {
			$mode = $this->mode;
		}

		if (is_file($pathname)) {
			$this->_errors[] = sprintf('%s is a file', $pathname);

			return false;
		}
		$pathname = rtrim($pathname, DIRECTORY_SEPARATOR);
		$nextPathname = substr($pathname, 0, (int)strrpos($pathname, DIRECTORY_SEPARATOR));

		if ($this->create($nextPathname, $mode)) {
			if (!file_exists($pathname)) {
				$old = umask(0);
				if (mkdir($pathname, $mode, true)) {
					$this->_messages[] = sprintf('%s created', $pathname);
					umask($old);

					return true;
				}
				$this->_errors[] = sprintf('%s NOT created', $pathname);
				umask($old);

				return false;
			}
		}

		return false;
	}

	/**
	 * Returns the size in bytes of this Folder and its contents.
	 *
	 * @return int size in bytes of current folder
	 */
	public function dirsize(): int {
		$size = 0;
		$directory = static::slashTerm((string)$this->path);
		$stack = [$directory];
		$count = count($stack);
		for ($i = 0, $j = $count; $i < $j; $i++) {
			if (is_file($stack[$i])) {
				$size += filesize($stack[$i]);
			} elseif (is_dir($stack[$i])) {
				$dir = dir($stack[$i]);
				if ($dir) {
					while (($entry = $dir->read()) !== false) {
						if ($entry === '.' || $entry === '..') {
							continue;
						}
						$add = $stack[$i] . $entry;

						if (is_dir($stack[$i] . $entry)) {
							$add = static::slashTerm($add);
						}
						$stack[] = $add;
					}
					$dir->close();
				}
			}
			$j = count($stack);
		}

		return $size;
	}

	/**
	 * Recursively Remove directories if the system allows.
	 *
	 * @param string|null $path Path of directory to delete
	 * @return bool Success
	 */
	public function delete(?string $path = null): bool {
		if (!$path) {
			$path = $this->pwd();
		}
		if (!$path) {
			return false;
		}
		$path = static::slashTerm($path);
		if (is_dir($path)) {
			$directory = $iterator = null;
			try {
				$directory = new RecursiveDirectoryIterator($path, RecursiveDirectoryIterator::CURRENT_AS_SELF);
				$iterator = new RecursiveIteratorIterator($directory, RecursiveIteratorIterator::CHILD_FIRST);
			} catch (Exception $e) {
				unset($directory, $iterator);

				return false;
			}

			foreach ($iterator as $item) {
				$filePath = $item->getPathname();
				if ($item->isFile() || $item->isLink()) {
					// phpcs:disable
					if (@unlink($filePath)) {
						// phpcs:enable
						$this->_messages[] = sprintf('%s removed', $filePath);
					} else {
						$this->_errors[] = sprintf('%s NOT removed', $filePath);
					}
				} elseif ($item->isDir() && !$item->isDot()) {
					// phpcs:disable
					if (@rmdir($filePath)) {
						// phpcs:enable
						$this->_messages[] = sprintf('%s removed', $filePath);
					} else {
						$this->_errors[] = sprintf('%s NOT removed', $filePath);

						unset($directory, $iterator, $item);

						return false;
					}
				}

				// inner iterators need to be unset too in order for locks on parents to be released
				unset($item);
			}

			// unsetting iterators helps releasing possible locks in certain environments,
			// which could otherwise make `rmdir()` fail
			unset($directory, $iterator);

			$path = rtrim($path, DIRECTORY_SEPARATOR);
			// phpcs:disable
			if (@rmdir($path)) {
				// phpcs:enable
				$this->_messages[] = sprintf('%s removed', $path);
			} else {
				$this->_errors[] = sprintf('%s NOT removed', $path);

				return false;
			}
		}

		return true;
	}

	/**
	 * Recursive directory copy.
	 *
	 * ### Options
	 *
	 * - `from` The directory to copy from, this will cause a cd() to occur, changing the results of pwd().
	 * - `mode` The mode to copy the files/directories with as integer, e.g. 0775.
	 * - `skip` Files/directories to skip.
	 * - `scheme` Folder::MERGE, Folder::OVERWRITE, Folder::SKIP
	 * - `recursive` Whether to copy recursively or not (default: true - recursive)
	 *
	 * @param string $to The directory to copy to.
	 * @param array<string, mixed> $options Array of options (see above).
	 * @return bool Success.
	 */
	public function copy(string $to, array $options = []): bool {
		if (!$this->pwd()) {
			return false;
		}
		$options += [
			'from' => $this->path,
			'mode' => $this->mode,
			'skip' => [],
			'scheme' => static::MERGE,
			'recursive' => true,
		];

		$fromDir = $options['from'];
		$toDir = $to;
		$mode = $options['mode'];

		if (!$this->cd($fromDir)) {
			$this->_errors[] = sprintf('%s not found', $fromDir);

			return false;
		}

		if (!is_dir($toDir)) {
			$this->create($toDir, $mode);
		}

		if (!is_writable($toDir)) {
			$this->_errors[] = sprintf('%s not writable', $toDir);

			return false;
		}

		$exceptions = array_merge(['.', '..', '.svn'], $options['skip']);
		// phpcs:disable
		if ($handle = @opendir($fromDir)) {
			// phpcs:enable
			while (($item = readdir($handle)) !== false) {
				$to = static::addPathElement($toDir, $item);
				if (($options['scheme'] !== static::SKIP || !is_dir($to)) && !in_array($item, $exceptions, true)) {
					$from = static::addPathElement($fromDir, $item);
					if (is_file($from) && (!is_file($to) || $options['scheme'] !== static::SKIP)) {
						if (copy($from, $to)) {
							chmod($to, intval($mode, 8));
							touch($to, filemtime($from) ?: null);
							$this->_messages[] = sprintf('%s copied to %s', $from, $to);
						} else {
							$this->_errors[] = sprintf('%s NOT copied to %s', $from, $to);
						}
					}

					if (is_dir($from) && file_exists($to) && $options['scheme'] === static::OVERWRITE) {
						$this->delete($to);
					}

					if (is_dir($from) && $options['recursive'] === false) {
						continue;
					}

					if (is_dir($from) && !file_exists($to)) {
						$old = umask(0);
						if (mkdir($to, $mode, true)) {
							umask($old);
							$old = umask(0);
							chmod($to, $mode);
							umask($old);
							$this->_messages[] = sprintf('%s created', $to);
							$options = ['from' => $from] + $options;
							$this->copy($to, $options);
						} else {
							$this->_errors[] = sprintf('%s not created', $to);
						}
					} elseif (is_dir($from) && $options['scheme'] === static::MERGE) {
						$options = ['from' => $from] + $options;
						$this->copy($to, $options);
					}
				}
			}
			closedir($handle);
		} else {
			return false;
		}

		return empty($this->_errors);
	}

	/**
	 * Recursive directory move.
	 *
	 * ### Options
	 *
	 * - `from` The directory to copy from, this will cause a cd() to occur, changing the results of pwd().
	 * - `mode` The mode to copy the files/directories with as integer, e.g. 0775.
	 * - `skip` Files/directories to skip.
	 * - `scheme` Folder::MERGE, Folder::OVERWRITE, Folder::SKIP
	 * - `recursive` Whether to copy recursively or not (default: true - recursive)
	 *
	 * @param string $to The directory to move to.
	 * @param array<string, mixed> $options Array of options (see above).
	 * @return bool Success
	 */
	public function move(string $to, array $options = []): bool {
		$options += ['from' => $this->path, 'mode' => $this->mode, 'skip' => [], 'recursive' => true];

		if ($this->copy($to, $options) && $this->delete($options['from'])) {
			return (bool)$this->cd($to);
		}

		return false;
	}

	/**
	 * get messages from latest method
	 *
	 * @param bool $reset Reset message stack after reading
	 * @return array<string>
	 */
	public function messages(bool $reset = true): array {
		$messages = $this->_messages;
		if ($reset) {
			$this->_messages = [];
		}

		return $messages;
	}

	/**
	 * get error from latest method
	 *
	 * @param bool $reset Reset error stack after reading
	 * @return array<string>
	 */
	public function errors(bool $reset = true): array {
		$errors = $this->_errors;
		if ($reset) {
			$this->_errors = [];
		}

		return $errors;
	}

	/**
	 * Get the real path (taking ".." and such into account)
	 *
	 * @param string $path Path to resolve
	 * @return string|false The resolved path
	 */
	public function realpath($path) {
		if (!str_contains($path, '..')) {
			if (!static::isAbsolute($path)) {
				$path = static::addPathElement((string)$this->path, $path);
			}

			return $path;
		}
		$path = str_replace('/', DIRECTORY_SEPARATOR, trim($path));
		$parts = explode(DIRECTORY_SEPARATOR, $path);
		$newparts = [];
		$newpath = '';
		if ($path[0] === DIRECTORY_SEPARATOR) {
			$newpath = DIRECTORY_SEPARATOR;
		}

		while (($part = array_shift($parts)) !== null) {
			if ($part === '.' || $part === '') {
				continue;
			}
			if ($part === '..') {
				if (!empty($newparts)) {
					array_pop($newparts);

					continue;
				}

				return false;
			}
			$newparts[] = $part;
		}
		$newpath .= implode(DIRECTORY_SEPARATOR, $newparts);

		return static::slashTerm($newpath);
	}

	/**
	 * Returns true if given $path ends in a slash (i.e. is slash-terminated).
	 *
	 * @param string $path Path to check
	 * @return bool true if path ends with slash, false otherwise
	 */
	public static function isSlashTerm(string $path): bool {
		$lastChar = $path[strlen($path) - 1];

		return $lastChar === '/' || $lastChar === '\\';
	}

}


================================================
FILE: src/Generator/Directive/BaseDirective.php
================================================
<?php

namespace IdeHelper\Generator\Directive;

use IdeHelper\ValueObject\KeyValue;
use IdeHelper\ValueObject\ValueObjectInterface;

/**
 * @see https://blog.jetbrains.com/phpstorm/2019/02/new-phpstorm-meta-php-features/
 * @method array<mixed> toArray()
 */
abstract class BaseDirective {

	/**
	 * Key for sorting inside collection.
	 *
	 * @return string
	 */
	abstract public function key();

	/**
	 * Final PHP pseudo code.
	 *
	 * @return string
	 */
	abstract public function build();

	/**
	 * @param array<string|\IdeHelper\ValueObject\ValueObjectInterface> $array
	 * @param int $indentation
	 *
	 * @return string
	 */
	protected function buildList(array $array, int $indentation = 2): string {
		$result = [];
		foreach ($array as $value) {
			if ($value instanceof ValueObjectInterface) {
				$element = (string)$value;
			} else {
				$element = $value;
			}
			$result[] = str_repeat("\t", $indentation) . $element;
		}

		$string = implode(',' . PHP_EOL, $result);
		if ($string) {
			$string .= ',';
		}

		return $string;
	}

	/**
	 * @param array<string, string|\IdeHelper\ValueObject\ValueObjectInterface> $array
	 * @param int $indentation
	 *
	 * @return string
	 */
	protected function buildKeyValueMap(array $array, int $indentation = 3): string {
		$result = [];
		foreach ($array as $alias => $value) {
			if ($value instanceof KeyValue) {
				$key = $value->key();
				$value = $value->value();
			} else {
				$key = "'" . str_replace("'", "\'", $alias) . "'";
			}
			$result[] = str_repeat("\t", $indentation) . $key . ' => ' . $value . ',';
		}

		return implode(PHP_EOL, $result);
	}

}


================================================
FILE: src/Generator/Directive/ExitPoint.php
================================================
<?php

namespace IdeHelper\Generator\Directive;

/**
 * Helps to annotate expected exit point methods.
 *
 * This is available since PhpStorm 2020.01
 *
 * ### Example
 *
 * exitPoint(\Cake\Console\ConsoleIo::abort());
 *
 * @see https://www.jetbrains.com/help/phpstorm/ide-advanced-metadata.html#define-exit-points
 */
class ExitPoint extends BaseDirective {

	/**
	 * @var string
	 */
	public const NAME = 'exitPoint';

	protected string $method;

	/**
	 * @param string $method
	 */
	public function __construct($method) {
		$this->method = $method;
	}

	/**
	 * Key for sorting inside collection.
	 *
	 * @return string
	 */
	public function key() {
		return $this->method . '@' . static::NAME;
	}

	/**
	 * @return array<string, mixed>
	 */
	public function toArray() {
		return [
			'method' => $this->method,
		];
	}

	/**
	 * @return string
	 */
	public function build() {
		$method = $this->method;

		$result = <<<TXT
	exitPoint($method);
TXT;

		return $result;
	}

}


================================================
FILE: src/Generator/Directive/ExpectedArguments.php
================================================
<?php

namespace IdeHelper\Generator\Directive;

/**
 * Helps to annotate expected method arguments.
 *
 * The position is 0-based.
 *
 * ### Example
 *
 * expectedArguments(
 *     \MyClass::addArgument(),
 *     1,
 *     \MyClass::OPTIONAL,
 *     \MyClass::REQUIRED
 * );
 *
 * or
 *
 * expectedArguments(
 *     \MyClass::getFlags(),
 *     0,
 *     argumentsSet('myFileObjectFlags')
 * );
 *
 * @see https://www.jetbrains.com/help/phpstorm/ide-advanced-metadata.html#expected-arguments
 */
class ExpectedArguments extends BaseDirective {

	/**
	 * @var string
	 */
	public const NAME = 'expectedArguments';

	protected string $method;

	protected int $position;

	/**
	 * @var array<string|\IdeHelper\ValueObject\ValueObjectInterface>
	 */
	protected array $list;

	/**
	 * @param string $method
	 * @param int $position Position, 0-based.
	 * @param array<string|\IdeHelper\ValueObject\ValueObjectInterface> $list
	 */
	public function __construct($method, $position, array $list) {
		$this->method = $method;
		$this->position = $position;
		$this->list = $list;
	}

	/**
	 * Key for sorting inside collection.
	 *
	 * @return string
	 */
	public function key() {
		return $this->method . '@' . $this->position . '@' . static::NAME;
	}

	/**
	 * @return array<string, mixed>
	 */
	public function toArray() {
		return [
			'method' => $this->method,
			'position' => $this->position,
			'list' => $this->list,
		];
	}

	/**
	 * @return string
	 */
	public function build() {
		$method = $this->method;
		$position = $this->position;

		$list = $this->buildList($this->list);
		$result = <<<TXT
	expectedArguments(
		$method,
		$position,
$list
	);
TXT;

		return $result;
	}

}


================================================
FILE: src/Generator/Directive/ExpectedReturnValues.php
================================================
<?php

namespace IdeHelper\Generator\Directive;

/**
 * Helps to annotate expected method return values.
 *
 * ### Example
 *
 * expectedReturnValues(
 *     \MyClass::addArgument(),
 *     \MyClass::SUCCESS,
 *     \MyClass::ERROR
 * );
 *
 * or
 *
 * expectedReturnValues(
 *     \MyClass::getFlags(),
 *     argumentsSet('myFileObjectFlags')
 * );
 *
 * @see https://www.jetbrains.com/help/phpstorm/ide-advanced-metadata.html#expected-return-values
 */
class ExpectedReturnValues extends BaseDirective {

	/**
	 * @var string
	 */
	public const NAME = 'expectedReturnValues';

	protected string $method;

	/**
	 * @var array<string|\IdeHelper\ValueObject\ValueObjectInterface>
	 */
	protected array $list;

	/**
	 * @param string $method
	 * @param array<string|\IdeHelper\ValueObject\ValueObjectInterface> $list
	 */
	public function __construct($method, array $list) {
		$this->method = $method;
		$this->list = $list;
	}

	/**
	 * Key for sorting inside collection.
	 *
	 * @return string
	 */
	public function key() {
		return $this->method . '@' . static::NAME;
	}

	/**
	 * @return array<string, mixed>
	 */
	public function toArray() {
		return [
			'method' => $this->method,
			'list' => $this->list,
		];
	}

	/**
	 * @return string
	 */
	public function build() {
		$method = $this->method;
		$list = $this->buildList($this->list);

		$result = <<<TXT
	expectedReturnValues(
		$method,
$list
	);
TXT;

		return $result;
	}

}


================================================
FILE: src/Generator/Directive/Override.php
================================================
<?php

namespace IdeHelper\Generator\Directive;

/**
 * Helps to annotate expected method argument and return type combinations.
 *
 * ### Example
 *
 * override(
 *     \MyClass::addArgument(0),
 *     map([,
 *         'A' => \MyClass::class,
 *         '' => '@|\Iterator',
 *     ])
 * );
 *
 * @see https://www.jetbrains.com/help/phpstorm/ide-advanced-metadata.html#override
 */
class Override extends BaseDirective {

	/**
	 * @var string
	 */
	public const NAME = 'override';

	protected string $method;

	/**
	 * @var array<string, string|\IdeHelper\ValueObject\ValueObjectInterface>
	 */
	protected array $map;

	/**
	 * @param string $method
	 * @param array<string, string|\IdeHelper\ValueObject\ValueObjectInterface> $map
	 */
	public function __construct($method, array $map) {
		$this->method = $method;
		$this->map = $map;
	}

	/**
	 * @return array<string, mixed>
	 */
	public function toArray() {
		return [
			'method' => $this->method,
			'map' => $this->map,
		];
	}

	/**
	 * Key for sorting inside collection.
	 *
	 * @return string
	 */
	public function key() {
		return $this->method . '@' . static::NAME;
	}

	/**
	 * @return string
	 */
	public function build() {
		$method = $this->method;
		$mapDefinitions = $this->buildKeyValueMap($this->map);

		$result = <<<TXT
	override(
		$method,
		map([
$mapDefinitions
		]),
	);
TXT;

		return $result;
	}

}


================================================
FILE: src/Generator/Directive/RegisterArgumentsSet.php
================================================
<?php

namespace IdeHelper\Generator\Directive;

/**
 * Helps to register an argument set to be used in other directives for DRY code.
 *
 * ### Example
 *
 * registerArgumentsSet(
 *     'mySet',
 *     \MyClass::OPTIONAL,
 *     \MyClass::REQUIRED
 * );
 *
 * Then it can be used in other places as argumentsSet('mySet').
 *
 * @see https://www.jetbrains.com/help/phpstorm/ide-advanced-metadata.html#arguments-set
 */
class RegisterArgumentsSet extends BaseDirective {

	/**
	 * @var string
	 */
	public const NAME = 'registerArgumentsSet';

	protected string $set;

	/**
	 * @var array<string|\IdeHelper\ValueObject\ValueObjectInterface>
	 */
	protected array $list;

	/**
	 * @param string $set
	 * @param array<string|\IdeHelper\ValueObject\ValueObjectInterface> $list
	 */
	public function __construct($set, array $list) {
		$this->set = $set;
		$this->list = $list;
	}

	/**
	 * Key for sorting inside collection.
	 *
	 * @return string
	 */
	public function key() {
		return $this->set . '@' . static::NAME;
	}

	/**
	 * @return array<string, mixed>
	 */
	public function toArray() {
		return [
			'set' => $this->set,
			'list' => $this->list,
		];
	}

	/**
	 * @return string
	 */
	public function build() {
		$set = "'" . $this->set . "'";
		$list = $this->buildList($this->list);

		$result = <<<TXT
	registerArgumentsSet(
		$set,
$list
	);
TXT;

		return $result;
	}

	/**
	 * @return string
	 */
	public function __toString() {
		return 'argumentsSet(\'' . $this->set . '\')';
	}

}


================================================
FILE: src/Generator/GeneratorInterface.php
================================================
<?php

namespace IdeHelper\Generator;

interface GeneratorInterface {

	/**
	 * @return string
	 */
	public function generate(): string;

}


================================================
FILE: src/Generator/PhpstormGenerator.php
================================================
<?php

namespace IdeHelper\Generator;

use IdeHelper\Console\Io;
use IdeHelper\Generator\Directive\RegisterArgumentsSet;

class PhpstormGenerator implements GeneratorInterface {

	protected TaskCollection $taskCollection;

	protected ?Io $io = null;

	/**
	 * @param \IdeHelper\Generator\TaskCollection $taskCollection
	 * @param \IdeHelper\Console\Io|null $io
	 */
	public function __construct(TaskCollection $taskCollection, ?Io $io = null) {
		$this->taskCollection = $taskCollection;
		$this->io = $io;
	}

	/**
	 * @return string
	 */
	public function generate(): string {
		$map = $this->taskCollection->getMap();

		$this->outputSetInfo($map);

		return $this->build($map);
	}

	/**
	 * @param array<\IdeHelper\Generator\Directive\BaseDirective> $map
	 *
	 * @return string
	 */
	protected function build(array $map): string {
		$overrides = [];
		foreach ($map as $directive) {
			$overrides[] = $directive->build();
		}
		$overrides = implode(PHP_EOL . PHP_EOL, $overrides);

		$template = <<<TXT
<?php
// @link https://confluence.jetbrains.com/display/PhpStorm/PhpStorm+Advanced+Metadata
namespace PHPSTORM_META {

$overrides

}

TXT;

		return $template;
	}

	/**
	 * @param array<\IdeHelper\Generator\Directive\BaseDirective> $map
	 *
	 * @return void
	 */
	protected function outputSetInfo(array $map): void {
		if (!$this->io) {
			return;
		}

		$sets = [];
		foreach ($map as $directive) {
			if ($directive instanceof RegisterArgumentsSet) {
				$sets[] = $directive->toArray()['set'];
			}
		}

		$this->io->verbose('The following sets are available for re-use:');
		foreach ($sets as $set) {
			$this->io->verbose('- ' . $set);
		}
	}

}


================================================
FILE: src/Generator/Task/BehaviorTask.php
================================================
<?php

namespace IdeHelper\Generator\Task;

use Cake\ORM\Table;
use IdeHelper\Filesystem\Folder;
use IdeHelper\Generator\Directive\ExpectedArguments;
use IdeHelper\Generator\Directive\Override;
use IdeHelper\Utility\App;
use IdeHelper\Utility\AppPath;
use IdeHelper\Utility\Plugin;
use IdeHelper\ValueObject\ClassName;
use IdeHelper\ValueObject\StringName;

class BehaviorTask implements TaskInterface {

	public const CLASS_TABLE = Table::class;

	/**
	 * @var array<string, int>
	 */
	protected array $addAliases = [
		'\\' . self::CLASS_TABLE . '::addBehavior()' => 0,
	];

	/**
	 * @var array<string, int>
	 */
	protected array $removeAliases = [
		'\\' . self::CLASS_TABLE . '::removeBehavior()' => 0,
	];

	/**
	 * @var array<string, int>
	 */
	protected array $hasAliases = [
		'\\' . self::CLASS_TABLE . '::hasBehavior()' => 0,
	];

	/**
	 * @var array<string>
	 */
	protected array $getAliases = [
		'\\' . self::CLASS_TABLE . '::getBehavior()',
	];

	/**
	 * @return array<string, \IdeHelper\Generator\Directive\BaseDirective>
	 */
	public function collect(): array {
		$prefixedList = $nonPrefixedList = [];
		$behaviors = $this->collectBehaviors();
		foreach ($behaviors as $name => $className) {
			$prefixedList[$name] = StringName::create($name);
			if (str_contains($name, '.')) {
				[, $name] = pluginSplit($name);
			}
			$nonPrefixedList[$name] = StringName::create($name);
		}

		ksort($prefixedList);
		ksort($nonPrefixedList);

		$result = [];
		foreach ($this->addAliases as $alias => $position) {
			$directive = new ExpectedArguments($alias, $position, $prefixedList);
			$result[$directive->key()] = $directive;
		}
		foreach ($this->removeAliases as $alias => $position) {
			$directive = new ExpectedArguments($alias, $position, $nonPrefixedList);
			$result[$directive->key()] = $directive;
		}
		foreach ($this->hasAliases as $alias => $position) {
			$directive = new ExpectedArguments($alias, $position, $nonPrefixedList);
			$result[$directive->key()] = $directive;
		}
		foreach ($this->getAliases as $alias) {
			$map = [];
			foreach ($behaviors as $name => $className) {
				if (str_contains($name, '.')) {
					[, $name] = pluginSplit($name);
				}
				$map[$name] = ClassName::create($className);
			}

			ksort($map);

			$directive = new Override($alias, $map);
			$result[$directive->key()] = $directive;
		}

		return $result;
	}

	/**
	 * @return array<string>
	 */
	protected function collectBehaviors(): array {
		$behaviors = [];

		$folders = array_merge(App::core('ORM/Behavior'), AppPath::get('Model/Behavior'));
		foreach ($folders as $folder) {
			$behaviors = $this->addBehaviors($behaviors, $folder);
		}

		$plugins = Plugin::all();
		foreach ($plugins as $plugin) {
			$folders = AppPath::get('Model/Behavior', $plugin);
			foreach ($folders as $folder) {
				$behaviors = $this->addBehaviors($behaviors, $folder, $plugin);
			}
		}

		ksort($behaviors);

		return $behaviors;
	}

	/**
	 * @param array<string, string> $behaviors
	 * @param string $folder
	 * @param string|null $plugin
	 *
	 * @return array<string, string>
	 */
	protected function addBehaviors(array $behaviors, string $folder, ?string $plugin = null): array {
		$folderContent = (new Folder($folder))->read(Folder::SORT_NAME, true);

		foreach ($folderContent[1] as $file) {
			preg_match('/^(.+)Behavior\.php$/', $file, $matches);
			if (!$matches) {
				continue;
			}
			$fullName = $matches[1];
			$name = $fullName;
			if ($plugin) {
				$name = $plugin . '.' . $fullName;
			}

			$className = App::className($name, 'Model/Behavior', 'Behavior');
			if (!$className) {
				$className = "Cake\ORM\Behavior\\{$name}Behavior";
			}

			$behaviors[$name] = $className;
		}

		return $behaviors;
	}

}


================================================
FILE: src/Generator/Task/CacheTask.php
================================================
<?php

namespace IdeHelper\Generator\Task;

use Cake\Cache\Cache;
use IdeHelper\Generator\Directive\ExpectedArguments;
use IdeHelper\Generator\Directive\RegisterArgumentsSet;
use IdeHelper\ValueObject\StringName;

class CacheTask implements TaskInterface {

	public const CLASS_CACHE = Cache::class;

	/**
	 * @var string
	 */
	public const SET_CACHE_ENGINES = 'cacheEngines';

	/**
	 * @var array<int>
	 */
	protected array $aliases = [
		'\\' . self::CLASS_CACHE . '::clear()' => 0,
		'\\' . self::CLASS_CACHE . '::read()' => 1,
		'\\' . self::CLASS_CACHE . '::readMany()' => 1,
		'\\' . self::CLASS_CACHE . '::delete()' => 1,
		'\\' . self::CLASS_CACHE . '::deleteMany()' => 1,
		'\\' . self::CLASS_CACHE . '::clearGroup()' => 1,
		'\\' . self::CLASS_CACHE . '::add()' => 2,
		'\\' . self::CLASS_CACHE . '::write()' => 2,
		'\\' . self::CLASS_CACHE . '::increment()' => 2,
		'\\' . self::CLASS_CACHE . '::decrement()' => 2,
		'\\' . self::CLASS_CACHE . '::remember()' => 2,
	];

	/**
	 * @return array<string, \IdeHelper\Generator\Directive\BaseDirective>
	 */
	public function collect(): array {
		$result = [];

		$list = $this->collectCacheEngines();
		$registerArgumentsSet = new RegisterArgumentsSet(static::SET_CACHE_ENGINES, $list);
		$result[$registerArgumentsSet->key()] = $registerArgumentsSet;

		foreach ($this->aliases as $alias => $position) {
			$directive = new ExpectedArguments($alias, $position, [$registerArgumentsSet]);
			$result[$directive->key()] = $directive;
		}

		return $result;
	}

	/**
	 * @return array<\IdeHelper\ValueObject\StringName>
	 */
	protected function collectCacheEngines(): array {
		$cacheEngines = Cache::configured();

		$result = [];
		foreach ($cacheEngines as $cacheEngine) {
			$result[$cacheEngine] = StringName::create($cacheEngine);
		}

		ksort($result);

		return $result;
	}

}


================================================
FILE: src/Generator/Task/CellTask.php
================================================
<?php

namespace IdeHelper\Generator\Task;

use Cake\View\Cell;
use Cake\View\CellTrait;
use IdeHelper\Filesystem\Folder;
use IdeHelper\Generator\Directive\Override;
use IdeHelper\Utility\App;
use IdeHelper\Utility\AppPath;
use IdeHelper\Utility\Plugin;
use IdeHelper\ValueObject\ClassName;

class CellTask implements TaskInterface {

	public const CLASS_CELL = CellTrait::class;

	protected static string $alias = '\\' . self::CLASS_CELL . '::cell()';

	/**
	 * @return array<string, \IdeHelper\Generator\Directive\BaseDirective>
	 */
	public function collect(): array {
		$map = [];

		$cells = $this->collectCells();
		foreach ($cells as $name => $className) {
			$map[$name] = ClassName::create($className);
		}

		ksort($map);

		$result = [];
		if ($map) {
			$directive = new Override(static::$alias, $map);
			$result[$directive->key()] = $directive;
		}

		return $result;
	}

	/**
	 * @return array<string>
	 */
	protected function collectCells(): array {
		$cells = [];

		$folders = AppPath::get('View/Cell');
		foreach ($folders as $folder) {
			$cells = $this->addCells($cells, $folder);
		}

		$plugins = Plugin::all();
		foreach ($plugins as $plugin) {
			$folders = AppPath::get('View/Cell', $plugin);
			foreach ($folders as $folder) {
				$cells = $this->addCells($cells, $folder, $plugin);
			}
		}

		return $cells;
	}

	/**
	 * @param array<string> $components
	 * @param string $folder
	 * @param string|null $plugin
	 *
	 * @return array<string>
	 */
	protected function addCells(array $components, $folder, $plugin = null) {
		$folderContent = (new Folder($folder))->read(Folder::SORT_NAME, true);

		foreach ($folderContent[1] as $file) {
			preg_match('/^(.+)Cell\.php$/', $file, $matches);
			if (!$matches) {
				continue;
			}
			$name = $matches[1];
			if ($plugin) {
				$name = $plugin . '.' . $name;
			}

			$className = App::className($name, 'View/Cell', 'Cell');
			if (!$className) {
				continue;
			}

			$methods = get_class_methods($className);
			$defaultCellMethods = get_class_methods(Cell::class);

			foreach ($methods as $method) {
				if (!in_array($method, $defaultCellMethods, true)) {
					$components[$name . '::' . $method] = $className;
				}
			}

			unset($components[$name . '::display']);
			$components[$name] = $className;
		}

		return $components;
	}

}


================================================
FILE: src/Generator/Task/ComponentTask.php
================================================
<?php

namespace IdeHelper\Generator\Task;

use Cake\Controller\ComponentRegistry;
use Cake\Controller\Controller;
use IdeHelper\Filesystem\Folder;
use IdeHelper\Generator\Directive\ExpectedArguments;
use IdeHelper\Generator\Directive\Override;
use IdeHelper\Utility\App;
use IdeHelper\Utility\AppPath;
use IdeHelper\Utility\Plugin;
use IdeHelper\ValueObject\ClassName;
use IdeHelper\ValueObject\StringName;

class ComponentTask implements TaskInterface {

	public const CLASS_CONTROLLER = Controller::class;
	public const CLASS_COMPONENT_REGISTRY = ComponentRegistry::class;

	/**
	 * @var array<string>
	 */
	protected array $loadAliases = [
		'\\' . self::CLASS_CONTROLLER . '::loadComponent(0)',
	];

	/**
	 * @var array<string, int>
	 */
	protected array $unloadAliases = [
		'\\' . self::CLASS_COMPONENT_REGISTRY . '::unload()' => 0,
	];

	/**
	 * @return array<string, \IdeHelper\Generator\Directive\BaseDirective>
	 */
	public function collect(): array {
		$addMap = [];
		$removeList = [];

		$components = $this->collectComponents();
		foreach ($components as $name => $className) {
			$addMap[$name] = ClassName::create($className);
			if (str_contains($name, '.')) {
				[, $name] = pluginSplit($name);
			}
			$removeList[$name] = StringName::create($name);
		}

		ksort($addMap);
		ksort($removeList);

		$result = [];
		foreach ($this->loadAliases as $alias) {
			$directive = new Override($alias, $addMap);
			$result[$directive->key()] = $directive;
		}
		foreach ($this->unloadAliases as $alias => $position) {
			$directive = new ExpectedArguments($alias, $position, $removeList);
			$result[$directive->key()] = $directive;
		}

		return $result;
	}

	/**
	 * @return array<string>
	 */
	protected function collectComponents(): array {
		$components = [];

		$folders = array_merge(App::core('Controller/Component'), AppPath::get('Controller/Component'));
		foreach ($folders as $folder) {
			$components = $this->addComponents($components, $folder);
		}

		$plugins = Plugin::all();
		foreach ($plugins as $plugin) {
			$folders = AppPath::get('Controller/Component', $plugin);
			foreach ($folders as $folder) {
				$components = $this->addComponents($components, $folder, $plugin);
			}
		}

		return $components;
	}

	/**
	 * @param array<string> $components
	 * @param string $folder
	 * @param string|null $plugin
	 *
	 * @return array<string>
	 */
	protected function addComponents(array $components, $folder, $plugin = null) {
		$folderContent = (new Folder($folder))->read(Folder::SORT_NAME, true);

		foreach ($folderContent[1] as $file) {
			preg_match('/^(.+)Component\.php$/', $file, $matches);
			if (!$matches) {
				continue;
			}
			$name = $matches[1];
			if ($plugin) {
				$name = $plugin . '.' . $name;
			}

			$className = App::className($name, 'Controller/Component', 'Component');
			if (!$className) {
				continue;
			}

			$components[$name] = $className;
		}

		return $components;
	}

}


================================================
FILE: src/Generator/Task/ConfigureTask.php
================================================
<?php

namespace IdeHelper\Generator\Task;

use Cake\Core\Configure;
use IdeHelper\Generator\Directive\ExpectedArguments;
use IdeHelper\Generator\Directive\RegisterArgumentsSet;
use IdeHelper\ValueObject\StringName;

class ConfigureTask implements TaskInterface {

	public const CLASS_CONFIGURE = Configure::class;

	/**
	 * @var string
	 */
	public const SET_CONFIGURE_KEYS = 'configureKeys';

	/**
	 * @var array<int>
	 */
	protected array $methods = [
		'\\' . self::CLASS_CONFIGURE . '::read()' => 0,
		'\\' . self::CLASS_CONFIGURE . '::readOrFail()' => 0,
		'\\' . self::CLASS_CONFIGURE . '::check()' => 0,
		'\\' . self::CLASS_CONFIGURE . '::write()' => 0,
		'\\' . self::CLASS_CONFIGURE . '::delete()' => 0,
		'\\' . self::CLASS_CONFIGURE . '::consume()' => 0,
		'\\' . self::CLASS_CONFIGURE . '::consumeOrFail()' => 0,
	];

	/**
	 * @return array<string, \IdeHelper\Generator\Directive\BaseDirective>
	 */
	public function collect(): array {
		$result = [];

		$list = $this->collectKeys();
		$registerArgumentsSet = new RegisterArgumentsSet(static::SET_CONFIGURE_KEYS, $list);
		$result[$registerArgumentsSet->key()] = $registerArgumentsSet;

		foreach ($this->methods as $method => $position) {
			$directive = new ExpectedArguments($method, $position, [$registerArgumentsSet]);
			$result[$directive->key()] = $directive;
		}

		return $result;
	}

	/**
	 * @return array<string>
	 */
	protected function collectKeys(): array {
		$keys = [];

		$configure = (array)Configure::read();
		$keys = $this->addKeys($keys, $configure);

		ksort($keys);

		return $keys;
	}

	/**
	 * @param array<string, mixed> $keys
	 * @param array<mixed> $data
	 * @param array<string> $path
	 *
	 * @return array<string, mixed>
	 */
	protected function addKeys(array $keys, array $data, array $path = []): array {
		foreach ($data as $key => $row) {
			if (is_numeric($key)) {
				continue;
			}

			$subPath = $path;
			$subPath[] = $key;
			$subPathString = implode('.', $subPath);

			$keys[$subPathString] = StringName::create($subPathString);

			if (!is_array($row)) {
				continue;
			}

			$keys = $this->addKeys($keys, $row, $subPath);
		}

		return $keys;
	}

}


================================================
FILE: src/Generator/Task/ConnectionTask.php
================================================
<?php

namespace IdeHelper\Generator\Task;

use Cake\Datasource\ConnectionManager;
use IdeHelper\Generator\Directive\ExpectedArguments;
use IdeHelper\ValueObject\StringName;

class ConnectionTask implements TaskInterface {

	/**
	 * @var string
	 */
	protected const METHOD_GET = '\\' . ConnectionManager::class . '::get()';

	/**
	 * @return array<string, \IdeHelper\Generator\Directive\BaseDirective>
	 */
	public function collect(): array {
		$result = [];

		$keys = $this->connectionKeys();

		ksort($keys);

		$directive = new ExpectedArguments(static::METHOD_GET, 0, $keys);
		$result[$directive->key()] = $directive;

		return $result;
	}

	/**
	 * @return array<\IdeHelper\ValueObject\StringName>
	 */
	protected function connectionKeys(): array {
		$configured = ConnectionManager::configured();

		$list = [];
		foreach ($configured as $key) {
			$list[$key] = StringName::create($key);
		}

		return $list;
	}

}


================================================
FILE: src/Generator/Task/ConsoleHelperTask.php
================================================
<?php

namespace IdeHelper\Generator\Task;

use Cake\Console\ConsoleIo;
use IdeHelper\Filesystem\Folder;
use IdeHelper\Generator\Directive\Override;
use IdeHelper\Utility\App;
use IdeHelper\Utility\AppPath;
use IdeHelper\Utility\Plugin;
use IdeHelper\ValueObject\ClassName;

class ConsoleHelperTask implements TaskInterface {

	public const CLASS_CONSOLE_IO = ConsoleIo::class;

	/**
	 * @var array<string>
	 */
	protected array $loadAliases = [
		'\\' . self::CLASS_CONSOLE_IO . '::helper(0)',
	];

	/**
	 * @return array<string, \IdeHelper\Generator\Directive\BaseDirective>
	 */
	public function collect(): array {
		$addMap = [];

		$components = $this->collectHelpers();
		foreach ($components as $name => $className) {
			$addMap[$name] = ClassName::create($className);
			if (str_contains($name, '.')) {
				[, $name] = pluginSplit($name);
			}
		}

		ksort($addMap);

		$result = [];
		foreach ($this->loadAliases as $alias) {
			$directive = new Override($alias, $addMap);
			$result[$directive->key()] = $directive;
		}

		return $result;
	}

	/**
	 * @return array<string>
	 */
	protected function collectHelpers(): array {
		$helpers = [];

		$folders = array_merge(App::core('Command/Helper'), AppPath::get('Command/Helper'));
		foreach ($folders as $folder) {
			$helpers = $this->addHelpers($helpers, $folder);
		}

		$plugins = Plugin::all();
		foreach ($plugins as $plugin) {
			$folders = AppPath::get('Command/Helper', $plugin);
			foreach ($folders as $folder) {
				$helpers = $this->addHelpers($helpers, $folder, $plugin);
			}
		}

		return $helpers;
	}

	/**
	 * @param array<string> $helpers
	 * @param string $folder
	 * @param string|null $plugin
	 *
	 * @return array<string>
	 */
	protected function addHelpers(array $helpers, $folder, $plugin = null) {
		$folderContent = (new Folder($folder))->read(Folder::SORT_NAME, true);

		foreach ($folderContent[1] as $file) {
			preg_match('/^(.+)Helper\.php$/', $file, $matches);
			if (!$matches) {
				continue;
			}
			$name = $matches[1];
			if ($plugin) {
				$name = $plugin . '.' . $name;
			}

			$className = App::className($name, 'Command/Helper', 'Helper');
			if (!$className) {
				continue;
			}

			$helpers[$name] = $className;
		}

		return $helpers;
	}

}


================================================
FILE: src/Generator/Task/ConsoleTask.php
================================================
<?php

namespace IdeHelper\Generator\Task;

use Cake\Console\ConsoleIo;
use IdeHelper\Generator\Directive\ExitPoint;

class ConsoleTask implements TaskInterface {

	/**
	 * @var string
	 */
	protected const METHOD_ABORT = '\\' . ConsoleIo::class . '::abort()';

	/**
	 * @return array<string, \IdeHelper\Generator\Directive\BaseDirective>
	 */
	public function collect(): array {
		$result = [];

		$directive = new ExitPoint(static::METHOD_ABORT);
		$result[$directive->key()] = $directive;

		return $result;
	}

}


================================================
FILE: src/Generator/Task/DatabaseTableColumnNameTask.php
================================================
<?php

namespace IdeHelper\Generator\Task;

use Cake\Datasource\ConnectionManager;
use IdeHelper\Generator\Directive\ExpectedArguments;
use IdeHelper\Generator\Directive\RegisterArgumentsSet;
use IdeHelper\ValueObject\StringName;

/**
 * This task is useful when using Migrations plugin and creating Migration files.
 */
class DatabaseTableColumnNameTask extends DatabaseTableTask {

	/**
	 * @var string
	 */
	public const SET_COLUMN_NAMES = 'columnNames';

	/**
	 * @var array<string>
	 */
	protected array $aliases = [
		'\Migrations\Db\Table::addColumn()',
		'\Migrations\Db\Table::changeColumn()',
		'\Migrations\Db\Table::removeColumn()',
		'\Migrations\Db\Table::renameColumn()',
		'\Migrations\Db\Table::hasColumn()',
	];

	/**
	 * @return array<string, \IdeHelper\Generator\Directive\BaseDirective>
	 */
	public function collect(): array {
		$list = [];

		$names = $this->collectTableColumnNames();
		foreach ($names as $type) {
			$list[$type] = StringName::create($type);
		}

		ksort($list);

		$result = [];
		$registerArgumentsSet = new RegisterArgumentsSet(static::SET_COLUMN_NAMES, $list);
		$result[$registerArgumentsSet->key()] = $registerArgumentsSet;

		foreach ($this->aliases as $alias) {
			$directive = new ExpectedArguments($alias, 0, [$registerArgumentsSet]);
			$result[$directive->key()] = $directive;
		}

		$directive = new ExpectedArguments('\Migrations\Db\Table::renameColumn()', 1, [$registerArgumentsSet]);
		$result[$directive->key()] = $directive;

		return $result;
	}

	/**
	 * @return array<string>
	 */
	protected function collectTableColumnNames(): array {
		$schema = $this->getConnection()->getSchemaCollection();

		$tables = $this->collectTables();

		$columns = [];
		foreach ($tables as $table) {
			$tableSchema = $schema->describe($table);
			$columns = array_merge($columns, $tableSchema->columns());
		}

		return array_unique($columns);
	}

	/**
	 * @param string $name
	 *
	 * @return \Cake\Database\Connection
	 */
	protected function getConnection(string $name = 'default') {
		/** @var \Cake\Database\Connection $connection */
		$connection = ConnectionManager::get($name);

		return $connection;
	}

}


================================================
FILE: src/Generator/Task/DatabaseTableColumnTypeTask.php
================================================
<?php

namespace IdeHelper\Generator\Task;

use Cake\Core\Plugin;
use Cake\Datasource\ConnectionManager;
use IdeHelper\Generator\Directive\ExpectedArguments;
use IdeHelper\Generator\Directive\RegisterArgumentsSet;
use IdeHelper\ValueObject\StringName;
use Migrations\Db\Adapter\AdapterFactory;
use Migrations\Db\Adapter\AdapterInterface;
use Migrations\Migrations;
use Phinx\Db\Adapter\AdapterInterface as PhinxAdapterInterface;

/**
 * This task is useful when using Migrations plugin and creating Migration files.
 */
class DatabaseTableColumnTypeTask implements TaskInterface {

	/**
	 * @var string
	 */
	public const SET_COLUMN_TYPES = 'columnTypes';

	/**
	 * @var array<string>
	 */
	protected array $aliases = [
		'\Migrations\Db\Table::addColumn()',
		'\Migrations\Db\Table::changeColumn()',
	];

	/**
	 * Used if the Migrations plugin is not loaded
	 *
	 * @var array<string>
	 */
	protected array $defaultTypes = [
		'string',
		'char',
		'text',
		'integer',
		'smallinteger',
		'biginteger',
		'bit',
		'float',
		'decimal',
		'double',
		'datetime',
		'timestamp',
		'time',
		'date',
		'blob',
		'binary',
		'boolean',
		'uuid',
		'year',
		'json',
		'binaryuuid',
	];

	/**
	 * @return array<string, \IdeHelper\Generator\Directive\BaseDirective>
	 */
	public function collect(): array {
		$list = [];

		$types = $this->collectTableColumnTypes();
		foreach ($types as $type) {
			$list[$type] = StringName::create($type);
		}

		ksort($list);

		$result = [];
		$registerArgumentsSet = new RegisterArgumentsSet(static::SET_COLUMN_TYPES, $list);
		$result[$registerArgumentsSet->key()] = $registerArgumentsSet;

		foreach ($this->aliases as $alias) {
			$directive = new ExpectedArguments($alias, 1, [$registerArgumentsSet]);
			$result[$directive->key()] = $directive;
		}

		return $result;
	}

	/**
	 * @return array<string>
	 */
	protected function collectTableColumnTypes(): array {
		if (!Plugin::isLoaded('Migrations')) {
			return $this->defaultTypes;
		}

		$adapter = $this->getAdapter();

		return $adapter->getColumnTypes();
	}

	/**
	 * @param string $name
	 *
	 * @return \Phinx\Db\Adapter\AdapterInterface|\Migrations\Db\Adapter\AdapterInterface
	 */
	protected function getAdapter(string $name = 'default') {
		// Migrations v5+ (no Phinx)
		if (class_exists('Migrations\Db\Adapter\AdapterFactory')) {
			return $this->getAdapterV5($name);
		}

		// Migrations v4 (Phinx-based)
		return $this->getAdapterV4($name);
	}

	/**
	 * @param string $name
	 *
	 * @return \Migrations\Db\Adapter\AdapterInterface
	 */
	protected function getAdapterV5(string $name): AdapterInterface {
		/** @var \Cake\Database\Connection $connection */
		$connection = ConnectionManager::get($name);
		$driver = $connection->getDriver();
		$driverClass = get_class($driver);
		$driverName = strtolower(substr((string)strrchr($driverClass, '\\'), 1));

		$config = $connection->config();
		$database = $config['database'] ?? null;

		$factory = AdapterFactory::instance();

		return $factory->getAdapter($driverName, [
			'adapter' => $driverName,
			'connection' => $connection,
			'database' => $database,
		]);
	}

	/**
	 * @deprecated Will be removed in a future version
	 *
	 * @param string $name
	 *
	 * @return \Phinx\Db\Adapter\AdapterInterface
	 */
	protected function getAdapterV4(string $name): PhinxAdapterInterface {
		$params = [
			'connection' => $name,
		];

		$migrations = new Migrations();
		$input = $migrations->getInput('Migrate', [], $params);
		$migrations->setInput($input);
		$manager = $migrations->getManager($migrations->getConfig());

		$env = $manager->getEnvironment('default');

		return $env->getAdapter();
	}

}


================================================
FILE: src/Generator/Task/DatabaseTableTask.php
================================================
<?php

namespace IdeHelper\Generator\Task;

use Bake\Utility\TableScanner;
use Cake\Core\Configure;
use Cake\Datasource\ConnectionManager;
use IdeHelper\Generator\Directive\ExpectedArguments;
use IdeHelper\Generator\Directive\RegisterArgumentsSet;
use IdeHelper\ValueObject\StringName;
use Throwable;

/**
 * This task is useful when using Migrations plugin and creating Migration files.
 */
class DatabaseTableTask implements TaskInterface {

	/**
	 * @var string
	 */
	public const SET_TABLE_NAMES = 'tableNames';

	/**
	 * @var array<string>|null
	 */
	protected static ?array $tables = null;

	/**
	 * @var array<string>
	 */
	protected array $aliases = [
		'\Migrations\BaseMigration::table()',
		'\Migrations\BaseMigration::hasTable()',
		'\Migrations\BaseSeed::table()',
		'\Migrations\BaseSeed::hasTable()',
	];

	/**
	 * @return array<string, \IdeHelper\Generator\Directive\BaseDirective>
	 */
	public function collect(): array {
		$list = [];

		$tables = $this->collectTables();
		foreach ($tables as $table) {
			$list[$table] = StringName::create($table);
		}

		$result = [];

		ksort($list);
		$registerArgumentsSet = new RegisterArgumentsSet(static::SET_TABLE_NAMES, $list);
		$result[$registerArgumentsSet->key()] = $registerArgumentsSet;

		foreach ($this->aliases as $alias) {
			$directive = new ExpectedArguments($alias, 0, [$registerArgumentsSet]);
			$result[$directive->key()] = $directive;
		}

		return $result;
	}

	/**
	 * @return array<string>
	 */
	protected function collectTables(): array {
		if (static::$tables !== null) {
			$tables = static::$tables;
		} else {
			$db = $this->getConnection();
			try {
				/** @var array<string>|null $ignore */
				$ignore = Configure::read('IdeHelper.ignoreDatabaseTables');
				$tables = (new TableScanner($db, $ignore))->listUnskipped();
			} catch (Throwable $exception) {
				$tables = [];
			}
			static::$tables = $tables;
		}

		$blacklist = (array)Configure::read('IdeHelper.skipDatabaseTables');
		foreach ($tables as $key => $table) {
			foreach ($blacklist as $regex) {
				if (preg_match($regex, $table)) {
					unset($tables[$key]);
				}
			}
		}

		return $tables;
	}

	/**
	 * @param string $name
	 *
	 * @return \Cake\Database\Connection
	 */
	protected function getConnection(string $name = 'default') {
		/** @var \Cake\Database\Connection $connection */
		$connection = ConnectionManager::get($name);

		return $connection;
	}

}


================================================
FILE: src/Generator/Task/DatabaseTypeTask.php
================================================
<?php

namespace IdeHelper\Generator\Task;

use Cake\Database\TypeFactory;
use IdeHelper\Generator\Directive\ExpectedArguments;
use IdeHelper\Generator\Directive\Override;
use IdeHelper\ValueObject\ClassName;
use IdeHelper\ValueObject\StringName;
use Throwable;

/**
 * For Database TypeFactory calls around column types.
 */
class DatabaseTypeTask implements TaskInterface {

	public const CLASS_TYPE = TypeFactory::class;

	/**
	 * @return array<string, \IdeHelper\Generator\Directive\BaseDirective>
	 */
	public function collect(): array {
		$result = [];

		$types = $this->getTypes();

		$map = [];
		foreach ($types as $type => $className) {
			$map[$type] = ClassName::create($className);
		}
		ksort($map);

		$method = '\\' . static::CLASS_TYPE . '::build(0)';
		$directive = new Override($method, $map);
		$result[$directive->key()] = $directive;

		$list = [];
		foreach ($types as $type => $className) {
			$list[$type] = StringName::create($type);
		}
		ksort($list);

		$method = '\\' . static::CLASS_TYPE . '::map()';
		$directive = new ExpectedArguments($method, 0, $list);
		$result[$directive->key()] = $directive;

		return $result;
	}

	/**
	 * @return array<string>
	 */
	protected function getTypes(): array {
		$types = [];

		try {
			$allTypes = TypeFactory::buildAll();
		} catch (Throwable $exception) {
			return $types;
		}

		foreach ($allTypes as $key => $type) {
			if (str_starts_with($key, 'enum-')) {
				continue;
			}

			$types[$key] = get_class($type);
		}

		ksort($types);

		return $types;
	}

}


================================================
FILE: src/Generator/Task/ElementTask.php
================================================
<?php

namespace IdeHelper\Generator\Task;

use Cake\Core\App;
use Cake\View\View;
use IdeHelper\Generator\Directive\ExpectedArguments;
use IdeHelper\Utility\Plugin;
use IdeHelper\ValueObject\StringName;
use RecursiveDirectoryIterator;
use RecursiveIteratorIterator;
use RecursiveRegexIterator;
use RegexIterator;

class ElementTask implements TaskInterface {

	public const CLASS_VIEW = View::class;

	/**
	 * @return array<string, \IdeHelper\Generator\Directive\BaseDirective>
	 */
	public function collect(): array {
		$result = [];

		$elements = $this->collectElements();
		$list = [];
		foreach ($elements as $element) {
			$list[$element] = StringName::create($element);
		}

		ksort($list);

		$method = '\\' . static::CLASS_VIEW . '::element()';
		$directive = new ExpectedArguments($method, 0, $list);
		$result[$directive->key()] = $directive;

		return $result;
	}

	/**
	 * @return array<string>
	 */
	protected function collectElements(): array {
		$paths = App::path('templates');

		$result = [];
		$result = $this->addElements($result, $paths);

		$plugins = Plugin::all();
		foreach ($plugins as $plugin) {
			$paths = App::path('templates', $plugin);
			$result = $this->addElements($result, $paths, $plugin);
		}

		sort($result);

		return $result;
	}

	/**
	 * @param array<string> $result
	 * @param array<string> $paths
	 * @param string|null $plugin
	 *
	 * @return array<string>
	 */
	protected function addElements(array $result, array $paths, ?string $plugin = null): array {
		foreach ($paths as $path) {
			$path .= 'element' . DS;
			if (!is_dir($path)) {
				continue;
			}

			$Directory = new RecursiveDirectoryIterator($path);
			$Iterator = new RecursiveIteratorIterator($Directory);
			$Regex = new RegexIterator($Iterator, '/^.+\.php$/i', RecursiveRegexIterator::GET_MATCH);

			foreach ($Regex as $file) {
				$name = str_replace($path, '', $file[0]);
				$name = substr($name, 0, -4);
				$name = str_replace(DS, '/', $name);
				if ($plugin) {
					$name = $plugin . '.' . $name;
				}
				$result[] = $name;
			}
		}

		return $result;
	}

}


================================================
FILE: src/Generator/Task/EntityTask.php
================================================
<?php

namespace IdeHelper\Generator\Task;

use Cake\ORM\Table;
use IdeHelper\Generator\Directive\ExpectedArguments;
use IdeHelper\Generator\Directive\RegisterArgumentsSet;
use IdeHelper\ValueObject\StringName;
use Throwable;

class EntityTask extends ModelTask {

	/**
	 * @var string
	 */
	public const SET_ENTITY_FIELDS = 'entityFields';

	/**
	 * @var array<int> array<string, int>
	 */
	public static array $methods = [
		'has' => 0,
		'get' => 0,
		'hasValue' => 0,
		'isEmpty' => 0,
		'isDirty' => 0,
		'getOriginal' => 0,
		'setDirty' => 0,
		'setError' => 0,
		'getError' => 0,
		'getInvalidField' => 0,
	];

	/**
	 * @return array<string, \IdeHelper\Generator\Directive\BaseDirective>
	 */
	public function collect(): array {
		$fields = $this->getEntityFields();

		$result = [];
		foreach ($fields as $entityClass => $entityFields) {
			$registerArgumentsSet = new RegisterArgumentsSet(static::SET_ENTITY_FIELDS . ':' . $entityClass, $entityFields);
			$result[$registerArgumentsSet->key()] = $registerArgumentsSet;

			foreach (static::$methods as $method => $position) {
				$entityMethod = '\\' . $entityClass . '::' . $method . '()';
				$directive = new ExpectedArguments($entityMethod, $position, [$registerArgumentsSet]);
				$result[$directive->key()] = $directive;
			}
		}

		return $result;
	}

	/**
	 * @return array<array<string>>
	 */
	protected function getEntityFields(): array {
		$modelFields = [];

		$models = $this->collectModels();
		foreach ($models as $model => $className) {
			$fields = [];
			$tableObject = null;
			try {
				/** @var \Cake\ORM\Table $tableObject */
				$tableObject = new $className();
				$fields = $tableObject->getSchema()->columns();

			} catch (Throwable $exception) {
				// Do nothing
			}

			if ($tableObject) {
				try {
					$fieldsFromRelations = $this->addFromRelations($tableObject);
					$fields = array_merge($fields, $fieldsFromRelations);
					$fields = array_unique($fields);
				} catch (Throwable $exception) {
					// Do nothing
				}
			}

			$entityClass = $tableObject ? $tableObject->getEntityClass() : null;
			try {
				/** @var \Cake\Datasource\EntityInterface $entityObject */
				$entityObject = new $entityClass();
				$visibleFields = $entityObject->getVisible();
				$virtualFields = $entityObject->getVirtual();
				$fields = array_merge($fields, $virtualFields, $visibleFields);
				$fields = array_unique($fields);
			} catch (Throwable $exception) {
				// Do nothing
			}

			if (!$fields) {
				continue;
			}

			$list = [];
			foreach ($fields as $field) {
				$list[$field] = StringName::create($field);
			}

			ksort($list);

			$modelFields[$entityClass] = $list;
		}

		return $modelFields;
	}

	/**
	 * @param \Cake\ORM\Table $table
	 *
	 * @return array<string>
	 */
	protected function addFromRelations(Table $table): array {
		$fields = [];

		/** @var \Cake\ORM\AssociationCollection<\Cake\ORM\Association> $associations */
		$associations = $table->associations();

		foreach ($associations as $association) {
			$fields[] = $association->getProperty();
		}

		return $fields;
	}

}


================================================
FILE: src/Generator/Task/EnvTask.php
================================================
<?php

namespace IdeHelper\Generator\Task;

use IdeHelper\Generator\Directive\ExpectedArguments;
use IdeHelper\ValueObject\StringName;

class EnvTask implements TaskInterface {

	/**
	 * @var string
	 */
	protected const METHOD_ENV = '\\' . 'env()';

	/**
	 * Keys from Web based request, will be merged with CLI ones.
	 *
	 * @var array<string>
	 */
	protected static array $keys = [
		'HTTP_HOST',
		'HTTPS',
		'REMOTE_ADDR',
		'REMOTE_PORT',
		'DOCUMENT_ROOT',
		'DOCUMENT_URI',
		'PHP_SELF',
		'CGI_MODE',
		'SCRIPT_NAME',
		'HTTP_ACCEPT_LANGUAGE',
		'HTTP_ACCEPT_ENCODING',
		'HTTP_ACCEPT',
		'HTTP_COOKIE',
		'HTTP_USER_AGENT',
		'HTTP_CONNECTION',
		'HOME',
		'REDIRECT_STATUS',
		'SERVER_NAME',
		'SERVER_PORT',
		'SERVER_PROTOCOL',
		'GATEWAY_INTERFACE',
		'REQUEST_SCHEME',
		'REQUEST_URI',
		'REQUEST_METHOD',
		'CONTENT_LENGTH',
		'CONTENT_TYPE',
		'QUERY_STRING',
		'REQUEST_TIME',
		'SCRIPT_FILENAME',
	];

	/**
	 * @return array<string, \IdeHelper\Generator\Directive\BaseDirective>
	 */
	public function collect(): array {
		$result = [];

		$keys = $this->envKeys();

		ksort($keys);

		$method = static::METHOD_ENV;
		$directive = new ExpectedArguments($method, 0, $keys);
		$result[$directive->key()] = $directive;

		return $result;
	}

	/**
	 * @return array<\IdeHelper\ValueObject\StringName>
	 */
	protected function envKeys(): array {
		$keys = array_keys($_SERVER);
		$keys = array_merge($keys, static::$keys);
		$keys = array_unique($keys);

		$list = [];

		foreach ($keys as $key) {
			if (str_starts_with($key, '_')) {
				continue;
			}

			$list[$key] = StringName::create($key);
		}

		return $list;
	}

}


================================================
FILE: src/Generator/Task/FixtureTask.php
================================================
<?php

namespace IdeHelper\Generator\Task;

use Cake\TestSuite\TestCase;
use IdeHelper\Filesystem\Folder;
use IdeHelper\Generator\Directive\ExpectedArguments;
use IdeHelper\Utility\Plugin;
use IdeHelper\ValueObject\StringName;

class FixtureTask implements TaskInterface {

	/**
	 * @var string
	 */
	protected const METHOD_ADD_FIXTURE = '\\' . TestCase::class . '::addFixture()';

	/**
	 * @return array<string, \IdeHelper\Generator\Directive\BaseDirective>
	 */
	public function collect(): array {
		$result = [];

		$fixtures = $this->getFixtures();

		$method = static::METHOD_ADD_FIXTURE;
		$directive = new ExpectedArguments($method, 0, $fixtures);
		$result[$directive->key()] = $directive;

		return $result;
	}

	/**
	 * @return array<\IdeHelper\ValueObject\StringName>
	 */
	protected function getFixtures(): array {
		$list = [];

		$fixtures = [];
		$fixtureFolder = ROOT . DS . 'tests' . DS . 'Fixture' . DS;
		$fixtures += $this->parseFixtures($fixtureFolder, 'app');

		$plugins = Plugin::all();
		foreach ($plugins as $plugin) {
			$path = Plugin::path($plugin);
			$fixtureFolder = $path . 'tests' . DS . 'Fixture' . DS;
			$fixtures += $this->parseFixtures($fixtureFolder, 'plugin.' . $plugin);
		}

		$fixtureFolder = ROOT . DS . 'vendor' . DS . 'cakephp' . DS . 'cakephp' . DS . 'tests' . DS . 'Fixture' . DS;
		$fixtures += $this->parseFixtures($fixtureFolder, 'core');

		foreach ($fixtures as $fixture) {
			$list[$fixture] = StringName::create($fixture);
		}

		ksort($list);

		return $list;
	}

	/**
	 * @param string $fixtureFolder
	 * @param string $domain
	 * @param string|null $subFolder
	 *
	 * @return array<string>
	 */
	protected function parseFixtures(string $fixtureFolder, string $domain, ?string $subFolder = null): array {
		if (!is_dir($fixtureFolder)) {
			return [];
		}

		$folder = new Folder($fixtureFolder);
		$content = $folder->read();

		$fixtures = [];
		foreach ($content[1] as $file) {
			if (!str_ends_with($file, 'Fixture.php')) {
				continue;
			}
			$fixture = substr($file, 0, -11);
			if ($subFolder) {
				$fixture = str_replace(DS, '/', $subFolder) . '/' . $fixture;
			}
			$fixture = $domain . '.' . $fixture;

			$fixtures[$fixture] = $fixture;
		}

		foreach ($content[0] as $folder) {
			$fixtures += $this->parseFixtures($fixtureFolder . $folder . DS, $domain, $folder);
		}

		return $fixtures;
	}

}


================================================
FILE: src/Generator/Task/FormHelperTask.php
================================================
<?php

namespace IdeHelper\Generator\Task;

use Cake\ORM\TableRegistry;
use Cake\View\Helper\FormHelper;
use IdeHelper\Generator\Directive\ExpectedArguments;
use IdeHelper\Utility\App;
use IdeHelper\ValueObject\StringName;
use ReflectionClass;
use Throwable;

class FormHelperTask extends ModelTask {

	public const CLASS_FORM_HELPER = FormHelper::class;

	/**
	 * @return array<string, \IdeHelper\Generator\Directive\BaseDirective>
	 */
	public function collect(): array {
		$result = [];

		$list = $this->collectFieldNames();

		ksort($list);

		$method = '\\' . static::CLASS_FORM_HELPER . '::control()';
		$directive = new ExpectedArguments($method, 0, $list);
		$result[$directive->key()] = $directive;

		return $result;
	}

	/**
	 * @return array<string>
	 */
	protected function collectFieldNames(): array {
		$models = $this->collectModels();

		$allFields = [];
		foreach ($models as $model => $className) {
			/** @phpstan-var class-string<object>|null $tableClass */
			$tableClass = App::className($model, 'Model/Table', 'Table');
			if (!$tableClass) {
				continue;
			}

			$tableReflection = new ReflectionClass($tableClass);
			if (!$tableReflection->isInstantiable()) {
				continue;
			}

			try {
				$modelObject = TableRegistry::getTableLocator()->get($model);
				$fields = $modelObject->getSchema()->columns();

			} catch (Throwable $exception) {
				continue;
			}

			$allFields = array_merge($allFields, $fields);
		}

		$allFields = array_unique($allFields);

		$list = [];
		foreach ($allFields as $field) {
			$list[$field] = StringName::create($field);
		}

		return $list;
	}

}


================================================
FILE: src/Generator/Task/HelperTask.php
================================================
<?php

namespace IdeHelper\Generator\Task;

use Cake\View\View;
use Cake\View\ViewBuilder;
use IdeHelper\Filesystem\Folder;
use IdeHelper\Generator\Directive\ExpectedArguments;
use IdeHelper\Generator\Directive\Override;
use IdeHelper\Utility\App;
use IdeHelper\Utility\AppPath;
use IdeHelper\Utility\Plugin;
use IdeHelper\ValueObject\ClassName;

class HelperTask implements TaskInterface {

	protected const CLASS_VIEW = View::class;
	protected const CLASS_VIEW_BUILDER = ViewBuilder::class;

	/**
	 * @var array<string>
	 */
	protected array $overrideMethods = [
		'\\' . self::CLASS_VIEW . '::loadHelper(0)',
		'\\' . self::CLASS_VIEW . '::addHelper(0)',
	];

	/**
	 * @var string
	 */
	protected const METHOD_VIEW_BUILDER = '\\' . self::CLASS_VIEW_BUILDER . '::addHelper()';

	/**
	 * @return array<string, \IdeHelper\Generator\Directive\BaseDirective>
	 */
	public function collect(): array {
		$helpers = $this->collectHelpers();

		$map = [];
		foreach ($helpers as $name => $className) {
			$map[$name] = ClassName::create($className);
		}
		ksort($map);

		$result = [];

		foreach ($this->overrideMethods as $method) {
			$directive = new Override($method, $map);
			$result[$directive->key()] = $directive;
		}

		$list = [];
		foreach ($helpers as $name => $className) {
			$list[$name] = "'$name'";
		}
		ksort($list);

		$directive = new ExpectedArguments(static::METHOD_VIEW_BUILDER, 0, $list);
		$result[$directive->key()] = $directive;

		return $result;
	}

	/**
	 * @return array<string>
	 */
	protected function collectHelpers(): array {
		$helpers = [];

		$folders = array_merge(App::core('View/Helper'), AppPath::get('View/Helper'));
		foreach ($folders as $folder) {
			$helpers = $this->addHelpers($helpers, $folder);
		}

		$plugins = Plugin::all();
		foreach ($plugins as $plugin) {
			$folders = AppPath::get('View/Helper', $plugin);
			foreach ($folders as $folder) {
				$helpers = $this->addHelpers($helpers, $folder, $plugin);
			}
		}

		return $helpers;
	}

	/**
	 * @param array<string> $helpers
	 * @param string $folder
	 * @param string|null $plugin
	 *
	 * @return array<string>
	 */
	protected function addHelpers(array $helpers, $folder, $plugin = null) {
		$folderContent = (new Folder($folder))->read(Folder::SORT_NAME, true);

		foreach ($folderContent[1] as $file) {
			preg_match('/^(.+)Helper\.php$/', $file, $matches);
			if (!$matches) {
				continue;
			}
			$name = $matches[1];
			if ($plugin) {
				$name = $plugin . '.' . $name;
			}

			$className = App::className($name, 'View/Helper', 'Helper');
			if (!$className) {
				continue;
			}

			$helpers[$name] = $className;
		}

		return $helpers;
	}

}


================================================
FILE: src/Generator/Task/LayoutTask.php
================================================
<?php

namespace IdeHelper\Generator\Task;

use Cake\Core\App;
use Cake\View\ViewBuilder;
use DirectoryIterator;
use IdeHelper\Generator\Directive\ExpectedArguments;
use IdeHelper\Utility\Plugin;
use IdeHelper\ValueObject\StringName;
use RecursiveRegexIterator;
use RegexIterator;

class LayoutTask implements TaskInterface {

	public const CLASS_VIEW_BUILDER = ViewBuilder::class;

	/**
	 * @return array<string, \IdeHelper\Generator\Directive\BaseDirective>
	 */
	public function collect(): array {
		$result = [];

		$layouts = $this->collectLayouts();
		$list = [];
		foreach ($layouts as $layout) {
			$list[$layout] = StringName::create($layout);
		}

		ksort($list);

		$method = '\\' . static::CLASS_VIEW_BUILDER . '::setLayout()';
		$directive = new ExpectedArguments($method, 0, $list);
		$result[$directive->key()] = $directive;

		return $result;
	}

	/**
	 * @return array<string>
	 */
	protected function collectLayouts(): array {
		$paths = App::path('templates');

		$result = [];
		$result = $this->addLayouts($result, $paths);

		$plugins = Plugin::all();
		foreach ($plugins as $plugin) {
			$paths = App::path('templates', $plugin);
			$result = $this->addLayouts($result, $paths, $plugin);
		}

		sort($result);

		return $result;
	}

	/**
	 * @param array<string> $result
	 * @param array<string> $paths
	 * @param string|null $plugin
	 *
	 * @return array<string>
	 */
	protected function addLayouts(array $result, array $paths, ?string $plugin = null): array {
		foreach ($paths as $path) {
			$path .= 'layout' . DS;
			if (!is_dir($path)) {
				continue;
			}

			$directory = new DirectoryIterator($path);
			$regexIterator = new RegexIterator($directory, '/^.+\.php$/i', RecursiveRegexIterator::GET_MATCH);

			foreach ($regexIterator as $file) {
				$name = str_replace($path, '', $file[0]);
				$name = substr($name, 0, -4);
				$name = str_replace(DS, '/', $name);
				if ($plugin) {
					$name = $plugin . '.' . $name;
				}
				$result[] = $name;
			}
		}

		return $result;
	}

}


================================================
FILE: src/Generator/Task/MailerTask.php
================================================
<?php

namespace IdeHelper\Generator\Task;

use Cake\Mailer\MailerAwareTrait;
use IdeHelper\Filesystem\Folder;
use IdeHelper\Generator\Directive\Override;
use IdeHelper\Utility\App;
use IdeHelper\Utility\AppPath;
use IdeHelper\Utility\Plugin;
use IdeHelper\ValueObject\ClassName;

class MailerTask implements TaskInterface {

	public const CLASS_MAILER = MailerAwareTrait::class;

	protected static string $alias = '\\' . self::CLASS_MAILER . '::getMailer(0)';

	/**
	 * @return array<string, \IdeHelper\Generator\Directive\BaseDirective>
	 */
	public function collect(): array {
		$map = [];

		$mailers = $this->collectMailers();
		foreach ($mailers as $name => $className) {
			$map[$name] = ClassName::create($className);
		}

		ksort($map);

		$result = [];
		if ($map) {
			$directive = new Override(static::$alias, $map);
			$result[$directive->key()] = $directive;
		}

		return $result;
	}

	/**
	 * @return array<string>
	 */
	protected function collectMailers(): array {
		$mailers = [];

		$folders = AppPath::get('Mailer');
		foreach ($folders as $folder) {
			$mailers = $this->addMailers($mailers, $folder);
		}

		$plugins = Plugin::all();
		foreach ($plugins as $plugin) {
			$folders = AppPath::get('Mailer', $plugin);
			foreach ($folders as $folder) {
				$mailers = $this->addMailers($mailers, $folder, $plugin);
			}
		}

		return $mailers;
	}

	/**
	 * @param array<string> $components
	 * @param string $folder
	 * @param string|null $plugin
	 *
	 * @return array<string>
	 */
	protected function addMailers(array $components, $folder, $plugin = null) {
		$folderContent = (new Folder($folder))->read(Folder::SORT_NAME, true);

		foreach ($folderContent[1] as $file) {
			preg_match('/^(.+)Mailer\.php$/', $file, $matches);
			if (!$matches) {
				continue;
			}
			$name = $matches[1];
			if ($plugin) {
				$name = $plugin . '.' . $name;
			}

			$className = App::className($name, 'Mailer', 'Mailer');
			if (!$className) {
				continue;
			}

			$components[$name] = $className;
		}

		return $components;
	}

}


================================================
FILE: src/Generator/Task/ModelTask.php
================================================
<?php

namespace IdeHelper\Generator\Task;

use Cake\ORM\Table;
use IdeHelper\Filesystem\Folder;
use IdeHelper\Generator\Directive\Override;
use IdeHelper\Utility\App;
use IdeHelper\Utility\AppPath;
use IdeHelper\Utility\Plugin;
use IdeHelper\ValueObject\ClassName;
use ReflectionClass;

class ModelTask implements TaskInterface {

	/**
	 * @var array<string>
	 */
	protected array $aliases = [
		'\Cake\ORM\Locator\LocatorInterface::get(0)',
		'\Cake\ORM\Locator\LocatorAwareTrait::fetchTable(0)',
		'\Cake\Datasource\ModelAwareTrait::fetchModel(0)',
	];

	/**
	 * Buffer
	 *
	 * @var array<string, string>|null
	 */
	protected static ?array $models = null;

	public function __construct() {
		$this->clearBuffer();
	}

	/**
	 * @return void
	 */
	public static function clearBuffer(): void {
		static::$models = null;
	}

	/**
	 * @return array<string, \IdeHelper\Generator\Directive\BaseDirective>
	 */
	public function collect(): array {
		$map = [];

		$models = $this->collectModels();
		foreach ($models as $model => $className) {
			$map[$model] = ClassName::create($className);
		}

		ksort($map);

		$result = [];
		foreach ($this->aliases as $alias) {
			$directive = new Override($alias, $map);
			$result[$directive->key()] = $directive;
		}

		return $result;
	}

	/**
	 * @return array<string, string>
	 */
	protected function collectModels(): array {
		if (static::$models !== null) {
			return static::$models;
		}

		$models = [];

		$folders = AppPath::get('Model/Table');
		foreach ($folders as $folder) {
			$models = $this->addModels($models, $folder);
		}

		$plugins = Plugin::all();
		foreach ($plugins as $plugin) {
			$folders = AppPath::get('Model/Table', $plugin);
			foreach ($folders as $folder) {
				$models = $this->addModels($models, $folder, $plugin);
			}
		}

		static::$models = $models;

		return $models;
	}

	/**
	 * @param array<string, string> $models
	 * @param string $folder
	 * @param string|null $plugin
	 *
	 * @return array<string, string>
	 */
	protected function addModels(array $models, $folder, $plugin = null) {
		$folderContent = (new Folder($folder))->read(Folder::SORT_NAME, true);

		foreach ($folderContent[1] as $file) {
			preg_match('/^(.+)Table\.php$/', $file, $matches);
			if (!$matches) {
				continue;
			}
			$model = $matches[1];
			if ($plugin) {
				$model = $plugin . '.' . $model;
			}

			/** @phpstan-var class-string<object>|null $className */
			$className = App::className($model, 'Model/Table', 'Table');
			if (!$className) {
				continue;
			}

			$reflectionClass = new ReflectionClass($className);
			if (!$reflectionClass->isInstantiable() || !$reflectionClass->isSubclassOf(Table::class)) {
				continue;
			}

			$models[$model] = $className;
		}

		return $models;
	}

}


================================================
FILE: src/Generator/Task/PluginTask.php
================================================
<?php

namespace IdeHelper\Generator\Task;

use Cake\Core\Configure;
use Cake\Core\PluginApplicationInterface;
use Cake\Http\BaseApplication;
use IdeHelper\Generator\Directive\Override;
use IdeHelper\ValueObject\ClassName;

class PluginTask implements TaskInterface {

	/**
	 * We need to use this until PhpStorm fixed the issue around concrete classes here
	 */
	public const INTERFACE_APPLICATION = PluginApplicationInterface::class;

	public const CLASS_APPLICATION = BaseApplication::class;

	/**
	 * @var array<string>
	 */
	protected array $aliases = [
		'\\' . self::INTERFACE_APPLICATION . '::addPlugin(0)',
	];

	/**
	 * @return array<string, \IdeHelper\Generator\Directive\BaseDirective>
	 */
	public function collect(): array {
		$map = [];

		$plugins = $this->collectPlugins();
		foreach ($plugins as $name) {
			$map[$name] = ClassName::create(static::CLASS_APPLICATION);
		}

		ksort($map);

		$result = [];
		foreach ($this->aliases as $alias) {
			$directive = new Override($alias, $map);
			$result[$directive->key()] = $directive;
		}

		return $result;
	}

	/**
	 * Read from PluginCollection loaded config.
	 *
	 * @return array<string>
	 */
	protected function collectPlugins(): array {
		$plugins = (array)Configure::read('plugins');

		$names = array_keys($plugins);

		sort($names);

		return $names;
	}

}


================================================
FILE: src/Generator/Task/RequestTask.php
================================================
<?php

namespace IdeHelper\Generator\Task;

use Cake\Http\ServerRequest;
use Cake\Http\Session;
use Cake\Routing\Route\Route;
use Cake\Routing\Router;
use IdeHelper\Generator\Directive\ExpectedArguments;
use IdeHelper\Generator\Directive\Override;
use IdeHelper\Utility\Plugin;
use IdeHelper\ValueObject\ClassName;
use IdeHelper\ValueObject\StringName;

class RequestTask implements TaskInterface {

	public const CLASS_REQUEST = ServerRequest::class;

	/**
	 * @var array<string>
	 */
	protected static array $paramKeys = [
		'controller',
		'action',
		'plugin',
		'prefix',
		'pass',
		'_matchedRoute',
		'_ext',
	];

	/**
	 * @var array<string, string>
	 */
	protected static array $attributeKeys = [
		'csrfToken' => 'string',
		'params' => 'array',
		'webroot' => 'string',
		'base' => 'string',
		'here' => 'string',
		'cspScriptNonce' => 'string',
		'cspStyleNonce' => 'string',
		'formTokenData' => 'array',
		'paging' => 'array',
	];

	/**
	 * @return array<string, \IdeHelper\Generator\Directive\BaseDirective>
	 */
	public function collect(): array {
		$result = [];

		$list = $this->collectParamKeys();

		$method = '\\' . static::CLASS_REQUEST . '::getParam()';
		$directive = new ExpectedArguments($method, 0, $list);
		$result[$directive->key()] = $directive;

		$map = $this->collectAttributes();

		$method = '\\' . static::CLASS_REQUEST . '::getAttribute(0)';
		$directive = new Override($method, $map);
		$result[$directive->key()] = $directive;

		return $result;
	}

	/**
	 * @return array<string, \IdeHelper\ValueObject\StringName>
	 */
	protected function collectParamKeys(): array {
		$keys = [];
		foreach (static::$paramKeys as $key) {
			$keys[$key] = StringName::create($key);
		}

		ksort($keys);

		return $keys;
	}

	/**
	 * @return array<string, mixed>
	 */
	protected function collectAttributes(): array {
		$request = Router::getRequest() ?: new ServerRequest();
		$defaults = array_keys($request->getAttributes());

		$attributes = [
			'route' => ClassName::create(Route::class),
			'session' => ClassName::create(Session::class),
		];
		foreach (static::$attributeKeys as $key => $type) {
			$attributes[$key] = StringName::create($type);
		}

		$attributes = $this->addAttributesFromPlugins($attributes);

		foreach ($defaults as $default) {
			if (isset($attributes[$default])) {
				continue;
			}

			$attributes[$default] = StringName::create('');
		}

		ksort($attributes);

		return $attributes;
	}

	/**
	 * @param array<string, mixed> $attributes
	 * @return array<string, mixed>
	 */
	protected function addAttributesFromPlugins(array $attributes): array {
		if (Plugin::isLoaded('Authorization')) {
			$attributes['identity'] = ClassName::create('Authorization\IdentityInterface');
		} elseif (Plugin::isLoaded('Authentication')) {
			$attributes['identity'] = ClassName::create('Authentication\IdentityInterface');
		}
		if (Plugin::isLoaded('Authentication')) {
			$attributes['authentication'] = ClassName::create('Authentication\AuthenticationService');
			$attributes['authenticationResult'] = ClassName::create('Authentication\Authenticator\Result');
		}

		return $attributes;
	}

}


================================================
FILE: src/Generator/Task/RoutePathTask.php
================================================
<?php

namespace IdeHelper\Generator\Task;

use Cake\Core\Configure;
use Cake\Routing\Router;
use Cake\View\Helper\HtmlHelper;
use Cake\View\Helper\UrlHelper;
use IdeHelper\Filesystem\Folder;
use IdeHelper\Generator\Directive\ExpectedArguments;
use IdeHelper\Generator\Directive\RegisterArgumentsSet;
use IdeHelper\Utility\AppPath;
use IdeHelper\Utility\ControllerActionParser;
use IdeHelper\Utility\Plugin;
use IdeHelper\ValueObject\StringName;

class RoutePathTask implements TaskInterface {

	public const CLASS_ROUTER = Router::class;
	public const CLASS_URL_HELPER = UrlHelper::class;
	public const CLASS_HTML_HELPER = HtmlHelper::class;

	/**
	 * @var string
	 */
	public const SET_ROUTE_PATHS = 'routePaths';

	protected ControllerActionParser $controllerActionParser;

	public function __construct() {
		$this->controllerActionParser = new ControllerActionParser();
	}

	/**
	 * @return array<string, \IdeHelper\Generator\Directive\BaseDirective>
	 */
	public function collect(): array {
		$result = [];

		$list = $this->collectPaths();
		$registerArgumentsSet = new RegisterArgumentsSet(static::SET_ROUTE_PATHS, $list);
		$result[$registerArgumentsSet->key()] = $registerArgumentsSet;

		$method = '\\' . static::CLASS_ROUTER . '::pathUrl()';
		$directive = new ExpectedArguments($method, 0, [$registerArgumentsSet]);
		$result[$directive->key()] = $directive;

		$method = '\\' . static::CLASS_URL_HELPER . '::buildFromPath()';
		$directive = new ExpectedArguments($method, 0, [$registerArgumentsSet]);
		$result[$directive->key()] = $directive;

		$method = '\\' . static::CLASS_HTML_HELPER . '::linkFromPath()';
		$directive = new ExpectedArguments($method, 1, [$registerArgumentsSet]);
		$result[$directive->key()] = $directive;

		$method = '\\urlArray()';
		$directive = new ExpectedArguments($method, 0, [$registerArgumentsSet]);
		$result[$directive->key()] = $directive;

		return $result;
	}

	/**
	 * @return array<string>
	 */
	protected function collectPaths(): array {
		$plugins = Plugin::all();

		$controllerPaths = AppPath::get('Controller');

		$paths = [];
		foreach ($controllerPaths as $controllerPath) {
			$paths += $this->_paths($controllerPath);
		}

		foreach ($plugins as $plugin) {
			$pluginControllerPath = Plugin::classPath($plugin) . 'Controller' . DS;
			$paths += $this->_paths($pluginControllerPath, $plugin);
		}

		ksort($paths);

		return $paths;
	}

	/**
	 * @param string $folder
	 * @param string|null $plugin
	 * @param string|null $prefix
	 * @return array<string>
	 */
	protected function _paths(string $folder, ?string $plugin = null, ?string $prefix = null): array {
		$paths = [];

		$folderContent = (new Folder($folder))->read(Folder::SORT_NAME, true);

		foreach ($folderContent[1] as $file) {
			$name = basename($file);
			preg_match('/^(.+)Controller\.php$/', $name, $matches);
			if (!$matches || $matches[1] === 'App') {
				continue;
			}
			$controllerName = $matches[1];

			$actions = $this->controllerActionParser->parse($folder . $file);
			foreach ($actions as $action) {
				$routePath = $controllerName . '::' . $action;
				if ($prefix) {
					$routePath = $prefix . '/' . $routePath;
				}
				if ($plugin) {
					$routePath = $plugin . '.' . $routePath;
				}

				$paths[$routePath] = StringName::create($routePath);
			}
		}

		foreach ($folderContent[0] as $subFolder) {
			$prefixes = (array)Configure::read('IdeHelper.prefixes') ?: null;

			if ($prefixes !== null && !in_array($subFolder, $prefixes, true)) {
				continue;
			}

			$sub = $this->_paths($folder . $subFolder . DS, $plugin, $subFolder);
			$paths += $sub;
		}

		return $paths;
	}

}


================================================
FILE: src/Generator/Task/TableAssociationTask.php
================================================
<?php

namespace IdeHelper\Generator\Task;

use Cake\ORM\Association\BelongsTo;
use Cake\ORM\Association\BelongsToMany;
use Cake\ORM\Association\HasMany;
use Cake\ORM\Association\HasOne;
use Cake\ORM\Table;
use IdeHelper\Generator\Directive\Override;
use IdeHelper\ValueObject\ClassName;

class TableAssociationTask extends ModelTask {

	public const CLASS_TABLE = Table::class;

	/**
	 * @var array<string, string>
	 */
	protected array $aliases = [
		'\\' . self::CLASS_TABLE . '::belongsTo(0)' => BelongsTo::class,
		'\\' . self::CLASS_TABLE . '::hasOne(0)' => HasOne::class,
		'\\' . self::CLASS_TABLE . '::hasMany(0)' => HasMany::class,
		'\\' . self::CLASS_TABLE . '::belongToMany(0)' => BelongsToMany::class,
	];

	/**
	 * @return array<string, \IdeHelper\Generator\Directive\BaseDirective>
	 */
	public function collect(): array {
		$models = $this->collectModels();

		$result = [];
		foreach ($this->aliases as $alias => $className) {
			$map = [];
			foreach ($models as $model => $modelClassName) {
				$map[$model] = ClassName::create($className);
			}

			ksort($map);

			$directive = new Override($alias, $map);
			$result[$directive->key()] = $directive;
		}

		return $result;
	}

}


================================================
FILE: src/Generator/Task/TableFinderTask.php
================================================
<?php

namespace IdeHelper\Generator\Task;

use Cake\Datasource\QueryInterface;
use Cake\ORM\Association;
use Cake\ORM\Query\SelectQuery;
use Cake\ORM\Table;
use Cake\ORM\TableRegistry;
use IdeHelper\Generator\Directive\Override;
use IdeHelper\Utility\App;
use IdeHelper\ValueObject\ClassName;
use ReflectionClass;
use ReflectionException;
use ReflectionMethod;
use Throwable;

class TableFinderTask extends ModelTask {

	/**
	 * @var string
	 */
	public const INTERFACE_QUERY = QueryInterface::class;

	/**
	 * @var string
	 */
	public const CLASS_TABLE = Table::class;

	/**
	 * @var string
	 */
	public const CLASS_ASSOCIATION = Association::class;

	/**
	 * @var string
	 */
	public const CLASS_QUERY = SelectQuery::class;

	/**
	 * @var array<string>
	 */
	protected array $cache = [];

	/**
	 * @return array<string, \IdeHelper\Generator\Directive\BaseDirective>
	 */
	public function collect(): array {
		$result = [];

		$finders = $this->collectFinders();
		foreach ($finders as $className => $methods) {
			$map = [];
			foreach ($methods as $method) {
				$map[$method] = ClassName::create(static::CLASS_QUERY);
			}

			ksort($map);

			$method = '\\' . $className . '::find(0)';
			$directive = new Override($method, $map);
			$result[$directive->key()] = $directive;
		}

		return $result;
	}

	/**
	 * @return array<string, array<string>>
	 */
	protected function collectFinders(): array {
		$baseFinders = $this->getFinderMethods(static::CLASS_TABLE);
		$customFinders = $this->getCustomFinders();

		$allFinders = array_merge($baseFinders, $customFinders);
		$allFinders = array_unique($allFinders);

		sort($allFinders);

		$finders = [];
		$finders[static::CLASS_TABLE] = $allFinders;
		$finders[static::CLASS_ASSOCIATION] = $allFinders;
		$finders[static::INTERFACE_QUERY] = $allFinders;

		return $finders;
	}

	/**
	 * @return array<string>
	 */
	protected function getCustomFinders(): array {
		$models = $this->collectModels();

		$allFinders = [];
		foreach ($models as $model => $className) {
			$customFinders = $this->getFinderMethods($className);

			/** @phpstan-var class-string<object>|null $tableClass */
			$tableClass = App::className($model, 'Model/Table', 'Table');
			if (!$tableClass) {
				continue;
			}

			$tableReflection = new ReflectionClass($tableClass);
			if (!$tableReflection->isInstantiable()) {
				$allFinders = array_merge($allFinders, $customFinders);

				continue;
			}

			try {
				$modelObject = TableRegistry::getTableLocator()->get($model);
				$behaviors = $modelObject->behaviors();

				/** @var iterable<\Cake\ORM\Behavior> $iterator */
				$iterator = $behaviors->getIterator();
				foreach ($iterator as $behavior) {
					$behaviorClass = get_class($behavior);
					if (in_array($behaviorClass, $this->cache, true)) {
						continue;
					}

					$this->cache[] = $behaviorClass;

					if ($behavior->implementedFinders()) {
						$customFinders = array_merge($customFinders, array_keys($behavior->implementedFinders()));
					}
				}
			} catch (Throwable $exception) {
			}

			$allFinders = array_merge($allFinders, $customFinders);
		}

		return array_unique($allFinders);
	}

	/**
	 * Gets protected/private property of a class.
	 *
	 * So
	 *   $this->invokeProperty($object, '_foo');
	 * is equal to
	 *   $object->_foo
	 * (assuming the property was directly publicly accessible)
	 *
	 * @param object $object Instantiated object that we want the property off.
	 * @param string $name Property name to fetch.
	 *
	 * @return mixed Property value.
	 */
	protected function invokeProperty(&$object, string $name) {
		$reflection = new ReflectionClass(get_class($object));
		if (!$reflection->hasProperty($name)) {
			return null;
		}
		$property = $reflection->getProperty($name);

		return $property->getValue($object);
	}

	/**
	 * @param string $className
	 *
	 * @return array<string>
	 */
	protected function getFinderMethods($className) {
		$result = [];

		$methods = get_class_methods($className);
		foreach ($methods as $method) {
			$result = $this->addMethod($result, $method, $className);
		}

		ksort($result);

		return $result;
	}

	/**
	 * @param array<string> $result
	 * @param string $method
	 * @param string $className
	 *
	 * @return array<string>
	 */
	protected function addMethod(array $result, $method, $className) {
		// We must exclude all find...By... patterns as possible false positives for now (refs https://github.com/cakephp/cakephp/issues/11240)
		if ($method === 'findOrCreate' || preg_match('/^find.*By[A-Z][a-zA-Z]+/', $method)) {
			return $result;
		}
		if (!preg_match('/^find([A-Z][a-zA-Z]+)/', $method, $matches)) {
			return $result;
		}

		try {
			$methodReflection = new ReflectionMethod($className, $method);
		} catch (ReflectionException $e) {
			return $result;
		}

		$parameters = $methodReflection->getParameters();
		if (count($parameters) < 1) {
			return $result;
		}

		$name = lcfirst($matches[1]);

		$parameter = $parameters[0];

		/** @var \ReflectionNamedType|\ReflectionUnionType|null $parameterType */
		$parameterType = $parameter->getType();
		if (!$parameterType || !method_exists($parameterType, 'getName') || $parameterType->getName() !== SelectQuery::class) {
			return $result;
		}

		$result[] = $name;

		return $result;
	}

}


================================================
FILE: src/Generator/Task/TaskInterface.php
================================================
<?php

namespace IdeHelper\Generator\Task;

interface TaskInterface {

	/**
	 * @return array<string, \IdeHelper\Generator\Directive\BaseDirective>
	 */
	public function collect(): array;

}


================================================
FILE: src/Generator/Task/TranslationKeyTask.php
================================================
<?php

namespace IdeHelper\Generator\Task;

use Cake\Utility\Inflector;
use IdeHelper\Generator\Directive\ExpectedArguments;
use IdeHelper\Utility\App;
use IdeHelper\Utility\Plugin;
use IdeHelper\Utility\TranslationParser;
use IdeHelper\ValueObject\StringName;
use RecursiveDirectoryIterator;
use RecursiveIteratorIterator;
use RecursiveRegexIterator;
use RegexIterator;

/**
 * @link https://book.cakephp.org/5/en/core-libraries/global-constants-and-functions.html#global-functions
 */
class TranslationKeyTask implements TaskInterface {

	protected TranslationParser $translationParser;

	public function __construct() {
		$this->translationParser = new TranslationParser();
	}

	/**
	 * function __(string $singular, ...$args): string
	 *
	 * @var string
	 */
	protected const METHOD_DEFAULT = '__()';

	/**
	 * function __d(string $domain, string $msg, ...$args): string
	 *
	 * @var string
	 */
	protected const METHOD_DOMAIN = '__d()';

	/**
	 * @return array<string, \IdeHelper\Generator\Directive\BaseDirective>
	 */
	public function collect(): array {
		$result = [];

		$translationKeys = $this->translationKeys();

		$domains = [];
		$domainKeys = [];
		foreach ($translationKeys as $domain => $keys) {
			if ($domain === 'default') {
				$method = '\\' . static::METHOD_DEFAULT;
				$directive = new ExpectedArguments($method, 0, $keys);
				$result[$directive->key()] = $directive;

				continue;
			}

			$domains[$domain] = StringName::create($domain);
			$domainKeys += $keys;
		}

		if ($domainKeys) {
			ksort($domainKeys);

			$method = '\\' . static::METHOD_DOMAIN;
			$directive = new ExpectedArguments($method, 1, $domainKeys);
			$result[$directive->key()] = $directive;
		}

		$domains = $this->completeDomains($domains);

		if ($domains) {
			$method = '\\' . static::METHOD_DOMAIN;
			$directive = new ExpectedArguments($method, 0, $domains);
			$result[$directive->key()] = $directive;
		}

		return $result;
	}

	/**
	 * @return array<string, array<string, \IdeHelper\ValueObject\StringName>>
	 */
	protected function translationKeys(): array {
		$translations = $this->parseTranslations();

		$translationsKeys = [];
		foreach ($translations as $domain => $array) {
			$result = [];
			foreach ($array as $key) {
				$result[$key] = StringName::create($key);
			}

			ksort($result);

			$translationsKeys[$domain] = $result;
		}

		ksort($translationsKeys);

		return $translationsKeys;
	}

	/**
	 * @return array<array<string>>
	 */
	protected function parseTranslations(): array {
		$keys = [];

		$localePaths = App::path('locales');
		foreach ($localePaths as $localePath) {
			if (!is_dir($localePath)) {
				continue;
			}

			$directoryIterator = new RecursiveDirectoryIterator($localePath);
			$iterator = new RecursiveIteratorIterator($directoryIterator);
			$regexIterator = new RegexIterator($iterator, '/^.+\.po/i', RecursiveRegexIterator::GET_MATCH);

			foreach ($regexIterator as $files) {
				foreach ($files as $file) {
					if (!file_exists($file)) {
						continue;
					}

					$domainKeys = $this->translationParser->parse($file);

					$domain = pathinfo($file, PATHINFO_FILENAME);
					if (!isset($keys[$domain])) {
						$keys[$domain] = [];
					}
					$keys[$domain] += $domainKeys;
				}
			}

			$plugins = Plugin::all();
			foreach ($plugins as $plugin) {
				$localePath = Plugin::path($plugin) . 'resources' . DIRECTORY_SEPARATOR . 'locales' . DIRECTORY_SEPARATOR;

				if (!is_dir($localePath)) {
					continue;
				}

				$directoryIterator = new RecursiveDirectoryIterator($localePath);
				$iterator = new RecursiveIteratorIterator($directoryIterator);
				$regexIterator = new RegexIterator($iterator, '/^.+\.po/i', RecursiveRegexIterator::GET_MATCH);

				foreach ($regexIterator as $files) {
					foreach ($files as $file) {
						if (!file_exists($file)) {
							continue;
						}

						$domainKeys = $this->translationParser->parse($file);

						$domain = pathinfo($file, PATHINFO_FILENAME);
						if (!isset($keys[$domain])) {
							$keys[$domain] = [];
						}
						$keys[$domain] += $domainKeys;
					}
				}
			}
		}

		return $keys;
	}

	/**
	 * @param array<\IdeHelper\ValueObject\StringName> $domains
	 *
	 * @return array<\IdeHelper\ValueObject\StringName>
	 */
	protected function completeDomains(array $domains): array {
		$plugins = Plugin::all();
		foreach ($plugins as $plugin) {
			$pieces = explode('/', $plugin);
			foreach ($pieces as $key => $piece) {
				$pieces[$key] = Inflector::underscore($piece);
			}

			$domain = implode('/', $pieces);

			// Issue of https://github.com/cakephp/docs/pull/6585 and for 5.0 to be resolved
			if (count($pieces) > 1) {
				$lastPiece = array_pop($pieces);
				unset($domains[$lastPiece]);
			}

			$domains[$domain] = StringName::create($domain);
		}

		if (!isset($domains['cake'])) {
			$domains['cake'] = StringName::create('cake');
		}

		ksort($domains);

		return $domains;
	}

}


================================================
FILE: src/Generator/Task/ValidationTask.php
================================================
<?php

namespace IdeHelper\Generator\Task;

use Cake\Validation\Validator;
use IdeHelper\Generator\Directive\ExpectedArguments;
use IdeHelper\Generator\Directive\RegisterArgumentsSet;
use IdeHelper\ValueObject\StringName;

class ValidationTask implements TaskInterface {

	/**
	 * @var string
	 */
	public const SET_VALIDATION_WHEN = 'validationWhen';

	/**
	 * @var array<string, int>
	 */
	protected static array $methods = [
		'requirePresence' => 1,
		'allowEmptyFor' => 2,
		'allowEmptyString' => 2,
		'allowEmptyFile' => 2,
		'allowEmptyArray' => 2,
		'allowEmptyDate' => 2,
		'allowEmptyTime' => 2,
		'allowEmptyDateTime' => 2,
		'notEmptyString' => 2,
		'notEmptyFile' => 2,
		'notEmptyArray' => 2,
		'notEmptyDate' => 2,
		'notEmptyTime' => 2,
		'notEmptyDateTime' => 2,
	];

	/**
	 * @return array<string, \IdeHelper\Generator\Directive\BaseDirective>
	 */
	public function collect(): array {
		$result = [];

		$list = $this->getValidatorRequirePresence();
		$registerArgumentsSet = new RegisterArgumentsSet(static::SET_VALIDATION_WHEN, $list);
		$result[$registerArgumentsSet->key()] = $registerArgumentsSet;

		foreach (static::$methods as $method => $position) {
			$method = '\\' . Validator::class . '::' . $method . '()';
			$directive = new ExpectedArguments($method, $position, [$registerArgumentsSet]);
			$result[$directive->key()] = $directive;
		}

		return $result;
	}

	/**
	 * @return array<\IdeHelper\ValueObject\ValueObjectInterface>
	 */
	protected function getValidatorRequirePresence(): array {
		return [
			StringName::create('create'),
			StringName::create('update'),
		];
	}

}


================================================
FILE: src/Generator/TaskCollection.php
================================================
<?php

namespace IdeHelper\Generator;

use Cake\Core\Configure;
use IdeHelper\Generator\Task\BehaviorTask;
use IdeHelper\Generator\Task\CacheTask;
use IdeHelper\Generator\Task\CellTask;
use IdeHelper\Generator\Task\ComponentTask;
use IdeHelper\Generator\Task\ConfigureTask;
use IdeHelper\Generator\Task\ConnectionTask;
use IdeHelper\Generator\Task\ConsoleHelperTask;
use IdeHelper\Generator\Task\ConsoleTask;
use IdeHelper\Generator\Task\DatabaseTableColumnNameTask;
use IdeHelper\Generator\Task\DatabaseTableColumnTypeTask;
use IdeHelper\Generator\Task\DatabaseTableTask;
use IdeHelper\Generator\Task\DatabaseTypeTask;
use IdeHelper\Generator\Task\ElementTask;
use IdeHelper\Generator\Task\EntityTask;
use IdeHelper\Generator\Task\EnvTask;
use IdeHelper\Generator\Task\FixtureTask;
use IdeHelper\Generator\Task\FormHelperTask;
use IdeHelper\Generator\Task\HelperTask;
use IdeHelper\Generator\Task\LayoutTask;
use IdeHelper\Generator\Task\MailerTask;
use IdeHelper\Generator\Task\ModelTask;
use IdeHelper\Generator\Task\PluginTask;
use IdeHelper\Generator\Task\RequestTask;
use IdeHelper\Generator\Task\RoutePathTask;
use IdeHelper\Generator\Task\TableAssociationTask;
use IdeHelper\Generator\Task\TableFinderTask;
use IdeHelper\Generator\Task\TaskInterface;
use IdeHelper\Generator\Task\TranslationKeyTask;
use IdeHelper\Generator\Task\ValidationTask;
use InvalidArgumentException;

class TaskCollection {

	/**
	 * @var array<class-string<\IdeHelper\Generator\Task\TaskInterface>, class-string<\IdeHelper\Generator\Task\TaskInterface>>
	 */
	protected array $defaultTasks = [
		ModelTask::class => ModelTask::class,
		BehaviorTask::class => BehaviorTask::class,
		ComponentTask::class => ComponentTask::class,
		HelperTask::class => HelperTask::class,
		MailerTask::class => MailerTask::class,
		TableAssociationTask::class => TableAssociationTask::class,
		TableFinderTask::class => TableFinderTask::class,
		DatabaseTypeTask::class => DatabaseTypeTask::class,
		ElementTask::class => ElementTask::class,
		LayoutTask::class => LayoutTask::class,
		PluginTask::class => PluginTask::class,
		ValidationTask::class => ValidationTask::class,
		RoutePathTask::class => RoutePathTask::class,
		CacheTask::class => CacheTask::class,
		RequestTask::class => RequestTask::class,
		EnvTask::class => EnvTask::class,
		ConsoleTask::class => ConsoleTask::class,
		ConnectionTask::class => ConnectionTask::class,
		FormHelperTask::class => FormHelperTask::class,
		DatabaseTableTask::class => DatabaseTableTask::class,
		DatabaseTableColumnNameTask::class => DatabaseTableColumnNameTask::class,
		DatabaseTableColumnTypeTask::class => DatabaseTableColumnTypeTask::class,
		EntityTask::class => EntityTask::class,
		FixtureTask::class => FixtureTask::class,
		TranslationKeyTask::class => TranslationKeyTask::class,
		ConfigureTask::class => ConfigureTask::class,
		CellTask::class => CellTask::class,
		ConsoleHelperTask::class => ConsoleHelperTask::class,
	];

	/**
	 * @var array<\IdeHelper\Generator\Task\TaskInterface>
	 */
	protected array $tasks = [];

	/**
	 * @param array<string|\IdeHelper\Generator\Task\TaskInterface> $tasks
	 */
	public function __construct(array $tasks = []) {
		$defaultTasks = $this->defaultTasks();
		$tasks += $defaultTasks;

		foreach ($tasks as $task) {
			if (!$task) {
				continue;
			}

			$this->add($task);
		}
	}

	/**
	 * @return array<class-string<\IdeHelper\Generator\Task\TaskInterface>>
	 */
	protected function defaultTasks(): array {
		$tasks = (array)Configure::read('IdeHelper.generatorTasks') + $this->defaultTasks;

		foreach ($tasks as $k => $v) {
			if (is_numeric($k)) {
				$tasks[$v] = $v;
				unset($tasks[$k]);
			}
		}

		return $tasks;
	}

	/**
	 * Adds a task to the collection.
	 *
	 * @param \IdeHelper\Generator\Task\TaskInterface|string $task The task to map.
	 * @throws \InvalidArgumentException
	 * @return $this
	 */
	protected function add($task) {
		if (is_string($task)) {
			$task = new $task();
		}

		$class = get_class($task);
		if (!$task instanceof TaskInterface) {
			throw new InvalidArgumentException(
				sprintf('Cannot use `%s` as task, it is not implementing `%s`.', $class, TaskInterface::class),
			);
		}

		$this->tasks[$class] = $task;

		return $this;
	}

	/**
	 * @return array<\IdeHelper\Generator\Task\TaskInterface>
	 */
	public function tasks(): array {
		return $this->tasks;
	}

	/**
	 * @return array<\IdeHelper\Generator\Directive\BaseDirective>
	 */
	public function getMap(): array {
		$map = [];
		foreach ($this->tasks as $task) {
			$map += $task->collect();
		}

		ksort($map);

		return $map;
	}

}


================================================
FILE: src/IdeHelperPlugin.php
================================================
<?php

namespace IdeHelper;

use Cake\Console\CommandCollection;
use Cake\Core\BasePlugin;
use IdeHelper\Command\Annotate\AllCommand;
use IdeHelper\Command\Annotate\CallbacksCommand;
use IdeHelper\Command\Annotate\ClassesCommand;
use IdeHelper\Command\Annotate\CommandsCommand;
use IdeHelper\Command\Annotate\ComponentsCommand;
use IdeHelper\Command\Annotate\ControllersCommand;
use IdeHelper\Command\Annotate\HelpersCommand;
use IdeHelper\Command\Annotate\ModelsCommand;
use IdeHelper\Command\Annotate\TemplatesCommand;
use IdeHelper\Command\Annotate\ViewCommand;
use IdeHelper\Command\GenerateCodeCompletionCommand;
use IdeHelper\Command\GeneratePhpStormMetaCommand;
use IdeHelper\Command\IlluminateCommand;

/**
 * Plugin for IdeHelper
 */
class IdeHelperPlugin extends BasePlugin {

	/**
	 * Define the console commands for an application.
	 *
	 * @param \Cake\Console\CommandCollection $commands The CommandCollection to add commands into.
	 * @return \Cake\Console\CommandCollection The updated collection.
	 */
	public function console(CommandCollection $commands): CommandCollection {
		$commands->add('annotate models', ModelsCommand::class);
		$commands->add('annotate view', ViewCommand::class);
		$commands->add('annotate helpers', HelpersCommand::class);
		$commands->add('annotate components', ComponentsCommand::class);
		$commands->add('annotate templates', TemplatesCommand::class);
		$commands->add('annotate controllers', ControllersCommand::class);
		$commands->add('annotate commands', CommandsCommand::class);
		$commands->add('annotate classes', ClassesCommand::class);
		$commands->add('annotate callbacks', CallbacksCommand::class);
		$commands->add('annotate all', AllCommand::class);

		$commands->add('generate code_completion', GenerateCodeCompletionCommand::class);
		$commands->add('generate phpstorm', GeneratePhpStormMetaCommand::class);
		$commands->add('illuminate code', IlluminateCommand::class);

		return $commands;
	}

}


================================================
FILE: src/Illuminator/Illuminator.php
================================================
<?php

namespace IdeHelper\Illuminator;

use IdeHelper\Filesystem\Folder;

class Illuminator {

	protected TaskCollection $taskCollection;

	/**
	 * @param \IdeHelper\Illuminator\TaskCollection $taskCollection
	 */
	public function __construct(TaskCollection $taskCollection) {
		$this->taskCollection = $taskCollection;
	}

	/**
	 * @param string $path
	 * @param string|null $filter
	 * @return int
	 */
	public function illuminate($path, $filter) {
		$files = $this->getFiles($path);

		$count = 0;
		foreach ($files as $file) {
			$name = pathinfo($file, PATHINFO_FILENAME);
			if ($this->shouldSkip($name, $filter)) {
				continue;
			}

			if (!$this->taskCollection->run($file)) {
				continue;
			}

			$count++;
		}

		return $count;
	}

	/**
	 * @param string $fileName
	 * @param string|null $filter
	 *
	 * @return bool
	 */
	protected function shouldSkip($fileName, $filter) {
		if (!$filter) {
			return false;
		}

		return !preg_match('/' . preg_quote($filter, '/') . '/i', $fileName);
	}

	/**
	 * @param string $path
	 * @return array<string>
	 */
	protected function getFiles($path) {
		$folder = new Folder($path);
		$result = $folder->findRecursive('.*\.php', true);

		return $result;
	}

}


================================================
FILE: src/Illuminator/Task/AbstractTask.php
================================================
<?php

namespace IdeHelper\Illuminator\Task;

use Cake\Core\Configure;
use Cake\Core\InstanceConfigTrait;
use IdeHelper\Annotator\Traits\FileTrait;
use PHP_CodeSniffer\Config;

$composerVendorDir = getcwd() . DS . 'vendor';
$codesnifferDir = 'squizlabs' . DS . 'php_codesniffer';
if (!is_dir($composerVendorDir . DS . $codesnifferDir)) {
	$ideHelperDir = substr(__DIR__, 0, (int)strpos(__DIR__, DS . 'cakephp-ide-helper'));
	$composerVendorDir = dirname($ideHelperDir);
}
$manualAutoload = $composerVendorDir . DS . $codesnifferDir . DS . 'autoload.php';
if (!class_exists(Config::class) && file_exists($manualAutoload)) {
	require $manualAutoload;
}

/**
 * Reads the annotated properties of an entity and adds the constants based on those.
 */
abstract class AbstractTask {

	use FileTrait;
	use InstanceConfigTrait;

	/**
	 * @var string
	 */
	public const CONFIG_DRY_RUN = 'dry-run';

	/**
	 * @var string
	 */
	public const CONFIG_PLUGIN = 'plugin';

	/**
	 * @var string
	 */
	public const CONFIG_NAMESPACE = 'namespace';

	/**
	 * @var string
	 */
	public const CONFIG_VERBOSE = 'verbose';

	/**
	 * @var string
	 */
	public const COUNT_ADDED = 'added';

	/**
	 * @var array<string, mixed>
	 */
	protected array $_defaultConfig = [];

	/**
	 * @param array<string, mixed> $config
	 */
	public function __construct(array $config) {
		$this->setConfig($config);

		$namespace = $this->getConfig(static::CONFIG_PLUGIN) ?: Configure::read('App.namespace', 'App');
		$namespace = str_replace('/', '\\', $namespace);
		$this->setConfig(static::CONFIG_NAMESPACE, $namespace);
	}

	/**
	 * @param string $path
	 * @return bool
	 */
	abstract public function shouldRun(string $path): bool;

	/**
	 * @param string $content
	 * @param string $path
	 * @return string
	 */
	abstract public function run(string $content, string $path): string;

}


================================================
FILE: src/Illuminator/Task/ControllerDefaultTableTask.php
================================================
<?php

namespace IdeHelper\Illuminator\Task;

use Cake\Core\Configure;
use IdeHelper\Annotator\Traits\DocBlockTrait;
use IdeHelper\Annotator\Traits\FileTrait;
use PHP_CodeSniffer\Files\File;

/**
 * Adds $defaultTable = '' property to controllers that don't have a corresponding table class.
 */
class ControllerDefaultTableTask extends AbstractTask {

	use FileTrait;
	use DocBlockTrait;

	/**
	 * @var array<string, mixed>
	 */
	protected array $_defaultConfig = [
		'fastPropertyCheck' => false,
	];

	/**
	 * @param string $path
	 * @return bool
	 */
	public function shouldRun(string $path): bool {
		$className = pathinfo($path, PATHINFO_FILENAME);
		if (!str_ends_with($className, 'Controller')) {
			return false;
		}

		if ($className === 'AppController' || preg_match('#[A-Za-z0-9]AppController$#', $className)) {
			return false;
		}

		if (!preg_match('#[\\\/]Controller[\\\/]#', $path)) {
			return false;
		}

		return true;
	}

	/**
	 * @param string $content
	 * @param string $path Path to file.
	 * @return string
	 */
	public function run(string $content, string $path): string {
		$file = $this->getFile('', $content);
		$classIndex = $file->findNext(T_CLASS, 0);
		if (!$classIndex) {
			return $content;
		}

		if ($this->hasDefaultTableProperty($file, $classIndex, $content)) {
			return $content;
		}

		$className = pathinfo($path, PATHINFO_FILENAME);
		$namespace = $this->extractNamespace($content);
		if (!$namespace) {
			return $content;
		}

		$baseNamespace = $this->detectPluginFromNamespace($namespace);

		$modelName = substr($className, 0, -10);
		$modelClassName = str_replace('/', '\\', $baseNamespace) . '\\Model\\Table\\' . $modelName . 'Table';

		if (class_exists($modelClassName)) {
			return $content;
		}

		return $this->addDefaultTableProperty($file, $classIndex, $content);
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param int $classIndex
	 * @param string $content
	 * @return bool
	 */
	protected function hasDefaultTableProperty(File $file, int $classIndex, string $content): bool {
		// Fast regex check for performance (optional, can be enabled via config)
		if ($this->getConfig('fastPropertyCheck')) {
			if (preg_match('/\bprotected \?string \$defaultTable\b/', $content)) {
				return true;
			}

			return false;
		}

		// Robust token-based check within class scope
		$tokens = $file->getTokens();

		$openBraceIndex = $tokens[$classIndex]['scope_opener'];
		$closeBraceIndex = $tokens[$classIndex]['scope_closer'];
		if (!$openBraceIndex || !$closeBraceIndex) {
			return false;
		}

		for ($i = $openBraceIndex + 1; $i < $closeBraceIndex; $i++) {
			if ($tokens[$i]['code'] !== T_VARIABLE) {
				continue;
			}

			if ($tokens[$i]['content'] === '$defaultTable') {
				return true;
			}
		}

		return false;
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param int $classIndex
	 * @param string $content
	 * @return string
	 */
	protected function addDefaultTableProperty(File $file, int $classIndex, string $content): string {
		$tokens = $file->getTokens();

		$openBraceIndex = $tokens[$classIndex]['scope_opener'];
		$closeBraceIndex = $tokens[$classIndex]['scope_closer'];
		if (!$openBraceIndex || !$closeBraceIndex) {
			return $content;
		}

		$indentation = Configure::read('IdeHelper.illuminatorIndentation') ?? "\t";

		$fixer = $this->getFixer($file);

		$property = PHP_EOL . PHP_EOL . $indentation . 'protected ?string $defaultTable = \'\';';

		$fixer->addContent($openBraceIndex, $property);

		return $fixer->getContents();
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param int $index
	 * @return string
	 */
	protected function detectIndentation(File $file, int $index): string {
		$tokens = $file->getTokens();

		$line = $tokens[$index]['line'];
		$firstOfLine = $index;
		while ($firstOfLine - 1 >= 0 && $tokens[$firstOfLine - 1]['line'] === $line) {
			$firstOfLine--;
		}

		$whitespace = '';
		for ($i = $firstOfLine; $i < $index; $i++) {
			if ($tokens[$i]['code'] === T_WHITESPACE) {
				$whitespace .= $tokens[$i]['content'];
			}
		}

		return $whitespace;
	}

	/**
	 * @param string $content
	 * @return string|null
	 */
	protected function extractNamespace(string $content): ?string {
		if (preg_match('/^namespace\s+([^;]+);/m', $content, $matches)) {
			return $matches[1];
		}

		return null;
	}

	/**
	 * @param string $namespace
	 * @return string
	 */
	protected function detectPluginFromNamespace(string $namespace): string {
		$plugin = $this->getConfig(static::CONFIG_PLUGIN);
		if ($plugin) {
			return $plugin;
		}

		$parts = explode('\\', $namespace);
		$controllerIndex = array_search('Controller', $parts, true);
		if ($controllerIndex !== false && $controllerIndex > 0) {
			return implode('\\', array_slice($parts, 0, $controllerIndex));
		}

		return Configure::read('App.namespace', 'App');
	}

}


================================================
FILE: src/Illuminator/Task/EntityFieldTask.php
================================================
<?php

namespace IdeHelper\Illuminator\Task;

use Cake\Core\Configure;
use Cake\Utility\Inflector;
use IdeHelper\Annotation\PropertyAnnotation;
use IdeHelper\Annotation\PropertyReadAnnotation;
use IdeHelper\Annotator\Traits\DocBlockTrait;
use IdeHelper\Annotator\Traits\FileTrait;
use PHP_CodeSniffer\Files\File;
use PHP_CodeSniffer\Util\Tokens;

/**
 * Reads the annotated properties of an entity and adds the constants based on those.
 */
class EntityFieldTask extends AbstractTask {

	use FileTrait;
	use DocBlockTrait;

	/**
	 * @var string
	 */
	public const PREFIX = 'FIELD_';

	/**
	 * @var array<string, mixed>
	 */
	protected array $_defaultConfig = [
		'visibility' => null,
	];

	/**
	 * @var bool|null
	 */
	protected $_visibility;

	/**
	 * @param string $path
	 * @return bool
	 */
	public function shouldRun(string $path): bool {
		return (bool)preg_match('#' . preg_quote(DS) . 'Model' . preg_quote(DS) . 'Entity' . preg_quote(DS) . '.+\\.php$#', $path);
	}

	/**
	 * @param string $content
	 * @param string $path Path to file.
	 * @return string
	 */
	public function run(string $content, string $path): string {
		$file = $this->getFile('', $content);

		$classIndex = $file->findNext(T_CLASS, 0);
		if (!$classIndex) {
			return $content;
		}

		$tokens = $file->getTokens();

		$fields = $this->getFields($file, $classIndex);

		$existingConstants = $this->getFieldConstants($tokens, $tokens[$classIndex]['scope_opener'], $tokens[$classIndex]['scope_closer']);
		if ($existingConstants) {
			$fields = array_diff_key($fields, $existingConstants);
			$existingConstant = array_pop($existingConstants);
			$index = $existingConstant['index'];
			$addToExisting = true;
		} else {
			$index = $file->findPrevious(T_WHITESPACE, $tokens[$classIndex]['scope_closer'] + -1, $tokens[$classIndex]['scope_opener'], true);
			if ($index === false) {
				$index = $tokens[$classIndex]['scope_opener'];
			}
			$addToExisting = false;
		}

		return $this->addClassConstants($file, $fields, $index, $addToExisting, 0) ?: $content;
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param int $classIndex
	 * @return array<string, array<string, mixed>>
	 */
	protected function getFields(File $file, int $classIndex): array {
		$tokens = $file->getTokens();

		$docBlockCloseTagIndex = $this->findDocBlockCloseTagIndex($file, $classIndex);
		if (!$docBlockCloseTagIndex || empty($tokens[$docBlockCloseTagIndex]['comment_opener'])) {
			return [];
		}

		$fields = [];
		for ($i = $tokens[$docBlockCloseTagIndex]['comment_opener'] + 1; $i < $docBlockCloseTagIndex; $i++) {

			if ($tokens[$i]['code'] !== T_DOC_COMMENT_TAG) {
				continue;
			}
			if ($tokens[$i]['content'] !== PropertyAnnotation::TAG && $tokens[$i]['content'] !== PropertyReadAnnotation::TAG) {
				continue;
			}

			/** @var \PHPStan\PhpDocParser\Ast\PhpDoc\PropertyTagValueNode $valueNode */
			$valueNode = static::getValueNode($tokens[$i]['content'], $tokens[$i + 2]['content']);
			$returnTypes = $this->valueNodeParts($valueNode);
			$typeString = $this->renderUnionTypes($returnTypes);

			$varAndComment = substr($tokens[$i + 2]['content'], strlen($typeString) + 1);
			$varName = mb_substr($varAndComment, 1);
			$pieces = explode(' ', $varName);
			$field = $pieces[0];

			if (str_starts_with($field, '_')) {
				continue;
			}
			// We also skip camelCase as those are not the convention
			if (Inflector::underscore($field) !== $field) {
				continue;
			}

			$fields[$field] = [
				'name' => $field,
				'constant' => static::PREFIX . mb_strtoupper($field),
				'index' => $i,
			];
		}

		return $fields;
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param int $index First functional code after docblock
	 *
	 * @return int|null
	 */
	protected function findDocBlockCloseTagIndex(File $file, int $index): ?int {
		$prevCode = $file->findPrevious(Tokens::$emptyTokens, $index - 1, null, true);
		if (!$prevCode) {
			return null;
		}

		return $file->findPrevious(T_DOC_COMMENT_CLOSE_TAG, $index - 1, $prevCode) ?: null;
	}

	/**
	 * @param \PHP_CodeSniffer\Files\File $file
	 * @param array<array<string, mixed>> $fields
	 * @param int $index Index of first token of previous line
	 * @param bool $addToExisting
	 * @param int $level
	 * @return string|null
	 */
	protected function addClassConstants(File $file, array $fields, $index, $addToExisting, $level = 1) {
		if (!$fields) {
			return null;
		}

		$tokens = $file->getTokens();

		$line = $tokens[$index]['line'];

		$i = $index;
		while ($tokens[$i + 1]['line'] === $line) {
			$i++;
		}

		$lastTokenOfLastLine = $i;

		$whitespace = '';
		$firstOfLine = $index;
		while ($tokens[$firstOfLine - 1]['line'] === $tokens[$index]['line']) {
			$firstOfLine--;
			$whitespace .= $tokens[$firstOfLine]['content'];
		}
		if ($level < 1) {
			$whitespace = Configure::read('IdeHelper.illuminatorIndentation') ?? "\t";
		}

		$beginIndex = $lastTokenOfLastLine;
		$visibility = '';
		if ($this->visibility()) {
			$visibility = 'public ';
		}

		$fixer = $this->getFixer($file);

		$fixer->beginChangeset();

		if (!$addToExisting) {
			$fixer->addNewline($beginIndex);
		}

		foreach ($fields as $field) {
			$fixer->addContent($beginIndex, $whitespace . $visibility . 'const ' . $field['constant'] . ' = \'' . $field['name'] . '\';');
			$fixer->addNewline($beginIndex);
		}

		$fixer->endChangeset();

		return $fixer->getContents();
	}

	/**
	 * @param array<array<string, mixed>> $tokens
	 * @param int $startIndex
	 * @param int $endIndex
	 * @return array<string, array<string, mixed>>
	 */
	protected function getFieldConstants(array $tokens, int $startIndex, int $endIndex) {
		$constants = [];

		for ($i = $startIndex + 1; $i < $endIndex; $i++) {
			if ($tokens[$i]['code'] !== T_CONST) {
				continue;
			}
			$index = $i + 1;
			if ($tokens[$index]['code'] === T_WHITESPACE) {
				$index++;
			}
			if ($tokens[$index]['code'] !== T_STRING) {
				continue;
			}

			$constant = $tokens[$index]['content'];

			$pos = strpos($constant, '_') ?: 0;
			$prefix = substr($constant, 0, $pos) ?: '';
			if ($prefix . '_' !== static::PREFIX) {
				continue;
			}

			$field = substr($constant, $pos + 1);
			$field = strtolower($field);

			$constants[$field] = [
				'index' => $i,
				'prefix' => $prefix,
				'name' => $field,
				'constant' => $constant,
			];
		}

		return $constants;
	}

	/**
	 * If visibility "public" should be used, for PHP 7.1+ only.
	 *
	 * @return bool
	 */
	protected function visibility(): bool {
		if ($this->_visibility !== null) {
			return $this->_visibility;
		}

		$visConfig = $this->getConfig('visibility') ?? true;

		return $this->_visibility = $visConfig;
	}

}


================================================
FILE: src/Illuminator/Task/TableValidationLinkTask.php
================================================
<?php

namespace IdeHelper\Illuminator\Task;

use PhpParser\Node;
use PhpParser\NodeTraverser;
use PhpParser\NodeVisitorAbstract;
use PhpParser\ParserFactory;
use Throwable;

/**
 * Adds @link annotations above 'rule' definitions that reference table provider methods.
 *
 * When validation rules use 'provider' => 'table' with a method reference,
 * this task adds a @link annotation directly above the 'rule' line to help
 * IDEs recognize the method usage.
 */
class TableValidationLinkTask extends AbstractTask {

	/**
	 * @param string $path
	 * @return bool
	 */
	public function shouldRun(string $path): bool {
		$className = pathinfo($path, PATHINFO_FILENAME);

		return $className !== 'Table' && str_ends_with($className, 'Table');
	}

	/**
	 * @param string $content
	 * @param string $path Path to file.
	 * @return string
	 */
	public function run(string $content, string $path): string {
		$links = $this->findTableProviderMethods($content);
		if (!$links) {
			return $content;
		}

		return $this->insertLinkAnnotations($content, $links);
	}

	/**
	 * Find all ->add() calls with 'provider' => 'table' and extract the method names.
	 *
	 * @param string $content
	 * @return array<int, string> Map of line number (of 'rule' key) => method name
	 */
	protected function findTableProviderMethods(string $content): array {
		$parser = (new ParserFactory())->createForNewestSupportedVersion();

		try {
			$ast = $parser->parse($content);
		} catch (Throwable $e) {
			return [];
		}

		if ($ast === null) {
			return [];
		}

		$visitor = new class extends NodeVisitorAbstract {
			/**
			 * @var array<int, string>
			 */
			public array $links = [];

			/**
			 * @param \PhpParser\Node $node
			 * @return int|null
			 */
			public function enterNode(Node $node): ?int {
				if (!$node instanceof Node\Expr\MethodCall) {
					return null;
				}

				if (!$node->name instanceof Node\Identifier || $node->name->name !== 'add') {
					return null;
				}

				// Need at least 3 arguments: field, ruleName, options array
				if (count($node->args) < 3) {
					return null;
				}

				$optionsArg = $node->args[2];
				if (!$optionsArg instanceof Node\Arg) {
					return null;
				}

				$options = $optionsArg->value;
				if (!$options instanceof Node\Expr\Array_) {
					return null;
				}

				$result = $this->extractTableProviderMethod($options);
				if ($result !== null) {
					$this->links[$result['ruleLine']] = $result['methodName'];
				}

				return null;
			}

			/**
			 * @param \PhpParser\Node\Expr\Array_ $options
			 * @return array{ruleLine: int, methodName: string}|null
			 */
			protected function extractTableProviderMethod(Node\Expr\Array_ $options): ?array {
				$hasTableProvider = false;
				$methodName = null;
				$ruleLine = null;

				foreach ($options->items as $item) {
					if (!$item instanceof Node\Expr\ArrayItem || $item->key === null) {
						continue;
					}

					$key = $this->getStringValue($item->key);
					if ($key === null) {
						continue;
					}

					if ($key === 'provider') {
						$value = $this->getStringValue($item->value);
						if ($value === 'table') {
							$hasTableProvider = true;
						}
					}

					if ($key === 'rule') {
						$methodName = $this->extractMethodFromRule($item->value);
						$ruleLine = $item->getStartLine();
					}
				}

				if ($hasTableProvider && $methodName !== null && $ruleLine !== null) {
					return ['ruleLine' => $ruleLine, 'methodName' => $methodName];
				}

				return null;
			}

			/**
			 * @param \PhpParser\Node\Expr $value
			 * @return string|null
			 */
			protected function extractMethodFromRule(Node\Expr $value): ?string {
				// 'rule' => 'methodName'
				$stringValue = $this->getStringValue($value);
				if ($stringValue !== null) {
					return $stringValue;
				}

				// 'rule' => ['methodName', 'arg1', ...]
				if ($value instanceof Node\Expr\Array_ && count($value->items) > 0) {
					$firstItem = $value->items[0];
					if ($firstItem instanceof Node\Expr\ArrayItem) {
						return $this->getStringValue($firstItem->value);
					}
				}

				return null;
			}

			/**
			 * @param \PhpParser\Node\Expr $expr
			 * @return string|null
			 */
			protected function getStringValue(Node\Expr $expr): ?string {
				if ($expr instanceof Node\Scalar\String_) {
					return $expr->value;
				}

				return null;
			}
		};

		$traverser = new NodeTraverser();
		$traverser->addVisitor($visitor);
		$traverser->traverse($ast);

		return $visitor->links;
	}

	/**
	 * Insert @link annotations above the specified lines.
	 *
	 * @param string $content
	 * @param array<int, string> $links Map of line number => method name
	 * @return string
	 */
	protected function insertLinkAnnotations(string $content, array $links): string {
		$lines = explode("\n", $content);

		// Sort by line number descending to avoid offset issues when inserting
		krsort($links);

		foreach ($links as $lineNumber => $methodName) {
			$index = $lineNumber - 1; // Convert to 0-based index
			if (!isset($lines[$index])) {
				continue;
			}

			// Check if there's already a @link annotation for this method
			if ($index > 0 && $this->hasLinkAnnotation($lines[$index - 1], $methodName)) {
				continue;
			}

			// Get the indentation of the target line
			$targetLine = $lines[$index];
			preg_match('/^(\s*)/', $targetLine, $matches);
			$indent = $matches[1] ?? '';

			// Insert the @link annotation
			$annotation = $indent . '/** @link ' . $methodName . '() */';
			array_splice($lines, $index, 0, [$annotation]);
		}

		return implode("\n", $lines);
	}

	/**
	 * Check if a line already contains a @link annotation for the given method.
	 *
	 * @param string $line
	 * @param string $methodName
	 * @return bool
	 */
	protected function hasLinkAnnotation(string $line, string $methodName): bool {
		return str_contains($line, '@link') && str_contains($line, $methodName);
	}

}


================================================
FILE: src/Illuminator/TaskCollection.php
================================================
<?php

namespace IdeHelper\Illuminator;

use Cake\Console\ConsoleIo;
use Cake\Core\Configure;
use IdeHelper\Console\Io;
use IdeHelper\Illuminator\Task\AbstractTask;
use IdeHelper\Illuminator\Task\ControllerDefaultTableTask;
use IdeHelper\Illuminator\Task\EntityFieldTask;
use IdeHelper\Illuminator\Task\TableValidationLinkTask;
use InvalidArgumentException;
use RuntimeException;
use SebastianBergmann\Diff\Differ;
use SebastianBergmann\Diff\Output\DiffOnlyOutputBuilder;

class TaskCollection {

	/**
	 * @var string
	 */
	public const CONFIG_DRY_RUN = 'dry-run';

	protected Io $_io;

	/**
	 * @var array<string, mixed>
	 */
	protected array $_config;

	/**
	 * @var array<class-string<\IdeHelper\Illuminator\Task\AbstractTask>, class-string<\IdeHelper\Illuminator\Task\AbstractTask>>
	 */
	protected array $defaultTasks = [
		ControllerDefaultTableTask::class => ControllerDefaultTableTask::class,
		EntityFieldTask::class => EntityFieldTask::class,
		TableValidationLinkTask::class => TableValidationLinkTask::class,
	];

	/**
	 * @var array<\IdeHelper\Illuminator\Task\AbstractTask>
	 */
	protected array $tasks = [];

	/**
	 * @param \IdeHelper\Console\Io $io
	 * @param array<string, mixed> $config
	 * @param array<string> $tasks
	 * @throws \InvalidArgumentException
	 */
	public function __construct(Io $io, array $config, array $tasks = []) {
		$this->_io = $io;
		$this->_config = $config;

		$defaultTasks = $this->defaultTasks();

		$keyMap = $this->taskNames($defaultTasks);
		$filterMap = array_diff($tasks, $keyMap);
		if ($filterMap) {
			throw new InvalidArgumentException('Tasks do not exist: ' . implode(', ', $filterMap) . '.');
		}

		foreach ($defaultTasks as $key => $task) {
			if (!$task) {
				continue;
			}
			$lookupKey = $keyMap[$key];
			if ($tasks && !in_array($lookupKey, $tasks, true)) {
				continue;
			}

			$this->add($task);
		}
	}

	/**
	 * @return array<class-string<\IdeHelper\Illuminator\Task\AbstractTask>>
	 */
	protected function defaultTasks(): array {
		$tasks = (array)Configure::read('IdeHelper.illuminatorTasks') + $this->defaultTasks;

		foreach ($tasks as $k => $v) {
			if (is_numeric($k)) {
				$tasks[$v] = $v;
				unset($tasks[$k]);
			}
		}

		return $tasks;
	}

	/**
	 * Adds a task to the collection.
	 *
	 * @param \IdeHelper\Illuminator\Task\AbstractTask|string $task The task to map.
	 * @throws \InvalidArgumentException
	 * @return $this
	 */
	protected function add($task) {
		if (is_string($task)) {
			$task = new $task($this->_config);
		}

		$class = get_class($task);
		if (!$task instanceof AbstractTask) {
			throw new InvalidArgumentException(
				sprintf('Cannot use `%s` as task, it is not implementing `%s`.', $class, AbstractTask::class),
			);
		}

		$this->tasks[$class] = $task;

		return $this;
	}

	/**
	 * @return array<\IdeHelper\Illuminator\Task\AbstractTask>
	 */
	public function tasks(): array {
		return $this->tasks;
	}

	/**
	 * @param array<string>|array<\IdeHelper\Illuminator\Task\AbstractTask> $tasks
	 * @throws \RuntimeException
	 * @return array<string>
	 */
	public function taskNames($tasks = []): array {
		if (!$tasks) {
			$tasks = $this->tasks;
		}

		$keys = array_keys($tasks);
		$keyMap = array_combine($keys, $keys) ?: [];
		foreach ($keyMap as $k => $v) {
			preg_match('#\bTask\\\\([A-Za-z0-9]+)Task$#', $v, $matches);
			if (!$matches) {
				throw new RuntimeException('Invalid task name: ' . $v);
			}
			$keyMap[$k] = $matches[1];
		}

		return $keyMap;
	}

	/**
	 * @param string $path File path
	 * @return bool True if file is/was modified; false if nothing changed.
	 */
	public function run(string $path): bool {
		$file = str_replace(ROOT . DS, DS, $path);
		$this->_io->verbose('# ' . $file);

		$content = $result = null;

		foreach ($this->tasks as $task) {
			if (!$task->shouldRun($path)) {
				continue;
			}

			if ($content === null) {
				$content = file_get_contents($path);
				if ($content === false) {
					throw new RuntimeException('Cannot read file');
				}
				$result = $content;
			}

			$result = $task->run((string)$result, $path);
		}

		if ($content === null || $result === $content) {
			return false;
		}

		$this->displayDiff($content, (string)$result);
		$this->storeFile($path, (string)$result, $this->_config[static::CONFIG_DRY_RUN]);

		return true;
	}

	/**
	 * @param string $oldContent
	 * @param string $newContent
	 * @return void
	 */
	protected function displayDiff(string $oldContent, string $newContent): void {
		$differ = new Differ(new DiffOnlyOutputBuilder());
		$array = $differ->diffToArray($oldContent, $newContent);

		$begin = null;
		$end = null;
		/**
		 * @var int $key
		 */
		foreach ($array as $key => $row) {
			if ($row[1] === 0) {
				continue;
			}

			if ($begin === null) {
				$begin = $key;
			}
			$end = $key;
		}
		if ($begin === null) {
			return;
		}
		$firstLineOfOutput = $begin > 0 ? $begin - 1 : 0;
		$lastLineOfOutput = count($array) - 1 > $end ? $end + 1 : $end;

		for ($i = $firstLineOfOutput; $i <= $lastLineOfOutput; $i++) {
			$row = $array[$i];

			$char = ' ';
			$output = trim($row[0], "\n\r\0\x0B");

			if ($row[1] === 1) {
				$char = '+';
				$this->_io->info('   | ' . $char . $output, 1, ConsoleIo::VERBOSE);
			} elseif ($row[1] === 2) {
				$char = '-';
				$this->_io->out('<warning>' . '   | ' . $char . $output . '</warning>', 1, ConsoleIo::VERBOSE);
			} else {
				$this->_io->out('   | ' . $char . $output, 1, ConsoleIo::VERBOSE);
			}
		}
	}

	/**
	 * @param string $path
	 * @param string $contents
	 * @param bool $dryRun
	 * @throws \RuntimeException When the file cannot be written.
	 * @return void
	 */
	protected function storeFile(string $path, string $contents, bool $dryRun): void {
		if ($dryRun) {
			return;
		}

		if (file_put_contents($path, $contents) === false) {
			throw new RuntimeException(sprintf('Failed to write file `%s`.', $path));
		}
	}

}


================================================
FILE: src/Utility/App.php
================================================
<?php

namespace IdeHelper\Utility;

use Cake\Core\App as CoreApp;
use Cake\Core\Configure;
use Cake\Http\Exception\NotFoundException;
use Throwable;

class App extends CoreApp {

	/**
	 * @param string $class
	 * @param string $type
	 * @param string $suffix
	 * @param bool $includeApp
	 *
	 * @return string|null
	 */
	public static function className(string $class, string $type = '', string $suffix = '', bool $includeApp = true): ?string {
		try {
			if (str_contains($class, '\\')) {
				return class_exists($class) ? $class : null;
			}

			[$plugin, $name] = pluginSplit($class);
			$fullName = '\\' . str_replace('/', '\\', $type . '\\' . $name) . $suffix;

			$appNamespace = $includeApp ? Configure::read('App.namespace') : null;
			$base = $plugin ?: $appNamespace;
			if ($base !== null) {
				$base = str_replace('/', '\\', rtrim($base, '\\'));

				if (static::_classExistsInBase($fullName, $base)) {
					/** @var class-string */
					return $base . $fullName;
				}
			}

			if ($plugin || !static::_classExistsInBase($fullName, 'Cake')) {
				return null;
			}

			/** @var class-string */
			return 'Cake' . $fullName;
		} catch (Throwable $e) {
			// Do nothing
		}

		return null;
	}

	/**
	 * @param string $class
	 * @param string $type
	 * @param string $suffix
	 *
	 * @throws \Cake\Http\Exception\NotFoundException
	 *
	 * @return string
	 */
	public static function classNameOrFail(string $class, string $type = '', string $suffix = ''): string {
		$className = parent::className($class, $type, $suffix);
		if (!$className) {
			throw new NotFoundException('Class not found.');
		}

		return $className;
	}

}


================================================
FILE: src/Utility/AppPath.php
================================================
<?php

namespace IdeHelper\Utility;

use Cake\Core\App;
use Cake\Core\Exception\MissingPluginException;

class AppPath {

	/**
	 * @param string $type
	 * @param string|null $plugin
	 * @throws \Cake\Core\Exception\MissingPluginException
	 * @return array<string>
	 */
	public static function get(string $type, ?string $plugin = null): array {
		try {
			return App::classPath($type, $plugin);
		} catch (MissingPluginException $exception) {
		}

		return App::classPath($type, $plugin);
	}

}


================================================
FILE: src/Utility/CollectionClass.php
================================================
<?php

namespace IdeHelper\Utility;

use Cake\Core\Configure;
use Cake\Core\Exception\CakeException;

class CollectionClass {

	/**
	 * @param string $name FQCN
	 *
	 * @return string
	 */
	public static function name(string $name): string {
		$configured = Configure::read('IdeHelper.templateCollectionObject');
		if ($configured === null || $configured === true) {
			return $name;
		}
		if ($configured === false) {
			return 'array';
		}
		if (!is_string($configured)) {
			throw new CakeException('`templateCollectionObject` config must be `string|bool|null`.');
		}

		return $configured;
	}

}


================================================
FILE: src/Utility/ControllerActionParser.php
================================================
<?php

namespace IdeHelper\Utility;

use App\Controller\AppController;
use ReflectionClass;
use ReflectionMethod;
use RuntimeException;
use Throwable;

class ControllerActionParser {

	/**
	 * @var array<string>|null
	 */
	protected static $appControllerActions;

	/**
	 * @param string $path
	 *
	 * @return array<string>
	 */
	public function parse(string $path): array {
		$actions = $this->parseFile($path);

		if (static::$appControllerActions === null) {
			try {
				$class = new ReflectionClass(AppController::class);
				$methods = $class->getMethods(ReflectionMethod::IS_PUBLIC);
			} catch (Throwable $exception) {
				return [];
			}

			static::$appControllerActions = [];
			foreach ($methods as $method) {
				static::$appControllerActions[] = $method->getName();
			}
		}

		$actions = array_diff($actions, static::$appControllerActions);

		return array_values($actions);
	}

	/**
	 * @param string $path
	 *
	 * @return array<string>
	 */
	protected function parseFile($path): array {
		$content = file_get_contents($path);
		if ($content === false) {
			throw new RuntimeException('Cannot read file');
		}

		preg_match_all('/public function (.+)\(/', $content, $matches);
		if (empty($matches[1])) {
			return [];
		}

		return $matches[1];
	}

}


================================================
FILE: src/Utility/GenericString.php
================================================
<?php

namespace IdeHelper\Utility;

use Cake\Core\Configure;
use Cake\Datasource\ResultSetInterface;

class GenericString {

	/**
	 * @param string $value
	 * @param string|null $type
	 *
	 * @return string
	 */
	public static function generate(string $value, ?string $type = null): string {
		if ($type !== null && str_starts_with($type, '\\')) {
			$typeCheck = substr($type, 1);
		} else {
			$typeCheck = $type;
		}

		$detailed = Configure::read('IdeHelper.genericsInParam') === 'detailed';
		if ($detailed && $typeCheck === ResultSetInterface::class) {
			return sprintf($type . '<int, %s>', $value);
		}

		if (Configure::read('IdeHelper.arrayAsGenerics') && ($type === null || in_array($type, ['array', 'iterable'], true))) {
			return sprintf(($type ?: 'array' ) . '<%s>', $value);
		}
		if (Configure::read('IdeHelper.objectAsGenerics') && $type !== null) {
			return sprintf($type . '<%s>', $value);
		}

		if ($typeCheck === ResultSetInterface::class) {
			if (Configure::read('IdeHelper.concreteEntitiesInParam')) {
				return sprintf($type . '<%s>', $value);
			}

			return $value . '[]|' . $type . '<' . $value . '>';
		}

		$value .= '[]';
		if ($type) {
			$value .= '|' . $type;
		}

		return $value;
	}

}


================================================
FILE: src/Utility/Plugin.php
================================================
<?php

namespace IdeHelper\Utility;

use Cake\Core\Configure;
use Cake\Core\Plugin as CorePlugin;

class Plugin extends CorePlugin {

	/**
	 * @return array<string>
	 */
	public static function all(): array {
		$plugins = static::loaded();
		$plugins = array_combine($plugins, $plugins);

		$pluginMap = (array)Configure::read('IdeHelper.plugins');
		foreach ($pluginMap as $plugin) {
			if (str_starts_with($plugin, '-')) {
				$plugin = substr($plugin, 1);
				unset($plugins[$plugin]);

				continue;
			}

			$plugins[$plugin] = $plugin;
		}

		return $plugins;
	}

}


================================================
FILE: src/Utility/PluginPath.php
================================================
<?php

namespace IdeHelper\Utility;

use Cake\Core\Exception\MissingPluginException;

class PluginPath {

	/**
	 * @param string $plugin
	 * @throws \Cake\Core\Exception\MissingPluginException
	 * @return string
	 */
	public static function get(string $plugin): string {
		try {
			return Plugin::path($plugin);
		} catch (MissingPluginException $exception) {
		}

		return Plugin::path($plugin);
	}

	/**
	 * @param string $plugin
	 *
	 * @return string
	 */
	public static function classPath(string $plugin): string {
		try {
			return Plugin::classPath($plugin);
		} catch (MissingPluginException $exception) {
		}

		return Plugin::classPath($plugin);
	}

}


================================================
FILE: src/Utility/TranslationParser.php
================================================
<?php

namespace IdeHelper\Utility;

use Cake\I18n\Parser\PoFileParser;

class TranslationParser {

	protected PoFileParser $poFileParser;

	public function __construct() {
		$this->poFileParser = new PoFileParser();
	}

	/**
	 * @param string $path File path
	 *
	 * @return array<string>
	 */
	public function parse(string $path): array {
		$result = $this->poFileParser->parse($path);
		$resultKeys = array_keys($result);

		$domainKeys = [];
		foreach ($resultKeys as $resultKey) {
			$resultKey = $this->escapeSlashes($resultKey);

			$domainKeys[$resultKey] = $resultKey;
		}

		return $domainKeys;
	}

	/**
	 * @param string $key
	 *
	 * @return string
	 */
	protected function escapeSlashes(string $key): string {
		return addcslashes($key, '\'');
	}

}


================================================
FILE: src/ValueObject/ArgumentsSet.php
================================================
<?php

namespace IdeHelper\ValueObject;

/**
 * Helps to use an existing argument set to be used in other directives for DRY code.
 *
 * Then it can be used in other places as argumentsSet('mySet').
 *
 * @see https://www.jetbrains.com/help/phpstorm/ide-advanced-metadata.html#arguments-set
 */
class ArgumentsSet implements ValueObjectInterface {

	protected string $value;

	/**
	 * @param string $value
	 */
	private function __construct(string $value) {
		$this->value = $value;
	}

	/**
	 * Creates itself from a string.
	 *
	 * @param string $value
	 *
	 * @return static
	 */
	public static function create(string $value) {
		return new static($value);
	}

	/**
	 * @return string
	 */
	public function raw(): string {
		return $this->value;
	}

	/**
	 * @return string
	 */
	public function __toString(): string {
		return 'argumentsSet(\'' . $this->value . '\')';
	}

}


================================================
FILE: src/ValueObject/ClassName.php
================================================
<?php

namespace IdeHelper\ValueObject;

/**
 * Holds a FQCN string, which can be auto-casted to string
 */
class ClassName implements ValueObjectInterface {

	protected string $className;

	/**
	 * @param string $className
	 */
	private function __construct(string $className) {
		$this->className = $className;
	}

	/**
	 * Creates itself from a fully qualified class name.
	 *
	 * @param string $className
	 * @return static
	 */
	public static function create(string $className) {
		if (str_starts_with($className, '\\')) {
			$className = substr($className, 1);
		}

		return new static($className);
	}

	/**
	 * @return string
	 */
	public function raw(): string {
		return $this->className;
	}

	/**
	 * @return string
	 */
	public function __toString(): string {
		return '\\' . $this->className . '::class';
	}

}


================================================
FILE: src/ValueObject/KeyValue.php
================================================
<?php

namespace IdeHelper\ValueObject;

/**
 * Holds a ValueObject key/value combination that will be treated literally on output.
 */
class KeyValue {

	protected ValueObjectInterface $key;

	protected ValueObjectInterface $value;

	/**
	 * @param \IdeHelper\ValueObject\ValueObjectInterface $key
	 * @param \IdeHelper\ValueObject\ValueObjectInterface $value
	 */
	private function __construct(ValueObjectInterface $key, ValueObjectInterface $value) {
		$this->key = $key;
		$this->value = $value;
	}

	/**
	 * Creates itself from a ValueObjectInterface key and value.
	 *
	 * @param \IdeHelper\ValueObject\ValueObjectInterface $key
	 * @param \IdeHelper\ValueObject\ValueObjectInterface $value
	 *
	 * @return static
	 */
	public static function create(ValueObjectInterface $key, ValueObjectInterface $value) {
		return new static($key, $value);
	}

	/**
	 * @return \IdeHelper\ValueObject\ValueObjectInterface
	 */
	public function key(): ValueObjectInterface {
		return $this->key;
	}

	/**
	 * @return \IdeHelper\ValueObject\ValueObjectInterface
	 */
	public function value(): ValueObjectInterface {
		return $this->value;
	}

}


================================================
FILE: src/ValueObject/LiteralName.php
================================================
<?php

namespace IdeHelper\ValueObject;

/**
 * Holds a string that will be treated literally on output (no extra quoting).
 */
class LiteralName implements ValueObjectInterface {

	protected string $value;

	/**
	 * @param string $value
	 */
	private function __construct(string $value) {
		$this->value = $value;
	}

	/**
	 * Creates itself from a string.
	 *
	 * @param string $value
	 *
	 * @return static
	 */
	public static function create(string $value) {
		return new static($value);
	}

	/**
	 * @return string
	 */
	public function raw(): string {
		return $this->value;
	}

	/**
	 * @return string
	 */
	public function __toString(): string {
		return $this->raw();
	}

}


================================================
FILE: src/ValueObject/StringName.php
================================================
<?php

namespace IdeHelper\ValueObject;

/**
 * Holds a string with auto added `'` chars - can be auto-casted to string on output.
 */
class StringName implements ValueObjectInterface {

	protected string $value;

	/**
	 * @param string $value
	 */
	private function __construct(string $value) {
		$this->value = $value;
	}

	/**
	 * Creates itself from a string.
	 *
	 * @param string $value
	 *
	 * @return static
	 */
	public static function create(string $value) {
		return new static($value);
	}

	/**
	 * @return string
	 */
	public function raw(): string {
		return $this->value;
	}

	/**
	 * @return string
	 */
	public function __toString(): string {
		return '\'' . $this->value . '\'';
	}

}


================================================
FILE: src/ValueObject/ValueObjectInterface.php
================================================
<?php

namespace IdeHelper\ValueObject;

interface ValueObjectInterface {

	/**
	 * Creates itself from a string.
	 *
	 * @param string $value
	 *
	 * @return static
	 */
	public static function create(string $value);

	/**
	 * Returns raw input.
	 *
	 * @return string
	 */
	public function raw(): string;

	/**
	 * Returns formatted output.
	 *
	 * @return string
	 */
	public function __toString(): string;

}


================================================
FILE: src/View/Helper/DocBlockHelper.php
================================================
<?php

namespace IdeHelper\View\Helper;

use Bake\View\Helper\DocBlockHelper as BakeDocBlockHelper;
use Cake\Core\App;
use Cake\Core\Configure;
use Cake\ORM\Association;
use Cake\Utility\Inflector;
use IdeHelper\Utility\GenericString;

class DocBlockHelper extends BakeDocBlockHelper {

	/**
	 * @var array<string, bool>|null
	 */
	protected static $nullableMap;

	/**
	 * @var array<string>
	 */
	protected array $virtualFields = [];

	/**
	 * Overwrite Bake plugin class method until https://github.com/cakephp/bake/pull/470 lands.
	 *
	 * @param array<array<string, mixed>> $propertySchema The property schema to use for generating the type map.
	 * @return array<string, string> The property DocType map.
	 */
	public function buildEntityPropertyHintTypeMap(array $propertySchema): array {
		$properties = [];
		foreach ($propertySchema as $property => $info) {
			if ($info['kind'] === 'column') {
				$type = $this->columnTypeToHintType($info['type']);

				$properties[$property] = $this->columnTypeNullable($info, $type);
			}
		}

		return $properties;
	}

	/**
	 * @param array<string, string> $info
	 * @param string|null $type
	 * @param string|null $default
	 *
	 * @return string
	 */
	public function columnTypeNullable(array $info, ?string $type, ?string $default = null): string {
		if (!$type) {
			$type = $default ?: 'mixed';
		}

		if ($type === 'mixed' || empty($info['null'])) {
			return $type;
		}

		if (static::$nullableMap === null) {
			static::$nullableMap = (array)Configure::read('IdeHelper.nullableMap');
		}

		if (isset(static::$nullableMap[$type]) && static::$nullableMap[$type] === false) {
			return $type;
		}

		$type .= '|null';

		return $type;
	}

	/**
	 * {@inheritDoc}
	 *
	 * Overwrite with nullable option for now until Bake is adjusted ( https://github.com/cakephp/bake/issues/579 )
	 *
	 * @param array<string, array<string, mixed>> $propertySchema The property schema to use for generating the type map.
	 * @return array<string, string> The property DocType map.
	 */
	public function buildEntityAssociationHintTypeMap(array $propertySchema): array {
		$properties = [];
		foreach ($propertySchema as $property => $info) {
			if ($info['kind'] === 'association') {
				$type = $this->associatedEntityTypeToHintType($info['type'], $info['association']);
				if ($info['association']->type() === Association::MANY_TO_ONE) {
					$key = $info['association']->getForeignKey();
					if (is_array($key)) {
						$key = implode('-', $key);
					}
					$properties = $this->_insertAfter(
						$properties,
						$key,
						[$property => $this->columnTypeNullable($info, $type)],
					);
				} else {
					$properties[$property] = $this->columnTypeNullable($info, $type);
				}
			}
		}

		return $properties;
	}

	/**
	 * {@inheritDoc}
	 *
	 * Overwrite with array vs generics syntax switch.
	 *
	 * @param string $type The entity class type (a fully qualified class name).
	 * @param \Cake\ORM\Association $association The association related to the entity class.
	 * @return string The DocBlock type
	 */
	public function associatedEntityTypeToHintType(string $type, Association $association): string {
		$annotationType = $association->type();
		if (
			$annotationType === Association::MANY_TO_MANY ||
			$annotationType === Association::ONE_TO_MANY
		) {
			return GenericString::generate($type);
		}

		return $type;
	}

	/**
	 * {@inheritDoc}
	 *
	 * Overwrite with array vs generics syntax switch.
	 *
	 * @param array<string, array<array<string, mixed>>> $associations Associations list.
	 * @param array<string, array<string, mixed>> $associationInfo Association info.
	 * @param array<string, array<mixed>> $behaviors Behaviors list.
	 * @param string $entity Entity name.
	 * @param string $namespace Namespace.
	 * @return array<string>
	 */
	public function buildTableAnnotations(
		array $associations,
		array $associationInfo,
		array $behaviors,
		string $entity,
		string $namespace,
	): array {
		$annotations = [];
		foreach ($associations as $type => $assocs) {
			foreach ($assocs as $assoc) {
				$typeStr = Inflector::camelize($type);
				if (isset($associationInfo[$assoc['alias']])) {
					$tableFqn = $associationInfo[$assoc['alias']]['targetFqn'];
					$annotations[] = "@property {$tableFqn}&\Cake\ORM\Association\\{$typeStr} \${$assoc['alias']}";
				}
			}
		}

		$class = "\\{$namespace}\\Model\\Entity\\{$entity}";
		$classes = GenericString::generate($class);
		$classInterface = '\\Cake\\Datasource\\EntityInterface';
		if (Configure::read('IdeHelper.concreteEntitiesInParam')) {
			$classInterface = $class;
		}

		$generics = Configure::read('IdeHelper.genericsInParam');
		$detailed = $generics === 'detailed';
		$dataType = 'array';
		$dataListType = 'array';
		$optionsType = 'array';
		$itterable = 'iterable';
		$finderType = 'array|string';
		$findOrCreateSearchType = '\Cake\ORM\Query\SelectQuery|callable|array';
		if ($generics) {
			$dataType = $detailed ? 'array<string, mixed>' : 'array<mixed>';
			$dataListType = $detailed ? 'array<array<string, mixed>>' : 'array<mixed>';
			$optionsType = 'array<string, mixed>';
			$iterableEntity = $detailed ? $class : $classInterface;
			$itterable = "iterable<{$iterableEntity}>";
		}
		if ($detailed) {
			$finderType = 'array<string, mixed>|string';
			$findOrCreateSearchType = "\Cake\ORM\Query\SelectQuery<{$class}>|callable|array<string, mixed>";
		}

		$annotations[] = "@method {$class} newEmptyEntity()";
		$annotations[] = "@method {$class} newEntity({$dataType} \$data, {$optionsType} \$options = [])";
		$annotations[] = "@method {$classes} newEntities({$dataListType} \$data, {$optionsType} \$options = [])";
		$annotations[] = "@method {$class} get(mixed \$primaryKey, {$finderType} \$finder = 'all', \Psr\SimpleCache\CacheInterface|string|null \$cache = null, \Closure|string|null \$cacheKey = null, mixed ...\$args)";
		$annotations[] = "@method {$class} findOrCreate({$findOrCreateSearchType} \$search, ?callable \$callback = null, {$optionsType} \$options = [])";
		$annotations[] = "@method {$class} patchEntity({$classInterface} \$entity, {$dataType} \$data, {$optionsType} \$options = [])";
		$annotations[] = "@method {$classes} patchEntities({$itterable} \$entities, {$dataListType} \$data, {$optionsType} \$options = [])";
		$annotations[] = "@method {$class}|false save({$classInterface} \$entity, {$optionsType} \$options = [])";
		$annotations[] = "@method {$class} saveOrFail({$classInterface} \$entity, {$optionsType} \$options = [])";
		$resultSet = $detailed ? "\Cake\Datasource\ResultSetInterface<int, {$class}>" : "{$classes}|\Cake\Datasource\ResultSetInterface<{$class}>";
		$annotations[] = "@method {$resultSet}|false saveMany({$itterable} \$entities, {$optionsType} \$options = [])";
		$annotations[] = "@method {$resultSet} saveManyOrFail({$itterable} \$entities, {$optionsType} \$options = [])";
		$annotations[] = "@method {$resultSet}|false deleteMany({$itterable} \$entities, {$optionsType} \$options = [])";
		$annotations[] = "@method {$resultSet} deleteManyOrFail({$itterable} \$entities, {$optionsType} \$options = [])";

		foreach ($behaviors as $behavior => $behaviorData) {
			$className = App::className($behavior, 'Model/Behavior', 'Behavior');
			if (!$className) {
				$className = "Cake\ORM\Behavior\\{$behavior}Behavior";
			}

			$annotations[] = '@mixin \\' . $className;
		}

		return $annotations;
	}

	/**
	 * @param array<string> $virtualFields
	 *
	 * @return void
	 */
	public function setVirtualFields(array $virtualFields): void {
		$this->virtualFields = $virtualFields;
	}

	/**
	 * @return array<string>
	 */
	public function getVirtualFields(): array {
		return $this->virtualFields;
	}

}


================================================
FILE: tests/Fixture/BarBarsFixture.php
================================================
<?php

namespace IdeHelper\Test\Fixture;

use Cake\TestSuite\Fixture\TestFixture;

class BarBarsFixture extends TestFixture {

	/**
	 * Fields
	 */
	public array $fields = [
		'id' => ['type' => 'integer', 'length' => 11, 'unsigned' => false, 'null' => false, 'default' => null, 'comment' => '', 'autoIncrement' => true, 'precision' => null],
		'name' => ['type' => 'string', 'length' => 255, 'null' => false, 'default' => null, 'comment' => '', 'precision' => null, 'fixed' => null],
		'content' => ['type' => 'text', 'null' => false, 'default' => null, 'comment' => '', 'precision' => null, 'fixed' => null],
		'created' => ['type' => 'datetime', 'length' => null, 'null' => false, 'default' => null, 'comment' => '', 'precision' => null],
		'_constraints' => [
			'primary' => ['type' => 'primary', 'columns' => ['id'], 'length' => []],
		],
		'_options' => [
			'engine' => 'InnoDB',
			'collation' => 'utf8_general_ci',
		],
	];

	/**
	 * Records
	 */
	public array $records = [
		[
			'id' => 1,
			'name' => 'Lorem ipsum dolor sit amet',
			'content' => 'Lorem ipsum dolor sit amet',
			'created' => '2016-06-23 14:59:54',
		],
	];

}


================================================
FILE: tests/Fixture/CarsFixture.php
================================================
<?php

namespace IdeHelper\Test\Fixture;

use Cake\TestSuite\Fixture\TestFixture;
use TestApp\Model\Enum\CarStatus;

class CarsFixture extends TestFixture {

	/**
	 * Fields
	 */
	public array $fields = [
		'id' => ['type' => 'integer', 'length' => 11, 'unsigned' => false, 'null' => false, 'default' => null, 'comment' => '', 'autoIncrement' => true, 'precision' => null],
		'name' => ['type' => 'string', 'length' => 255, 'null' => false, 'default' => null, 'comment' => '', 'precision' => null, 'fixed' => null],
		'content' => ['type' => 'text', 'null' => false, 'default' => null, 'comment' => '', 'precision' => null, 'fixed' => null],
		'created' => ['type' => 'datetime', 'length' => null, 'null' => false, 'default' => null, 'comment' => '', 'precision' => null],
		'modified' => ['type' => 'datetime', 'length' => null, 'null' => true, 'default' => null, 'comment' => '', 'precision' => null],
		'status' => ['type' => 'tinyinteger', 'length' => 2, 'null' => false, 'default' => '0'],
		'_constraints' => [
			'primary' => ['type' => 'primary', 'columns' => ['id'], 'length' => []],
		],
		'_options' => [
			'engine' => 'InnoDB',
			'collation' => 'utf8_general_ci',
		],
	];

	/**
	 * Records
	 */
	public array $records = [
		[
			'id' => 1,
			'name' => 'Lorem ipsum dolor sit amet',
			'content' => 'Lorem ipsum dolor sit amet',
			'created' => '2016-06-23 14:59:54',
			'modified' => '2016-06-23 14:59:54',
			'status' => CarStatus::NEW,
		],
	];

}


================================================
FILE: tests/Fixture/FoosFixture.php
================================================
<?php

namespace IdeHelper\Test\Fixture;

use Cake\TestSuite\Fixture\TestFixture;

class FoosFixture extends TestFixture {

	/**
	 * Fields
	 */
	public array $fields = [
		'id' => ['type' => 'integer', 'length' => 11, 'unsigned' => false, 'null' => false, 'default' => null, 'comment' => '', 'autoIncrement' => true, 'precision' => null],
		'name' => ['type' => 'string', 'length' => 255, 'null' => false, 'default' => null, 'comment' => '', 'precision' => null, 'fixed' => null],
		'content' => ['type' => 'text', 'null' => false, 'default' => null, 'comment' => '', 'precision' => null, 'fixed' => null],
		'created' => ['type' => 'datetime', 'length' => null, 'null' => false, 'default' => null, 'comment' => '', 'precision' => null],
		'params' => ['type' => 'json', 'length' => null, 'null' => true, 'default' => null, 'comment' => '', 'precision' => null],
		'_constraints' => [
			'primary' => ['type' => 'primary', 'columns' => ['id'], 'length' => []],
		],
		'_options' => [
			'engine' => 'InnoDB',
			'collation' => 'utf8_general_ci',
		],
	];

	/**
	 * Records
	 */
	public array $records = [
		[
			'id' => 1,
			'name' => 'Lorem ipsum dolor sit amet',
			'content' => 'Lorem ipsum dolor sit amet',
			'created' => '2016-06-23 14:59:54',
			'params' => '[]',
		],
	];

}


================================================
FILE: tests/Fixture/HousesFixture.php
================================================
<?php

namespace IdeHelper\Test\Fixture;

use Cake\TestSuite\Fixture\TestFixture;

class HousesFixture extends TestFixture {

	/**
	 * Fields
	 */
	public array $fields = [
		'id' => ['type' => 'integer', 'length' => 11, 'unsigned' => false, 'null' => false, 'default' => null, 'comment' => '', 'autoIncrement' => true, 'precision' => null],
		'name' => ['type' => 'string', 'length' => 255, 'null' => false, 'default' => null, 'comment' => '', 'precision' => null, 'fixed' => null],
		'_constraints' => [
			'primary' => ['type' => 'primary', 'columns' => ['id'], 'length' => []],
		],
		'_options' => [
			'engine' => 'InnoDB',
			'collation' => 'utf8_general_ci',
		],
	];

	/**
	 * Records
	 */
	public array $records = [
		[
			'id' => 1,
			'name' => 'Lorem ipsum dolor sit amet',
		],
	];

}


================================================
FILE: tests/Fixture/WheelsFixture.php
================================================
<?php

namespace IdeHelper\Test\Fixture;

use Cake\TestSuite\Fixture\TestFixture;

class WheelsFixture extends TestFixture {

	/**
	 * Fields
	 */
	public array $fields = [
		'id' => ['type' => 'integer', 'length' => 11, 'unsigned' => false, 'null' => false, 'default' => null, 'comment' => '', 'autoIncrement' => true, 'precision' => null],
		'name' => ['type' => 'string', 'length' => 255, 'null' => false, 'default' => null, 'comment' => '', 'precision' => null, 'fixed' => null],
		'content' => ['type' => 'text', 'null' => false, 'default' => null, 'comment' => '', 'precision' => null, 'fixed' => null],
		'created' => ['type' => 'datetime', 'length' => null, 'null' => false, 'default' => null, 'comment' => '', 'precision' => null],
		'_constraints' => [
			'primary' => ['type' => 'primary', 'columns' => ['id'], 'length' => []],
		],
		'_options' => [
			'engine' => 'InnoDB',
			'collation' => 'utf8_general_ci',
		],
	];

	/**
	 * Records
	 */
	public array $records = [
		[
			'id' => 1,
			'name' => 'Lorem ipsum dolor sit amet',
			'content' => 'Lorem ipsum dolor sit amet',
			'created' => '2016-06-23 14:59:54',
		],
	];

}


================================================
FILE: tests/Fixture/WindowsFixture.php
================================================
<?php

namespace IdeHelper\Test\Fixture;

use Cake\TestSuite\Fixture\TestFixture;

class WindowsFixture extends TestFixture {

	/**
	 * Fields
	 */
	public array $fields = [
		'id' => ['type' => 'integer', 'length' => 11, 'unsigned' => false, 'null' => false, 'default' => null, 'comment' => '', 'autoIncrement' => true, 'precision' => null],
		'name' => ['type' => 'string', 'length' => 255, 'null' => false, 'default' => null, 'comment' => '', 'precision' => null, 'fixed' => null],
		'_constraints' => [
			'primary' => ['type' => 'primary', 'columns' => ['id'], 'length' => []],
		],
		'_options' => [
			'engine' => 'InnoDB',
			'collation' => 'utf8_general_ci',
		],
	];

	/**
	 * Records
	 */
	public array $records = [
		[
			'id' => 1,
			'name' => 'Lorem ipsum dolor sit amet',
		],
	];

}


================================================
FILE: tests/TestCase/Annotation/AnnotationFactoryTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Annotation;

use Cake\TestSuite\TestCase;
use IdeHelper\Annotation\AnnotationFactory;
use IdeHelper\Annotation\ExtendsAnnotation;
use IdeHelper\Annotation\MethodAnnotation;
use IdeHelper\Annotation\MixinAnnotation;
use IdeHelper\Annotation\PropertyAnnotation;
use IdeHelper\Annotation\PropertyReadAnnotation;
use IdeHelper\Annotation\UsesAnnotation;

class AnnotationFactoryTest extends TestCase {

	/**
	 * @return void
	 */
	public function testCreate() {
		$annotation = AnnotationFactory::create('@method', '\\Foo\\Model\\Entity\\Bar', 'doSth()', 1);
		$this->assertInstanceOf(MethodAnnotation::class, $annotation);

		$annotation = AnnotationFactory::create('@property', '\\Foo\\Model\\Entity\\Bar', '$baz', 1);
		$this->assertInstanceOf(PropertyAnnotation::class, $annotation);

		$annotation = AnnotationFactory::create('@property', '\\Foo\\Model\\Entity\\Bar', 'baz', 1);
		$this->assertInstanceOf(PropertyAnnotation::class, $annotation);

		$annotation = AnnotationFactory::create('@property-read', '\\Foo\\Model\\Entity\\Bar', 'baz', 1);
		$this->assertInstanceOf(PropertyReadAnnotation::class, $annotation);

		$annotation = AnnotationFactory::create('@mixin', '\\Foo\\Model\\Entity\\Bar');
		$this->assertInstanceOf(MixinAnnotation::class, $annotation);

		$annotation = AnnotationFactory::create('@uses', '\\Foo\\Model\\Entity\\Bar');
		$this->assertInstanceOf(UsesAnnotation::class, $annotation);

		$annotation = AnnotationFactory::create('@foooo', '\\Foo', '$foo');
		$this->assertNull($annotation);

		$annotation = AnnotationFactory::create('@mixin', '\\Foo', '!');
		$this->assertInstanceOf(MixinAnnotation::class, $annotation);
		$this->assertSame('!', $annotation->getDescription());

		$annotation = AnnotationFactory::create('@extends', '\\Foo<array{Bar: \Bar}>', '!');
		$this->assertInstanceOf(ExtendsAnnotation::class, $annotation);
		$this->assertSame('!', $annotation->getDescription());
	}

	/**
	 * @return void
	 */
	public function testCreateFromString() {
		/** @var \IdeHelper\Annotation\MethodAnnotation $annotation */
		$annotation = AnnotationFactory::createFromString('@method \\Foo\\Model\\Entity\\Bar doSth($x, $y, $z)');
		$this->assertInstanceOf(MethodAnnotation::class, $annotation);
		$this->assertSame('doSth($x, $y, $z)', $annotation->getMethod());

		/** @var \IdeHelper\Annotation\PropertyAnnotation $annotation */
		$annotation = AnnotationFactory::createFromString('@property \\Foo\\Model\\Entity\\Bar $baz');
		$this->assertInstanceOf(PropertyAnnotation::class, $annotation);
		$this->assertSame('$baz', $annotation->getProperty());

		/** @var \IdeHelper\Annotation\PropertyAnnotation $annotation */
		$annotation = AnnotationFactory::createFromString('@property \\Foo\\Model\\Entity\\Bar baz');
		$this->assertInstanceOf(PropertyAnnotation::class, $annotation);
		$this->assertSame('$baz', $annotation->getProperty());

		/** @var \IdeHelper\Annotation\PropertyAnnotation $annotation */
		$annotation = AnnotationFactory::createFromString('@property \\Foo\\Model\\Entity\\Bar $baz Some comment :)');
		$this->assertInstanceOf(PropertyAnnotation::class, $annotation);
		$this->assertSame('Some comment :)', $annotation->getDescription());

		$annotation = AnnotationFactory::createFromString('@property\\Foo\\Model\\Entity\\Bar$baz');
		$this->assertNull($annotation);

		/** @var \IdeHelper\Annotation\PropertyReadAnnotation $annotation */
		$annotation = AnnotationFactory::createFromString('@property-read \\Foo\\Model\\Entity\\Bar baz');
		$this->assertInstanceOf(PropertyReadAnnotation::class, $annotation);
		$this->assertSame('$baz', $annotation->getProperty());

		/** @var \IdeHelper\Annotation\MethodAnnotation $annotation */
		$annotation = AnnotationFactory::createFromString('@method \\Foo\\Model\\Entity\\Bar complex($x, $y = [], $z = null)');
		$this->assertInstanceOf(MethodAnnotation::class, $annotation);
		$this->assertSame('complex($x, $y = [], $z = null)', $annotation->getMethod());

		/** @var \IdeHelper\Annotation\MethodAnnotation $annotation */
		$annotation = AnnotationFactory::createFromString('@method \\Foo\\Model\\Entity\\Bar complex($x, $y = [], $z = null) !');
		$this->assertInstanceOf(MethodAnnotation::class, $annotation);
		$this->assertSame('complex($x, $y = [], $z = null)', $annotation->getMethod());

		/** @var \IdeHelper\Annotation\MixinAnnotation $annotation */
		$annotation = AnnotationFactory::createFromString('@mixin \\Foo\\Model\\Entity\\Bar');
		$this->assertInstanceOf(MixinAnnotation::class, $annotation);
		$this->assertSame('', $annotation->getDescription());

		/** @var \IdeHelper\Annotation\MixinAnnotation $annotation */
		$annotation = AnnotationFactory::createFromString('@mixin \\Foo\\Model\\Entity\\Bar !');
		$this->assertInstanceOf(MixinAnnotation::class, $annotation);
		$this->assertSame('!', $annotation->getDescription());

		/** @var \IdeHelper\Annotation\UsesAnnotation $annotation */
		$annotation = AnnotationFactory::createFromString('@uses \\Foo\\Model\\Entity\\Bar');
		$this->assertInstanceOf(UsesAnnotation::class, $annotation);
		$this->assertSame('', $annotation->getDescription());

		/** @var \IdeHelper\Annotation\UsesAnnotation $annotation */
		$annotation = AnnotationFactory::createFromString('@extends \App\Model\Table\Table<array{Typographic: \Tools\Model\Behavior\TypographicBehavior>');
		$this->assertInstanceOf(ExtendsAnnotation::class, $annotation);
		$this->assertSame('', $annotation->getDescription());

		/** @var \IdeHelper\Annotation\UsesAnnotation $annotation */
		$annotation = AnnotationFactory::createFromString('@extends \App\Model\Table\Table<array{Typographic: \Tools\Model\Behavior\TypographicBehavior, Rating: \Ratings\Model\Behavior\RatableBehavior> !');
		$this->assertInstanceOf(ExtendsAnnotation::class, $annotation);
		$this->assertSame('!', $annotation->getDescription());
	}

	/**
	 * Regression: types with spaces inside generic brackets (e.g. `ResultSetInterface<int, \Entity>`)
	 * used to be split at the first space, putting part of the type into the method name.
	 * That caused `matches()` to fail and annotations to be duplicated on subsequent runs
	 * when `genericsInParam: 'detailed'` was enabled.
	 *
	 * @return void
	 */
	public function testCreateFromStringWithSpaceInsideGenericType() {
		/** @var \IdeHelper\Annotation\MethodAnnotation $annotation */
		$annotation = AnnotationFactory::createFromString('@method \Cake\Datasource\ResultSetInterface<int, \Foo\Model\Entity\Bar>|false saveMany(iterable<\Foo\Model\Entity\Bar> $entities, array<string, mixed> $options = [])');
		$this->assertInstanceOf(MethodAnnotation::class, $annotation);
		$this->assertSame('\Cake\Datasource\ResultSetInterface<int, \Foo\Model\Entity\Bar>|false', $annotation->getType());
		$this->assertSame('saveMany(iterable<\Foo\Model\Entity\Bar> $entities, array<string, mixed> $options = [])', $annotation->getMethod());

		/** @var \IdeHelper\Annotation\PropertyAnnotation $annotation */
		$annotation = AnnotationFactory::createFromString('@property \Cake\ORM\Association\BelongsTo<\Foo\Model\Table\BarsTable> $Bar');
		$this->assertInstanceOf(PropertyAnnotation::class, $annotation);
		$this->assertSame('\Cake\ORM\Association\BelongsTo<\Foo\Model\Table\BarsTable>', $annotation->getType());
		$this->assertSame('$Bar', $annotation->getProperty());
	}

}


================================================
FILE: tests/TestCase/Annotation/ExtendsAnnotationTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Annotation;

use IdeHelper\Annotation\ExtendsAnnotation;
use IdeHelper\Annotation\PropertyAnnotation;
use RuntimeException;
use Shim\TestSuite\TestCase;

class ExtendsAnnotationTest extends TestCase {

	/**
	 * @return void
	 */
	public function testBuild() {
		$annotation = new ExtendsAnnotation('\Table<array{Sluggable: \Plugin\Model\Behavior\SluggableBehavior>');

		$result = (string)$annotation;
		$this->assertSame('@extends \Table<array{Sluggable: \Plugin\Model\Behavior\SluggableBehavior>', $result);
	}

	/**
	 * @return void
	 */
	public function testReplaceWith() {
		$replacementAnnotation = new ExtendsAnnotation('\Table<array{Sluggable: \Plugin\Model\Behavior\SluggableBehavior>');

		$annotation = new ExtendsAnnotation('\Table<array{X: \Y>');
		$annotation->replaceWith($replacementAnnotation);

		$result = (string)$annotation;
		$this->assertSame('@extends \Table<array{Sluggable: \Plugin\Model\Behavior\SluggableBehavior>', $result);
	}

	/**
	 * @return void
	 */
	public function testMatches() {
		$annotation = new ExtendsAnnotation('\Table<array{Sluggable: \Plugin\Model\Behavior\SluggableBehavior>');
		$comparisonAnnotation = new ExtendsAnnotation('\Table<array{Sluggable: \Plugin\Model\Behavior\SluggableBehavior>');
		$result = $annotation->matches($comparisonAnnotation);
		$this->assertTrue($result);

		$annotation = new ExtendsAnnotation('\Table<array{Sluggable: \Plugin\Model\Behavior\SluggableBehavior>');
		$comparisonAnnotation = new PropertyAnnotation('\\Foo\\Model\\Entity\\Bar', '$bar');
		$result = $annotation->matches($comparisonAnnotation);
		$this->assertFalse($result);

		$annotation = new ExtendsAnnotation('\Table<array{Sluggable: \Plugin\Model\Behavior\SluggableBehavior>');
		$comparisonAnnotation = new ExtendsAnnotation('\Table<array{Xyz: \Plugin\Model\Behavior\XyzBehavior>');
		$result = $annotation->matches($comparisonAnnotation);
		$this->assertTrue($result);
	}

	/**
	 * @return void
	 */
	public function testMatchesWithDescription() {
		$annotation = new ExtendsAnnotation('\Table<array{Sluggable: \Plugin\Model\Behavior\SluggableBehavior> !');
		$comparisonAnnotation = new ExtendsAnnotation('\Table<array{Sluggable: \Plugin\Model\Behavior\SluggableBehavior>');
		$result = $annotation->matches($comparisonAnnotation);

		$this->assertTrue($result);
		$this->assertSame('!', $annotation->getDescription());
		$this->assertSame('', $comparisonAnnotation->getDescription());
	}

	/**
	 * @return void
	 */
	public function testIndex() {
		$annotation = new ExtendsAnnotation('', 1);

		$this->assertTrue($annotation->hasIndex());
		$this->assertSame(1, $annotation->getIndex());
	}

	/**
	 * @return void
	 */
	public function testIndexInvalidCall() {
		$annotation = new ExtendsAnnotation('');

		$this->assertFalse($annotation->hasIndex());

		$this->expectException(RuntimeException::class);

		$annotation->getIndex();
	}

}


================================================
FILE: tests/TestCase/Annotation/MethodAnnotationTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Annotation;

use Cake\TestSuite\TestCase;
use IdeHelper\Annotation\MethodAnnotation;
use IdeHelper\Annotation\PropertyAnnotation;
use RuntimeException;

class MethodAnnotationTest extends TestCase {

	/**
	 * @return void
	 */
	public function testBuild() {
		$annotation = new MethodAnnotation('\\Foo\\Model\\Entity\\Bar', 'doSth()');

		$result = (string)$annotation;
		$this->assertSame('@method \\Foo\\Model\\Entity\\Bar doSth()', $result);
	}

	/**
	 * @return void
	 */
	public function testReplaceWith() {
		$replacementAnnotation = new MethodAnnotation('\\Something\\Model\\Entity\\Else', 'doSth(array $options = [])');

		$annotation = new MethodAnnotation('\\Foo\\Model\\Entity\\Bar', 'doSth()');
		$annotation->replaceWith($replacementAnnotation);

		$result = (string)$annotation;
		$this->assertSame('@method \\Something\\Model\\Entity\\Else doSth(array $options = [])', $result);
	}

	/**
	 * @return void
	 */
	public function testMatches() {
		$annotation = new MethodAnnotation('\\Foo\\Model\\Entity\\Bar', 'doSth()');
		$comparisonAnnotation = new MethodAnnotation('\\Something\\Else', 'doSth()');
		$result = $annotation->matches($comparisonAnnotation);
		$this->assertTrue($result);

		$annotation = new MethodAnnotation('\\Foo\\Model\\Entity\\Bar', 'doSth()');
		$comparisonAnnotation = new MethodAnnotation('\\Foo\\Model\\Entity\\Bar', 'sthElse()');
		$result = $annotation->matches($comparisonAnnotation);
		$this->assertFalse($result);

		$annotation = new MethodAnnotation('\\Foo\\Model\\Entity\\Bar', 'doSth()');
		$comparisonAnnotation = new PropertyAnnotation('\\Foo\\Model\\Entity\\Bar', 'doSth()');
		$result = $annotation->matches($comparisonAnnotation);
		$this->assertFalse($result);
	}

	/**
	 * @return void
	 */
	public function testMatchesWithDescription() {
		$annotation = new MethodAnnotation('\\Foo\\Model\\Table\\Bar', 'doSth() !');
		$comparisonAnnotation = new MethodAnnotation('\\Something\\Else', 'doSth()');
		$result = $annotation->matches($comparisonAnnotation);

		$this->assertTrue($result);
		$this->assertSame('!', $annotation->getDescription());
		$this->assertSame('', $comparisonAnnotation->getDescription());
	}

	/**
	 * @return void
	 */
	public function testIndex() {
		$annotation = new MethodAnnotation('', '', 1);

		$this->assertTrue($annotation->hasIndex());
		$this->assertSame(1, $annotation->getIndex());
	}

	/**
	 * @return void
	 */
	public function testIndexInvalidCall() {
		$annotation = new MethodAnnotation('', '');

		$this->assertFalse($annotation->hasIndex());

		$this->expectException(RuntimeException::class);

		$annotation->getIndex();
	}

}


================================================
FILE: tests/TestCase/Annotation/MixinAnnotationTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Annotation;

use Cake\TestSuite\TestCase;
use IdeHelper\Annotation\MixinAnnotation;
use IdeHelper\Annotation\PropertyAnnotation;
use RuntimeException;

class MixinAnnotationTest extends TestCase {

	/**
	 * @return void
	 */
	public function testBuild() {
		$annotation = new MixinAnnotation('\\Foo\\Model\\Entity\\Bar');

		$result = (string)$annotation;
		$this->assertSame('@mixin \\Foo\\Model\\Entity\\Bar', $result);
	}

	/**
	 * @return void
	 */
	public function testReplaceWith() {
		$replacementAnnotation = new MixinAnnotation('\\Something\\Model\\Entity\\Else');

		$annotation = new MixinAnnotation('\\Foo\\Model\\Entity\\Bar');
		$annotation->replaceWith($replacementAnnotation);

		$result = (string)$annotation;
		$this->assertSame('@mixin \\Something\\Model\\Entity\\Else', $result);
	}

	/**
	 * @return void
	 */
	public function testMatches() {
		$annotation = new MixinAnnotation('\\Foo\\Model\\Entity\\Bar');
		$comparisonAnnotation = new MixinAnnotation('\\Foo\\Model\\Entity\\Bar');
		$result = $annotation->matches($comparisonAnnotation);
		$this->assertTrue($result);

		$annotation = new MixinAnnotation('\\Foo\\Model\\Entity\\Bar');
		$comparisonAnnotation = new MixinAnnotation('\\Foo\\Model\\Entity\\BarBaz');
		$result = $annotation->matches($comparisonAnnotation);
		$this->assertFalse($result);

		$annotation = new MixinAnnotation('\\Foo\\Model\\Entity\\Bar');
		$comparisonAnnotation = new PropertyAnnotation('\\Foo\\Model\\Entity\\Bar', '$bar');
		$result = $annotation->matches($comparisonAnnotation);
		$this->assertFalse($result);
	}

	/**
	 * @return void
	 */
	public function testMatchesWithDescription() {
		$annotation = new MixinAnnotation('\\Foo\\Model\\Entity\\Bar !');
		$comparisonAnnotation = new MixinAnnotation('\\Foo\\Model\\Entity\\Bar');
		$result = $annotation->matches($comparisonAnnotation);
		$this->assertTrue($result);
		$this->assertSame('!', $annotation->getDescription());
		$this->assertSame('', $comparisonAnnotation->getDescription());

		$annotation = new MixinAnnotation('\\Foo\\Model\\Entity\\Bar');
		$comparisonAnnotation = new MixinAnnotation('\\Foo\\Model\\Entity\\Bar !');
		$result = $annotation->matches($comparisonAnnotation);
		$this->assertTrue($result);
		$this->assertSame('', $annotation->getDescription());
		$this->assertSame('!', $comparisonAnnotation->getDescription());
	}

	/**
	 * @return void
	 */
	public function testIndex() {
		$annotation = new MixinAnnotation('', 1);

		$this->assertTrue($annotation->hasIndex());
		$this->assertSame(1, $annotation->getIndex());
	}

	/**
	 * @return void
	 */
	public function testIndexInvalidCall() {
		$annotation = new MixinAnnotation('');

		$this->assertFalse($annotation->hasIndex());

		$this->expectException(RuntimeException::class);

		$annotation->getIndex();
	}

}


================================================
FILE: tests/TestCase/Annotation/ParamAnnotationTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Annotation;

use Cake\TestSuite\TestCase;
use IdeHelper\Annotation\MethodAnnotation;
use IdeHelper\Annotation\ParamAnnotation;

class ParamAnnotationTest extends TestCase {

	/**
	 * @return void
	 */
	public function testBuild() {
		$annotation = new ParamAnnotation('\\Foo\\Model\\Table\\Bar', '$baz');

		$result = (string)$annotation;
		$this->assertSame('@param \\Foo\\Model\\Table\\Bar $baz', $result);
	}

	/**
	 * @return void
	 */
	public function testReplaceWith() {
		$replacementAnnotation = new ParamAnnotation('\\Something\\Model\\Table\\Else', '$baz');

		$annotation = new ParamAnnotation('\\Foo\\Model\\Table\\Bar', '$baz');
		$annotation->replaceWith($replacementAnnotation);

		$result = (string)$annotation;
		$this->assertSame('@param \\Something\\Model\\Table\\Else $baz', $result);
	}

	/**
	 * @return void
	 */
	public function testMatches() {
		$annotation = new ParamAnnotation('\\Foo\\Model\\Table\\Bar', '$baz');
		$comparisonAnnotation = new ParamAnnotation('\\Something\\Else', '$baz');
		$result = $annotation->matches($comparisonAnnotation);
		$this->assertTrue($result);

		$annotation = new ParamAnnotation('\\Foo\\Model\\Table\\Bar', '$baz');
		$comparisonAnnotation = new ParamAnnotation('\\Foo\\Model\\Table\\Bar', '$bbb');
		$result = $annotation->matches($comparisonAnnotation);
		$this->assertFalse($result);

		$annotation = new ParamAnnotation('\\Foo\\Model\\Table\\Bar', '$baz');
		$comparisonAnnotation = new MethodAnnotation('\\Foo\\Model\\Table\\Bar', '$baz');
		$result = $annotation->matches($comparisonAnnotation);
		$this->assertFalse($result);
	}

	/**
	 * @return void
	 */
	public function testMatchesWithDescription() {
		$annotation = new ParamAnnotation('\\Foo\\Model\\Table\\Bar', '$baz !');
		$comparisonAnnotation = new ParamAnnotation('\\Something\\Else', '$baz');
		$result = $annotation->matches($comparisonAnnotation);

		$this->assertTrue($result);
		$this->assertSame('!', $annotation->getDescription());
		$this->assertSame('', $comparisonAnnotation->getDescription());
	}

}


================================================
FILE: tests/TestCase/Annotation/PropertyAnnotationTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Annotation;

use Cake\TestSuite\TestCase;
use IdeHelper\Annotation\MethodAnnotation;
use IdeHelper\Annotation\PropertyAnnotation;

class PropertyAnnotationTest extends TestCase {

	/**
	 * @return void
	 */
	public function testBuild() {
		$annotation = new PropertyAnnotation('\\Foo\\Model\\Table\\Bar', '$baz');

		$result = (string)$annotation;
		$this->assertSame('@property \\Foo\\Model\\Table\\Bar $baz', $result);
	}

	/**
	 * @return void
	 */
	public function testReplaceWith() {
		$replacementAnnotation = new PropertyAnnotation('\\Something\\Model\\Table\\Else', '$baz');

		$annotation = new PropertyAnnotation('\\Foo\\Model\\Table\\Bar', '$baz');
		$annotation->replaceWith($replacementAnnotation);

		$result = (string)$annotation;
		$this->assertSame('@property \\Something\\Model\\Table\\Else $baz', $result);
	}

	/**
	 * @return void
	 */
	public function testMatches() {
		$annotation = new PropertyAnnotation('\\Foo\\Model\\Table\\Bar', '$baz');
		$comparisonAnnotation = new PropertyAnnotation('\\Something\\Else', '$baz');
		$result = $annotation->matches($comparisonAnnotation);
		$this->assertTrue($result);

		$annotation = new PropertyAnnotation('\\Foo\\Model\\Table\\Bar', '$baz');
		$comparisonAnnotation = new PropertyAnnotation('\\Foo\\Model\\Table\\Bar', '$bbb');
		$result = $annotation->matches($comparisonAnnotation);
		$this->assertFalse($result);

		$annotation = new PropertyAnnotation('\\Foo\\Model\\Table\\Bar', '$baz');
		$comparisonAnnotation = new MethodAnnotation('\\Foo\\Model\\Table\\Bar', '$baz');
		$result = $annotation->matches($comparisonAnnotation);
		$this->assertFalse($result);
	}

	/**
	 * @return void
	 */
	public function testMatchesWithDescription() {
		$annotation = new PropertyAnnotation('\\Foo\\Model\\Table\\Bar', '$baz !');
		$comparisonAnnotation = new PropertyAnnotation('\\Something\\Else', '$baz');
		$result = $annotation->matches($comparisonAnnotation);

		$this->assertTrue($result);
		$this->assertSame('!', $annotation->getDescription());
		$this->assertSame('', $comparisonAnnotation->getDescription());
	}

	/**
	 * @return void
	 */
	public function testMatchesWithoutVariableChar() {
		$annotation = new PropertyAnnotation('\\Foo\\Model\\Table\\Bar', '$baz');
		$comparisonAnnotation = new PropertyAnnotation('\\Something\\Else', 'baz');
		$result = $annotation->matches($comparisonAnnotation);
		$this->assertTrue($result);
	}

}


================================================
FILE: tests/TestCase/Annotation/UsesAnnotationTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Annotation;

use IdeHelper\Annotation\PropertyAnnotation;
use IdeHelper\Annotation\UsesAnnotation;
use RuntimeException;
use Shim\TestSuite\TestCase;

class UsesAnnotationTest extends TestCase {

	/**
	 * @return void
	 */
	public function testBuild() {
		$annotation = new UsesAnnotation('\\Foo\\Model\\Entity\\Bar');

		$result = (string)$annotation;
		$this->assertSame('@uses \\Foo\\Model\\Entity\\Bar', $result);
	}

	/**
	 * @return void
	 */
	public function testReplaceWith() {
		$replacementAnnotation = new UsesAnnotation('\\Something\\Model\\Entity\\Else');

		$annotation = new UsesAnnotation('\\Foo\\Model\\Entity\\Bar');
		$annotation->replaceWith($replacementAnnotation);

		$result = (string)$annotation;
		$this->assertSame('@uses \\Something\\Model\\Entity\\Else', $result);
	}

	/**
	 * @return void
	 */
	public function testMatches() {
		$annotation = new UsesAnnotation('\\Foo\\Model\\Entity\\Bar');
		$comparisonAnnotation = new UsesAnnotation('\\Foo\\Model\\Entity\\Bar');
		$result = $annotation->matches($comparisonAnnotation);
		$this->assertTrue($result);

		$annotation = new UsesAnnotation('\\Foo\\Model\\Entity\\Bar');
		$comparisonAnnotation = new UsesAnnotation('\\Foo\\Model\\Entity\\BarBaz');
		$result = $annotation->matches($comparisonAnnotation);
		$this->assertFalse($result);

		$annotation = new UsesAnnotation('\\Foo\\Model\\Entity\\Bar');
		$comparisonAnnotation = new PropertyAnnotation('\\Foo\\Model\\Entity\\Bar', '$bar');
		$result = $annotation->matches($comparisonAnnotation);
		$this->assertFalse($result);
	}

	/**
	 * @return void
	 */
	public function testMatchesWithDescription() {
		$annotation = new UsesAnnotation('\\Foo\\Model\\Entity\\Bar !');
		$comparisonAnnotation = new UsesAnnotation('\\Foo\\Model\\Entity\\Bar');
		$result = $annotation->matches($comparisonAnnotation);
		$this->assertTrue($result);
		$this->assertSame('!', $annotation->getDescription());
		$this->assertSame('', $comparisonAnnotation->getDescription());

		$annotation = new UsesAnnotation('\\Foo\\Model\\Entity\\Bar');
		$comparisonAnnotation = new UsesAnnotation('\\Foo\\Model\\Entity\\Bar !');
		$result = $annotation->matches($comparisonAnnotation);
		$this->assertTrue($result);
		$this->assertSame('', $annotation->getDescription());
		$this->assertSame('!', $comparisonAnnotation->getDescription());
	}

	/**
	 * @return void
	 */
	public function testIndex() {
		$annotation = new UsesAnnotation('', 1);

		$this->assertTrue($annotation->hasIndex());
		$this->assertSame(1, $annotation->getIndex());
	}

	/**
	 * @return void
	 */
	public function testIndexInvalidCall() {
		$annotation = new UsesAnnotation('');

		$this->assertFalse($annotation->hasIndex());

		$this->expectException(RuntimeException::class);

		$annotation->getIndex();
	}

}


================================================
FILE: tests/TestCase/Annotation/VariableAnnotationTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Annotation;

use Cake\TestSuite\TestCase;
use IdeHelper\Annotation\MethodAnnotation;
use IdeHelper\Annotation\VariableAnnotation;

class VariableAnnotationTest extends TestCase {

	/**
	 * @return void
	 */
	public function testBuild() {
		$annotation = new VariableAnnotation('\\Foo\\Model\\Table\\Bar', '$baz');

		$result = (string)$annotation;
		$this->assertSame('@var \\Foo\\Model\\Table\\Bar $baz', $result);
	}

	/**
	 * @return void
	 */
	public function testReplaceWith() {
		$replacementAnnotation = new VariableAnnotation('\\Something\\Model\\Table\\Else', '$baz');

		$annotation = new VariableAnnotation('\\Foo\\Model\\Table\\Bar', '$baz');
		$annotation->replaceWith($replacementAnnotation);

		$result = (string)$annotation;
		$this->assertSame('@var \\Something\\Model\\Table\\Else $baz', $result);
	}

	/**
	 * @return void
	 */
	public function testMatches() {
		$annotation = new VariableAnnotation('\\Foo\\Model\\Table\\Bar', '$baz');
		$comparisonAnnotation = new VariableAnnotation('\\Something\\Else', '$baz');
		$result = $annotation->matches($comparisonAnnotation);
		$this->assertTrue($result);

		$annotation = new VariableAnnotation('\\Foo\\Model\\Table\\Bar', '$baz');
		$comparisonAnnotation = new VariableAnnotation('\\Foo\\Model\\Table\\Bar', '$bbb');
		$result = $annotation->matches($comparisonAnnotation);
		$this->assertFalse($result);

		$annotation = new VariableAnnotation('\\Foo\\Model\\Table\\Bar', '$baz');
		$comparisonAnnotation = new MethodAnnotation('\\Foo\\Model\\Table\\Bar', '$baz');
		$result = $annotation->matches($comparisonAnnotation);
		$this->assertFalse($result);
	}

	/**
	 * @return void
	 */
	public function testMatchesWithDescription() {
		$annotation = new VariableAnnotation('\\Foo\\Model\\Table\\Bar', '$baz !');
		$comparisonAnnotation = new VariableAnnotation('\\Something\\Else', '$baz');
		$result = $annotation->matches($comparisonAnnotation);

		$this->assertTrue($result);
		$this->assertSame('!', $annotation->getDescription());
		$this->assertSame('', $comparisonAnnotation->getDescription());
	}

	/**
	 * @return void
	 */
	public function testReplaceWithPreservesNullableForGuessed() {
		// Existing annotation has |null
		$annotation = new VariableAnnotation('\\App\\Model\\Entity\\Home|null', '$homeData');

		// New guessed annotation without null
		$replacementAnnotation = new VariableAnnotation('mixed', '$homeData');
		$replacementAnnotation->setGuessed(true);

		$annotation->replaceWith($replacementAnnotation);

		// Should preserve |null
		$result = (string)$annotation;
		$this->assertSame('@var mixed|null $homeData', $result);
	}

	/**
	 * @return void
	 */
	public function testReplaceWithPreservesNullForNonGuessed() {
		// Existing annotation has |null
		$annotation = new VariableAnnotation('\\App\\Model\\Entity\\Home|null', '$homeData');

		// New non-guessed annotation without null
		$replacementAnnotation = new VariableAnnotation('\\App\\Model\\Entity\\User', '$homeData');

		$annotation->replaceWith($replacementAnnotation);

		// Should preserve |null since user explicitly added it
		$result = (string)$annotation;
		$this->assertSame('@var \\App\\Model\\Entity\\User|null $homeData', $result);
	}

	/**
	 * @return void
	 */
	public function testReplaceWithDoesNotDuplicateNull() {
		// Existing annotation has |null
		$annotation = new VariableAnnotation('\\App\\Model\\Entity\\Home|null', '$homeData');

		// New guessed annotation already has null
		$replacementAnnotation = new VariableAnnotation('object|null', '$homeData');
		$replacementAnnotation->setGuessed(true);

		$annotation->replaceWith($replacementAnnotation);

		// Should NOT duplicate |null
		$result = (string)$annotation;
		$this->assertSame('@var object|null $homeData', $result);
	}

}


================================================
FILE: tests/TestCase/Annotator/CallbackAnnotatorTask/VirtualFieldCallbackAnnotatorTaskTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Annotator\CallbackAnnotatorTask;

use Cake\Console\ConsoleIo;
use IdeHelper\Annotator\AbstractAnnotator;
use IdeHelper\Annotator\CallbackAnnotatorTask\VirtualFieldCallbackAnnotatorTask;
use IdeHelper\Console\Io;
use Shim\TestSuite\ConsoleOutput;
use Shim\TestSuite\TestCase;

class VirtualFieldCallbackAnnotatorTaskTest extends TestCase {

	protected ConsoleOutput $out;

	protected ConsoleOutput $err;

	protected ?Io $io = null;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->out = new ConsoleOutput();
		$this->err = new ConsoleOutput();
		$consoleIo = new ConsoleIo($this->out, $this->err);
		$this->io = new Io($consoleIo);
	}

	/**
	 * @return void
	 */
	public function testShouldRun() {
		$task = $this->getTask('', '');

		$result = $task->shouldRun('/src/Model/Entity/Foo1.php');
		$this->assertTrue($result);

		$result = $task->shouldRun('/src/Model/Table/Foo2.php');
		$this->assertFalse($result);
	}

	/**
	 * @return void
	 */
	public function testAnnotate() {
		$content = file_get_contents(TEST_FILES . 'VirtualFieldAnnotation' . DS . 'VirtualFieldAnnotation.missing.php');
		$path = '/src/Model/Entity/Foo.php';
		$task = $this->getTask($path, $content);

		$result = $task->annotate($path);
		$this->assertTrue($result);

		$content = $task->getContent();
		$this->assertTextContains('* @see \TestApp\Model\Entity\Foo::$expected_release_type', $content);
	}

	/**
	 * @return void
	 */
	public function testAnnotateExisting() {
		$content = file_get_contents(TEST_FILES . 'VirtualFieldAnnotation' . DS . 'VirtualFieldAnnotation.existing.php');
		$path = '/src/Model/Entity/Foo.php';
		$task = $this->getTask($path, $content);

		$result = $task->annotate($path);
		$this->assertTrue($result);

		$content = $task->getContent();
		$count = substr_count($content, '@see');
		// We cannot avoid the duplication for incomplete tags for now
		$this->assertSame(3, $count, 'Count is ' . $count);

		$output = $this->out->output();
		$this->assertTextContains('@see \TestApp\Model\Entity\Foo::$something', $output);
	}

	/**
	 * @param string $path
	 * @param string $content
	 * @param array $params
	 *
	 * @return \IdeHelper\Annotator\CallbackAnnotatorTask\VirtualFieldCallbackAnnotatorTask
	 */
	protected function getTask(string $path, string $content, array $params = []) {
		$params += [
			AbstractAnnotator::CONFIG_DRY_RUN => true,
			AbstractAnnotator::CONFIG_VERBOSE => true,
		];

		return new VirtualFieldCallbackAnnotatorTask($this->io, $params, $path, $content);
	}

}


================================================
FILE: tests/TestCase/Annotator/CallbackAnnotatorTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Annotator;

use Cake\Console\ConsoleIo;
use Cake\TestSuite\TestCase;
use IdeHelper\Annotator\AbstractAnnotator;
use IdeHelper\Annotator\CallbackAnnotator;
use IdeHelper\Console\Io;
use RuntimeException;
use Shim\TestSuite\ConsoleOutput;

class CallbackAnnotatorTest extends TestCase {

	protected ConsoleOutput $out;

	protected ConsoleOutput $err;

	protected Io $io;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->out = new ConsoleOutput();
		$this->err = new ConsoleOutput();
		$consoleIo = new ConsoleIo($this->out, $this->err);
		$this->io = new Io($consoleIo);

		$file = TMP . 'CallbacksTable.php';
		if (file_exists($file)) {
			unlink($file);
		}
	}

	/**
	 * @return void
	 */
	protected function tearDown(): void {
		parent::tearDown();

		$file = TMP . 'CallbacksTable.php';
		if (file_exists($file)) {
			unlink($file);
		}
	}

	/**
	 * @return void
	 */
	public function testAnnotate() {
		$annotator = $this->_getAnnotatorMock([]);

		$path = APP . 'Model/Table/CallbacksTable.php';
		$execPath = TMP . 'CallbacksTable.php';
		copy($path, $execPath);

		$annotator->annotate($execPath);

		$content = file_get_contents($execPath);
		if ($content === false) {
			throw new RuntimeException('Cannot read file');
		}

		$testPath = TEST_FILES . 'Model/Table/CallbacksTable.php';
		$expectedContent = file_get_contents($testPath);
		if ($expectedContent === false) {
			throw new RuntimeException('Cannot read file');
		}
		$this->assertTextEquals($expectedContent, $content);

		$output = $this->out->output();

		$this->assertTextContains('  -> 2 annotations updated.', $output);
	}

	/**
	 * @param array $params
	 * @return \IdeHelper\Annotator\CallbackAnnotator
	 */
	protected function _getAnnotatorMock(array $params) {
		$params += [
			AbstractAnnotator::CONFIG_VERBOSE => true,
		];

		return new CallbackAnnotator($this->io, $params);
	}

}


================================================
FILE: tests/TestCase/Annotator/ClassAnnotatorTask/FormClassAnnotatorTaskTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Annotator\ClassAnnotatorTask;

use Cake\Console\ConsoleIo;
use IdeHelper\Annotator\AbstractAnnotator;
use IdeHelper\Annotator\ClassAnnotatorTask\FormClassAnnotatorTask;
use IdeHelper\Console\Io;
use Shim\TestSuite\ConsoleOutput;
use Shim\TestSuite\TestCase;

class FormClassAnnotatorTaskTest extends TestCase {

	protected ConsoleOutput $out;

	protected ConsoleOutput $err;

	protected ?Io $io = null;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->out = new ConsoleOutput();
		$this->err = new ConsoleOutput();
		$consoleIo = new ConsoleIo($this->out, $this->err);
		$this->io = new Io($consoleIo);
	}

	/**
	 * @return void
	 */
	public function testShouldRun() {
		$task = $this->getTask('');

		$content = 'namespace TestApp\\Foo' . PHP_EOL . 'use TestApp\\Form\\DocForm' . PHP_EOL . '$docForm->execute()';
		$result = $task->shouldRun('/src/Foo.php', $content);
		$this->assertTrue($result);

		$result = $task->shouldRun('/tests/Foo.php', $content);
		$this->assertFalse($result);
	}

	/**
	 * Test that nested namespace Forms (e.g. App\Form\Admin\ContactForm) don't cause regex errors.
	 *
	 * Without preg_quote(), the backslash in "Admin\Contact" would cause:
	 * "preg_match(): Compilation failed: unrecognized character follows \"
	 *
	 * @return void
	 */
	public function testShouldRunNestedNamespace() {
		$task = $this->getTask('');

		// Nested namespace Form class with matching variable name (contains backslash)
		// lcfirst('Admin\Contact') = 'admin\Contact', + 'Form' = 'admin\ContactForm'
		$content = 'namespace TestApp\\Foo' . PHP_EOL . 'use TestApp\\Form\\Admin\\ContactForm' . PHP_EOL . '$admin\\ContactForm->execute()';
		$result = $task->shouldRun('/src/Foo.php', $content);
		$this->assertTrue($result);

		// Without the execute() call, should return false
		$content = 'namespace TestApp\\Foo' . PHP_EOL . 'use TestApp\\Form\\Admin\\ContactForm' . PHP_EOL . '$admin\\ContactForm->something()';
		$result = $task->shouldRun('/src/Foo.php', $content);
		$this->assertFalse($result);
	}

	/**
	 * @return void
	 */
	public function testAnnotate() {
		$content = file_get_contents(TEST_FILES . 'FormAnnotation' . DS . 'FormAnnotation.missing.php');
		$task = $this->getTask($content);
		$path = '/src/Foo/Foo.php';

		$result = $task->annotate($path);
		$this->assertTrue($result);

		$content = $task->getContent();
		$this->assertTextContains('* @uses \TestApp\Form\DocForm::_execute()', $content);

		$output = $this->out->output();
		$this->assertTextContains('  -> 1 annotation added.', $output);
	}

	/**
	 * @return void
	 */
	public function testAnnotateExisting() {
		$content = file_get_contents(TEST_FILES . 'FormAnnotation' . DS . 'FormAnnotation.existing.php');
		$task = $this->getTask($content);
		$path = '/src/Foo/Foo.php';

		$result = $task->annotate($path);
		$this->assertFalse($result);

		$content = $task->getContent();
		$count = substr_count($content, '@uses');
		$this->assertSame(1, $count);

		$output = $this->out->output();
		$this->assertSame('', $output);
	}

	/**
	 * @param string $content
	 * @param array $params
	 *
	 * @return \IdeHelper\Annotator\ClassAnnotatorTask\FormClassAnnotatorTask
	 */
	protected function getTask(string $content, array $params = []) {
		$params += [
			AbstractAnnotator::CONFIG_DRY_RUN => true,
			AbstractAnnotator::CONFIG_VERBOSE => true,
		];

		return new FormClassAnnotatorTask($this->io, $params, $content);
	}

}


================================================
FILE: tests/TestCase/Annotator/ClassAnnotatorTask/MailerClassAnnotatorTaskTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Annotator\ClassAnnotatorTask;

use Cake\Console\ConsoleIo;
use IdeHelper\Annotator\AbstractAnnotator;
use IdeHelper\Annotator\ClassAnnotatorTask\MailerClassAnnotatorTask;
use IdeHelper\Console\Io;
use Shim\TestSuite\ConsoleOutput;
use Shim\TestSuite\TestCase;

class MailerClassAnnotatorTaskTest extends TestCase {

	protected ConsoleOutput $out;

	protected ConsoleOutput $err;

	protected ?Io $io = null;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->out = new ConsoleOutput();
		$this->err = new ConsoleOutput();
		$consoleIo = new ConsoleIo($this->out, $this->err);
		$this->io = new Io($consoleIo);
	}

	/**
	 * @return void
	 */
	public function testShouldRun() {
		$task = $this->getTask('');

		$content = 'namespace TestApp\\Foo' . PHP_EOL . 'use TestApp\\Mailer\\NotificationMailer' . PHP_EOL . '$notificationMailer->send(\'notify\')';
		$result = $task->shouldRun('/src/Foo.php', $content);
		$this->assertTrue($result);

		$result = $task->shouldRun('/tests/Foo.php', $content);
		$this->assertFalse($result);
	}

	/**
	 * @return void
	 */
	public function testShouldRunViaCall() {
		$task = $this->getTask('');

		$content = 'namespace TestApp\\Foo' . PHP_EOL . '$notificationMailer = $this->getMailer(\'Notification\')' . PHP_EOL . '$notificationMailer->send(\'notify\')';
		$result = $task->shouldRun('/src/Foo.php', $content);
		$this->assertTrue($result);

		$result = $task->shouldRun('/tests/Foo.php', $content);
		$this->assertFalse($result);
	}

	/**
	 * @return void
	 */
	public function testShouldRunViaCallPlugin() {
		$task = $this->getTask('');

		$content = 'namespace TestApp\\Foo' . PHP_EOL . '$notificationMailer = $this->getMailer(\'FooBar.Notification\')' . PHP_EOL . '$notificationMailer->send(\'notify\')';
		$result = $task->shouldRun('/src/Foo.php', $content);
		$this->assertTrue($result);

		$result = $task->shouldRun('/tests/Foo.php', $content);
		$this->assertFalse($result);
	}

	/**
	 * @return void
	 */
	public function testAnnotate() {
		$content = file_get_contents(TEST_FILES . 'MailerAnnotation' . DS . 'MailerAnnotation.missing.php');
		$task = $this->getTask($content);
		$path = '/src/Foo/Foo.php';

		$result = $task->annotate($path);
		$this->assertTrue($result);

		$content = $task->getContent();
		$this->assertTextContains('* @uses \TestApp\Mailer\NotificationMailer::notify()', $content);

		$output = $this->out->output();
		$this->assertTextContains('  -> 1 annotation added.', $output);
	}

	/**
	 * @return void
	 */
	public function testAnnotateSingleLine() {
		$content = file_get_contents(TEST_FILES . 'MailerAnnotation' . DS . 'MailerAnnotation.missing2.php');
		$task = $this->getTask($content);
		$path = '/src/Foo/Foo.php';

		$result = $task->annotate($path);
		$this->assertTrue($result);

		$content = $task->getContent();
		$this->assertTextContains('* @uses \TestApp\Mailer\NotificationMailer::notify()', $content);

		$output = $this->out->output();
		$this->assertTextContains('  -> 1 annotation added.', $output);
	}

	/**
	 * @return void
	 */
	public function testAnnotateMultiLine() {
		$content = file_get_contents(TEST_FILES . 'MailerAnnotation' . DS . 'MailerAnnotation.missing3.php');
		$task = $this->getTask($content);
		$path = '/src/Foo/Foo.php';

		$result = $task->annotate($path);
		$this->assertTrue($result);

		$content = $task->getContent();
		$this->assertTextContains('* @uses \TestApp\Mailer\NotificationMailer::notify()', $content);

		$output = $this->out->output();
		$this->assertTextContains('  -> 1 annotation added.', $output);
	}

	/**
	 * @return void
	 */
	public function testAnnotateExisting() {
		$content = file_get_contents(TEST_FILES . 'MailerAnnotation' . DS . 'MailerAnnotation.existing.php');
		$task = $this->getTask($content);
		$path = '/src/Foo/Foo.php';

		$result = $task->annotate($path);
		$this->assertFalse($result);

		$content = $task->getContent();
		$count = substr_count($content, '@uses');
		$this->assertSame(1, $count);

		$output = $this->out->output();
		$this->assertSame('', $output);
	}

	/**
	 * @return void
	 */
	public function testShouldRunInvalid() {
		$content = file_get_contents(TEST_FILES . 'MailerAnnotation' . DS . 'MailerAnnotation.invalid.php');
		$task = $this->getTask($content);
		$path = '/src/Foo/Foo.php';

		$result = $task->shouldRun($path, $content);
		$this->assertFalse($result);
	}

	/**
	 * @param string $content
	 * @param array $params
	 *
	 * @return \IdeHelper\Annotator\ClassAnnotatorTask\MailerClassAnnotatorTask
	 */
	protected function getTask(string $content, array $params = []) {
		$params += [
			AbstractAnnotator::CONFIG_DRY_RUN => true,
			AbstractAnnotator::CONFIG_VERBOSE => true,
		];

		return new MailerClassAnnotatorTask($this->io, $params, $content);
	}

}


================================================
FILE: tests/TestCase/Annotator/ClassAnnotatorTask/TableFindAnnotatorTaskTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Annotator\ClassAnnotatorTask;

use Cake\Console\ConsoleIo;
use IdeHelper\Annotator\AbstractAnnotator;
use IdeHelper\Annotator\ClassAnnotatorTask\TableFindAnnotatorTask;
use IdeHelper\Console\Io;
use Shim\TestSuite\ConsoleOutput;
use Shim\TestSuite\TestCase;

class TableFindAnnotatorTaskTest extends TestCase {

	protected ConsoleOutput $out;

	protected ConsoleOutput $err;

	protected Io $io;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->out = new ConsoleOutput();
		$this->err = new ConsoleOutput();
		$consoleIo = new ConsoleIo($this->out, $this->err);
		$this->io = new Io($consoleIo);
	}

	/**
	 * @return void
	 */
	public function testShouldRun(): void {
		$task = $this->getTask('');

		$result = $task->shouldRun('/src/Foo.php', '');
		$this->assertFalse($result);

		$result = $task->shouldRun('/src/Foo.php', '$x = $this->Table->find()->first();');
		$this->assertTrue($result);

		$result = $task->shouldRun('/src/Foo.php', '$x = $this->Table->find()->firstOrFail();');
		$this->assertTrue($result);

		$result = $task->shouldRun('/tests/Foo.php', '$x = $this->Table->find()->first();');
		$this->assertFalse($result);
	}

	/**
	 * @return void
	 */
	public function testAnnotate(): void {
		$content = file_get_contents(TEST_FILES . 'ClassAnnotation/TableFind/before.php');
		$this->assertIsString($content);

		$task = $this->getTask($content);
		$path = '/src/Controller/TestMeController.php';

		$result = $task->annotate($path);
		$this->assertTrue($result);

		$content = $task->getContent();
		// Only $this->Residents patterns should be detected
		$this->assertStringContainsString('/** @var \TestApp\Model\Entity\Resident|null $residentX */', $content);
		$this->assertStringContainsString('/** @var \TestApp\Model\Entity\Resident $residentY */', $content);

		// The $residentsTable patterns should NOT have annotations (not $this->TableName)
		$this->assertStringNotContainsString('@var \TestApp\Model\Entity\Resident|null $resident */', $content);
		$this->assertStringNotContainsString('@var \TestApp\Model\Entity\Resident $residentOther */', $content);
	}

	/**
	 * @return void
	 */
	public function testAnnotateNoMatches(): void {
		$content = <<<'PHP'
<?php
class FooController {
	public function test(): void {
		$table = $this->fetchTable('Users');
		$user = $table->find()->first();
	}
}
PHP;

		$task = $this->getTask($content);
		$path = '/src/Controller/FooController.php';

		$result = $task->annotate($path);
		$this->assertFalse($result);
	}

	/**
	 * @return void
	 */
	public function testAnnotateAlreadyAnnotated(): void {
		$content = <<<'PHP'
<?php
class FooController {
	public function test(): void {
		/** @var \App\Model\Entity\User|null $user */
		$user = $this->Users->find()->first();
	}
}
PHP;

		$task = $this->getTask($content);
		$path = '/src/Controller/FooController.php';

		$result = $task->annotate($path);
		$this->assertFalse($result);
	}

	/**
	 * @param string $content
	 * @param array<string, mixed> $params
	 * @return \IdeHelper\Annotator\ClassAnnotatorTask\TableFindAnnotatorTask
	 */
	protected function getTask(string $content, array $params = []): TableFindAnnotatorTask {
		$params += [
			AbstractAnnotator::CONFIG_DRY_RUN => true,
			AbstractAnnotator::CONFIG_VERBOSE => true,
		];

		return new TableFindAnnotatorTask($this->io, $params, $content);
	}

}


================================================
FILE: tests/TestCase/Annotator/ClassAnnotatorTask/TestClassAnnotatorTaskTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Annotator\ClassAnnotatorTask;

use Cake\Console\ConsoleIo;
use Cake\Core\Configure;
use IdeHelper\Annotator\AbstractAnnotator;
use IdeHelper\Annotator\ClassAnnotatorTask\TestClassAnnotatorTask;
use IdeHelper\Console\Io;
use Shim\TestSuite\ConsoleOutput;
use Shim\TestSuite\TestCase;

class TestClassAnnotatorTaskTest extends TestCase {

	protected ConsoleOutput $out;

	protected ConsoleOutput $err;

	protected ?Io $io = null;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->out = new ConsoleOutput();
		$this->err = new ConsoleOutput();
		$consoleIo = new ConsoleIo($this->out, $this->err);
		$this->io = new Io($consoleIo);
	}

	/**
	 * @return void
	 */
	public function testShouldRun() {
		$task = $this->getTask('');

		$content = 'namespace TestApp\Test\TestCase\Controller' . PHP_EOL . 'class FooControllerTest extends ControllerIntegrationTestCase';
		$result = $task->shouldRun('/tests/TestCase/Foo.php', $content);
		$this->assertTrue($result);

		$content = 'namespace TestApp\Test\TestCase\Command' . PHP_EOL . 'class FooCommandTest extends ConsoleIntegrationTestCase';
		$result = $task->shouldRun('/tests/TestCase/Foo.php', $content);
		$this->assertTrue($result);

		$result = $task->shouldRun('/tests/TestCase/Foo.php', 'namespace TestApp\Foo');
		$this->assertFalse($result);

		$result = $task->shouldRun('/tests/Foo.php', $content);
		$this->assertFalse($result);
	}

	/**
	 * @return void
	 */
	public function testAnnotate() {
		$content = file_get_contents(TEST_FILES . 'tests' . DS . 'BarControllerTest.missing.php');
		$task = $this->getTask($content);
		$path = '/tests/TestCase/Controller/BarControllerTest.php';

		$result = $task->annotate($path);
		$this->assertTrue($result);

		$content = $task->getContent();
		$this->assertTextContains('* @link \TestApp\Controller\BarController', $content);

		$output = $this->out->output();
		$this->assertTextContains('  -> 1 annotation added.', $output);
	}

	/**
	 * @return void
	 */
	public function testAnnotateExisting() {
		$content = file_get_contents(TEST_FILES . 'tests' . DS . 'BarControllerTest.existing.php');
		$task = $this->getTask($content);
		$path = '/tests/TestCase/Controller/BarControllerTest.php';

		$result = $task->annotate($path);
		$this->assertFalse($result);

		$content = $task->getContent();
		$count = substr_count($content, '@uses');
		$this->assertSame(1, $count);

		$output = $this->out->output();
		$this->assertSame('', $output);
	}

	/**
	 * @return void
	 */
	public function testAnnotatePreferUses() {
		Configure::write('IdeHelper.preferLinkOverUsesInTests', false);

		$content = file_get_contents(TEST_FILES . 'tests' . DS . 'BarControllerTest.missing.php');
		$task = $this->getTask($content);
		$path = '/tests/TestCase/Controller/BarControllerTest.php';

		$result = $task->annotate($path);
		$this->assertTrue($result);

		$content = $task->getContent();
		$this->assertTextContains('* @uses \TestApp\Controller\BarController', $content);

		$output = $this->out->output();
		$this->assertTextContains('  -> 1 annotation added.', $output);
	}

	/**
	 * @return void
	 */
	public function testAnnotateSkipsWhenUsesClassAttribute() {
		$content = file_get_contents(TEST_FILES . 'tests' . DS . 'BarControllerTest.attribute.php');
		$task = $this->getTask($content);
		$path = '/tests/TestCase/Controller/BarControllerTest.php';

		$result = $task->annotate($path);
		$this->assertFalse($result);

		$output = $this->out->output();
		$this->assertSame('', $output);
	}

	/**
	 * @return void
	 */
	public function testAnnotateExistingLink() {
		$content = file_get_contents(TEST_FILES . 'tests' . DS . 'BarControllerTest.link.php');
		$task = $this->getTask($content);
		$path = '/tests/TestCase/Controller/BarControllerTest.php';

		$result = $task->annotate($path);
		$this->assertFalse($result);

		$content = $task->getContent();
		$count = substr_count($content, '@link');
		$this->assertSame(1, $count);

		$output = $this->out->output();
		$this->assertSame('', $output);
	}

	/**
	 * @param string $content
	 * @param array $params
	 *
	 * @return \IdeHelper\Annotator\ClassAnnotatorTask\TestClassAnnotatorTask
	 */
	protected function getTask(string $content, array $params = []) {
		$params += [
			AbstractAnnotator::CONFIG_DRY_RUN => true,
			AbstractAnnotator::CONFIG_VERBOSE => true,
		];

		return new TestClassAnnotatorTask($this->io, $params, $content);
	}

}


================================================
FILE: tests/TestCase/Annotator/ClassAnnotatorTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Annotator;

use Cake\Console\ConsoleIo;
use Cake\TestSuite\TestCase;
use IdeHelper\Annotator\AbstractAnnotator;
use IdeHelper\Annotator\ClassAnnotator;
use IdeHelper\Console\Io;
use Shim\TestSuite\ConsoleOutput;

class ClassAnnotatorTest extends TestCase {

	protected ConsoleOutput $out;

	protected ConsoleOutput $err;

	protected Io $io;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->out = new ConsoleOutput();
		$this->err = new ConsoleOutput();
		$consoleIo = new ConsoleIo($this->out, $this->err);
		$this->io = new Io($consoleIo);

		$file = TMP . 'src' . DS . 'CustomClass.php';
		if (file_exists($file)) {
			unlink($file);
			rmdir(TMP . 'src' . DS);
		}
	}

	/**
	 * @return void
	 */
	protected function tearDown(): void {
		parent::tearDown();

		$file = TMP . 'src' . DS . 'CustomClass.php';
		if (file_exists($file)) {
			unlink($file);
			rmdir(TMP . 'src' . DS);
		}
	}

	/**
	 * @return void
	 */
	public function testAnnotate() {
		$annotator = $this->_getAnnotatorMock([]);

		$path = APP . 'Custom' . DS . 'CustomClass.php';
		if (!is_dir(TMP . 'src')) {
			mkdir(TMP . 'src', 0770, true);
		}
		$execPath = TMP . 'src' . DS . 'CustomClass.php';
		copy($path, $execPath);

		$annotator->annotate($execPath);

		$content = file_get_contents($execPath);

		$testPath = TEST_FILES . 'Custom' . DS . 'CustomClass.php';
		$expectedContent = file_get_contents($testPath);
		$this->assertTextEquals($expectedContent, $content);

		$output = $this->out->output();

		$this->assertTextContains('  -> 1 annotation added, 1 annotation removed.', $output);
	}

	/**
	 * @param array $params
	 * @return \IdeHelper\Annotator\ClassAnnotator
	 */
	protected function _getAnnotatorMock(array $params) {
		$params += [
			AbstractAnnotator::CONFIG_REMOVE => true,
			AbstractAnnotator::CONFIG_VERBOSE => true,
		];

		return new ClassAnnotator($this->io, $params);
	}

}


================================================
FILE: tests/TestCase/Annotator/CommandAnnotatorTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Annotator;

use Cake\Console\ConsoleIo;
use Cake\TestSuite\TestCase;
use IdeHelper\Annotator\AbstractAnnotator;
use IdeHelper\Annotator\CommandAnnotator;
use IdeHelper\Console\Io;
use Shim\TestSuite\ConsoleOutput;

class CommandAnnotatorTest extends TestCase {

	use DiffHelperTrait;

	protected array $fixtures = [
		'plugin.IdeHelper.Cars',
		'plugin.IdeHelper.Wheels',
	];

	protected ConsoleOutput $out;

	protected ConsoleOutput $err;

	protected Io $io;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->out = new ConsoleOutput();
		$this->err = new ConsoleOutput();
		$consoleIo = new ConsoleIo($this->out, $this->err);
		$this->io = new Io($consoleIo);
	}

	/**
	 * @return void
	 */
	public function testAnnotate() {
		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'Command/MyCommand.php'));
		$callback = function($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP . 'Command/MyCommand.php';
		$annotator->annotate($path);

		$output = $this->out->output();

		$this->assertTextContains('   -> 2 annotations added.', $output);
	}

	/**
	 * @param array $params
	 * @return \IdeHelper\Annotator\CommandAnnotator|\PHPUnit\Framework\MockObject\MockObject
	 */
	protected function _getAnnotatorMock(array $params): CommandAnnotator {
		$params += [
			AbstractAnnotator::CONFIG_REMOVE => true,
			AbstractAnnotator::CONFIG_DRY_RUN => true,
		];

		return $this->getMockBuilder(CommandAnnotator::class)->onlyMethods(['storeFile'])->setConstructorArgs([$this->io, $params])->getMock();
	}

}


================================================
FILE: tests/TestCase/Annotator/ComponentAnnotatorTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Annotator;

use Cake\Console\ConsoleIo;
use Cake\TestSuite\TestCase;
use IdeHelper\Annotator\AbstractAnnotator;
use IdeHelper\Annotator\ComponentAnnotator;
use IdeHelper\Console\Io;
use Shim\TestSuite\ConsoleOutput;
use Shim\TestSuite\TestTrait;

class ComponentAnnotatorTest extends TestCase {

	use DiffHelperTrait;
	use TestTrait;

	protected ConsoleOutput $out;

	protected ConsoleOutput $err;

	protected Io $io;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->out = new ConsoleOutput();
		$this->err = new ConsoleOutput();
		$consoleIo = new ConsoleIo($this->out, $this->err);
		$this->io = new Io($consoleIo);
	}

	/**
	 * @return void
	 */
	public function testAnnotate() {
		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'Controller/Component/MyComponent.php'));
		$callback = function($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP . 'Controller/Component/MyComponent.php';
		$annotator->annotate($path);

		$output = $this->out->output();

		$this->assertTextContains('   -> 3 annotations added.', $output);
	}

	/**
	 * Note that property always needs $ in front of it: $Prop instead of Prop.
	 *
	 * @return void
	 */
	public function testAnnotateWithExistingDocBlock() {
		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'Controller/Component/MyOtherComponent.php'));
		$callback = function($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP . 'Controller/Component/MyOtherComponent.php';
		$annotator->annotate($path);

		$output = $this->out->output();

		$this->assertTextContains('   -> 1 annotation added.', $output);
	}

	/**
	 * @param array $params
	 * @return \IdeHelper\Annotator\ComponentAnnotator|\PHPUnit\Framework\MockObject\MockObject
	 */
	protected function _getAnnotatorMock(array $params): ComponentAnnotator {
		$params += [
			AbstractAnnotator::CONFIG_REMOVE => true,
			AbstractAnnotator::CONFIG_DRY_RUN => true,
		];

		return $this->getMockBuilder(ComponentAnnotator::class)->onlyMethods(['storeFile'])->setConstructorArgs([$this->io, $params])->getMock();
	}

	/**
	 * @return void
	 */
	public function testAnnotateWithControllerUsage() {
		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'Controller/Component/MyControllerComponent.php'));
		$callback = function($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP . 'Controller/Component/MyControllerComponent.php';
		$annotator->annotate($path);

		$output = $this->out->output();

		$this->assertTextContains('   -> 1 annotation added.', $output);
	}

}


================================================
FILE: tests/TestCase/Annotator/ControllerAnnotatorTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Annotator;

use Cake\Console\ConsoleIo;
use Cake\TestSuite\TestCase;
use IdeHelper\Annotator\AbstractAnnotator;
use IdeHelper\Annotator\ControllerAnnotator;
use IdeHelper\Console\Io;
use Shim\TestSuite\ConsoleOutput;

class ControllerAnnotatorTest extends TestCase {

	use DiffHelperTrait;

	protected array $fixtures = [
		'plugin.IdeHelper.Cars',
		'plugin.IdeHelper.Wheels',
	];

	protected ConsoleOutput $out;

	protected ConsoleOutput $err;

	protected Io $io;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->out = new ConsoleOutput();
		$this->err = new ConsoleOutput();
		$consoleIo = new ConsoleIo($this->out, $this->err);
		$this->io = new Io($consoleIo);
	}

	/**
	 * @return void
	 */
	public function testAnnotate() {
		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'Controller/FoosController.php'));
		$callback = function($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP . 'Controller/FoosController.php';
		$annotator->annotate($path);

		$output = $this->out->output();

		$this->assertTextContains('   -> 1 annotation added.', $output);
	}

	/**
	 * @return void
	 */
	public function testAnnotateWithCustomModelAndLoadModel() {
		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'Controller/BarController.php'));
		$callback = function($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP . 'Controller/BarController.php';
		$annotator->annotate($path);

		$output = $this->out->output();

		$this->assertTextContains('   -> 3 annotations added.', $output);
	}

	/**
	 * @return void
	 */
	public function testAnnotateWithAppController() {
		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'Controller/AppController.php'));
		$callback = function($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP . 'Controller/AppController.php';
		$annotator->annotate($path);

		$output = $this->out->output();

		$this->assertTextContains('   -> 1 annotation added.', $output);
	}

	/**
	 * @param array $params
	 * @return \IdeHelper\Annotator\ControllerAnnotator|\PHPUnit\Framework\MockObject\MockObject
	 */
	protected function _getAnnotatorMock(array $params): ControllerAnnotator {
		$params += [
			AbstractAnnotator::CONFIG_REMOVE => true,
			AbstractAnnotator::CONFIG_DRY_RUN => true,
		];

		return $this->getMockBuilder(ControllerAnnotator::class)->onlyMethods(['storeFile'])->setConstructorArgs([$this->io, $params])->getMock();
	}

	/**
	 * @return void
	 */
	public function testAnnotateWithPluginController() {
		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'Controller/HousesController.php'));
		$callback = function ($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())
			->method('storeFile')
			->with($this->anything(), $this->callback($callback));

		$path = APP_ROOT . '/plugins/Controllers/src/Controller/HousesController.php';
		$annotator->setConfig(ControllerAnnotator::CONFIG_PLUGIN, 'Controllers');
		$annotator->annotate($path);

		$output = $this->out->output();

		$this->assertTextContains('   -> 1 annotation added.', $output);
	}

	/**
	 * @return void
	 */
	public function testAnnotateWithPluginControllerExplicit() {
		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'Controller/WindowsController.php'));
		$callback = function ($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())
			->method('storeFile')
			->with($this->anything(), $this->callback($callback));

		$path = APP_ROOT . '/plugins/Controllers/src/Controller/WindowsController.php';
		$annotator->setConfig(ControllerAnnotator::CONFIG_PLUGIN, 'Controllers');
		$annotator->annotate($path);

		$output = $this->out->output();

		$this->assertTextContains('   -> 1 annotation added.', $output);
	}

	/**
	 * @return void
	 */
	public function testAnnotateWithPluginControllerNoModel() {
		$annotator = $this->_getAnnotatorMock([]);

		$annotator->expects($this->never())
			->method('storeFile');

		$path = APP_ROOT . '/plugins/Controllers/src/Controller/GenericController.php';
		$annotator->setConfig(ControllerAnnotator::CONFIG_PLUGIN, 'Awesome');
		$annotator->annotate($path);

		$output = $this->out->output();
		$this->assertTextNotContains('annotation added.', $output);
	}

	/**
	 * @return void
	 */
	public function testAnnotateWithDynamicProperties() {
		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'Controller/DynamicPropertiesController.php'));
		$callback = function($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP . 'Controller/DynamicPropertiesController.php';
		$annotator->annotate($path);

		$output = $this->out->output();

		$this->assertTextContains('   -> 1 annotation added.', $output);
	}

	/**
	 * @return void
	 */
	public function testAnnotateWithDynamicPropertiesExistingDocblock() {
		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'Controller/DynamicPropertiesExistingDocblockController.php'));
		$callback = function($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP . 'Controller/DynamicPropertiesExistingDocblockController.php';
		$annotator->annotate($path);

		$output = $this->out->output();

		$this->assertTextContains('   -> 1 annotation added.', $output);
	}

}


================================================
FILE: tests/TestCase/Annotator/DiffHelperTrait.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Annotator;

use SebastianBergmann\Diff\Differ;
use SebastianBergmann\Diff\Output\DiffOnlyOutputBuilder;

trait DiffHelperTrait {

	/**
	 * Outputs some debug info for tests.
	 *
	 * @param string $expected
	 * @param string $actual
	 *
	 * @return void
	 */
	protected function _displayDiff($expected, $actual) {
		$differ = new Differ(new DiffOnlyOutputBuilder());
		$array = $differ->diffToArray($expected, $actual);

		$begin = null;
		$end = null;
		foreach ($array as $key => $row) {
			if ($row[1] === 0) {
				continue;
			}

			if ($begin === null) {
				$begin = $key;
			}
			$end = $key;
		}
		if ($begin === null) {
			return;
		}
		$firstLineOfOutput = $begin > 0 ? $begin - 1 : 0;
		$lastLineOfOutput = count($array) - 1 > $end ? $end + 1 : $end;

		$out = [];
		for ($i = $firstLineOfOutput; $i <= $lastLineOfOutput; $i++) {
			$row = $array[$i];
			$char = ' ';
			if ($row[1] === 1) {
				$char = '+';
				$out[] = $char . $row[0];
			} elseif ($row[1] === 2) {
				$char = '-';
				$out[] = $char . $row[0];
			} else {
				$out[] = $char . $row[0];
			}
		}

		echo PHP_EOL . '####### diff #######' . PHP_EOL . (implode(PHP_EOL, $out)) . PHP_EOL . '##### diff end #####' . PHP_EOL;
	}

}


================================================
FILE: tests/TestCase/Annotator/EntityAnnotatorTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Annotator;

use Cake\Console\ConsoleIo;
use Cake\Core\Configure;
use Cake\Database\Schema\TableSchema;
use Cake\ORM\TableRegistry;
use Cake\TestSuite\TestCase;
use Cake\View\View;
use IdeHelper\Annotator\AbstractAnnotator;
use IdeHelper\Annotator\EntityAnnotator;
use IdeHelper\Console\Io;
use IdeHelper\View\Helper\DocBlockHelper;
use Shim\TestSuite\ConsoleOutput;
use Shim\TestSuite\TestTrait;
use TestApp\Model\Table\FoosTable;

class EntityAnnotatorTest extends TestCase {

	use DiffHelperTrait;
	use TestTrait;

	protected ConsoleOutput $out;

	protected ConsoleOutput $err;

	protected Io $io;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		Configure::delete('IdeHelper');

		$this->out = new ConsoleOutput();
		$this->err = new ConsoleOutput();
		$consoleIo = new ConsoleIo($this->out, $this->err);
		$this->io = new Io($consoleIo);

		$x = TableRegistry::getTableLocator()->get('IdeHelper.Foos', ['className' => FoosTable::class]);
		$columns = [
			'id' => [
				'type' => 'integer',
				'length' => 11,
				'unsigned' => false,
				'null' => false,
				'default' => null,
				'comment' => '',
				'autoIncrement' => true,
				'baseType' => null,
				'precision' => null,
			],
			'name' => [
				'type' => 'string',
				'length' => 100,
				'null' => false,
				'default' => null,
				'comment' => '',
				'baseType' => null,
				'precision' => null,
				'fixed' => null,
			],
			'content' => [
				'type' => 'string',
				'length' => 100,
				'null' => false,
				'default' => null,
				'comment' => '',
				'baseType' => null,
				'precision' => null,
				'fixed' => null,
			],
			'offer_date' => [
				'type' => 'date',
				'length' => null,
				'null' => false,
				'default' => null,
				'comment' => '',
				'baseType' => null,
				'precision' => null,
			],
			'created' => [
				'type' => 'datetime',
				'length' => null,
				'null' => false,
				'default' => null,
				'comment' => '',
				'baseType' => null,
				'precision' => null,
			],
			'modified' => [
				'type' => 'datetime',
				'length' => null,
				'null' => true,
				'default' => null,
				'comment' => '',
				'baseType' => null,
				'precision' => null,
			],
			'params' => [
				'type' => 'json',
				'length' => null,
				'null' => true,
				'default' => null,
				'comment' => '',
				'precision' => null,
			],
		];
		$schema = new TableSchema('Foos', $columns);
		$x->setSchema($schema);
		TableRegistry::getTableLocator()->set('Foos', $x);
	}

	/**
	 * @return void
	 */
	public function testBuildExtendedEntityPropertyHintTypeMap() {
		$config = [];
		$annotator = new EntityAnnotator(new Io(new ConsoleIo()), $config);

		Configure::write('IdeHelper.typeMap', [
			'custom' => 'array',
			'longtext' => null,
		]);
		Configure::write('IdeHelper.nullableMap', [
			'custom' => false,
		]);

		$propertySchema = [
			'invalid' => [
				'kind' => 'column',
				'type' => 'invalid',
			],
			'custom' => [
				'kind' => 'column',
				'type' => 'custom',
				'null' => false,
			],
			'json' => [
				'kind' => 'column',
				'type' => 'json',
				'null' => true,
			],
			'resetted' => [
				'kind' => 'column',
				'type' => 'longtext',
			],
		];
		$helper = new DocBlockHelper(new View());

		/** @uses \IdeHelper\Annotator\EntityAnnotator::buildExtendedEntityPropertyHintTypeMap() */
		$result = $this->invokeMethod($annotator, 'buildExtendedEntityPropertyHintTypeMap', [$propertySchema, $helper]);
		$expected = [
			'custom' => 'array',
			'json' => 'array|null',
		];
		$this->assertSame($result, $expected);
	}

	/**
	 * @return void
	 */
	public function testAnnotate() {
		/** @var \TestApp\Model\Table\FoosTable $Table */
		$Table = TableRegistry::getTableLocator()->get('Foos');

		$schema = $Table->getSchema();
		$associations = $Table->associations();
		$annotator = $this->_getAnnotatorMock(['schema' => $schema, 'associations' => $associations]);

		$expectedContent = str_replace(["\r\n", "\r"], "\n", file_get_contents(TEST_FILES . 'Model/Entity/Foo.php'));
		$callback = function ($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP . 'Model/Entity/Foo.php';
		$annotator->annotate($path);

		$output = $this->out->output();

		$this->assertTextContains('   -> 4 annotations added, 1 annotation updated.', $output);
	}

	/**
	 * @return void
	 */
	public function testAnnotateWithExistingDocBlock() {
		/** @var \TestApp\Model\Table\CarsTable $Table */
		$Table = TableRegistry::getTableLocator()->get('Cars');

		$schema = $Table->getSchema();
		$associations = $Table->associations();
		$annotator = $this->_getAnnotatorMock(['schema' => $schema, 'associations' => $associations]);

		$expectedContent = str_replace(["\r\n", "\r"], "\n", file_get_contents(TEST_FILES . 'Model/Entity/Car.php'));
		$callback = function ($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP . 'Model/Entity/Car.php';
		$annotator->annotate($path);

		$output = $this->out->output();

		$this->assertTextContains('   -> 7 annotations added', $output);
	}

	/**
	 * @return void
	 */
	public function testAnnotateWithExistingDocBlockComplex() {
		/** @var \TestApp\Model\Table\WheelsTable $Table */
		$Table = TableRegistry::getTableLocator()->get('Wheels');

		$schema = $Table->getSchema();
		$associations = $Table->associations();
		$annotator = $this->_getAnnotatorMock(['schema' => $schema, 'associations' => $associations]);

		$expectedContent = str_replace(["\r\n", "\r"], "\n", file_get_contents(TEST_FILES . 'Model/Entity/Complex/Wheel.php'));
		$callback = function ($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP . 'Model/Entity/Complex/Wheel.php';
		$annotator->annotate($path);

		$output = $this->out->output();

		$this->assertTextContains('   -> 1 annotation added, 3 annotations removed, 1 annotation skipped.', $output);
	}

	/**
	 * @return void
	 */
	public function testAnnotateWithVirtualProperties() {
		/** @var \TestApp\Model\Table\FoosTable $Table */
		$Table = TableRegistry::getTableLocator()->get('Foos');
		$Table->hasMany('Wheels');

		$schema = $Table->getSchema();
		$associations = $Table->associations();
		$annotator = $this->_getAnnotatorMock(['schema' => $schema, 'associations' => $associations]);

		$expectedContent = str_replace(["\r\n", "\r"], "\n", file_get_contents(TEST_FILES . 'Model/Entity/Wheel.php'));
		$callback = function ($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP . 'Model/Entity/Wheel.php';
		$annotator->annotate($path);

		$output = $this->out->output();

		$this->assertTextContains('   -> 9 annotations added', $output);
	}

	/**
	 * @return void
	 */
	public function testAnnotateWithVirtualPropertiesReadOnly() {
		/** @var \TestApp\Model\Table\FoosTable $Table */
		$Table = TableRegistry::getTableLocator()->get('Foos');
		$Table->hasMany('Wheels');

		$schema = $Table->getSchema();
		$associations = $Table->associations();
		$annotator = $this->_getAnnotatorMock(['schema' => $schema, 'associations' => $associations]);

		$expectedContent = str_replace(["\r\n", "\r"], "\n", file_get_contents(TEST_FILES . 'Model/Entity/Virtual.php'));
		$callback = function ($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP . 'Model/Entity/Virtual.php';
		$annotator->annotate($path);

		$output = $this->out->output();

		$this->assertTextContains('   -> 10 annotations added', $output);
	}

	/**
	 * @return void
	 */
	public function testAnnotateWithVirtualPropertiesAndReturnTypes() {
		/** @var \TestApp\Model\Table\FoosTable $Table */
		$Table = TableRegistry::getTableLocator()->get('Foos');
		$Table->hasMany('Wheels');

		$schema = $Table->getSchema();
		$associations = $Table->associations();
		$annotator = $this->_getAnnotatorMock(['schema' => $schema, 'associations' => $associations]);

		$expectedContent = str_replace(["\r\n", "\r"], "\n", file_get_contents(TEST_FILES . 'Model/Entity/PHP7/Virtual.php'));
		$callback = function ($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP . 'Model/Entity/PHP7/Virtual.php';
		$annotator->annotate($path);

		$output = $this->out->output();

		$this->assertTextContains('   -> 11 annotations added', $output);
	}

	/**
	 * @return void
	 */
	public function testAnnotateHasOne() {
		/** @var \Relations\Model\Table\UsersTable $Table */
		$Table = TableRegistry::getTableLocator()->get('Relations.Users');

		$schema = $Table->getSchema();
		$associations = $Table->associations();
		$annotator = $this->_getAnnotatorMock(['schema' => $schema, 'associations' => $associations]);

		$expectedContent = str_replace(["\r\n", "\r"], "\n", file_get_contents(TEST_FILES . 'Model/Entity/Relations/User.php'));
		$callback = function ($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = PLUGINS . 'Relations/src/Model/Entity/User.php';
		$annotator->annotate($path);

		$output = (string)$this->out->output();

		$this->assertTextContains('   -> 4 annotations added', $output);
	}

	/**
	 * @return void
	 */
	public function testAnnotateBelongsToRequired() {
		/** @var \Relations\Model\Table\UsersTable $Table */
		$Table = TableRegistry::getTableLocator()->get('Relations.Foos');

		$schema = $Table->getSchema();
		$associations = $Table->associations();
		$annotator = $this->_getAnnotatorMock(['schema' => $schema, 'associations' => $associations]);

		$expectedContent = str_replace(["\r\n", "\r"], "\n", file_get_contents(TEST_FILES . 'Model/Entity/Relations/Foo.php'));
		$callback = function ($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = PLUGINS . 'Relations/src/Model/Entity/Foo.php';
		$annotator->annotate($path);

		$output = (string)$this->out->output();

		$this->assertTextContains('   -> 5 annotations added', $output);
	}

	/**
	 * @return void
	 */
	public function testAnnotateBelongsToNullable() {
		/** @var \Relations\Model\Table\BarsTable $Table */
		$Table = TableRegistry::getTableLocator()->get('Relations.Bars');

		$schema = $Table->getSchema();
		$associations = $Table->associations();
		$annotator = $this->_getAnnotatorMock(['schema' => $schema, 'associations' => $associations]);

		$expectedContent = str_replace(["\r\n", "\r"], "\n", file_get_contents(TEST_FILES . 'Model/Entity/Relations/Bar.php'));
		$callback = function ($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = PLUGINS . 'Relations/src/Model/Entity/Bar.php';
		$annotator->annotate($path);

		$output = (string)$this->out->output();

		$this->assertTextContains('   -> 4 annotations added', $output);
	}

	/**
	 * @return void
	 */
	public function testAnnotateWithGenericUsage() {
		/** @var \TestApp\Model\Table\FoosTable $Table */
		$Table = TableRegistry::getTableLocator()->get('Foos');
		$Table->hasMany('Wheels');

		$schema = $Table->getSchema();
		$associations = $Table->associations();
		$annotator = $this->_getAnnotatorMock(['schema' => $schema, 'associations' => $associations]);

		$expectedContent = str_replace(["\r\n", "\r"], "\n", file_get_contents(TEST_FILES . 'Model/Entity/PHP/Generics.php'));
		$callback = function ($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP . 'Model/Entity/PHP/Generics.php';

		Configure::write('IdeHelper.arrayAsGenerics', true);

		$annotator->annotate($path);

		Configure::delete('IdeHelper.arrayAsGenerics');

		$output = $this->out->output();

		$this->assertTextContains('   -> 1 annotation added, 1 annotation updated', $output);
	}

	/**
	 * @return void
	 */
	public function testAnnotateWithDuplicates() {
		/** @var \TestApp\Model\Table\FoosTable $Table */
		$Table = TableRegistry::getTableLocator()->get('Foos');

		$schema = $Table->getSchema();
		$associations = $Table->associations();
		$annotator = $this->_getAnnotatorMock(['schema' => $schema, 'associations' => $associations]);

		$expectedContent = str_replace(["\r\n", "\r"], "\n", file_get_contents(TEST_FILES . 'Model/Entity/PHP/Duplicates.php'));
		$callback = function ($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP . 'Model/Entity/PHP/Duplicates.php';

		$annotator->annotate($path);

		$output = $this->out->output();

		$this->assertTextContains('   -> 1 annotation removed', $output);
	}

	/**
	 * @return void
	 */
	public function testAnnotateWithComplexType() {
		/** @var \TestApp\Model\Table\FoosTable $Table */
		$Table = TableRegistry::getTableLocator()->get('Foos');

		$schema = $Table->getSchema();
		$associations = $Table->associations();
		$annotator = $this->_getAnnotatorMock(['schema' => $schema, 'associations' => $associations]);

		$expectedContent = str_replace(["\r\n", "\r"], "\n", file_get_contents(TEST_FILES . 'Model/Entity/PHP/ComplexType.php'));
		$callback = function ($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->never())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP . 'Model/Entity/PHP/ComplexType.php';

		$annotator->annotate($path);

		$output = $this->out->output();

		$this->assertTextContains('   -> 1 annotation skipped', $output);
	}

	/**
	 * @param array $params
	 * @return \IdeHelper\Annotator\EntityAnnotator|\PHPUnit\Framework\MockObject\MockObject
	 */
	protected function _getAnnotatorMock(array $params): EntityAnnotator {
		$params += [
			AbstractAnnotator::CONFIG_REMOVE => true,
			AbstractAnnotator::CONFIG_DRY_RUN => true,
		];

		return $this->getMockBuilder(EntityAnnotator::class)->onlyMethods(['storeFile'])->setConstructorArgs([$this->io, $params])->getMock();
	}

}


================================================
FILE: tests/TestCase/Annotator/HelperAnnotatorTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Annotator;

use Cake\Console\ConsoleIo;
use Cake\TestSuite\TestCase;
use IdeHelper\Annotator\AbstractAnnotator;
use IdeHelper\Annotator\HelperAnnotator;
use IdeHelper\Console\Io;
use Shim\TestSuite\ConsoleOutput;

class HelperAnnotatorTest extends TestCase {

	use DiffHelperTrait;

	protected ConsoleOutput $out;

	protected ConsoleOutput $err;

	protected Io $io;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->out = new ConsoleOutput();
		$this->err = new ConsoleOutput();
		$consoleIo = new ConsoleIo($this->out, $this->err);
		$this->io = new Io($consoleIo);
	}

	/**
	 * @return void
	 */
	public function testAnnotate() {
		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'View/Helper/MyHelper.php'));
		$callback = function($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP . 'View/Helper/MyHelper.php';
		$annotator->annotate($path);

		$output = $this->out->output();

		$this->assertTextContains('   -> 3 annotations added', $output);
	}

	/**
	 * @return void
	 */
	public function testAnnotatePreservesCustomMethodAnnotations() {
		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'View/Helper/MyMethodHelper.php'));
		$callback = function($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP . 'View/Helper/MyMethodHelper.php';
		$annotator->annotate($path);

		$output = $this->out->output();

		$this->assertTextContains('   -> 2 annotations added', $output);
	}

	/**
	 * @param array $params
	 * @return \IdeHelper\Annotator\HelperAnnotator|\PHPUnit\Framework\MockObject\MockObject
	 */
	protected function _getAnnotatorMock(array $params): HelperAnnotator {
		$params += [
			AbstractAnnotator::CONFIG_REMOVE => true,
			AbstractAnnotator::CONFIG_DRY_RUN => true,
		];

		return $this->getMockBuilder(HelperAnnotator::class)->onlyMethods(['storeFile'])->setConstructorArgs([$this->io, $params])->getMock();
	}

}


================================================
FILE: tests/TestCase/Annotator/ModelAnnotatorSpecificTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Annotator;

use Cake\Console\ConsoleIo;
use Cake\Core\Configure;
use Cake\Database\Schema\TableSchema;
use Cake\ORM\TableRegistry;
use Cake\TestSuite\TestCase;
use IdeHelper\Annotator\AbstractAnnotator;
use IdeHelper\Annotator\ModelAnnotator;
use IdeHelper\Console\Io;
use Shim\TestSuite\ConsoleOutput;
use TestApp\Model\Table\FoosTable;

/**
 * Test with concreteEntitiesInParam config on.
 */
class ModelAnnotatorSpecificTest extends TestCase {

	use DiffHelperTrait;

	/**
	 * @var array<string>
	 */
	protected array $fixtures = [
		'plugin.IdeHelper.Foos',
		'plugin.IdeHelper.Wheels',
		'plugin.IdeHelper.BarBars',
	];

	protected ConsoleOutput $out;

	protected ConsoleOutput $err;

	protected Io $io;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->out = new ConsoleOutput();
		$this->err = new ConsoleOutput();
		$consoleIo = new ConsoleIo($this->out, $this->err);
		$this->io = new Io($consoleIo);

		Configure::write('IdeHelper.assocsAsGenerics', true);
		Configure::write('IdeHelper.concreteEntitiesInParam', true);
		Configure::write('IdeHelper.genericsInParam', true);
		Configure::write('IdeHelper.tableBehaviors', 'mixin');

		$x = TableRegistry::getTableLocator()->get('IdeHelper.Foos', ['className' => FoosTable::class]);
		$columns = [
			'id' => [
				'type' => 'integer',
				'length' => 11,
				'unsigned' => false,
				'null' => false,
				'default' => null,
				'comment' => '',
				'autoIncrement' => true,
				'baseType' => null,
				'precision' => null,
			],
			'name' => [
				'type' => 'string',
				'length' => 100,
				'null' => false,
				'default' => null,
				'comment' => '',
				'baseType' => null,
				'precision' => null,
				'fixed' => null,
			],
			'content' => [
				'type' => 'string',
				'length' => 100,
				'null' => false,
				'default' => null,
				'comment' => '',
				'baseType' => null,
				'precision' => null,
				'fixed' => null,
			],
			'created' => [
				'type' => 'datetime',
				'length' => null,
				'null' => true,
				'default' => null,
				'comment' => '',
				'baseType' => null,
				'precision' => null,
			],
		];
		$schema = new TableSchema('Foos', $columns);
		$x->setSchema($schema);
		TableRegistry::getTableLocator()->set('Foos', $x);
	}

	/**
	 * @return void
	 */
	public function tearDown(): void {
		parent::tearDown();

		Configure::delete('IdeHelper.assocsAsGenerics');
		Configure::delete('IdeHelper.concreteEntitiesInParam');
		Configure::delete('IdeHelper.genericsInParam');
		Configure::delete('IdeHelper.tableBehaviors');
	}

	/**
	 * @param array $params
	 * @return \IdeHelper\Annotator\ModelAnnotator|\PHPUnit\Framework\MockObject\MockObject
	 */
	protected function _getAnnotatorMock(array $params): ModelAnnotator {
		$params += [
			AbstractAnnotator::CONFIG_REMOVE => true,
			AbstractAnnotator::CONFIG_DRY_RUN => true,
			AbstractAnnotator::CONFIG_VERBOSE => true,
		];

		return $this->getMockBuilder(ModelAnnotator::class)->onlyMethods(['storeFile'])->setConstructorArgs([$this->io, $params])->getMock();
	}

	/**
	 * @return void
	 */
	public function testAnnotateSpecific() {
		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'Model/Table/Specific/BarBarsTable.php'));
		$callback = function($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP . 'Model/Table/Specific/BarBarsTable.php';
		$annotator->annotate($path);

		$output = $this->out->output();

		$this->assertTextContains('  -> 7 annotations added', $output);
	}

	/**
	 * @return void
	 */
	public function testAnnotateSpecificDetailed() {
		Configure::write('IdeHelper.genericsInParam', 'detailed');

		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'Model/Table/Specific/BarBarsDetailedTable.php'));
		$callback = function($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP . 'Model/Table/Specific/BarBarsTable.php';
		$annotator->annotate($path);

		$output = $this->out->output();

		$this->assertTextContains('  -> 7 annotations added', $output);
	}

	/**
	 * @return void
	 */
	public function testAnnotateSpecificExistingMerge() {
		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'Model/Table/Specific/WheelsTable.php'));
		$callback = function($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP . 'Model/Table/Specific/WheelsTable.php';
		$annotator->annotate($path);

		$output = $this->out->output();

		$this->assertTextContains('  -> 14 annotations added, 1 annotation updated', $output);
	}

	/**
	 * @return void
	 */
	public function testAnnotateSpecificExistingReplace() {
		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'Model/Table/Specific/WheelsExtraTable.php'));
		$callback = function($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP . 'Model/Table/Specific/WheelsExtraTable.php';
		$annotator->annotate($path);

		$output = $this->out->output();

		$this->assertTextContains('  -> 1 annotation updated', $output);
	}

	/**
	 * @return void
	 */
	public function testAnnotateSpecificSkip() {
		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'Model/Table/Specific/SkipSomeTable.php'));
		$callback = function($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->never())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP . 'Model/Table/Specific/SkipSomeTable.php';
		$annotator->annotate($path);

		$output = $this->out->output();
		$this->assertSame('', $output);
	}

	/**
	 * @return void
	 */
	public function testAnnotateSpecificSkipAll() {
		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'Model/Table/Specific/SkipMeTable.php'));
		$callback = function($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->never())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP . 'Model/Table/Specific/SkipMeTable.php';
		$annotator->annotate($path);

		$output = $this->out->output();
		$this->assertSame('', $output);
	}

	/**
	 * @return void
	 */
	public function testAnnotateSpecificCatchExceptions() {
		$annotator = $this->_getAnnotatorMock([]);

		$path = APP . 'Model/Table/Specific/ExceptionsTable.php';
		$annotator->annotate($path);

		$output = $this->out->output();
		$this->assertTextNotContains('annotations added', $output);
	}

	/**
	 * @return void
	 */
	public function testAnnotateSpecificProtectedParent() {
		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'Model/Table/Specific/BarBarsAbstractTable.php'));
		$callback = function ($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->method('storeFile')
			->with($this->anything(), $this->callback($callback));

		$path = APP . 'Model/Table/Specific/BarBarsAbstractTable.php';
		$annotator->annotate($path);

		$output = $this->out->output();
		$this->assertTextContains('  -> 17 annotations added', $output);
	}

}


================================================
FILE: tests/TestCase/Annotator/ModelAnnotatorTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Annotator;

use Cake\Console\ConsoleIo;
use Cake\Core\Configure;
use Cake\Database\Schema\TableSchema;
use Cake\ORM\TableRegistry;
use Cake\TestSuite\TestCase;
use IdeHelper\Annotator\AbstractAnnotator;
use IdeHelper\Annotator\ModelAnnotator;
use IdeHelper\Console\Io;
use Shim\TestSuite\ConsoleOutput;
use TestApp\Model\Table\FoosTable;

class ModelAnnotatorTest extends TestCase {

	use DiffHelperTrait;

	/**
	 * @var array<string>
	 */
	protected array $fixtures = [
		'plugin.IdeHelper.Foos',
		'plugin.IdeHelper.Wheels',
		'plugin.IdeHelper.BarBars',
	];

	protected ConsoleOutput $out;

	protected ConsoleOutput $err;

	protected Io $io;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->out = new ConsoleOutput();
		$this->err = new ConsoleOutput();
		$consoleIo = new ConsoleIo($this->out, $this->err);
		$this->io = new Io($consoleIo);

		Configure::write('IdeHelper.assocsAsGenerics', true);
		Configure::write('IdeHelper.tableBehaviors', true);

		$x = TableRegistry::getTableLocator()->get('IdeHelper.Foos', ['className' => FoosTable::class]);
		$columns = [
			'id' => [
				'type' => 'integer',
				'length' => 11,
				'unsigned' => false,
				'null' => false,
				'default' => null,
				'comment' => '',
				'autoIncrement' => true,
				'baseType' => null,
				'precision' => null,
			],
			'name' => [
				'type' => 'string',
				'length' => 100,
				'null' => false,
				'default' => null,
				'comment' => '',
				'baseType' => null,
				'precision' => null,
				'fixed' => null,
			],
			'content' => [
				'type' => 'string',
				'length' => 100,
				'null' => false,
				'default' => null,
				'comment' => '',
				'baseType' => null,
				'precision' => null,
				'fixed' => null,
			],
			'created' => [
				'type' => 'datetime',
				'length' => null,
				'null' => true,
				'default' => null,
				'comment' => '',
				'baseType' => null,
				'precision' => null,
			],
			'params' => [
				'type' => 'json',
				'length' => null,
				'null' => true,
				'default' => null,
				'comment' => '',
				'precision' => null,
			],
		];
		$schema = new TableSchema('Foos', $columns);
		$x->setSchema($schema);
		TableRegistry::getTableLocator()->set('Foos', $x);
	}

	/**
	 * @return void
	 */
	public function tearDown(): void {
		parent::tearDown();

		Configure::delete('IdeHelper.assocsAsGenerics');
		Configure::delete('IdeHelper.tableEntityQuery');
		Configure::delete('IdeHelper.tableBehaviors');
	}

	/**
	 * @param array $params
	 * @return \IdeHelper\Annotator\ModelAnnotator|\PHPUnit\Framework\MockObject\MockObject
	 */
	protected function _getAnnotatorMock(array $params): ModelAnnotator {
		$params += [
			AbstractAnnotator::CONFIG_REMOVE => true,
			AbstractAnnotator::CONFIG_DRY_RUN => true,
			AbstractAnnotator::CONFIG_VERBOSE => true,
		];

		return $this->getMockBuilder(ModelAnnotator::class)->onlyMethods(['storeFile'])->setConstructorArgs([$this->io, $params])->getMock();
	}

	/**
	 * @param array $params
	 * @return \IdeHelper\Annotator\ModelAnnotator|\PHPUnit\Framework\MockObject\MockObject
	 */
	protected function _getEntityTemplateAnnotatorMock(array $params): ModelAnnotator {
		$params += [
			AbstractAnnotator::CONFIG_REMOVE => true,
			AbstractAnnotator::CONFIG_DRY_RUN => true,
			AbstractAnnotator::CONFIG_VERBOSE => true,
		];

		$mock = $this->getMockBuilder(ModelAnnotator::class)
			->onlyMethods(['storeFile', 'supportsEntityTemplate'])
			->setConstructorArgs([$this->io, $params])
			->getMock();
		$mock->method('supportsEntityTemplate')->willReturn(true);

		return $mock;
	}

	/**
	 * @return void
	 */
	public function testAnnotate() {
		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'Model/Table/BarBarsTable.php'));
		$callback = function($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP . 'Model/Table/BarBarsTable.php';
		$annotator->annotate($path);

		$output = $this->out->output();

		$this->assertTextContains('  -> 18 annotations added', $output);
	}

	/**
	 * @return void
	 */
	public function testAnnotateExistingMerge() {
		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'Model/Table/WheelsTable.php'));
		$callback = function($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP . 'Model/Table/WheelsTable.php';
		$annotator->annotate($path);

		$output = $this->out->output();

		$this->assertTextContains('  -> 15 annotations added, 1 annotation updated', $output);
	}

	/**
	 * @return void
	 */
	public function testAnnotateExistingReplace() {
		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'Model/Table/WheelsExtraTable.php'));
		$callback = function($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP . 'Model/Table/WheelsExtraTable.php';
		$annotator->annotate($path);

		$output = $this->out->output();

		$this->assertTextContains('  -> 1 annotation updated', $output);
	}

	/**
	 * @return void
	 */
	public function testAnnotateSkip() {
		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'Model/Table/SkipSomeTable.php'));
		$callback = function($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->never())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP . 'Model/Table/SkipSomeTable.php';
		$annotator->annotate($path);

		$output = $this->out->output();
		$this->assertSame('', $output);
	}

	/**
	 * @return void
	 */
	public function testAnnotateSkipAll() {
		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'Model/Table/SkipMeTable.php'));
		$callback = function($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->never())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP . 'Model/Table/SkipMeTable.php';
		$annotator->annotate($path);

		$output = $this->out->output();
		$this->assertSame('', $output);
	}

	/**
	 * @return void
	 */
	public function testAnnotateCatchExceptions() {
		$annotator = $this->_getAnnotatorMock([]);

		$path = APP . 'Model/Table/ExceptionsTable.php';
		$annotator->annotate($path);

		$output = $this->out->output();
		$this->assertTextNotContains('annotations added', $output);
	}

	/**
	 * @return void
	 */
	public function testAnnotateProtectedParent() {
		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'Model/Table/BarBarsAbstractTable.php'));
		$callback = function ($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->method('storeFile')
			->with($this->anything(), $this->callback($callback));

		$path = APP . 'Model/Table/BarBarsAbstractTable.php';
		$annotator->annotate($path);

		$output = $this->out->output();
		$this->assertTextContains('  -> 18 annotations added', $output);
	}

	/**
	 * @return void
	 */
	public function testAnnotateDetailed() {
		Configure::write('IdeHelper.genericsInParam', 'detailed');
		Configure::write('IdeHelper.arrayAsGenerics', true);
		Configure::write('IdeHelper.objectAsGenerics', true);

		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'Model/Table/BarBarsDetailedTable.php'));
		$callback = function ($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP . 'Model/Table/BarBarsTable.php';
		$annotator->annotate($path);

		Configure::delete('IdeHelper.genericsInParam');
		Configure::delete('IdeHelper.arrayAsGenerics');
		Configure::delete('IdeHelper.objectAsGenerics');

		$output = $this->out->output();
		$this->assertTextContains('  -> 18 annotations added', $output);
	}

	/**
	 * @return void
	 */
	public function testAnnotateWithEntityFindQuery() {
		Configure::write('IdeHelper.tableEntityQuery', true);

		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'Model/Table/BarBarsTable.php'));
		$expectedContent = str_replace(
			" * @method \\TestApp\\Model\\Entity\\BarBar get(mixed \$primaryKey, array|string \$finder = 'all', \\Psr\\SimpleCache\\CacheInterface|string|null \$cache = null, \\Closure|string|null \$cacheKey = null, mixed ...\$args)\n * @method \\TestApp\\Model\\Entity\\BarBar findOrCreate(\\Cake\\ORM\\Query\\SelectQuery|callable|array \$search, ?callable \$callback = null, array \$options = [])",
			" * @method \\TestApp\\Model\\Entity\\BarBar get(mixed \$primaryKey, array|string \$finder = 'all', \\Psr\\SimpleCache\\CacheInterface|string|null \$cache = null, \\Closure|string|null \$cacheKey = null, mixed ...\$args)\n * @method \\Cake\\ORM\\Query\\SelectQuery<\\TestApp\\Model\\Entity\\BarBar> find(string \$type = 'all', mixed ...\$args)\n * @method \\TestApp\\Model\\Entity\\BarBar findOrCreate(\\Cake\\ORM\\Query\\SelectQuery|callable|array \$search, ?callable \$callback = null, array \$options = [])",
			$expectedContent,
		);

		$callback = function ($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP . 'Model/Table/BarBarsTable.php';
		$annotator->annotate($path);

		$output = $this->out->output();
		$this->assertTextContains('  -> 19 annotations added', $output);
	}

	/**
	 * @return void
	 */
	public function testAnnotateWithEntityTemplate() {
		$annotator = $this->_getEntityTemplateAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'Model/Table/BarBarsEntityTemplateTable.php'));
		$callback = function ($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP . 'Model/Table/BarBarsTable.php';
		$annotator->annotate($path);

		$output = $this->out->output();
		$this->assertTextContains('  -> 18 annotations added', $output);
	}

}


================================================
FILE: tests/TestCase/Annotator/Template/VariableExtractorTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Annotator\Template;

use IdeHelper\Annotator\Template\VariableExtractor;
use IdeHelper\Annotator\Traits\FileTrait;
use PHP_CodeSniffer\Config;
use Shim\TestSuite\TestCase;

$composerVendorDir = PLUGIN_ROOT . DS . 'vendor';
$codesnifferDir = 'squizlabs' . DS . 'php_codesniffer';
$manualAutoload = $composerVendorDir . DS . $codesnifferDir . DS . 'autoload.php';
if (!class_exists(Config::class) && file_exists($manualAutoload)) {
	require $manualAutoload;
}

class VariableExtractorTest extends TestCase {

	use FileTrait;

	protected VariableExtractor $variableExtractor;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->variableExtractor = new VariableExtractor();
	}

	/**
	 * @return void
	 */
	public function testExtract() {
		$path = APP_ROOT . DS . 'templates' . DS . 'Foos' . DS . 'vars.php';

		$file = $this->getFile($path);

		$result = $this->variableExtractor->extract($file);

		$expected = [
			'obj' => [
				'type' => 'object',
				'excludeReason' => null,
			],
			'car' => [
				'type' => 'object',
				'excludeReason' => 'Declared in loop',
			],
			'allCars' => [
				'type' => 'object',
				'excludeReason' => null,
			],
			'wheel' => [
				'type' => 'object',
				'excludeReason' => null,
			],
			'date' => [
				'type' => 'object',
				'excludeReason' => null,
			],
			'i' => [
				'type' => null,
				'excludeReason' => 'Declared in loop',
			],
			'engine' => [
				'type' => null,
				'excludeReason' => 'Declared in loop',
			],
		];
		foreach ($expected as $name => $data) {
			$this->assertSame($name, $result[$name]['name'], print_r($result[$name], true));
			$this->assertSame($data['type'], $result[$name]['type'], print_r($result[$name], true));
			$this->assertSame($data['excludeReason'], $result[$name]['excludeReason'], print_r($result[$name], true));
		}
	}

	/**
	 * @return void
	 */
	public function testExtractExceptions() {
		$content = <<<'PHP'
<?php
foreach ($exceptions as $exception) {}

try {
} catch (Exception $e) {
}
PHP;

		$file = $this->getFile('', $content);

		$result = $this->variableExtractor->extract($file);

		$expected = [
			'exceptions' => [
				'excludeReason' => null,
			],
			'exception' => [
				'excludeReason' => 'Declared in loop',
			],
			'e' => [
				'excludeReason' => 'Try catch',
			],
		];
		foreach ($expected as $name => $data) {
			$this->assertSame($data['excludeReason'], $result[$name]['excludeReason'], print_r($result[$name], true));
		}
	}

	/**
	 * @return void
	 */
	public function testExtractAssignment() {
		$content = <<<'PHP'
<?php
if (strpos($module, '.')) {
    [$prefix, $moduleName, $suffix] = explode('.', $module);
}
//list($x, $y) = [$z, $z]; // We dont support the old syntax yet/anymore
PHP;

		$file = $this->getFile('', $content);

		$result = $this->variableExtractor->extract($file);

		$expected = [
			'module' => [
				'excludeReason' => null,
			],
			'moduleName' => [
				'excludeReason' => 'Assignment',
			],
			'prefix' => [
				'excludeReason' => 'Assignment',
			],
			'suffix' => [
				'excludeReason' => 'Assignment',
			],
			/*
			'x' => [
				'excludeReason' => 'Assignment',
			],
			'y' => [
				'excludeReason' => 'Assignment',
			],
			'z' => [
				'excludeReason' => null,
			],
			*/
		];
		foreach ($expected as $name => $data) {
			$this->assertSame($data['excludeReason'], $result[$name]['excludeReason'], print_r($result[$name], true));
		}
	}

	/**
	 * @return void
	 */
	public function testExtractTypeStringAndArray() {
		$content = <<<'PHP'
<?php
echo $x['foo'];
echo $string;
echo $y . 'z' . $z;
?>
<?= $str ?>
PHP;

		$file = $this->getFile('', $content);

		$result = $this->variableExtractor->extract($file);

		$expected = [
			'string' => [
				'type' => 'string',
			],
			'x' => [
				'type' => 'array',
			],
			'y' => [
				'type' => 'string',
			],
			'z' => [
				'type' => 'string',
			],
			'str' => [
				'type' => 'string',
			],
		];
		foreach ($expected as $name => $data) {
			$this->assertSame($data['type'], $result[$name]['type'], print_r($result[$name], true));
		}
	}
	/**
	 * @return void
	 */
	public function testExtractFromStrings(): void {
		$content = <<<'PHP'
<?php
echo "<strong>'{$url}'</strong>: $title.";
PHP;
		$file = $this->getFile('', $content);

		$result = $this->variableExtractor->extract($file);

		$this->assertSame(['title', 'url'], array_keys($result));
	}

	/**
	 * Test that anonymous function parameters are excluded
	 *
	 * @return void
	 */
	public function testExtractExcludesAnonymousFunctionParameters() {
		$content = <<<'PHP'
<?php
$yourMoodIds = array_map(function($m) { return $m->mood_id; }, $participantMoods ?? []);
$filtered = array_filter($items, function($item) {
	return $item->active;
});
usort($data, function($a, $b) {
	return $a->sort_order <=> $b->sort_order;
});
$doubled = array_map(fn($x) => $x * 2, $numbers);

// Test with 'use' clause
$multiplier = 5;
$result = array_map(function($n) use ($multiplier) {
	return $n * $multiplier;
}, $values);
PHP;

		$file = $this->getFile('', $content);

		$result = $this->variableExtractor->extract($file);

		// Check that regular variables are found with correct exclusion reason
		$regularVars = ['yourMoodIds', 'participantMoods', 'filtered', 'items', 'data', 'doubled', 'numbers', 'multiplier', 'result', 'values'];
		foreach ($regularVars as $var) {
			$this->assertArrayHasKey($var, $result, "Variable \$$var should be found");
			if (in_array($var, ['yourMoodIds', 'filtered', 'doubled', 'multiplier', 'result'])) {
				$this->assertEquals('Assignment', $result[$var]['excludeReason'], "Variable \$$var should be excluded as assignment");
			} else {
				$this->assertNull($result[$var]['excludeReason'], "Variable \$$var should not be excluded");
			}
		}

		// Check that anonymous function parameters are excluded
		$functionParams = ['m', 'item', 'a', 'b', 'x', 'n'];
		foreach ($functionParams as $param) {
			$this->assertArrayHasKey($param, $result, "Parameter \$$param should be found");
			$this->assertEquals('Anonymous function parameter', $result[$param]['excludeReason'], "Parameter \$$param should be excluded as anonymous function parameter");
		}
	}

	/**
	 * Test that variables passed to compact() are extracted
	 *
	 * @return void
	 */
	public function testExtractFromCompact(): void {
		$content = <<<'PHP'
<?php
echo $this->element(
    'residents/dropdowns', compact(
        'accounts', 'unit_options', 'homes', 'units', 'includeSubmit'
    )
);
$result = compact('foo', "bar");

// Method calls should be ignored
$obj->compact('ignored1');
SomeClass::compact('ignored2');

// Edge cases: array keys and concatenation should be ignored
compact(['key' => 'arrayValue']);
compact('concat' . 'enated');
PHP;

		$file = $this->getFile('', $content);

		$result = $this->variableExtractor->extract($file);

		// All variables from compact() calls should be found
		$expected = ['accounts', 'unit_options', 'homes', 'units', 'includeSubmit', 'foo', 'bar', 'result', 'obj', 'arrayValue'];
		foreach ($expected as $var) {
			$this->assertArrayHasKey($var, $result, "Variable \$$var should be found from compact()");
		}

		// Method call arguments should NOT be found
		$this->assertArrayNotHasKey('ignored1', $result, 'Method call arguments should not be extracted');
		$this->assertArrayNotHasKey('ignored2', $result, 'Static method call arguments should not be extracted');

		// Array keys should NOT be found (only values)
		$this->assertArrayNotHasKey('key', $result, 'Array keys should not be extracted');

		// Concatenated strings should NOT be found
		$this->assertArrayNotHasKey('concat', $result, 'Concatenated strings should not be extracted');
		$this->assertArrayNotHasKey('enated', $result, 'Concatenated strings should not be extracted');

		// result is assigned, so should be excluded
		$this->assertEquals('Assignment', $result['result']['excludeReason']);

		// Variables from compact should not have an exclude reason
		$compactVars = ['accounts', 'unit_options', 'homes', 'units', 'includeSubmit', 'foo', 'bar'];
		foreach ($compactVars as $var) {
			$this->assertNull($result[$var]['excludeReason'], "Variable \$$var from compact() should not be excluded");
		}
	}

}


================================================
FILE: tests/TestCase/Annotator/TemplateAnnotatorTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Annotator;

use Cake\Console\ConsoleIo;
use Cake\Core\Configure;
use Cake\Database\Schema\TableSchema;
use Cake\ORM\TableRegistry;
use Cake\TestSuite\TestCase;
use IdeHelper\Annotator\AbstractAnnotator;
use IdeHelper\Annotator\TemplateAnnotator;
use IdeHelper\Console\Io;
use Shim\TestSuite\ConsoleOutput;
use Shim\TestSuite\TestTrait;
use TestApp\Model\Table\FoosTable;

class TemplateAnnotatorTest extends TestCase {

	use DiffHelperTrait;
	use TestTrait;

	protected ConsoleOutput $out;

	protected ConsoleOutput $err;

	protected Io $io;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->out = new ConsoleOutput();
		$this->err = new ConsoleOutput();
		$consoleIo = new ConsoleIo($this->out, $this->err);
		$this->io = new Io($consoleIo);

		$x = TableRegistry::getTableLocator()->get('IdeHelper.Foos', ['className' => FoosTable::class]);
		$columns = [
			'id' => [
				'type' => 'integer',
				'length' => 11,
				'unsigned' => false,
				'null' => false,
				'default' => null,
				'comment' => '',
				'autoIncrement' => true,
				'baseType' => null,
				'precision' => null,
			],
		];
		$schema = new TableSchema('Foos', $columns);
		$x->setSchema($schema);
		TableRegistry::getTableLocator()->set('Foos', $x);

		Configure::delete('IdeHelper');
		Configure::write('IdeHelper.preemptive', true);
	}

	/**
	 * @return void
	 */
	protected function tearDown(): void {
		Configure::delete('IdeHelper');

		parent::tearDown();
	}

	/**
	 * @return void
	 */
	public function testGetVariableAnnotations() {
		Configure::write('IdeHelper.autoCollect', function(array $variable) {
			if ($variable['name'] === 'date') {
				return 'Cake\I18n\DateTime';
			}

			return 'mixed';
		});

		$annotator = $this->_getAnnotatorMock([]);

		$variable = [
			'name' => 'date',
			'type' => 'object',
		];
		/** @uses \IdeHelper\Annotator\TemplateAnnotator::_getVariableAnnotation() */
		$result = $this->invokeMethod($annotator, 'getVariableAnnotation', [$variable]);
		$this->assertSame('@var Cake\I18n\DateTime $date', (string)$result);
	}

	/**
	 * @return void
	 */
	public function testNeedsViewAnnotation() {
		Configure::write('IdeHelper.preemptive', false);

		$annotator = $this->_getAnnotatorMock([]);

		$content = '';
		/** @uses \IdeHelper\Annotator\TemplateAnnotator::_needsViewAnnotation() */
		$result = $this->invokeMethod($annotator, 'needsViewAnnotation', [$content]);
		$this->assertFalse($result);

		$content = 'Foo Bar';
		/** @uses \IdeHelper\Annotator\TemplateAnnotator::_needsViewAnnotation() */
		$result = $this->invokeMethod($annotator, 'needsViewAnnotation', [$content]);
		$this->assertFalse($result);

		$content = 'Foo <?php echo $this->Foo->bar(); ?>';
		/** @uses \IdeHelper\Annotator\TemplateAnnotator::_needsViewAnnotation() */
		$result = $this->invokeMethod($annotator, 'needsViewAnnotation', [$content]);
		$this->assertTrue($result);

		$content = 'Foo <?= $x; ?>';
		/** @uses \IdeHelper\Annotator\TemplateAnnotator::_needsViewAnnotation() */
		$result = $this->invokeMethod($annotator, 'needsViewAnnotation', [$content]);
		$this->assertTrue($result);
	}

	/**
	 * Tests create() parsing part and creating a new PHP tag in first line.
	 *
	 * @return void
	 */
	public function testAnnotate() {
		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'templates/edit.php'));
		$callback = function($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP_ROOT . DS . 'templates/Foos/edit.php';
		$annotator->annotate($path);

		$output = $this->out->output();

		$this->assertTextContains('   -> 2 annotations added.', $output);
	}

	/**
	 * Tests loop and entity->field, as well as writing into an existing PHP tag.
	 *
	 * @return void
	 */
	public function testAnnotateLoop() {
		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'templates/loop.php'));
		$callback = function($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP_ROOT . DS . 'templates/Foos/loop.php';
		$annotator->annotate($path);

		$output = $this->out->output();

		$this->assertTextContains('   -> 3 annotations added.', $output);
	}

	/**
	 * Tests loop and entity->field, as well as writing into an existing PHP tag.
	 *
	 * @return void
	 */
	public function testAnnotatePhpLine() {
		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'templates/phpline.php'));
		$callback = function($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP_ROOT . DS . 'templates/Foos/phpline.php';
		$annotator->annotate($path);

		$output = $this->out->output();

		$this->assertTextContains('   -> 3 annotations added.', $output);
	}

	/**
	 * Tests merging with existing PHP tag and doc block.
	 *
	 * @return void
	 */
	public function testAnnotateExistingBasic() {
		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'templates/existing.php'));
		$callback = function($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP_ROOT . DS . 'templates/Foos/existing.php';
		$annotator->annotate($path);

		$output = $this->out->output();

		$this->assertTextContains('   -> 2 annotations added.', $output);
	}

	/**
	 * Tests merging with existing PHP tag and doc block and replacing outdated annotations.
	 *
	 * @return void
	 */
	public function testAnnotateExistingOutdated() {
		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'templates/outdated.php'));
		$callback = function($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP_ROOT . DS . 'templates/Foos/outdated.php';
		$annotator->annotate($path);

		$output = $this->out->output();

		$this->assertTextContains('   -> 2 annotations updated, 1 annotation removed, 1 annotation skipped.', $output);
	}

	/**
	 * Tests merging with existing PHP tag and doc block - PHP strict_types mode.
	 *
	 * @return void
	 */
	public function testAnnotateExistingStrict() {
		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'templates/existing_strict.php'));
		$callback = function($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP_ROOT . DS . 'templates/Foos/existing_strict.php';
		$annotator->annotate($path);

		$output = $this->out->output();

		$this->assertTextContains('   -> 1 annotation added.', $output);
	}

	/**
	 * Tests with empty template
	 *
	 * @return void
	 */
	public function testAnnotateEmptyPreemptive() {
		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'templates/empty.php'));
		$callback = function($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP_ROOT . DS . 'templates/Foos/empty.php';
		$annotator->annotate($path);

		$output = $this->out->output();

		$this->assertTextContains('   -> 1 annotation added.', $output);
	}

	/**
	 * Tests with template variables.
	 *
	 * @return void
	 */
	public function testAnnotateVars() {
		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'templates/vars.php'));
		$callback = function($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP_ROOT . DS . 'templates/Foos/vars.php';
		$annotator->annotate($path);

		$output = $this->out->output();

		$this->assertTextContains('   -> 6 annotations added.', $output);
	}

	/**
	 * Tests with empty template
	 *
	 * @return void
	 */
	public function testAnnotateEmpty() {
		Configure::write('IdeHelper.preemptive', false);

		$annotator = $this->_getAnnotatorMock([]);

		$callback = function($value) {
		};
		$annotator->expects($this->never())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP_ROOT . DS . 'templates/Foos/empty.php';
		$annotator->annotate($path);

		$output = $this->out->output();

		$this->assertTextEquals('', $output);
	}

	/**
	 * Tests merging with existing inline doc block.
	 *
	 * @return void
	 */
	public function testAnnotateInline() {
		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'templates/inline.php'));
		$callback = function($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP_ROOT . DS . 'templates/Foos/inline.php';
		$annotator->annotate($path);

		$output = $this->out->output();

		$this->assertTextContains('   -> 1 annotation added.', $output);
	}

	/**
	 * Tests that a docblock with a following inline one works.
	 *
	 * @return void
	 */
	public function testAnnotateWithFollowingInline() {
		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'templates/following_inline.php'));
		$callback = function($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP_ROOT . DS . 'templates/Foos/following_inline.php';
		$annotator->annotate($path);

		$output = $this->out->output();

		$this->assertTextContains('   -> 1 annotation added.', $output);
	}

	/**
	 * Tests that a docblock with arrays in different types, e.g. shape.
	 *
	 * @return void
	 */
	public function testAnnotateWithShapedArray() {
		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'templates/array.php'));
		$callback = function($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP_ROOT . DS . 'templates/Foos/array.php';
		$annotator->annotate($path);

		$output = $this->out->output();

		$this->assertTextContains('   -> 1 annotation added.', $output);
	}

	/**
	 * Tests that a multiline array is parsed completly.
	 *
	 * @return void
	 */
	public function testAnnotateWithMultilineArray() {
		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'templates/multiline.php'));
		$callback = function($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP_ROOT . DS . 'templates/Foos/multiline.php';
		$annotator->annotate($path);

		$output = $this->out->output();

		$this->assertTextContains('   -> 1 annotation added.', $output);
	}

	/**
	 * Tests that anonymous function parameters are excluded from annotations.
	 *
	 * @return void
	 */
	public function testAnnotateWithAnonymousFunctions() {
		Configure::write('IdeHelper.autoCollect', 'mixed');
		$annotator = $this->_getAnnotatorMock([]);

		$expectedVariables = [
			'$this',
			'$participantMoods',
			'$yourMoodIds',
			'$items',
			'$filtered',
			'$data',
			'$numbers',
			'$doubled',
			'$multiplier',
			'$values',
			'$result',
		];

		// Variables that should NOT get annotations (anonymous function parameters)
		$excludedVariables = ['$m', '$item', '$a', '$b', '$x', '$n'];
		// Note: $id is excluded too, but it's a foreach loop variable, not an anonymous function parameter

		$callback = function($value) use ($expectedVariables, $excludedVariables) {
			// Extract just the PHPDoc block
			if (preg_match('/\/\*\*(.*?)\*\//s', $value, $matches)) {
				$docBlock = $matches[1];

				foreach ($excludedVariables as $var) {
					// Check if the variable appears in an @var annotation in the doc block
					if (preg_match('/@var\s+[^\s]+\s+\\' . preg_quote($var, '/') . '/', $docBlock)) {
						$this->fail("Variable {$var} should not have an annotation (it's an anonymous function parameter)");
					}
				}
			}

			return true;
		};

		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP_ROOT . DS . 'templates/Foos/anonymous.php';
		$annotator->annotate($path);
	}

	/**
	 * Tests that $this inside string interpolation doesn't create duplicate annotations.
	 *
	 * @return void
	 */
	public function testAnnotateWithStringInterpolation() {
		Configure::write('IdeHelper.autoCollect', 'mixed');
		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'templates/string_interpolation.php'));
		$callback = function($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP_ROOT . DS . 'templates/Foos/string_interpolation.php';
		$annotator->annotate($path);

		$output = $this->out->output();

		// Should only add 1 annotation: $name (not a duplicate $this)
		$this->assertTextContains('   -> 1 annotation added.', $output);
	}

	/**
	 * Tests that existing custom view annotations are preserved when the class exists.
	 *
	 * @return void
	 */
	public function testAnnotatePreservesCustomViewAnnotation() {
		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'templates/custom_view.php'));
		$callback = function($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP_ROOT . DS . 'templates/Foos/custom_view.php';
		$annotator->annotate($path);

		$output = $this->out->output();

		// Should add 1 annotation ($cars) but skip updating the existing $this annotation
		$this->assertTextContains('   -> 1 annotation added, 1 annotation skipped.', $output);
	}

	/**
	 * @param array $params
	 * @return \IdeHelper\Annotator\TemplateAnnotator|\PHPUnit\Framework\MockObject\MockObject
	 */
	protected function _getAnnotatorMock(array $params): TemplateAnnotator {
		$params += [
			AbstractAnnotator::CONFIG_REMOVE => true,
			AbstractAnnotator::CONFIG_DRY_RUN => true,
		];

		return $this->getMockBuilder(TemplateAnnotator::class)->onlyMethods(['storeFile'])->setConstructorArgs([$this->io, $params])->getMock();
	}

}


================================================
FILE: tests/TestCase/Annotator/ViewAnnotatorTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Annotator;

use Cake\Console\ConsoleIo;
use Cake\TestSuite\TestCase;
use IdeHelper\Annotator\AbstractAnnotator;
use IdeHelper\Annotator\ViewAnnotator;
use IdeHelper\Console\Io;
use Shim\TestSuite\ConsoleOutput;
use Shim\TestSuite\TestTrait;

class ViewAnnotatorTest extends TestCase {

	use DiffHelperTrait;
	use TestTrait;

	protected ConsoleOutput $out;

	protected ConsoleOutput $err;

	protected Io $io;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->loadPlugins(['Shim']);
		$this->out = new ConsoleOutput();
		$this->err = new ConsoleOutput();
		$consoleIo = new ConsoleIo($this->out, $this->err);
		$this->io = new Io($consoleIo);
	}

	/**
	 * @return void
	 */
	public function testAnnotate() {
		$annotator = $this->_getAnnotatorMock([]);

		$expectedContent = str_replace("\r\n", "\n", file_get_contents(TEST_FILES . 'View/AppView.php'));
		$callback = function($value) use ($expectedContent) {
			$value = str_replace(["\r\n", "\r"], "\n", $value);
			if ($value !== $expectedContent) {
				$this->_displayDiff($expectedContent, $value);
			}

			return $value === $expectedContent;
		};
		$annotator->expects($this->once())->method('storeFile')->with($this->anything(), $this->callback($callback));

		$path = APP . 'View/AppView.php';
		$annotator->annotate($path);

		$output = $this->out->output();

		$this->assertTextContains('   -> 4 annotations added', $output);
	}

	/**
	 * @param array $params
	 * @return \IdeHelper\Annotator\ViewAnnotator|\PHPUnit\Framework\MockObject\MockObject
	 */
	protected function _getAnnotatorMock(array $params): ViewAnnotator {
		$params += [
			AbstractAnnotator::CONFIG_REMOVE => true,
			AbstractAnnotator::CONFIG_DRY_RUN => true,
		];

		return $this->getMockBuilder(ViewAnnotator::class)->onlyMethods(['storeFile'])->setConstructorArgs([$this->io, $params])->getMock();
	}

	/**
	 * @return void
	 */
	public function testGetHelpers(): void {
		$annotator = $this->_getAnnotatorMock([]);

		$result = $this->invokeMethod($annotator, 'addExtractedHelpers', [[]]);
		$expected = [
			'My' => 'TestApp\View\Helper\MyHelper',
			'Configure' => 'Shim\View\Helper\ConfigureHelper',
		];
		$this->assertEquals($expected, $result);
	}

}


================================================
FILE: tests/TestCase/CodeCompletion/CodeCompletionGeneratorTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\CodeCompletion;

use Cake\TestSuite\TestCase;
use IdeHelper\CodeCompletion\CodeCompletionGenerator;
use IdeHelper\CodeCompletion\TaskCollection;

class CodeCompletionGeneratorTest extends TestCase {

	protected CodeCompletionGenerator $generator;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->loadPlugins(['MyNamespace/MyPlugin', 'Shim']);
		$taskCollection = new TaskCollection();
		$this->generator = new CodeCompletionGenerator($taskCollection);

		$file = TMP . 'CodeCompletionCakeORM.php';
		if (file_exists($file)) {
			unlink($file);
		}
		$file = TMP . 'CodeCompletionCakeORMQuery.php';
		if (file_exists($file)) {
			unlink($file);
		}
	}

	/**
	 * @return void
	 */
	public function testCollect() {
		$result = $this->generator->generate();

		$expected = [
			'Cake\Controller',
			'Cake\ORM',
			'Cake\ORM\Query',
			'Cake\View',
		];

		$this->assertSame($expected, $result);
		$this->assertFileExists(TMP . 'CodeCompletionCakeORM.php');
		$this->assertFileExists(TMP . 'CodeCompletionCakeORMQuery.php');

		$result = file_get_contents(TMP . 'CodeCompletionCakeORM.php');

		$expected = <<<'TXT'
<?php
namespace Cake\ORM;

/**
 * Only for code completion - regenerate using `bin/cake code_completion generate`.
 */
abstract class BehaviorRegistry extends \Cake\Core\ObjectRegistry {

	/**
	 * MyNamespace/MyPlugin.My behavior.
	 *
	 * @var \MyNamespace\MyPlugin\Model\Behavior\MyBehavior
	 */
	public $My;

	/**
	 * Shim.Nullable behavior.
	 *
	 * @var \Shim\Model\Behavior\NullableBehavior
	 */
	public $Nullable;

}

use ArrayObject;
use Cake\Datasource\EntityInterface;
use Cake\Event\EventInterface;
use Cake\ORM\Query\SelectQuery;
use Cake\ORM\RulesChecker;
use Cake\Validation\Validator;

if (false) {
	class Table {
		public function beforeMarshal(EventInterface $event, ArrayObject $data, ArrayObject $options): void {}
		public function afterMarshal(EventInterface $event, EntityInterface $entity, ArrayObject $options): void {}
		public function beforeFind(EventInterface $event, SelectQuery $query, ArrayObject $options, bool $primary): void {}
		public function buildValidator(EventInterface $event, Validator $validator, string $name): void {}
		public function buildRules(RulesChecker $rules): RulesChecker { return $rules; }
		public function beforeRules(EventInterface $event, EntityInterface $entity, ArrayObject $options, string $operation): void {}
		public function afterRules(EventInterface $event, EntityInterface $entity, ArrayObject $options, bool $result, string $operation): void {}
		public function beforeSave(EventInterface $event, EntityInterface $entity, ArrayObject $options): void {}
		public function afterSave(EventInterface $event, EntityInterface $entity, ArrayObject $options): void {}
		public function afterSaveCommit(EventInterface $event, EntityInterface $entity, ArrayObject $options): void {}
		public function beforeDelete(EventInterface $event, EntityInterface $entity, ArrayObject $options): void {}
		public function afterDelete(EventInterface $event, EntityInterface $entity, ArrayObject $options): void {}
		public function afterDeleteCommit(EventInterface $event, EntityInterface $entity, ArrayObject $options): void {}
	}

	class Behavior {
		public function beforeMarshal(EventInterface $event, ArrayObject $data, ArrayObject $options): void {}
		public function afterMarshal(EventInterface $event, EntityInterface $entity, ArrayObject $options): void {}
		public function beforeFind(EventInterface $event, SelectQuery $query, ArrayObject $options, bool $primary): void {}
		public function buildValidator(EventInterface $event, Validator $validator, string $name): void {}
		public function buildRules(RulesChecker $rules): RulesChecker { return $rules; }
		public function beforeRules(EventInterface $event, EntityInterface $entity, ArrayObject $options, string $operation): void {}
		public function afterRules(EventInterface $event, EntityInterface $entity, ArrayObject $options, bool $result, string $operation): void {}
		public function beforeSave(EventInterface $event, EntityInterface $entity, ArrayObject $options): void {}
		public function afterSave(EventInterface $event, EntityInterface $entity, ArrayObject $options): void {}
		public function afterSaveCommit(EventInterface $event, EntityInterface $entity, ArrayObject $options): void {}
		public function beforeDelete(EventInterface $event, EntityInterface $entity, ArrayObject $options): void {}
		public function afterDelete(EventInterface $event, EntityInterface $entity, ArrayObject $options): void {}
		public function afterDeleteCommit(EventInterface $event, EntityInterface $entity, ArrayObject $options): void {}
	}
}

TXT;

		$this->assertTextEquals($expected, $result);

		$result = file_get_contents(TMP . 'CodeCompletionCakeORMQuery.php');

		$expected = <<<'TXT'
<?php
namespace Cake\ORM\Query;

/**
 * Only for code completion - regenerate using `bin/cake code_completion generate`.
 */
use Cake\Database\ExpressionInterface;
use Cake\Datasource\ResultSetInterface;
use Closure;
use Psr\SimpleCache\CacheInterface;

if (false) {
	/**
	 * @template TSubject
	 */
	class SelectQuery {
		/**
		 * @return static<TSubject>
		 */
		public function find(string $finder, mixed ...$args) {}

		/**
		 * @return static<TSubject>
		 */
		public function where(
			ExpressionInterface|Closure|array|string|null $conditions = null,
			array $types = [],
			bool $overwrite = false,
		) {}

		/**
		 * @return static<TSubject>
		 */
		public function andWhere($conditions, array $types = []) {}

		/**
		 * @return static<TSubject>
		 */
		public function matching(string $assoc, ?Closure $builder = null) {}

		/**
		 * @return static<TSubject>
		 */
		public function leftJoinWith(string $assoc, ?Closure $builder = null) {}

		/**
		 * @return static<TSubject>
		 */
		public function innerJoinWith(string $assoc, ?Closure $builder = null) {}

		/**
		 * @return static<TSubject>
		 */
		public function notMatching(string $assoc, ?Closure $builder = null) {}

		/**
		 * @return static<TSubject>
		 */
		public function contain(mixed $associations, Closure|bool $override = false) {}

		/**
		 * @return static<TSubject>
		 */
		public function clearContain() {}

		/**
		 * @return static<TSubject>
		 */
		public function cache(Closure|string|false $key, CacheInterface|string $config = 'default') {}

		/**
		 * @return static<TSubject>
		 */
		public function groupBy(ExpressionInterface|array|string $fields, bool $overwrite = false) {}

		/**
		 * @return static<TSubject>
		 */
		public function orderBy(ExpressionInterface|Closure|array|string $fields, bool $overwrite = false) {}

		/**
		 * @return static<TSubject>
		 */
		public function enableAutoFields(bool $value = true) {}

		/**
		 * @return static<TSubject>
		 */
		public function disableAutoFields() {}

		/**
		 * @return static<array<string,mixed>>
		 */
		public function disableHydration() {}

		/**
		 * @return ResultSetInterface<array-key, TSubject>
		 */
		public function all() {}

		/**
		 * @return TSubject|null
		 */
		public function first() {}

		/**
		 * @return TSubject
		 */
		public function firstOrFail() {}

		/**
		 * @return array<TSubject>
		 */
		public function toArray() {}
	}
}

TXT;

		$this->assertTextEquals($expected, $result);
	}

}


================================================
FILE: tests/TestCase/CodeCompletion/Task/BehaviorTaskTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\CodeCompletion\Task;

use Cake\TestSuite\TestCase;
use IdeHelper\CodeCompletion\Task\BehaviorTask;

class BehaviorTaskTest extends TestCase {

	protected BehaviorTask $task;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->loadPlugins(['MyNamespace/MyPlugin', 'Shim']);
		$this->task = new BehaviorTask();
	}

	/**
	 * @return void
	 */
	public function testCollect() {
		$result = $this->task->create();

		$expected = <<<'TXT'
abstract class BehaviorRegistry extends \Cake\Core\ObjectRegistry {

	/**
	 * MyNamespace/MyPlugin.My behavior.
	 *
	 * @var \MyNamespace\MyPlugin\Model\Behavior\MyBehavior
	 */
	public $My;

	/**
	 * Shim.Nullable behavior.
	 *
	 * @var \Shim\Model\Behavior\NullableBehavior
	 */
	public $Nullable;

}

TXT;
		$this->assertTextEquals($expected, $result);
	}

}


================================================
FILE: tests/TestCase/CodeCompletion/Task/ControllerEventsTaskTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\CodeCompletion\Task;

use Cake\Core\Configure;
use Cake\TestSuite\TestCase;
use IdeHelper\CodeCompletion\Task\ControllerEventsTask;

class ControllerEventsTaskTest extends TestCase {

	protected ControllerEventsTask $task;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->task = new ControllerEventsTask();
	}

	/**
	 * @return void
	 */
	public function testCollectLegacy(): void {
		Configure::write('IdeHelper.codeCompletionReturnType', false);

		$result = $this->task->create();

		$expected = <<<'TXT'

use Cake\Event\EventInterface;
use Cake\Http\Response;
use Psr\Http\Message\UriInterface;

if (false) {
	class Controller {
		/**
		 * @param \Cake\Event\EventInterface $event
		 *
		 * @return void
		 */
		public function startup(EventInterface $event) {
		}

		/**
		 * @param \Cake\Event\EventInterface $event
		 *
		 * @return void
		 */
		public function beforeFilter(EventInterface $event) {
		}

		/**
		 * @param \Cake\Event\EventInterface $event
		 *
		 * @return void
		 */
		public function beforeRender(EventInterface $event) {
		}

		/**
		 * @param \Cake\Event\EventInterface $event
		 *
		 * @return void
		 */
		public function afterFilter(EventInterface $event) {
		}

		/**
		 * @param \Cake\Event\EventInterface $event
		 *
		 * @return void
		 */
		public function shutdown(EventInterface $event) {
		}

		/**
		 * @param \Cake\Event\EventInterface $event
		 * @param \Psr\Http\Message\UriInterface|array|string $url
		 * @param \Cake\Http\Response $response
		 *
		 * @return void
		 */
		public function beforeRedirect(EventInterface $event, UriInterface|array|string $url, Response $response) {
		}
	}

	class Component {
		/**
		 * @param \Cake\Event\EventInterface $event
		 *
		 * @return void
		 */
		public function startup(EventInterface $event) {
		}

		/**
		 * @param \Cake\Event\EventInterface $event
		 *
		 * @return void
		 */
		public function beforeFilter(EventInterface $event) {
		}

		/**
		 * @param \Cake\Event\EventInterface $event
		 *
		 * @return void
		 */
		public function beforeRender(EventInterface $event) {
		}

		/**
		 * @param \Cake\Event\EventInterface $event
		 *
		 * @return void
		 */
		public function afterFilter(EventInterface $event) {
		}

		/**
		 * @param \Cake\Event\EventInterface $event
		 *
		 * @return void
		 */
		public function shutdown(EventInterface $event) {
		}

		/**
		 * @param \Cake\Event\EventInterface $event
		 * @param \Psr\Http\Message\UriInterface|array|string $url
		 * @param \Cake\Http\Response $response
		 *
		 * @return void
		 */
		public function beforeRedirect(EventInterface $event, UriInterface|array|string $url, Response $response) {
		}
	}
}

TXT;
		$this->assertTextEquals($expected, $result);
	}

	/**
	 * @return void
	 */
	public function testCollect() {
		Configure::write('IdeHelper.codeCompletionReturnType', true);

		$result = $this->task->create();

		$expected = <<<'TXT'

use Cake\Event\EventInterface;
use Cake\Http\Response;
use Psr\Http\Message\UriInterface;

if (false) {
	class Controller {
		public function startup(EventInterface $event): void {
		}

		public function beforeFilter(EventInterface $event): void {
		}

		public function beforeRender(EventInterface $event): void {
		}

		public function afterFilter(EventInterface $event): void {
		}

		public function shutdown(EventInterface $event): void {
		}

		/**
		 * @param \Cake\Event\EventInterface $event
		 * @param \Psr\Http\Message\UriInterface|array|string $url
		 * @param \Cake\Http\Response $response
		 *
		 * @return void
		 */
		public function beforeRedirect(EventInterface $event, UriInterface|array|string $url, Response $response): void {
		}
	}

	class Component {
		public function startup(EventInterface $event): void {
		}

		public function beforeFilter(EventInterface $event): void {
		}

		public function beforeRender(EventInterface $event): void {
		}

		public function afterFilter(EventInterface $event): void {
		}

		public function shutdown(EventInterface $event): void {
		}

		/**
		 * @param \Cake\Event\EventInterface $event
		 * @param \Psr\Http\Message\UriInterface|array|string $url
		 * @param \Cake\Http\Response $response
		 *
		 * @return void
		 */
		public function beforeRedirect(EventInterface $event, UriInterface|array|string $url, Response $response): void {
		}
	}
}

TXT;

		$this->assertTextEquals($expected, $result);
	}

}


================================================
FILE: tests/TestCase/CodeCompletion/Task/ModelEventsTaskTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\CodeCompletion\Task;

use Cake\TestSuite\TestCase;
use IdeHelper\CodeCompletion\Task\ModelEventsTask;

class ModelEventsTaskTest extends TestCase {

	protected ModelEventsTask $task;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->task = new ModelEventsTask();
	}

	/**
	 * @return void
	 */
	public function testCollect() {
		$result = $this->task->create();

		$expected = <<<'TXT'

use ArrayObject;
use Cake\Datasource\EntityInterface;
use Cake\Event\EventInterface;
use Cake\ORM\Query\SelectQuery;
use Cake\ORM\RulesChecker;
use Cake\Validation\Validator;

if (false) {
	class Table {
		public function beforeMarshal(EventInterface $event, ArrayObject $data, ArrayObject $options): void {}
		public function afterMarshal(EventInterface $event, EntityInterface $entity, ArrayObject $options): void {}
		public function beforeFind(EventInterface $event, SelectQuery $query, ArrayObject $options, bool $primary): void {}
		public function buildValidator(EventInterface $event, Validator $validator, string $name): void {}
		public function buildRules(RulesChecker $rules): RulesChecker { return $rules; }
		public function beforeRules(EventInterface $event, EntityInterface $entity, ArrayObject $options, string $operation): void {}
		public function afterRules(EventInterface $event, EntityInterface $entity, ArrayObject $options, bool $result, string $operation): void {}
		public function beforeSave(EventInterface $event, EntityInterface $entity, ArrayObject $options): void {}
		public function afterSave(EventInterface $event, EntityInterface $entity, ArrayObject $options): void {}
		public function afterSaveCommit(EventInterface $event, EntityInterface $entity, ArrayObject $options): void {}
		public function beforeDelete(EventInterface $event, EntityInterface $entity, ArrayObject $options): void {}
		public function afterDelete(EventInterface $event, EntityInterface $entity, ArrayObject $options): void {}
		public function afterDeleteCommit(EventInterface $event, EntityInterface $entity, ArrayObject $options): void {}
	}

	class Behavior {
		public function beforeMarshal(EventInterface $event, ArrayObject $data, ArrayObject $options): void {}
		public function afterMarshal(EventInterface $event, EntityInterface $entity, ArrayObject $options): void {}
		public function beforeFind(EventInterface $event, SelectQuery $query, ArrayObject $options, bool $primary): void {}
		public function buildValidator(EventInterface $event, Validator $validator, string $name): void {}
		public function buildRules(RulesChecker $rules): RulesChecker { return $rules; }
		public function beforeRules(EventInterface $event, EntityInterface $entity, ArrayObject $options, string $operation): void {}
		public function afterRules(EventInterface $event, EntityInterface $entity, ArrayObject $options, bool $result, string $operation): void {}
		public function beforeSave(EventInterface $event, EntityInterface $entity, ArrayObject $options): void {}
		public function afterSave(EventInterface $event, EntityInterface $entity, ArrayObject $options): void {}
		public function afterSaveCommit(EventInterface $event, EntityInterface $entity, ArrayObject $options): void {}
		public function beforeDelete(EventInterface $event, EntityInterface $entity, ArrayObject $options): void {}
		public function afterDelete(EventInterface $event, EntityInterface $entity, ArrayObject $options): void {}
		public function afterDeleteCommit(EventInterface $event, EntityInterface $entity, ArrayObject $options): void {}
	}
}

TXT;

		$this->assertTextEquals($expected, $result);
	}

}


================================================
FILE: tests/TestCase/CodeCompletion/Task/ViewEventsTaskTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\CodeCompletion\Task;

use Cake\TestSuite\TestCase;
use IdeHelper\CodeCompletion\Task\ViewEventsTask;

class ViewEventsTaskTest extends TestCase {

	protected ViewEventsTask $task;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->task = new ViewEventsTask();
	}

	/**
	 * @return void
	 */
	public function testCollect() {
		$result = $this->task->create();

		$expected = <<<'TXT'

use Cake\Event\EventInterface;

if (false) {
	class Helper {
		public function beforeRenderFile(EventInterface $event): void {}
		public function afterRenderFile(EventInterface $event): void {}
		public function beforeRender(EventInterface $event): void {}
		public function afterRender(EventInterface $event): void {}
		public function beforeLayout(EventInterface $event): void {}
		public function afterLayout(EventInterface $event): void {}
	}
}

TXT;

		$this->assertTextEquals($expected, $result);
	}

}


================================================
FILE: tests/TestCase/CodeCompletion/TaskCollectionTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\CodeCompletion;

use Cake\TestSuite\TestCase;
use IdeHelper\CodeCompletion\TaskCollection;

class TaskCollectionTest extends TestCase {

	protected TaskCollection $taskCollection;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->taskCollection = new TaskCollection();
	}

	/**
	 * @return void
	 */
	public function testTasks() {
		$result = $this->taskCollection->tasks();

		$this->assertNotEmpty($result);
	}

}


================================================
FILE: tests/TestCase/Command/Annotate/ClassesCommandPathAwareTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Command\Annotate;

use Cake\Console\TestSuite\ConsoleIntegrationTestTrait;
use Cake\Core\Configure;
use Cake\TestSuite\TestCase;
use IdeHelper\Test\TestCase\Command\Annotate\Fixture\SecondTestPathAwareAnnotatorTask;
use IdeHelper\Test\TestCase\Command\Annotate\Fixture\TestPathAwareAnnotatorTask;

class ClassesCommandPathAwareTest extends TestCase {

	use ConsoleIntegrationTestTrait;

	/**
	 * @var array<string>
	 */
	protected array $createdFiles = [];

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->loadPlugins(['IdeHelper', 'Awesome']);
	}

	/**
	 * @return void
	 */
	protected function tearDown(): void {
		Configure::delete('IdeHelper.classAnnotatorTasks');
		foreach ($this->createdFiles as $path) {
			@unlink($path);
		}
		$this->createdFiles = [];
		@rmdir(ROOT . DS . 'tests' . DS . 'fixtures-pathaware');
		@rmdir(ROOT . DS . 'tests' . DS);
		@rmdir(PLUGINS . 'Awesome' . DS . 'tests' . DS . 'fixtures-pathaware');
		@rmdir(PLUGINS . 'Awesome' . DS . 'tests');
		parent::tearDown();
	}

	/**
	 * @return string
	 */
	protected function placePluginFixtureFile(): string {
		$dir = PLUGINS . 'Awesome' . DS . 'tests' . DS . 'fixtures-pathaware' . DS;
		if (!is_dir($dir)) {
			mkdir($dir, 0o777, true);
		}
		$path = $dir . 'PluginScannedClass.php';
		file_put_contents($path, "<?php\nclass PluginScannedClass {}\n");
		$this->createdFiles[] = $path;

		return $path;
	}

	/**
	 * Drop a tiny PHP class into the directory the fixture task declares so
	 * `_classes()` will visit it and emit verbose-mode output we can match.
	 *
	 * @return string
	 */
	protected function placeFixtureFile(): string {
		$dir = ROOT . DS . 'tests' . DS . 'fixtures-pathaware' . DS;
		if (!is_dir($dir)) {
			mkdir($dir, 0o777, true);
		}
		$path = $dir . 'CustomScannedClass.php';
		file_put_contents($path, "<?php\nclass CustomScannedClass {}\n");
		$this->createdFiles[] = $path;

		return $path;
	}

	/**
	 * @return void
	 */
	public function testPathAwareTaskDirectoryIsWalked(): void {
		$this->placeFixtureFile();

		Configure::write('IdeHelper.classAnnotatorTasks', [
			TestPathAwareAnnotatorTask::class => TestPathAwareAnnotatorTask::class,
		]);

		$this->exec('annotate classes -d -v');
		$this->assertExitSuccess();
		$this->assertOutputContains('tests' . DS . 'fixtures-pathaware');
		$this->assertOutputContains('CustomScannedClass');
	}

	/**
	 * Plugin-mode integration: with `-p PluginName`, scanPaths() is resolved
	 * relative to the plugin's root, so the fixture directory inside the
	 * plugin is reached even though the same path inside the app is empty.
	 *
	 * @return void
	 */
	public function testPathAwareTaskWalksPluginPathInPluginMode(): void {
		$this->placePluginFixtureFile();

		Configure::write('IdeHelper.classAnnotatorTasks', [
			TestPathAwareAnnotatorTask::class => TestPathAwareAnnotatorTask::class,
		]);

		$this->exec('annotate classes -p Awesome -d -v');
		$this->assertExitSuccess();
		$this->assertOutputContains('fixtures-pathaware');
		$this->assertOutputContains('PluginScannedClass');
	}

	/**
	 * Two registered path-aware tasks declaring the same scan path: the
	 * directory must be walked once. Verbose output shows the directory
	 * header on every walk, so we count occurrences and assert exactly 1.
	 *
	 * @return void
	 */
	public function testDuplicateScanPathsAcrossTasksAreWalkedOnlyOnce(): void {
		$this->placeFixtureFile();

		Configure::write('IdeHelper.classAnnotatorTasks', [
			TestPathAwareAnnotatorTask::class => TestPathAwareAnnotatorTask::class,
			SecondTestPathAwareAnnotatorTask::class => SecondTestPathAwareAnnotatorTask::class,
		]);

		$this->exec('annotate classes -d -v');
		$this->assertExitSuccess();

		$marker = 'tests' . DS . 'fixtures-pathaware';
		$count = substr_count($this->_out->messages()[0] ?? '', $marker);
		// Some Cake versions return messages as array; concat for safety:
		if (!$count) {
			$count = substr_count(implode("\n", $this->_out->messages()), $marker);
		}
		$this->assertSame(
			1,
			$count,
			"Directory '{$marker}' should be walked exactly once when two tasks declare it; saw {$count} occurrences.",
		);
	}

	/**
	 * @return void
	 */
	public function testNonExistentPathAwareDirectoryIsSkippedSilently(): void {
		Configure::write('IdeHelper.classAnnotatorTasks', [
			TestPathAwareAnnotatorTask::class => TestPathAwareAnnotatorTask::class,
		]);

		$this->exec('annotate classes -d -v');
		$this->assertExitSuccess();
		// No fixture file placed; the declared directory does not exist.
		// Just must not crash; default scan still ran.
	}

}


================================================
FILE: tests/TestCase/Command/Annotate/ClassesCommandTestCaseWalkTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Command\Annotate;

use Cake\Console\TestSuite\ConsoleIntegrationTestTrait;
use Cake\TestSuite\TestCase;

/**
 * Regression test for the default `tests/TestCase/` walk performed by
 * `bin/cake annotate classes` when `TestClassAnnotatorTask` is in the
 * registered task list. Guards against the walk silently disappearing
 * during refactors.
 */
class ClassesCommandTestCaseWalkTest extends TestCase {

	use ConsoleIntegrationTestTrait;

	/**
	 * @var array<string>
	 */
	protected array $createdFiles = [];

	/**
	 * @var array<string>
	 */
	protected array $createdDirs = [];

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->loadPlugins(['IdeHelper']);
	}

	/**
	 * @return void
	 */
	protected function tearDown(): void {
		foreach ($this->createdFiles as $path) {
			@unlink($path);
		}
		foreach (array_reverse($this->createdDirs) as $dir) {
			@rmdir($dir);
		}
		$this->createdFiles = [];
		$this->createdDirs = [];
		parent::tearDown();
	}

	/**
	 * Drop a controller-test class into the app's tests/TestCase/Controller/
	 * tree so the command's verbose output reports the directory walk.
	 *
	 * @return void
	 */
	protected function placeControllerTestFile(): void {
		$testCaseDir = ROOT . DS . 'tests' . DS . 'TestCase' . DS;
		$controllerDir = $testCaseDir . 'Controller' . DS;
		foreach ([$testCaseDir, $controllerDir] as $dir) {
			if (!is_dir($dir)) {
				mkdir($dir, 0o777, true);
				$this->createdDirs[] = $dir;
			}
		}
		$path = $controllerDir . 'WalkProbeControllerTest.php';
		file_put_contents(
			$path,
			"<?php\nnamespace App\\Test\\TestCase\\Controller;\nclass WalkProbeControllerTest {}\n",
		);
		$this->createdFiles[] = $path;
	}

	/**
	 * The default test-case scan must reach files inside tests/TestCase/.
	 * Verbose output emits the directory header for every walked folder, so
	 * we assert the marker shows up.
	 *
	 * @return void
	 */
	public function testTestCaseDirectoryIsWalkedByDefault(): void {
		$this->placeControllerTestFile();

		$this->exec('annotate classes -d -v');
		$this->assertExitSuccess();
		$this->assertOutputContains('tests' . DS . 'TestCase' . DS . 'Controller');
		$this->assertOutputContains('WalkProbeControllerTest');
	}

}


================================================
FILE: tests/TestCase/Command/Annotate/Fixture/SecondTestPathAwareAnnotatorTask.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Command\Annotate\Fixture;

use IdeHelper\Annotator\ClassAnnotatorTask\AbstractClassAnnotatorTask;
use IdeHelper\Annotator\ClassAnnotatorTask\PathAwareClassAnnotatorTaskInterface;

/**
 * Second test fixture: declares the same scan path as TestPathAwareAnnotatorTask
 * but in a deliberately different shape — backslash separators and no trailing
 * slash — to exercise both the dedup branch in
 * ClassesCommand::_walkPathAwareTasks() and the path normalization that makes
 * the dedup key stable across separator / trailing-slash style variations.
 */
class SecondTestPathAwareAnnotatorTask extends AbstractClassAnnotatorTask implements PathAwareClassAnnotatorTaskInterface {

	/**
	 * @return array<string>
	 */
	public static function scanPaths(): array {
		return ['tests\\fixtures-pathaware'];
	}

	/**
	 * @param string $path
	 * @param string $content
	 * @return bool
	 */
	public function shouldRun(string $path, string $content): bool {
		return false;
	}

	/**
	 * @param string $path
	 * @return bool
	 */
	public function annotate(string $path): bool {
		return false;
	}

}


================================================
FILE: tests/TestCase/Command/Annotate/Fixture/TestPathAwareAnnotatorTask.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Command\Annotate\Fixture;

use IdeHelper\Annotator\ClassAnnotatorTask\AbstractClassAnnotatorTask;
use IdeHelper\Annotator\ClassAnnotatorTask\PathAwareClassAnnotatorTaskInterface;

/**
 * Test fixture: a class annotator task that declares a custom scan path
 * via PathAwareClassAnnotatorTaskInterface but does no real annotation
 * work (shouldRun always false).
 */
class TestPathAwareAnnotatorTask extends AbstractClassAnnotatorTask implements PathAwareClassAnnotatorTaskInterface {

	/**
	 * @return array<string>
	 */
	public static function scanPaths(): array {
		return ['tests/fixtures-pathaware/'];
	}

	/**
	 * @param string $path
	 * @param string $content
	 * @return bool
	 */
	public function shouldRun(string $path, string $content): bool {
		return false;
	}

	/**
	 * @param string $path
	 * @return bool
	 */
	public function annotate(string $path): bool {
		return false;
	}

}


================================================
FILE: tests/TestCase/Command/AnnotateCommandTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Command;

use Cake\Console\TestSuite\ConsoleIntegrationTestTrait;
use Cake\Core\Configure;
use Cake\TestSuite\TestCase;
use IdeHelper\Command\AnnotateCommand;
use PHPUnit\Framework\Attributes\DataProvider;

class AnnotateCommandTest extends TestCase {

	use ConsoleIntegrationTestTrait;

	protected array $fixtures = [
		'plugin.IdeHelper.Cars',
		'plugin.IdeHelper.Wheels',
		'plugin.IdeHelper.Houses',
		'plugin.IdeHelper.Windows',
	];

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		if (!is_dir(LOGS)) {
			mkdir(LOGS, 0770, true);
		}
		$this->loadPlugins(['IdeHelper']);

		Configure::write('IdeHelper.assocsAsGenerics', true);
	}

	/**
	 * @return void
	 */
	public function tearDown(): void {
		parent::tearDown();

		Configure::delete('IdeHelper.assocsAsGenerics');
	}

	/**
	 * @return void
	 */
	public function testModels(): void {
		$this->exec('annotate models -d -v -r');
		$this->assertExitSuccess();
		$this->assertOutputContains(' annotations added');
	}

	/**
	 * @return void
	 */
	public function testViews(): void {
		$this->exec('annotate view -d -v -r');
		$this->assertExitSuccess();
		$this->assertOutputContains(' annotations added');
	}

	/**
	 * @return void
	 */
	public function testHelpers(): void {
		$this->exec('annotate helpers -d -v -r');
		$this->assertExitSuccess();
		$this->assertOutputContains(' annotations added');
	}

	/**
	 * @return void
	 */
	public function testTemplates(): void {
		$this->exec('annotate templates -d -v -r');
		$this->assertExitSuccess();
		$this->assertOutputContains(' annotations added');
	}

	/**
	 * @return void
	 */
	public function testTemplatesSkipFiles(): void {
		$this->exec('annotate templates -d -v --file templates/element/deeply/nested.php');
		$this->assertExitSuccess();
		$this->assertOutputContains('-> nested');
		$this->assertOutputNotContains('-> example');
	}

	/**
	 * @return void
	 */
	public function testControllers() {
		$this->exec('annotate controllers -d -v -r');
		$this->assertExitSuccess();
		$this->assertOutputContains('BarController');
		$this->assertOutputContains(' annotations added');
		$this->assertOutputContains('FoosController');
	}

	/**
	 * @return void
	 */
	public function testCommands(): void {
		$this->exec('annotate commands -d -v -r');
		$this->assertExitSuccess();
		$this->assertOutputContains(' 2 annotations added');
	}

	/**
	 * @return void
	 */
	public function testClasses(): void {
		$this->exec('annotate classes -d -v');
		$this->assertExitSuccess();
		$this->assertOutputContains(' annotation added');
	}

	/**
	 * @return void
	 */
	public function testCallbacks(): void {
		$this->exec('annotate callbacks -d -v');
		$this->assertExitSuccess();
	}

	/**
	 * @return void
	 */
	public function testAll() {
		$this->exec('annotate all -d -v -r');
		$this->assertExitSuccess();

		$this->assertOutputContains('[Models]');
		$this->assertOutputContains('[Controllers]');
		$this->assertOutputContains('[View]');
		$this->assertOutputContains('[Templates]');
		$this->assertOutputContains('[Commands]');
		$this->assertOutputContains('[Components]');
		$this->assertOutputContains('[Helpers]');
	}

	/**
	 * @return void
	 */
	public function testAllCiModeNoChanges() {
		$this->exec('annotate all -d -v --ci -p Awesome');
		$this->assertExitSuccess($this->_out->output());
	}

	/**
	 * @return void
	 */
	public function testAllCiModeChanges() {
		$this->exec('annotate all -d -v --ci');

		$this->assertExitCode(AnnotateCommand::CODE_CHANGES, $this->_out->output());
	}

	/**
	 * @return array
	 */
	public static function provideSubcommandsForCiModeTest() {
		return [
			'models' => ['models'],
			'view' => ['view'],
			'helpers' => ['helpers'],
			'components' => ['components'],
			'templates' => ['templates'],
			'controllers' => ['controllers'],
		];
	}

	/**
	 *
	 * @param string $subcommand The subcommand to be tested
	 * @return void
	 */
	#[DataProvider('provideSubcommandsForCiModeTest')]
	public function testIndividualSubcommandCiModeNoChanges(string $subcommand): void {
		$this->skipIf($subcommand === 'view', 'View does not support the plugin parameter');

		$this->exec('annotate ' . $subcommand . ' -d -v --ci -p Awesome');
		$this->assertExitSuccess($this->_out->output());
	}

	/**
	 *
	 * @param string $subcommand The subcommand to be tested
	 * @return void
	 */
	#[DataProvider('provideSubcommandsForCiModeTest')]
	public function testIndividualSubcommandCiModeChanges(string $subcommand): void {
		$this->exec('annotate ' . $subcommand . ' -d -v --ci');

		$this->assertExitCode(AnnotateCommand::CODE_CHANGES, $this->_out->output());
	}

}


================================================
FILE: tests/TestCase/Command/GenerateCodeCompletionCommandTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Command;

use Cake\Console\TestSuite\ConsoleIntegrationTestTrait;
use Cake\TestSuite\TestCase;

class GenerateCodeCompletionCommandTest extends TestCase {

	use ConsoleIntegrationTestTrait;

	protected array $files = [
		TMP . 'CodeCompletionCakeController.php',
		TMP . 'CodeCompletionCakeORM.php',
		TMP . 'CodeCompletionCakeORMQuery.php',
		TMP . 'CodeCompletionCakeView.php',
	];

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		foreach ($this->files as $file) {
			if (file_exists($file)) {
				unlink($file);
			}
		}
		$this->loadPlugins(['IdeHelper']);
	}

	/**
	 * @return void
	 */
	protected function tearDown(): void {
		parent::tearDown();

		foreach ($this->files as $file) {
			if (file_exists($file)) {
				unlink($file);
			}
		}
	}

	/**
	 * @return void
	 */
	public function testGenerate() {
		$this->exec('generate code_completion');
		$this->assertOutputContains('CodeCompletion files generated: Cake\Controller, Cake\ORM, Cake\ORM\Query, Cake\View');
		$this->assertExitSuccess();
	}

}


================================================
FILE: tests/TestCase/Command/GeneratePhpstormMetaCommandTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Command;

use Cake\Console\ConsoleIo;
use Cake\Console\TestSuite\ConsoleIntegrationTestTrait;
use Cake\TestSuite\TestCase;
use IdeHelper\Command\GeneratePhpStormMetaCommand;
use PHPUnit\Framework\MockObject\MockObject;
use Shim\TestSuite\ConsoleOutput;

class GeneratePhpstormMetaCommandTest extends TestCase {

	use ConsoleIntegrationTestTrait;

	protected array $fixtures = [
		'plugin.IdeHelper.Cars',
		'plugin.IdeHelper.Wheels',
	];

	protected GeneratePhpStormMetaCommand|MockObject $command;

	/**
	 * @var \Shim\TestSuite\ConsoleOutput
	 */
	protected ConsoleOutput $out;

	/**
	 * @var \Shim\TestSuite\ConsoleOutput
	 */
	protected ConsoleOutput $err;

	/**
	 * @var \Cake\Console\ConsoleIo
	 */
	protected ConsoleIo $io;

	protected const META_FOLDER = ROOT . DS . '.phpstorm.meta.php' . DS;
	protected const META_FILE = self::META_FOLDER . '.ide-helper.meta.php';

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		if (!is_dir(LOGS)) {
			mkdir(LOGS, 0770, true);
		}
		if (file_exists(static::META_FILE)) {
			unlink(static::META_FILE);
		}
		if (is_dir(static::META_FOLDER)) {
			rmdir(static::META_FOLDER);
		}
		$this->loadPlugins(['IdeHelper']);
	}

	/**
	 * @return void
	 */
	protected function tearDown(): void {
		parent::tearDown();
		unset($this->command);
	}

	/**
	 * @return void
	 */
	public function testDirExists() {
		$this->assertFalse(file_exists(static::META_FILE));

		$this->exec('generate phpstorm');
		$this->assertTrue(file_exists(static::META_FILE));
	}

	/**
	 * @return void
	 */
	public function testDirExistsDryRun() {
		$this->assertFalse(file_exists(static::META_FILE));
		$this->exec('generate phpstorm -d');

		$this->assertFalse(file_exists(static::META_FILE));
		$this->assertFalse(file_exists(static::META_FOLDER));
	}

	/**
	 * @return void
	 */
	public function testGenerateDryRun() {
		$this->exec('generate phpstorm -d');
		$this->assertOutputContains(' needs updating');

		$this->assertSame(GeneratePhpStormMetaCommand::CODE_CHANGES, $this->_exitCode);
	}

	/**
	 * @return void
	 */
	public function testGenerate() {
		$this->exec('generate phpstorm');
		$this->assertOutputContains('Meta file `/.phpstorm.meta.php/.ide-helper.meta.php` generated.');

		$this->exec('generate phpstorm');
		$this->assertOutputContains('Meta file `/.phpstorm.meta.php/.ide-helper.meta.php` still up to date.');

		$this->assertExitSuccess();
	}

}


================================================
FILE: tests/TestCase/Command/IlluminateCommandTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Command;

use Cake\Console\TestSuite\ConsoleIntegrationTestTrait;
use Cake\TestSuite\TestCase;

class IlluminateCommandTest extends TestCase {

	use ConsoleIntegrationTestTrait;

	/**
	 * @return void
	 */
	public function testIlluminateDryRun() {
		$this->loadPlugins(['IdeHelper']);
		$this->exec('illuminate code -d -v');

		$this->assertExitCode(2);
		$this->assertOutputContains('# /src/Model/Entity/Foo.php');
	}

}


================================================
FILE: tests/TestCase/Console/IoTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Console;

use Cake\Console\ConsoleIo;
use Cake\Console\Exception\StopException;
use Cake\TestSuite\TestCase;
use IdeHelper\Console\Io;
use Shim\TestSuite\ConsoleOutput;

class IoTest extends TestCase {

	protected Io $io;

	protected ConsoleIo $consoleIo;

	protected ConsoleOutput $out;

	protected ConsoleOutput $err;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		if (!is_dir(LOGS)) {
			mkdir(LOGS, 0770, true);
		}

		$this->out = new ConsoleOutput();
		$this->err = new ConsoleOutput();
		$this->consoleIo = new ConsoleIo($this->out, $this->err);
		$this->io = new Io($this->consoleIo);
	}

	/**
	 * @return void
	 */
	protected function tearDown(): void {
		parent::tearDown();
		unset($this->Shell);
	}

	/**
	 * @return void
	 */
	public function testSuccess() {
		$this->io->success('Foos');

		$output = $this->out->output();
		$this->assertTextContains('Foos', $output);
	}

	/**
	 * @return void
	 */
	public function testInfo() {
		$this->io->info('Foos');

		$output = $this->out->output();
		$this->assertTextContains('Foos', $output);
	}

	/**
	 * @return void
	 */
	public function testComment() {
		$this->io->comment('Foos');

		$output = $this->out->output();
		$this->assertTextContains('Foos', $output);
	}

	/**
	 * @return void
	 */
	public function testWarn() {
		$this->io->warn('Foos');

		$output = $this->err->output();
		$this->assertTextContains('Foos', $output);
	}

	/**
	 * @return void
	 */
	public function testError() {
		$this->io->error('Foos');

		$output = $this->err->output();
		$this->assertTextContains('Foos', $output);
	}

	/**
	 * @return void
	 */
	public function testErr() {
		$this->io->err('Foos');

		$output = $this->err->output();
		$this->assertTextContains('Foos', $output);
	}

	/**
	 * @return void
	 */
	public function testVerbose() {
		$this->consoleIo->level(ConsoleIo::VERBOSE);
		$this->io->verbose('Foos');

		$output = $this->out->output();
		$this->assertTextContains('Foos', $output);
	}

	/**
	 * @return void
	 */
	public function testQuiet() {
		$this->consoleIo->level(ConsoleIo::QUIET);
		$this->io->quiet('Foos');

		$output = $this->out->output();
		$this->assertTextContains('Foos', $output);
	}

	/**
	 * @return void
	 */
	public function testNl() {
		$output = $this->io->nl();

		$this->assertSame(ConsoleOutput::LF, $output);
	}

	/**
	 * @return void
	 */
	public function testHr() {
		$this->io->hr();

		$output = $this->out->output();
		$this->assertTextContains('----', $output);
	}

	/**
	 * @return void
	 */
	public function testAbort() {
		$this->expectException(StopException::class);

		$this->io->abort('Foos');
	}

}


================================================
FILE: tests/TestCase/Generator/Directive/ExitPointTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Generator\Directive;

use Cake\Console\ConsoleIo;
use IdeHelper\Generator\Directive\ExitPoint;
use Shim\TestSuite\TestCase;

class ExitPointTest extends TestCase {

	/**
	 * @return void
	 */
	public function testBuild() {
		$directive = new ExitPoint('\\' . ConsoleIo::class . '::abort()');

		$result = $directive->build();
		$expected = <<<'TXT'
	exitPoint(\Cake\Console\ConsoleIo::abort());
TXT;
		$this->assertSame($expected, $result);
		$this->assertSame('\\' . ConsoleIo::class . '::abort()@exitPoint', $directive->key());
	}

}


================================================
FILE: tests/TestCase/Generator/Directive/ExpectedArgumentsTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Generator\Directive;

use Cake\ORM\Table;
use IdeHelper\Generator\Directive\ExpectedArguments;
use Shim\TestSuite\TestCase;

class ExpectedArgumentsTest extends TestCase {

	/**
	 * @return void
	 */
	public function testBuild() {
		$map = [
			'\Foo\Bar::class',
			'"string"',
		];
		$directive = new ExpectedArguments('\\' . Table::class . '::addBehavior()', 0, $map);

		$result = $directive->build();
		$expected = <<<'TXT'
	expectedArguments(
		\Cake\ORM\Table::addBehavior(),
		0,
		\Foo\Bar::class,
		"string",
	);
TXT;
		$this->assertSame($expected, $result);
		$this->assertSame('\\' . Table::class . '::addBehavior()@0@expectedArguments', $directive->key());
	}

}


================================================
FILE: tests/TestCase/Generator/Directive/ExpectedReturnValuesTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Generator\Directive;

use Cake\ORM\Table;
use IdeHelper\Generator\Directive\ExpectedReturnValues;
use Shim\TestSuite\TestCase;

class ExpectedReturnValuesTest extends TestCase {

	/**
	 * @return void
	 */
	public function testBuild() {
		$map = [
			'\Foo\Bar::class',
			'"string"',
		];
		$directive = new ExpectedReturnValues('\\' . Table::class . '::addBehavior()', $map);

		$result = $directive->build();
		$expected = <<<'TXT'
	expectedReturnValues(
		\Cake\ORM\Table::addBehavior(),
		\Foo\Bar::class,
		"string",
	);
TXT;
		$this->assertSame($expected, $result);
		$this->assertSame('\\' . Table::class . '::addBehavior()@expectedReturnValues', $directive->key());
	}

}


================================================
FILE: tests/TestCase/Generator/Directive/OverrideTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Generator\Directive;

use Cake\ORM\Table;
use IdeHelper\Generator\Directive\Override;
use IdeHelper\ValueObject\ClassName;
use IdeHelper\ValueObject\KeyValue;
use Shim\TestSuite\TestCase;

class OverrideTest extends TestCase {

	/**
	 * @return void
	 */
	public function testBuild() {
		$map = [
			'Tree' => ClassName::create(Table::class),
			'CounterCache' => ClassName::create(Table::class),
		];
		$directive = new Override('\\' . Table::class . '::addBehavior(0)', $map);

		$result = $directive->build();
		$expected = <<<'TXT'
	override(
		\Cake\ORM\Table::addBehavior(0),
		map([
			'Tree' => \Cake\ORM\Table::class,
			'CounterCache' => \Cake\ORM\Table::class,
		]),
	);
TXT;
		$this->assertSame($expected, $result);
		$this->assertSame('\\' . Table::class . '::addBehavior(0)@override', $directive->key());
	}

	/**
	 * @return void
	 */
	public function testBuildLiteralKey() {
		$key = ClassName::create(Table::class);

		$value = ClassName::create(Table::class);
		$keyValue = KeyValue::create($key, $value);
		$map = [
			'\\' . Table::class . '::class' => $keyValue,
		];
		$directive = new Override('\\' . Table::class . '::addBehavior(0)', $map);

		$result = $directive->build();
		$expected = <<<'TXT'
	override(
		\Cake\ORM\Table::addBehavior(0),
		map([
			\Cake\ORM\Table::class => \Cake\ORM\Table::class,
		]),
	);
TXT;
		$this->assertSame($expected, $result);
		$this->assertSame('\\' . Table::class . '::addBehavior(0)@override', $directive->key());
	}

}


================================================
FILE: tests/TestCase/Generator/Directive/RegisterArgumentsSetTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Generator\Directive;

use IdeHelper\Generator\Directive\ExpectedArguments;
use IdeHelper\Generator\Directive\ExpectedReturnValues;
use IdeHelper\Generator\Directive\RegisterArgumentsSet;
use Shim\TestSuite\TestCase;

class RegisterArgumentsSetTest extends TestCase {

	/**
	 * @return void
	 */
	public function testBuild() {
		$list = [
			'\Foo\Bar::class',
			'"string"',
		];
		$directive = new RegisterArgumentsSet('foo', $list);

		$result = $directive->build();
		$expected = <<<'TXT'
	registerArgumentsSet(
		'foo',
		\Foo\Bar::class,
		"string",
	);
TXT;
		$this->assertSame($expected, $result);
		$this->assertSame('foo@registerArgumentsSet', $directive->key());
	}

	/**
	 * @return void
	 */
	public function testToString() {
		$list = [
			'\Foo\Bar::class',
		];
		$directive = new RegisterArgumentsSet('fooBar', $list);

		$result = (string)$directive;
		$this->assertSame('argumentsSet(\'fooBar\')', $result);
	}

	/**
	 * @return void
	 */
	public function testSetInsideArguments() {
		$list = [
			'\Foo\Bar::class',
			'"string"',
		];
		$argumentsSet = new RegisterArgumentsSet('fooBar', $list);

		$list = [
			$argumentsSet,
		];
		$directive = new ExpectedArguments('\My\Class::someMethod()', 1, $list);

		$result = $directive->build();
		$expected = <<<'TXT'
	expectedArguments(
		\My\Class::someMethod(),
		1,
		argumentsSet('fooBar'),
	);
TXT;
		$this->assertSame($expected, $result);
	}

	/**
	 * @return void
	 */
	public function testArgumentsSetInsideReturnValues() {
		$list = [
			'\Foo\Bar::class',
			'"string"',
		];
		$argumentsSet = new RegisterArgumentsSet('fooBar', $list);

		$list = [
			$argumentsSet,
		];
		$directive = new ExpectedReturnValues('\My\Class::someMethod()', $list);

		$result = $directive->build();
		$expected = <<<'TXT'
	expectedReturnValues(
		\My\Class::someMethod(),
		argumentsSet('fooBar'),
	);
TXT;
		$this->assertSame($expected, $result);
	}

}


================================================
FILE: tests/TestCase/Generator/PhpstormGeneratorTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Generator;

use Cake\Core\Configure;
use Cake\Core\Plugin;
use IdeHelper\Generator\PhpstormGenerator;
use IdeHelper\Generator\Task\EnvTask;
use IdeHelper\Generator\Task\FixtureTask;
use IdeHelper\Generator\TaskCollection;
use Shim\TestSuite\TestCase;
use TestApp\Generator\Task\TestEnvTask;
use TestApp\Generator\Task\TestFixtureTask;

class PhpstormGeneratorTest extends TestCase {

	/**
	 * @var array<string>
	 */
	protected array $fixtures = [
		'plugin.IdeHelper.Cars',
		'plugin.IdeHelper.Wheels',
	];

	protected ?PhpstormGenerator $generator = null;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();
		$this->loadPlugins(['Awesome', 'Controllers', 'MyNamespace/MyPlugin', 'Relations', 'Shim', 'IdeHelper']);

		$taskCollection = new TaskCollection([
			EnvTask::class => TestEnvTask::class,
			FixtureTask::class => TestFixtureTask::class,
		]);
		$this->generator = new PhpstormGenerator($taskCollection);

		$file = TMP . '.meta.php';
		if (file_exists($file)) {
			unlink($file);
		}
	}

	/**
	 * @return void
	 */
	protected function tearDown(): void {
		parent::tearDown();

		$file = TMP . '.meta.php';
		if (file_exists($file)) {
			unlink($file);
		}
	}

	/**
	 * @return void
	 */
	public function testCollect() {
		Configure::write('IdeHelper.skipDatabaseTables', ['/^(?!wheels)/']);

		$result = $this->generator->generate();
		file_put_contents(TMP . '.meta.php', $result);

		$cakeVersion = Configure::version();
		if (version_compare($cakeVersion, '5.2.0', '<')) {
			$fileName = '.meta_lowest.php';
		} elseif (version_compare($cakeVersion, '5.3.0', '<')) {
			$fileName = '.meta_52.php';
		} else {
			$fileName = '.meta.php';
		}
		$file = Plugin::path('IdeHelper') . 'tests' . DS . 'test_files' . DS . 'meta' . DS . 'phpstorm' . DS . $fileName;

		// Trick to let the test file get updated: --debug is for PHPUnit 11+, --cache-result for PHPUnit 10
		if (!empty($_SERVER['argv']) && (in_array('--debug', $_SERVER['argv'], true) || in_array('--cache-result', $_SERVER['argv'], true))) {
			debug('Adding results to ' . $fileName);
			file_put_contents($file, $result);
		}

		$expected = file_get_contents($file);

		$this->assertTextEquals($expected, $result);
	}

}


================================================
FILE: tests/TestCase/Generator/Task/BehaviorTaskTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Generator\Task;

use Cake\TestSuite\TestCase;
use IdeHelper\Generator\Task\BehaviorTask;

class BehaviorTaskTest extends TestCase {

	protected BehaviorTask $task;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->loadPlugins(['Shim']);
		$this->task = new BehaviorTask();
	}

	/**
	 * @return void
	 */
	public function testCollect() {
		$result = $this->task->collect();

		$this->assertCount(4, $result);

		/** @var \IdeHelper\Generator\Directive\Override $directive */
		$directive = array_shift($result);
		$this->assertSame('\Cake\ORM\Table::addBehavior()', $directive->toArray()['method']);

		$list = $directive->toArray()['list'];

		$expected = '\'Timestamp\'';
		$this->assertSame($expected, (string)$list['Timestamp']);

		$expected = '\'Shim.Nullable\'';
		$this->assertSame($expected, (string)$list['Shim.Nullable']);

		/** @var \IdeHelper\Generator\Directive\Override $directive */
		$directive = array_shift($result);
		$this->assertSame('\Cake\ORM\Table::removeBehavior()', $directive->toArray()['method']);

		$list = $directive->toArray()['list'];

		$expected = '\'Timestamp\'';
		$this->assertSame($expected, (string)$list['Timestamp']);

		$expected = '\'Nullable\'';
		$this->assertSame($expected, (string)$list['Nullable']);
	}

}


================================================
FILE: tests/TestCase/Generator/Task/CacheTaskTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Generator\Task;

use Cake\TestSuite\TestCase;
use IdeHelper\Generator\Directive\RegisterArgumentsSet;
use IdeHelper\Generator\Task\CacheTask;

class CacheTaskTest extends TestCase {

	protected CacheTask $task;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->task = new CacheTask();
	}

	/**
	 * @return void
	 */
	public function testCollect() {
		$result = $this->task->collect();

		$this->assertCount(12, $result);

		/** @var \IdeHelper\Generator\Directive\RegisterArgumentsSet $directive */
		$directive = array_shift($result);
		$this->assertInstanceOf(RegisterArgumentsSet::class, $directive);
		$this->assertSame(CacheTask::SET_CACHE_ENGINES, $directive->toArray()['set']);

		/** @var \IdeHelper\Generator\Directive\ExpectedArguments $directive */
		$directive = array_shift($result);
		$this->assertSame('\Cake\Cache\Cache::clear()', $directive->toArray()['method']);

		$list = $directive->toArray()['list'];
		$list = array_map(function ($className) {
			return (string)$className;
		}, $list);

		$expected = [
			'argumentsSet(\'cacheEngines\')',
		];
		$this->assertSame($expected, $list);
	}

}


================================================
FILE: tests/TestCase/Generator/Task/CellTaskTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Generator\Task;

use Cake\TestSuite\TestCase;
use IdeHelper\Generator\Task\CellTask;

class CellTaskTest extends TestCase {

	protected CellTask $task;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->task = new CellTask();
	}

	/**
	 * @return void
	 */
	public function testCollect() {
		$result = $this->task->collect();

		$this->assertCount(1, $result);

		/** @var \IdeHelper\Generator\Directive\Override $directive */
		$directive = array_shift($result);
		$this->assertSame('\Cake\View\CellTrait::cell()', $directive->toArray()['method']);

		$map = $directive->toArray()['map'];

		$expected = '\TestApp\View\Cell\TestCell::class';
		$this->assertSame($expected, (string)$map['Test']);
	}

}


================================================
FILE: tests/TestCase/Generator/Task/ComponentTaskTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Generator\Task;

use Cake\TestSuite\TestCase;
use IdeHelper\Generator\Task\ComponentTask;

class ComponentTaskTest extends TestCase {

	protected ComponentTask $task;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->task = new ComponentTask();
	}

	/**
	 * @return void
	 */
	public function testCollect() {
		$result = $this->task->collect();

		$this->assertCount(2, $result);

		/** @var \IdeHelper\Generator\Directive\Override $directive */
		$directive = array_shift($result);
		$this->assertSame('\Cake\Controller\Controller::loadComponent(0)', $directive->toArray()['method']);

		$map = $directive->toArray()['map'];

		$expected = '\Cake\Controller\Component\FormProtectionComponent::class';
		$this->assertSame($expected, (string)$map['FormProtection']);

		$expected = '\TestApp\Controller\Component\MyOtherComponent::class';
		$this->assertSame($expected, (string)$map['MyOther']);
	}

}


================================================
FILE: tests/TestCase/Generator/Task/ConfigureTaskTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Generator\Task;

use Cake\TestSuite\TestCase;
use IdeHelper\Generator\Directive\RegisterArgumentsSet;
use IdeHelper\Generator\Task\ConfigureTask;
use Shim\TestSuite\TestTrait;

class ConfigureTaskTest extends TestCase {

	use TestTrait;

	protected ConfigureTask $task;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->task = new ConfigureTask();
	}

	/**
	 * @return void
	 */
	public function testCollect() {
		$result = $this->task->collect();

		$this->assertCount(8, $result);

		/** @var \IdeHelper\Generator\Directive\RegisterArgumentsSet $directive */
		$directive = array_shift($result);
		$this->assertInstanceOf(RegisterArgumentsSet::class, $directive);
		$this->assertSame(ConfigureTask::SET_CONFIGURE_KEYS, $directive->toArray()['set']);

		/** @var \IdeHelper\Generator\Directive\ExpectedArguments $directive */
		$directive = array_shift($result);
		$this->assertSame('\Cake\Core\Configure::read()', $directive->toArray()['method']);

		$list = $directive->toArray()['list'];
		$list = array_map(function ($className) {
			return (string)$className;
		}, $list);

		$expected = [
			'argumentsSet(\'configureKeys\')',
		];
		$this->assertSame($expected, $list);
	}

	/**
	 * @return void
	 */
	public function testCollectKeys(): void {
		$result = $this->invokeMethod($this->task, 'collectKeys');

		$this->assertArrayHasKey('App.paths.templates', $result);
		$this->assertArrayNotHasKey('paths', $result);
		$this->assertArrayNotHasKey('templates', $result);

		$this->assertSame('\'debug\'', (string)$result['debug']);
	}

}


================================================
FILE: tests/TestCase/Generator/Task/ConnectionTaskTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Generator\Task;

use IdeHelper\Generator\Task\ConnectionTask;
use Shim\TestSuite\TestCase;

class ConnectionTaskTest extends TestCase {

	protected ?ConnectionTask $task = null;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->task = new ConnectionTask();
	}

	/**
	 * @return void
	 */
	public function testCollect() {
		$result = $this->task->collect();

		$this->assertCount(1, $result);

		/** @var \IdeHelper\Generator\Directive\ExpectedArguments $directive */
		$directive = array_shift($result);
		$this->assertSame('\Cake\Datasource\ConnectionManager::get()', $directive->toArray()['method']);

		$list = $directive->toArray()['list'];
		$list = array_map(function ($className) {
			return (string)$className;
		}, $list);

		$expected = [
			'test' => "'test'",
		];
		$this->assertSame($expected, $list);
	}

}


================================================
FILE: tests/TestCase/Generator/Task/ConsoleHelperTaskTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Generator\Task;

use Cake\TestSuite\TestCase;
use IdeHelper\Generator\Task\ConsoleHelperTask;

class ConsoleHelperTaskTest extends TestCase {

	protected ConsoleHelperTask $task;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->task = new ConsoleHelperTask();
	}

	/**
	 * @return void
	 */
	public function testCollect() {
		$result = $this->task->collect();

		$this->assertCount(1, $result);

		/** @var \IdeHelper\Generator\Directive\Override $directive */
		$directive = array_shift($result);
		$this->assertSame('\Cake\Console\ConsoleIo::helper(0)', $directive->toArray()['method']);

		$map = $directive->toArray()['map'];

		$expected = '\Cake\Command\Helper\ProgressHelper::class';
		$this->assertSame($expected, (string)$map['Progress']);

		$expected = '\Cake\Command\Helper\TableHelper::class';
		$this->assertSame($expected, (string)$map['Table']);
	}

}


================================================
FILE: tests/TestCase/Generator/Task/ConsoleTaskTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Generator\Task;

use Cake\TestSuite\TestCase;
use IdeHelper\Generator\Task\ConsoleTask;

class ConsoleTaskTest extends TestCase {

	protected ConsoleTask $task;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->task = new ConsoleTask();
	}

	/**
	 * @return void
	 */
	public function testCollect() {
		$result = $this->task->collect();

		$this->assertCount(1, $result);

		/** @var \IdeHelper\Generator\Directive\ExitPoint $directive */
		$directive = array_shift($result);
		$this->assertSame('\Cake\Console\ConsoleIo::abort()', $directive->toArray()['method']);
	}

}


================================================
FILE: tests/TestCase/Generator/Task/DatabaseTableColumnNameTaskTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Generator\Task;

use Cake\TestSuite\TestCase;
use IdeHelper\Generator\Task\DatabaseTableColumnNameTask;

class DatabaseTableColumnNameTaskTest extends TestCase {

	/**
	 * @var array<string>
	 */
	protected array $fixtures = [
		'plugin.IdeHelper.Cars',
		'plugin.IdeHelper.Wheels',
	];

	protected DatabaseTableColumnNameTask $task;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->fetchTable('Cars');
		$this->fetchTable('Wheels');

		$this->task = new DatabaseTableColumnNameTask();
	}

	/**
	 * @return void
	 */
	protected function tearDown(): void {
		parent::tearDown();

		unset($this->task);
	}

	/**
	 * @return void
	 */
	public function testCollect() {
		$result = $this->task->collect();

		$this->assertCount(7, $result);

		/** @var \IdeHelper\Generator\Directive\RegisterArgumentsSet $directive */
		$directive = array_shift($result);
		$this->assertSame(DatabaseTableColumnNameTask::SET_COLUMN_NAMES, $directive->toArray()['set']);

		/** @var \IdeHelper\Generator\Directive\ExpectedArguments $directive */
		$directive = array_shift($result);
		$this->assertSame('\Migrations\Db\Table::addColumn()', $directive->toArray()['method']);

		$list = $directive->toArray()['list'];
		$list = array_map(function ($className) {
			return (string)$className;
		}, $list);

		$expectedList = [
			'argumentsSet(\'columnNames\')',
		];
		$this->assertSame($expectedList, $list);

		/** @var \IdeHelper\Generator\Directive\ExpectedArguments $directive */
		$directive = array_shift($result);
		$this->assertSame('\Migrations\Db\Table::changeColumn()', $directive->toArray()['method']);

		$list = $directive->toArray()['list'];
		$list = array_map(function ($className) {
			return (string)$className;
		}, $list);
		$this->assertSame($expectedList, $list);

		/** @var \IdeHelper\Generator\Directive\ExpectedArguments $directive */
		$directive = array_shift($result);
		$this->assertSame('\Migrations\Db\Table::removeColumn()', $directive->toArray()['method']);

		$list = $directive->toArray()['list'];
		$list = array_map(function ($className) {
			return (string)$className;
		}, $list);
		$this->assertSame($expectedList, $list);

		/** @var \IdeHelper\Generator\Directive\ExpectedArguments $directive */
		$directive = array_shift($result);
		$this->assertSame('\Migrations\Db\Table::renameColumn()', $directive->toArray()['method']);

		$list = $directive->toArray()['list'];
		$list = array_map(function ($className) {
			return (string)$className;
		}, $list);
		$this->assertSame($expectedList, $list);

		/** @var \IdeHelper\Generator\Directive\ExpectedArguments $directive */
		$directive = array_shift($result);
		$this->assertSame('\Migrations\Db\Table::hasColumn()', $directive->toArray()['method']);

		$list = $directive->toArray()['list'];
		$list = array_map(function ($className) {
			return (string)$className;
		}, $list);
		$this->assertSame($expectedList, $list);
	}

}


================================================
FILE: tests/TestCase/Generator/Task/DatabaseTableColumnTypeTaskTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Generator\Task;

use Cake\Core\Plugin;
use Cake\Database\Driver\Mysql;
use Cake\Database\Driver\Postgres;
use Cake\Datasource\ConnectionManager;
use Cake\TestSuite\TestCase;
use IdeHelper\Generator\Directive\ExpectedArguments;
use IdeHelper\Generator\Task\DatabaseTableColumnTypeTask;
use TestApp\Generator\Task\TestDatabaseTableColumnTypeTask;

class DatabaseTableColumnTypeTaskTest extends TestCase {

	/**
	 * @var array<string>
	 */
	protected array $fixtures = [
		'plugin.IdeHelper.Cars',
		'plugin.IdeHelper.Wheels',
	];

	protected DatabaseTableColumnTypeTask $task;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->fetchTable('Cars');
		$this->fetchTable('Wheels');

		$this->task = new DatabaseTableColumnTypeTask();
	}

	/**
	 * @return void
	 */
	public function testCollect() {
		$result = $this->task->collect();

		$this->assertCount(3, $result);

		/** @var \IdeHelper\Generator\Directive\RegisterArgumentsSet $directive */
		$directive = array_shift($result);
		$this->assertSame(DatabaseTableColumnTypeTask::SET_COLUMN_TYPES, $directive->toArray()['set']);

		$list = $directive->toArray()['list'];
		$list = array_map(function ($className) {
			return (string)$className;
		}, $list);

		$expectedList = [
			'text' => "'text'",
			'integer' => "'integer'",
		];
		foreach ($expectedList as $key => $value) {
			$this->assertArrayHasKey($key, $list);
			$this->assertSame($value, $list[$key]);
		}

		/** @var \IdeHelper\Generator\Directive\ExpectedArguments $directive */
		$directive = array_shift($result);
		$this->assertInstanceOf(ExpectedArguments::class, $directive);
		$this->assertSame('\Migrations\Db\Table::addColumn()', $directive->toArray()['method']);

		$list = array_map(function ($value) {
			return (string)$value;
		}, $list);

		$expectedList = [
			'text' => "'text'",
			'integer' => "'integer'",
		];
		foreach ($expectedList as $key => $value) {
			$this->assertArrayHasKey($key, $list);
			$this->assertSame($value, $list[$key]);
		}

		/** @var \IdeHelper\Generator\Directive\ExpectedArguments $directive */
		$directive = array_shift($result);
		$this->assertSame('\Migrations\Db\Table::changeColumn()', $directive->toArray()['method']);

		$list = $directive->toArray()['list'];
		$list = array_map(function ($className) {
			return (string)$className;
		}, $list);

		$expectedList = [
			'argumentsSet(\'columnTypes\')',
		];
		$this->assertSame($expectedList, $list);
	}

	/**
	 * @return void
	 */
	public function testCollectPluginLoaded() {
		$driver = ConnectionManager::get('test')->getDriver();
		$this->skipIf(!($driver instanceof Mysql || $driver instanceof Postgres), 'Only for Postgres/Mysql');

		$this->assertFalse(Plugin::isLoaded('Migrations'));

		$plugin = Plugin::getCollection()->create('Migrations');
		Plugin::getCollection()->add($plugin);

		$this->assertTrue(Plugin::isLoaded('Migrations'));

		$this->task = new TestDatabaseTableColumnTypeTask();
		$result = $this->task->collect();

		$this->assertCount(3, $result);

		/** @var \IdeHelper\Generator\Directive\RegisterArgumentsSet $directive */
		$directive = array_shift($result);
		$this->assertSame(DatabaseTableColumnTypeTask::SET_COLUMN_TYPES, $directive->toArray()['set']);

		$list = $directive->toArray()['list'];
		$list = array_map(function ($className) {
			return (string)$className;
		}, $list);
		$expectedList = [
			'text' => "'text'",
			'integer' => "'integer'",
		];
		foreach ($expectedList as $key => $value) {
			$this->assertArrayHasKey($key, $list);
			$this->assertSame($value, $list[$key]);
		}

		/** @var \IdeHelper\Generator\Directive\ExpectedArguments $directive */
		$directive = array_shift($result);
		$this->assertSame('\Migrations\Db\Table::addColumn()', $directive->toArray()['method']);

		$list = $directive->toArray()['list'];
		$list = array_map(function ($className) {
			return (string)$className;
		}, $list);

		$expectedList = [
			'argumentsSet(\'columnTypes\')',
		];
		$this->assertSame($expectedList, $list);

		/** @var \IdeHelper\Generator\Directive\ExpectedArguments $directive */
		$directive = array_shift($result);
		$this->assertSame('\Migrations\Db\Table::changeColumn()', $directive->toArray()['method']);

		Plugin::getCollection()->remove('Migrations');
		$this->assertFalse(Plugin::isLoaded('Migrations'));
	}

}


================================================
FILE: tests/TestCase/Generator/Task/DatabaseTableTaskTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Generator\Task;

use Cake\TestSuite\TestCase;
use IdeHelper\Generator\Directive\RegisterArgumentsSet;
use IdeHelper\Generator\Task\DatabaseTableTask;

class DatabaseTableTaskTest extends TestCase {

	/**
	 * @var array<string>
	 */
	protected array $fixtures = [
		'plugin.IdeHelper.Cars',
		'plugin.IdeHelper.Wheels',
	];

	protected DatabaseTableTask $task;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->fetchTable('Cars');
		$this->fetchTable('Wheels');

		$this->task = new DatabaseTableTask();
	}

	/**
	 * @return void
	 */
	protected function tearDown(): void {
		parent::tearDown();

		unset($this->task);
	}

	/**
	 * @return void
	 */
	public function testCollect() {
		$result = $this->task->collect();

		$this->assertCount(5, $result);

		/** @var \IdeHelper\Generator\Directive\RegisterArgumentsSet $directive */
		$directive = array_shift($result);
		$this->assertInstanceOf(RegisterArgumentsSet::class, $directive);
		$this->assertSame(DatabaseTableTask::SET_TABLE_NAMES, $directive->toArray()['set']);

		$list = $directive->toArray()['list'];
		$expectedList = [
			'cars' => "'cars'",
			'wheels' => "'wheels'",
		];
		foreach ($expectedList as $key => $value) {
			$this->assertArrayHasKey($key, $list);
			$this->assertSame($value, (string)$list[$key]);
		}

		$expectedMethods = [
			'\Migrations\BaseMigration::table()',
			'\Migrations\BaseMigration::hasTable()',
			'\Migrations\BaseSeed::table()',
			'\Migrations\BaseSeed::hasTable()',
		];

		foreach ($expectedMethods as $expectedMethod) {
			/** @var \IdeHelper\Generator\Directive\ExpectedArguments $directive */
			$directive = array_shift($result);
			$this->assertSame($expectedMethod, $directive->toArray()['method']);

			$list = $directive->toArray()['list'];
			$list = array_map(function ($className) {
				return (string)$className;
			}, $list);

			$expectedList = [
				'argumentsSet(\'tableNames\')',
			];
			$this->assertSame($expectedList, $list);
		}
	}

}


================================================
FILE: tests/TestCase/Generator/Task/DatabaseTypeTaskTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Generator\Task;

use Cake\Database\TypeFactory;
use Cake\TestSuite\TestCase;
use IdeHelper\Generator\Task\DatabaseTypeTask;
use TestApp\Database\Type\UuidType;

class DatabaseTypeTaskTest extends TestCase {

	protected DatabaseTypeTask $task;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->task = new DatabaseTypeTask();
	}

	/**
	 * @return void
	 */
	public function testCollect() {
		TypeFactory::set('uuid', new UuidType());

		$result = $this->task->collect();

		$this->assertCount(2, $result);

		/** @var \IdeHelper\Generator\Directive\Override $directive */
		$directive = array_shift($result);
		$this->assertSame('\Cake\Database\TypeFactory::build(0)', $directive->toArray()['method']);

		$map = $directive->toArray()['map'];

		$expected = '\Cake\Database\Type\BinaryType::class';
		$this->assertSame($expected, (string)$map['binary']);

		$expected = '\TestApp\Database\Type\UuidType::class';
		$this->assertSame($expected, (string)$map['uuid']);

		/** @var \IdeHelper\Generator\Directive\Override $directive */
		$directive = array_shift($result);
		$this->assertSame('\Cake\Database\TypeFactory::map()', $directive->toArray()['method']);

		$list = $directive->toArray()['list'];
		$this->assertSame('\'json\'', (string)$list['json']);
	}

}


================================================
FILE: tests/TestCase/Generator/Task/ElementTaskTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Generator\Task;

use Cake\TestSuite\TestCase;
use IdeHelper\Generator\Task\ElementTask;
use Shim\TestSuite\TestTrait;

class ElementTaskTest extends TestCase {

	use TestTrait;

	protected ElementTask $task;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->loadPlugins(['Awesome']);
		$this->task = new ElementTask();
	}

	/**
	 * @return void
	 */
	public function testCollect() {
		$result = $this->task->collect();

		$this->assertCount(1, $result);

		/** @var \IdeHelper\Generator\Directive\Override $directive */
		$directive = array_shift($result);
		$this->assertSame('\Cake\View\View::element()', $directive->toArray()['method']);

		$list = $directive->toArray()['list'];
		$list = array_map(function ($className) {
			return (string)$className;
		}, $list);

		$expectedMap = [
			'Awesome.pagination' => '\'Awesome.pagination\'',
			'deeply/nested' => '\'deeply/nested\'',
			'example' => '\'example\'',
		];
		$this->assertSame($expectedMap, $list);
	}

}


================================================
FILE: tests/TestCase/Generator/Task/EntityTaskTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Generator\Task;

use Cake\TestSuite\TestCase;
use IdeHelper\Generator\Directive\ExpectedArguments;
use IdeHelper\Generator\Directive\RegisterArgumentsSet;
use IdeHelper\Generator\Task\EntityTask;

class EntityTaskTest extends TestCase {

	/**
	 * @var array<string>
	 */
	protected array $fixtures = [
		'plugin.IdeHelper.Cars',
		'plugin.IdeHelper.Wheels',
	];

	protected EntityTask $task;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->loadPlugins(['Awesome', 'Controllers', 'MyNamespace/MyPlugin', 'Relations', 'Shim', 'IdeHelper']);
		$this->task = new EntityTask();
	}

	/**
	 * @return void
	 */
	public function testCollect() {
		$result = $this->task->collect();

		$this->assertCount(99, $result);

		/** @var \IdeHelper\Generator\Directive\RegisterArgumentsSet $directive */
		$directive = array_shift($result);
		$this->assertInstanceOf(RegisterArgumentsSet::class, $directive);
		$this->assertStringContainsString(EntityTask::SET_ENTITY_FIELDS, $directive->toArray()['set']);

		$list = $directive->toArray()['list'];
		$list = array_map(function ($className) {
			return (string)$className;
		}, $list);

		$expected = [
			'content' => "'content'",
			'created' => "'created'",
			'foo' => "'foo'",
			'houses' => "'houses'",
			'id' => "'id'",
			'name' => "'name'",
		];
		$this->assertSame($expected, $list);

		$directive = array_shift($result);
		$this->assertInstanceOf(ExpectedArguments::class, $directive);
	}

}


================================================
FILE: tests/TestCase/Generator/Task/EnvTaskTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Generator\Task;

use IdeHelper\Generator\Task\EnvTask;
use Shim\TestSuite\TestCase;

class EnvTaskTest extends TestCase {

	protected ?EnvTask $task = null;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->task = new EnvTask();
	}

	/**
	 * @return void
	 */
	public function testCollect() {
		$result = $this->task->collect();

		$this->assertCount(1, $result);

		/** @var \IdeHelper\Generator\Directive\ExpectedArguments $directive */
		$directive = array_shift($result);
		$this->assertSame('\env()', $directive->toArray()['method']);

		$list = $directive->toArray()['list'];
		$list = array_map(function ($className) {
			return (string)$className;
		}, $list);

		$expected = [
			'HTTP_HOST' => "'HTTP_HOST'",
			'REMOTE_ADDR' => "'REMOTE_ADDR'",
		];
		foreach ($expected as $key => $value) {
			$this->assertSame($value, $list[$key]);
		}
	}

}


================================================
FILE: tests/TestCase/Generator/Task/FixtureTaskTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Generator\Task;

use Cake\TestSuite\TestCase;
use IdeHelper\Generator\Task\FixtureTask;

class FixtureTaskTest extends TestCase {

	protected FixtureTask $task;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->loadPlugins(['MyNamespace/MyPlugin', 'IdeHelper']);
		$this->task = new FixtureTask();
	}

	/**
	 * @return void
	 */
	public function testCollect() {
		$result = $this->task->collect();

		$this->assertCount(1, $result);

		/** @var \IdeHelper\Generator\Directive\ExpectedArguments $directive */
		$directive = array_shift($result);
		$this->assertSame('\\' . TestCase::class . '::addFixture()', $directive->toArray()['method']);

		$list = $directive->toArray()['list'];
		$list = array_map(function ($className) {
			return (string)$className;
		}, $list);

		$expected = [
			'app.SmallWindows' => '\'app.SmallWindows\'',
			'core.Posts' => '\'core.Posts\'',
			'plugin.IdeHelper.Windows' => '\'plugin.IdeHelper.Windows\'',
			'plugin.MyNamespace/MyPlugin.Sub/My' => '\'plugin.MyNamespace/MyPlugin.Sub/My\'',
		];
		foreach ($expected as $key => $value) {
			$this->assertSame($value, $list[$key]);
		}
	}

}


================================================
FILE: tests/TestCase/Generator/Task/FormHelperTaskTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Generator\Task;

use Cake\TestSuite\TestCase;
use IdeHelper\Generator\Directive\ExpectedArguments;
use IdeHelper\Generator\Task\FormHelperTask;

class FormHelperTaskTest extends TestCase {

	/**
	 * @var array<string>
	 */
	protected array $fixtures = [
		'plugin.IdeHelper.Cars',
		'plugin.IdeHelper.Wheels',
	];

	protected FormHelperTask $task;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->loadPlugins(['Awesome', 'Controllers', 'MyNamespace/MyPlugin', 'Relations', 'Shim', 'IdeHelper']);
		$this->fetchTable('Cars');
		$this->fetchTable('Wheels');

		$this->task = new FormHelperTask();
	}

	/**
	 * @return void
	 */
	protected function tearDown(): void {
		parent::tearDown();

		unset($this->task);
	}

	/**
	 * @return void
	 */
	public function testCollect() {
		$result = $this->task->collect();

		$this->assertCount(1, $result);

		/** @var \IdeHelper\Generator\Directive\ExpectedArguments $directive */
		$directive = array_shift($result);
		$this->assertInstanceOf(ExpectedArguments::class, $directive);

		$list = $directive->toArray()['list'];
		$list = array_map(function ($className) {
			return (string)$className;
		}, $list);

		$expectedList = [
			'content' => "'content'",
			'created' => "'created'",
			'id' => "'id'",
			'modified' => "'modified'",
			'name' => "'name'",
			'params' => "'params'",
			'status' => "'status'",
			'user_id' => "'user_id'",
		];
		$this->assertSame($expectedList, $list);
	}

}


================================================
FILE: tests/TestCase/Generator/Task/HelperTaskTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Generator\Task;

use Cake\TestSuite\TestCase;
use IdeHelper\Generator\Task\HelperTask;

class HelperTaskTest extends TestCase {

	protected HelperTask $task;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->loadPlugins(['Shim']);
		$this->task = new HelperTask();
	}

	/**
	 * @return void
	 */
	public function testCollect() {
		$result = $this->task->collect();

		$this->assertCount(3, $result);

		/** @var \IdeHelper\Generator\Directive\Override $directive */
		$directive = array_shift($result);
		$this->assertSame('\Cake\View\View::loadHelper(0)', $directive->toArray()['method']);

		/** @var \IdeHelper\Generator\Directive\Override $directive */
		$directive = array_shift($result);
		$this->assertSame('\Cake\View\View::addHelper(0)', $directive->toArray()['method']);

		$map = $directive->toArray()['map'];

		$expected = '\Cake\View\Helper\FormHelper::class';
		$this->assertSame($expected, (string)$map['Form']);

		$expected = '\Shim\View\Helper\ConfigureHelper::class';
		$this->assertSame($expected, (string)$map['Shim.Configure']);

		/** @var \IdeHelper\Generator\Directive\ExpectedArguments $directive */
		$directive = array_shift($result);
		$this->assertSame('\Cake\View\ViewBuilder::addHelper()', $directive->toArray()['method']);

		$list = $directive->toArray()['list'];

		$expected = "'Form'";
		$this->assertSame($expected, (string)$list['Form']);

		$expected = "'Shim.Configure'";
		$this->assertSame($expected, (string)$list['Shim.Configure']);
	}

}


================================================
FILE: tests/TestCase/Generator/Task/LayoutTaskTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Generator\Task;

use Cake\TestSuite\TestCase;
use IdeHelper\Generator\Task\LayoutTask;
use Shim\TestSuite\TestTrait;

class LayoutTaskTest extends TestCase {

	use TestTrait;

	protected LayoutTask $task;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->task = new LayoutTask();
	}

	/**
	 * @return void
	 */
	public function testCollect() {
		$result = $this->task->collect();

		$this->assertCount(1, $result);

		/** @var \IdeHelper\Generator\Directive\Override $directive */
		$directive = array_shift($result);
		$this->assertSame('\Cake\View\ViewBuilder::setLayout()', $directive->toArray()['method']);

		$list = $directive->toArray()['list'];
		$list = array_map(function ($className) {
			return (string)$className;
		}, $list);

		$expectedMap = [
			'ajax' => '\'ajax\'',
		];
		$this->assertSame($expectedMap, $list);
	}

}


================================================
FILE: tests/TestCase/Generator/Task/MailerTaskTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Generator\Task;

use Cake\TestSuite\TestCase;
use IdeHelper\Generator\Task\MailerTask;

class MailerTaskTest extends TestCase {

	protected MailerTask $task;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->task = new MailerTask();
	}

	/**
	 * @return void
	 */
	public function testCollect() {
		$result = $this->task->collect();

		$this->assertCount(1, $result);

		/** @var \IdeHelper\Generator\Directive\Override $directive */
		$directive = array_shift($result);
		$this->assertSame('\Cake\Mailer\MailerAwareTrait::getMailer(0)', $directive->toArray()['method']);

		$map = $directive->toArray()['map'];

		$expected = '\TestApp\Mailer\UserMailer::class';
		$this->assertSame($expected, (string)$map['User']);
	}

}


================================================
FILE: tests/TestCase/Generator/Task/ModelTaskTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Generator\Task;

use Cake\TestSuite\TestCase;
use IdeHelper\Generator\Task\ModelTask;

class ModelTaskTest extends TestCase {

	protected ModelTask $task;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->loadPlugins(['Awesome', 'Controllers', 'MyNamespace/MyPlugin', 'Relations']);
		$this->task = new ModelTask();
	}

	/**
	 * @return void
	 */
	public function testCollect() {
		$result = $this->task->collect();

		$this->assertCount(3, $result);

		/** @var \IdeHelper\Generator\Directive\Override $directive */
		$directive = array_shift($result);
		$this->assertSame('\Cake\ORM\Locator\LocatorInterface::get(0)', $directive->toArray()['method']);

		$map = $directive->toArray()['map'];
		$map = array_map(function ($className) {
			return (string)$className;
		}, $map);

		$expectedMap = [
			'Awesome.Houses' => '\Awesome\Model\Table\HousesTable::class',
			'Awesome.Windows' => '\Awesome\Model\Table\WindowsTable::class',
			'BarBars' => '\TestApp\Model\Table\BarBarsTable::class',
			'BarBarsAbstract' => '\TestApp\Model\Table\BarBarsAbstractTable::class',
			'Callbacks' => '\TestApp\Model\Table\CallbacksTable::class',
			'Cars' => '\TestApp\Model\Table\CarsTable::class',
			'Controllers.Houses' => '\Controllers\Model\Table\HousesTable::class',
			'CustomFinder' => '\TestApp\Model\Table\CustomFinderTable::class',
			'Exceptions' => '\TestApp\Model\Table\ExceptionsTable::class',
			'Foos' => '\TestApp\Model\Table\FoosTable::class',
			'MyNamespace/MyPlugin.My' => '\MyNamespace\MyPlugin\Model\Table\MyTable::class',
			'Relations.Bars' => '\Relations\Model\Table\BarsTable::class',
			'Relations.Foos' => '\Relations\Model\Table\FoosTable::class',
			'Relations.Users' => '\Relations\Model\Table\UsersTable::class',
			'SkipMe' => '\TestApp\Model\Table\SkipMeTable::class',
			'SkipSome' => '\TestApp\Model\Table\SkipSomeTable::class',
			'Wheels' => '\TestApp\Model\Table\WheelsTable::class',
			'WheelsExtra' => '\TestApp\Model\Table\WheelsExtraTable::class',
		];
		$this->assertSame($expectedMap, $map);
	}

}


================================================
FILE: tests/TestCase/Generator/Task/PluginTaskTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Generator\Task;

use Cake\Core\Configure;
use Cake\TestSuite\TestCase;
use IdeHelper\Generator\Task\PluginTask;

class PluginTaskTest extends TestCase {

	protected PluginTask $task;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->loadPlugins(['Bake', 'Migrations', 'Shim']);
		$this->task = new PluginTask();
	}

	/**
	 * @return void
	 */
	public function testCollect() {
		$result = $this->task->collect();

		$this->assertCount(1, $result);

		/** @var \IdeHelper\Generator\Directive\Override $directive */
		$directive = array_shift($result);
		$this->assertSame('\Cake\Core\PluginApplicationInterface::addPlugin(0)', $directive->toArray()['method']);

		$map = $directive->toArray()['map'];
		$map = array_map(function ($className) {
			return (string)$className;
		}, $map);

		$expected = [
			'Bake' => '\Cake\Http\BaseApplication::class',
			'Cake/TwigView' => '\Cake\Http\BaseApplication::class',
			'Migrations' => '\Cake\Http\BaseApplication::class',
			'Shim' => '\Cake\Http\BaseApplication::class',
		];
		if (version_compare(Configure::version(), '5.1.0', '<')) {
			$expected = [];
		}
		$this->assertSame($expected, $map);
	}

}


================================================
FILE: tests/TestCase/Generator/Task/RequestTaskTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Generator\Task;

use IdeHelper\Generator\Task\RequestTask;
use Shim\TestSuite\TestCase;

class RequestTaskTest extends TestCase {

	protected ?RequestTask $task = null;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->task = new RequestTask();
	}

	/**
	 * @return void
	 */
	public function testCollect() {
		$result = $this->task->collect();

		$this->assertCount(2, $result);

		/** @var \IdeHelper\Generator\Directive\ExpectedArguments $directive */
		$directive = array_shift($result);
		$this->assertSame('\Cake\Http\ServerRequest::getParam()', $directive->toArray()['method']);

		$list = $directive->toArray()['list'];
		$list = array_map(function ($className) {
			return (string)$className;
		}, $list);

		$expected = [
			'_ext' => "'_ext'",
			'_matchedRoute' => "'_matchedRoute'",
			'action' => "'action'",
			'controller' => "'controller'",
			'pass' => "'pass'",
			'plugin' => "'plugin'",
			'prefix' => "'prefix'",
		];
		$this->assertSame($expected, $list);

		/** @var \IdeHelper\Generator\Directive\Override $directive */
		$directive = array_shift($result);
		$this->assertSame('\Cake\Http\ServerRequest::getAttribute(0)', $directive->toArray()['method']);

		$map = $directive->toArray()['map'];

		$expected = '\Cake\Http\Session::class';
		$this->assertSame($expected, (string)$map['session']);
	}

}


================================================
FILE: tests/TestCase/Generator/Task/RoutePathTaskTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Generator\Task;

use Cake\TestSuite\TestCase;
use IdeHelper\Generator\Task\RoutePathTask;

class RoutePathTaskTest extends TestCase {

	protected RoutePathTask $task;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->loadPlugins(['Awesome']);
		$this->task = new RoutePathTask();
	}

	/**
	 * @return void
	 */
	public function testCollect() {
		$result = $this->task->collect();

		$this->assertCount(5, $result);

		/** @var \IdeHelper\Generator\Directive\RegisterArgumentsSet $directive */
		$directive = array_shift($result);
		$this->assertSame(RoutePathTask::SET_ROUTE_PATHS, $directive->toArray()['set']);

		$list = $directive->toArray()['list'];
		$list = array_map(function ($value) {
			return (string)$value;
		}, $list);

		$expected = [
			'Awesome.Admin/AwesomeHouses::openDoor' => "'Awesome.Admin/AwesomeHouses::openDoor'",
			'Bar::index' => "'Bar::index'",
		];
		$this->assertSame($expected, $list);

		/** @var \IdeHelper\Generator\Directive\ExpectedArguments $directive */
		$directive = array_shift($result);
		$this->assertSame('\Cake\Routing\Router::pathUrl()', $directive->toArray()['method']);

		$list = $directive->toArray()['list'];
		$list = array_map(function ($value) {
			return (string)$value;
		}, $list);

		$expected = [
			'argumentsSet(\'routePaths\')',
		];
		$this->assertSame($expected, $list);

		/** @var \IdeHelper\Generator\Directive\ExpectedArguments $directive */
		$directive = array_shift($result);
		$this->assertSame('\Cake\View\Helper\UrlHelper::buildFromPath()', $directive->toArray()['method']);

		/** @var \IdeHelper\Generator\Directive\ExpectedArguments $directive */
		$directive = array_shift($result);
		$this->assertSame('\Cake\View\Helper\HtmlHelper::linkFromPath()', $directive->toArray()['method']);
	}

}


================================================
FILE: tests/TestCase/Generator/Task/TableAssociationTaskTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Generator\Task;

use Cake\TestSuite\TestCase;
use IdeHelper\Generator\Task\TableAssociationTask;

class TableAssociationTaskTest extends TestCase {

	protected TableAssociationTask $task;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->loadPlugins(['IdeHelper', 'Shim', 'Awesome', 'Controllers', 'Relations', 'MyNamespace/MyPlugin']);
		$this->task = new TableAssociationTask();
	}

	/**
	 * @return void
	 */
	public function testCollect() {
		$result = $this->task->collect();

		$this->assertCount(4, $result);

		/** @var \IdeHelper\Generator\Directive\Override $directive */
		$directive = array_shift($result);
		$this->assertSame('\Cake\ORM\Table::belongsTo(0)', $directive->toArray()['method']);

		$map = $directive->toArray()['map'];
		$map = array_map(function ($className) {
			return (string)$className;
		}, $map);

		$expectedMap = [
			'Awesome.Houses' => '\Cake\ORM\Association\BelongsTo::class',
			'Awesome.Windows' => '\Cake\ORM\Association\BelongsTo::class',
			'BarBars' => '\Cake\ORM\Association\BelongsTo::class',
			'BarBarsAbstract' => '\Cake\ORM\Association\BelongsTo::class',
			'Callbacks' => '\Cake\ORM\Association\BelongsTo::class',
			'Cars' => '\Cake\ORM\Association\BelongsTo::class',
			'Controllers.Houses' => '\Cake\ORM\Association\BelongsTo::class',
			'CustomFinder' => '\Cake\ORM\Association\BelongsTo::class',
			'Exceptions' => '\Cake\ORM\Association\BelongsTo::class',
			'Foos' => '\Cake\ORM\Association\BelongsTo::class',
			'MyNamespace/MyPlugin.My' => '\Cake\ORM\Association\BelongsTo::class',
			'Relations.Bars' => '\Cake\ORM\Association\BelongsTo::class',
			'Relations.Foos' => '\Cake\ORM\Association\BelongsTo::class',
			'Relations.Users' => '\Cake\ORM\Association\BelongsTo::class',
			'SkipMe' => '\Cake\ORM\Association\BelongsTo::class',
			'SkipSome' => '\Cake\ORM\Association\BelongsTo::class',
			'Wheels' => '\Cake\ORM\Association\BelongsTo::class',
			'WheelsExtra' => '\Cake\ORM\Association\BelongsTo::class',
		];
		$this->assertSame($expectedMap, $map);
	}

}


================================================
FILE: tests/TestCase/Generator/Task/TableFinderTaskTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Generator\Task;

use Cake\Core\Configure;
use Cake\TestSuite\TestCase;
use IdeHelper\Generator\Task\TableFinderTask;
use Shim\TestSuite\TestTrait;
use TestApp\Model\Table\CustomFinderTable;

class TableFinderTaskTest extends TestCase {

	use TestTrait;

	protected TableFinderTask $task;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		Configure::write('IdeHelper.preemptive', true);

		$this->task = new TableFinderTask();
	}

	/**
	 * @return void
	 */
	protected function tearDown(): void {
		Configure::delete('IdeHelper');

		parent::tearDown();
	}

	/**
	 * @return void
	 */
	public function testCollect() {
		$result = $this->task->collect();

		$this->assertCount(3, $result);

		/** @var \IdeHelper\Generator\Directive\Override $directive */
		$directive = array_shift($result);
		$this->assertSame('\Cake\ORM\Table::find(0)', $directive->toArray()['method']);

		$map = $directive->toArray()['map'];
		$map = array_map(function ($className) {
			return (string)$className;
		}, $map);

		$expectedMap = [
			'all' => '\Cake\ORM\Query\SelectQuery::class',
			'children' => '\Cake\ORM\Query\SelectQuery::class',
			'list' => '\Cake\ORM\Query\SelectQuery::class',
			'path' => '\Cake\ORM\Query\SelectQuery::class',
			'somethingCustom' => '\Cake\ORM\Query\SelectQuery::class',
			'threaded' => '\Cake\ORM\Query\SelectQuery::class',
			'treeList' => '\Cake\ORM\Query\SelectQuery::class',
		];
		$this->assertSame($expectedMap, $map);
	}

	/**
	 * @return void
	 */
	public function testAddMethod() {
		$result = [];

		$class = CustomFinderTable::class;
		$method = 'findSomethingCustom';

		/** @uses \IdeHelper\Generator\Task\TableFinderTask::addMethod() */
		$result = $this->invokeMethod($this->task, 'addMethod', [$result, $method, $class]);
		$this->assertSame(['somethingCustom'], $result);
	}

	/**
	 * @return void
	 */
	public function testAddMethodInvalid() {
		$result = [];

		$class = CustomFinderTable::class;

		$method = 'findBySomethingCustom';
		/** @uses \IdeHelper\Generator\Task\TableFinderTask::addMethod() */
		$result = $this->invokeMethod($this->task, 'addMethod', [$result, $method, $class]);
		$this->assertSame([], $result);

		$method = 'findSomethingCustomBySomethingElse';
		/** @uses \IdeHelper\Generator\Task\TableFinderTask::addMethod() */
		$result = $this->invokeMethod($this->task, 'addMethod', [$result, $method, $class]);
		$this->assertSame([], $result);
	}

}


================================================
FILE: tests/TestCase/Generator/Task/TranslationKeyTaskTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Generator\Task;

use Cake\Core\Configure;
use IdeHelper\Generator\Task\TranslationKeyTask;
use Shim\TestSuite\TestCase;

class TranslationKeyTaskTest extends TestCase {

	protected ?TranslationKeyTask $task = null;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->task = new TranslationKeyTask();

		$this->loadPlugins(['Awesome', 'Controllers', 'MyNamespace/MyPlugin', 'Relations', 'Shim', 'IdeHelper']);
		Configure::write('App.paths.locales', [
			APP_ROOT . DS . 'locales' . DS,
		]);
	}

	/**
	 * @return void
	 */
	public function testCollect() {
		$result = $this->task->collect();

		$this->assertCount(3, $result);

		/** @var \IdeHelper\Generator\Directive\ExpectedArguments $directive */
		$directive = array_shift($result);
		$this->assertSame('\__()', $directive->toArray()['method']);

		$list = $directive->toArray()['list'];
		$list = array_map(function ($className) {
			return (string)$className;
		}, $list);

		$expected = [
			'A {0} placeholder' => "'A {0} placeholder'",
			'Some \\\' special case' => '\'Some \\\' special case\'',
			'my foo and bar' => "'my foo and bar'",
		];
		$this->assertSame($expected, $list);

		/** @var \IdeHelper\Generator\Directive\ExpectedArguments $directive */
		$directive = array_shift($result);
		$this->assertSame('\__d()', $directive->toArray()['method']);

		$list = $directive->toArray()['list'];
		$list = array_map(function ($className) {
			return (string)$className;
		}, $list);

		$expected = [
			'A plugin translation' => '\'A plugin translation\'',
		];
		$this->assertSame($expected, $list);

		/** @var \IdeHelper\Generator\Directive\ExpectedArguments $directive */
		$directive = array_shift($result);
		$this->assertSame('\__d()', $directive->toArray()['method']);

		$list = $directive->toArray()['list'];
		$list = array_map(function ($className) {
			return (string)$className;
		}, $list);

		// 'my_plugin' is now superseded by 'my_namespace/my_plugin'
		$expected = [
			'awesome' => '\'awesome\'',
			'cake' => '\'cake\'',
			'controllers' => '\'controllers\'',
			'ide_helper' => '\'ide_helper\'',
			'my_namespace/my_plugin' => '\'my_namespace/my_plugin\'',
			'relations' => '\'relations\'',
			'shim' => '\'shim\'',
		];
		if (version_compare(Configure::version(), '5.1.0', '<')) {
			$expected = [
				'awesome' => '\'awesome\'',
				'bake' => '\'bake\'',
				'cake' => '\'cake\'',
				'cake/twig_view' => '\'cake/twig_view\'',
				'controllers' => '\'controllers\'',
				'ide_helper' => '\'ide_helper\'',
				'migrations' => '\'migrations\'',
				'my_namespace/my_plugin' => '\'my_namespace/my_plugin\'',
				'relations' => '\'relations\'',
				'shim' => '\'shim\'',
			];
		}

		$this->assertSame($expected, $list);
	}

}


================================================
FILE: tests/TestCase/Generator/Task/ValidationTaskTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Generator\Task;

use IdeHelper\Generator\Directive\RegisterArgumentsSet;
use IdeHelper\Generator\Task\ValidationTask;
use Shim\TestSuite\TestCase;

class ValidationTaskTest extends TestCase {

	protected ?ValidationTask $task = null;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->task = new ValidationTask();
	}

	/**
	 * @return void
	 */
	public function testCollect() {
		$result = $this->task->collect();

		$this->assertCount(15, $result);

		/** @var \IdeHelper\Generator\Directive\RegisterArgumentsSet $directive */
		$directive = array_shift($result);
		$this->assertInstanceOf(RegisterArgumentsSet::class, $directive);
		$this->assertSame(ValidationTask::SET_VALIDATION_WHEN, $directive->toArray()['set']);

		$list = $directive->toArray()['list'];
		$list = array_map(function ($className) {
			return (string)$className;
		}, $list);

		$expected = [
			"'create'",
			"'update'",
		];
		$this->assertSame($expected, $list);

		/** @var \IdeHelper\Generator\Directive\Override $directive */
		$directive = array_shift($result);
		$this->assertSame('\Cake\Validation\Validator::requirePresence()', $directive->toArray()['method']);

		$list = $directive->toArray()['list'];
		$list = array_map(function ($className) {
			return (string)$className;
		}, $list);

		$expected = [
			'argumentsSet(\'validationWhen\')',
		];
		$this->assertSame($expected, $list);
	}

}


================================================
FILE: tests/TestCase/Generator/TaskCollectionTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Generator;

use Cake\TestSuite\TestCase;
use IdeHelper\Generator\TaskCollection;

class TaskCollectionTest extends TestCase {

	protected TaskCollection $taskCollection;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->taskCollection = new TaskCollection();
	}

	/**
	 * @return void
	 */
	public function testTasks() {
		$result = $this->taskCollection->tasks();

		$this->assertNotEmpty($result);
	}

}


================================================
FILE: tests/TestCase/Illuminator/IlluminatorTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Illuminator;

use Cake\Console\ConsoleIo;
use Cake\TestSuite\TestCase;
use IdeHelper\Console\Io;
use IdeHelper\Illuminator\Illuminator;
use IdeHelper\Illuminator\TaskCollection;
use Shim\TestSuite\ConsoleOutput;

class IlluminatorTest extends TestCase {

	protected ConsoleOutput $out;

	protected ConsoleOutput $err;

	protected Io $io;

	protected Illuminator $illuminator;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->out = new ConsoleOutput();
		$this->err = new ConsoleOutput();
		$consoleIo = new ConsoleIo($this->out, $this->err);
		$consoleIo->level($consoleIo::VERBOSE);
		$this->io = new Io($consoleIo);

		$taskCollection = new TaskCollection($this->io, ['dry-run' => true]);

		$this->illuminator = new Illuminator($taskCollection);
	}

	/**
	 * @return void
	 */
	public function testIlluminate() {
		$path = TEST_FILES;
		$count = $this->illuminator->illuminate($path, null);

		$this->assertSame(14, $count);

		$out = $this->out->output();

		$this->assertTextContains('public const FIELD_ID = \'id\';', $out);
	}

}


================================================
FILE: tests/TestCase/Illuminator/Task/ControllerDefaultTableTaskTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Illuminator\Task;

use Cake\Console\ConsoleIo;
use Cake\TestSuite\TestCase;
use IdeHelper\Annotator\AbstractAnnotator;
use IdeHelper\Console\Io;
use IdeHelper\Illuminator\Task\ControllerDefaultTableTask;
use Shim\TestSuite\ConsoleOutput;

class ControllerDefaultTableTaskTest extends TestCase {

	protected ConsoleOutput $out;

	protected ConsoleOutput $err;

	protected Io $io;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->out = new ConsoleOutput();
		$this->err = new ConsoleOutput();
		$consoleIo = new ConsoleIo($this->out, $this->err);
		$this->io = new Io($consoleIo);
	}

	/**
	 * @return void
	 */
	public function testShouldRun() {
		$task = $this->_getTask();

		$result = $task->shouldRun('src/Controller/NoTableController.php');
		$this->assertTrue($result);

		$result = $task->shouldRun('src/Controller/AppController.php');
		$this->assertFalse($result);

		$result = $task->shouldRun('src/Model/Table/Wheels.php');
		$this->assertFalse($result);
	}

	/**
	 * @return void
	 */
	public function testShouldRunWithDifferentPathSeparators() {
		$task = $this->_getTask();

		// Forward slashes
		$result = $task->shouldRun('src/Controller/TestController.php');
		$this->assertTrue($result);

		// Backslashes (Windows-style)
		$result = $task->shouldRun('src\\Controller\\TestController.php');
		$this->assertTrue($result);

		// Should fail without Controller in path
		$result = $task->shouldRun('src/TestController.php');
		$this->assertFalse($result);
	}

	/**
	 * @return void
	 */
	public function testRunWithExistingTable() {
		$task = $this->_getTask();

		$path = APP . 'Controller/FoosController.php';
		$this->assertFileExists($path);

		$content = file_get_contents($path);
		$result = $task->run($content, $path);

		// Should not add defaultTable if table exists
		$this->assertSame($content, $result);
	}

	/**
	 * @return void
	 */
	public function testRunWithoutTable() {
		$task = $this->_getTask();

		$content = <<<'PHP'
<?php
namespace App\Controller;

use Cake\Controller\Controller;

class NoTableController extends Controller {
}

PHP;

		$expected = <<<'PHP'
<?php
namespace App\Controller;

use Cake\Controller\Controller;

class NoTableController extends Controller {

	protected ?string $defaultTable = '';
}

PHP;

		$path = 'src/Controller/NoTableController.php';
		$result = $task->run($content, $path);

		$this->assertTextEquals($expected, $result);
		$this->assertStringContainsString("protected ?string \$defaultTable = '';", $result);
	}

	/**
	 * @return void
	 */
	public function testRunWithExistingProperty() {
		$task = $this->_getTask();

		$content = <<<'PHP'
<?php
namespace App\Controller;

use Cake\Controller\Controller;

class CustomController extends Controller {

	protected ?string $defaultTable = 'CustomTable';

}

PHP;

		$path = 'src/Controller/CustomController.php';
		$result = $task->run($content, $path);

		// Should not add if property already exists
		$this->assertSame($content, $result);
	}

	/**
	 * @return void
	 */
	public function testRunWithOtherProperties() {
		$task = $this->_getTask();

		$content = <<<'PHP'
<?php
namespace App\Controller;

use Cake\Controller\Controller;

class PropertiesController extends Controller {

	protected string $myProperty = 'test';

	public function index() {
	}
}

PHP;

		$expected = <<<'PHP'
<?php
namespace App\Controller;

use Cake\Controller\Controller;

class PropertiesController extends Controller {

	protected ?string $defaultTable = '';

	protected string $myProperty = 'test';

	public function index() {
	}
}

PHP;

		$path = 'src/Controller/PropertiesController.php';
		$result = $task->run($content, $path);

		$this->assertTextEquals($expected, $result);
		$this->assertStringContainsString("protected ?string \$defaultTable = '';", $result);
	}

	/**
	 * @return void
	 */
	public function testRunWithPluginController() {
		$task = $this->_getTask();

		$content = <<<'PHP'
<?php
namespace MyPlugin\Controller;

use Cake\Controller\Controller;

class CustomController extends Controller {
}

PHP;

		$expected = <<<'PHP'
<?php
namespace MyPlugin\Controller;

use Cake\Controller\Controller;

class CustomController extends Controller {

	protected ?string $defaultTable = '';
}

PHP;

		$path = 'plugins/MyPlugin/src/Controller/CustomController.php';
		$result = $task->run($content, $path);

		$this->assertTextEquals($expected, $result);
	}

	/**
	 * @return void
	 */
	public function testRunWithNestedPluginNamespace() {
		$task = $this->_getTask();

		$content = <<<'PHP'
<?php
namespace Vendor\MyPlugin\Controller;

use Cake\Controller\Controller;

class CustomController extends Controller {
}

PHP;

		$expected = <<<'PHP'
<?php
namespace Vendor\MyPlugin\Controller;

use Cake\Controller\Controller;

class CustomController extends Controller {

	protected ?string $defaultTable = '';
}

PHP;

		$path = 'plugins/Vendor/MyPlugin/src/Controller/CustomController.php';
		$result = $task->run($content, $path);

		$this->assertTextEquals($expected, $result);
	}

	/**
	 * @return void
	 */
	public function testRunWithFastPropertyCheck() {
		$task = $this->_getTask([
			'fastPropertyCheck' => true,
		]);

		$content = <<<'PHP'
<?php
namespace App\Controller;

use Cake\Controller\Controller;

class ExistingController extends Controller {

	protected ?string $defaultTable = '';
}

PHP;

		$path = 'src/Controller/ExistingController.php';
		$result = $task->run($content, $path);

		// Should not add if property already exists (using fast regex check)
		$this->assertSame($content, $result);
	}

	/**
	 * @return void
	 */
	public function testRunWithPropertyInCommentDefaultCheck() {
		$task = $this->_getTask();

		$content = <<<'PHP'
<?php
namespace App\Controller;

use Cake\Controller\Controller;

/**
 * Controller with defaultTable in comment
 * protected ?string $defaultTable = '';
 */
class CommentController extends Controller {
}

PHP;

		$expected = <<<'PHP'
<?php
namespace App\Controller;

use Cake\Controller\Controller;

/**
 * Controller with defaultTable in comment
 * protected ?string $defaultTable = '';
 */
class CommentController extends Controller {

	protected ?string $defaultTable = '';
}

PHP;

		$path = 'src/Controller/CommentController.php';
		$result = $task->run($content, $path);

		// Token-based check correctly identifies no actual property exists
		$this->assertTextEquals($expected, $result);
	}

	/**
	 * @return void
	 */
	public function testRunWithPropertyInCommentFastCheck() {
		$task = $this->_getTask([
			'fastPropertyCheck' => true,
		]);

		$content = <<<'PHP'
<?php
namespace App\Controller;

use Cake\Controller\Controller;

/**
 * Controller with defaultTable in comment
 * protected ?string $defaultTable = '';
 */
class CommentController extends Controller {
}

PHP;

		$path = 'src/Controller/CommentController.php';
		$result = $task->run($content, $path);

		// Fast regex check has false-positive on comment (acceptable trade-off for speed)
		// If you need 100% accuracy, don't enable fastPropertyCheck
		$this->assertSame($content, $result);
	}

	/**
	 * @param array $params
	 * @return \IdeHelper\Illuminator\Task\ControllerDefaultTableTask
	 */
	protected function _getTask(array $params = []) {
		$params += [
			AbstractAnnotator::CONFIG_DRY_RUN => true,
			AbstractAnnotator::CONFIG_VERBOSE => true,
		];

		return new ControllerDefaultTableTask($params);
	}

}


================================================
FILE: tests/TestCase/Illuminator/Task/EntityFieldTaskTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Illuminator\Task;

use Cake\Console\ConsoleIo;
use Cake\TestSuite\TestCase;
use IdeHelper\Annotator\AbstractAnnotator;
use IdeHelper\Console\Io;
use IdeHelper\Illuminator\Task\EntityFieldTask;
use Shim\TestSuite\ConsoleOutput;

class EntityFieldTaskTest extends TestCase {

	protected ConsoleOutput $out;

	protected ConsoleOutput $err;

	protected Io $io;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->out = new ConsoleOutput();
		$this->err = new ConsoleOutput();
		$consoleIo = new ConsoleIo($this->out, $this->err);
		$this->io = new Io($consoleIo);
	}

	/**
	 * @return void
	 */
	public function testShouldRun() {
		$task = $this->_getTask();

		$result = $task->shouldRun('src/Model/Entity/Wheel.php');
		$this->assertTrue($result);

		$result = $task->shouldRun('src/Model/Table/Wheels.php');
		$this->assertFalse($result);
	}

	/**
	 * @return void
	 */
	public function testIlluminate() {
		$task = $this->_getTask([
			'visibility' => false,
		]);

		$path = APP . 'Model/Entity/Complex/Wheel.php';
		$result = $task->run(file_get_contents($path), $path);

		$this->assertTextContains('const FIELD_ID = \'id\';', $result);

		$result = str_replace('    ', "\t", $result);
		$expected = file_get_contents(TEST_FILES . 'Model/Entity/Constants/Wheel.php');
		$this->assertTextEquals($expected, $result);
	}

	/**
	 * @return void
	 */
	public function testIlluminateComplex() {
		$task = $this->_getTask([
			'visibility' => false,
		]);

		$path = APP . 'Model/Entity/Complex/Wheel.php';
		$this->assertFileExists($path);
		$result = $task->run(file_get_contents($path), $path);

		$result = str_replace('    ', "\t", $result);
		$expected = file_get_contents(TEST_FILES . 'Model/Entity/Constants/Wheel.php');
		$this->assertTextEquals($expected, $result);
	}

	/**
	 * @return void
	 */
	public function testIlluminateComplex2() {
		$task = $this->_getTask([
			'visibility' => false,
		]);

		$path = APP . 'Model/Entity/Complex2/Wheel.php';
		$this->assertFileExists($path);
		$result = $task->run(file_get_contents($path), $path);

		$result = str_replace('    ', "\t", $result);
		$expected = file_get_contents(TEST_FILES . 'Model/Entity/Constants/WheelComplex.php');
		$this->assertTextEquals($expected, $result);
	}

	/**
	 * @return void
	 */
	public function testIlluminateExisting() {
		$task = $this->_getTask([
			'visibility' => false,
		]);

		$path = TEST_FILES . 'Model/Entity/Constants/Wheel.php';
		$result = $task->run(file_get_contents($path), $path);

		$result = str_replace('    ', "\t", $result);
		$expected = file_get_contents(TEST_FILES . 'Model/Entity/Constants/Wheel.php');
		$this->assertTextEquals($expected, $result);
	}

	/**
	 * @return void
	 */
	public function testIlluminateExistingPartial() {
		$task = $this->_getTask([
			'visibility' => false,
		]);

		$path = TEST_FILES . 'Model/Entity/ConstantsPartial/Wheel.php';
		$result = $task->run(file_get_contents($path), $path);

		$result = str_replace('    ', "\t", $result);
		$expected = file_get_contents(TEST_FILES . 'Model/Entity/ConstantsPartialResult/Wheel.php');
		$this->assertTextEquals($expected, $result);
	}

	/**
	 * @return void
	 */
	public function testIlluminateVisibility() {
		$task = $this->_getTask([
			'visibility' => true,
		]);

		$path = TEST_FILES . 'Model/Entity/Wheel.php';
		$result = $task->run(file_get_contents($path), $path);

		$this->assertTextContains('public const FIELD_ID = \'id\';', $result);
	}

	/**
	 * @param array $params
	 * @return \IdeHelper\Illuminator\Task\EntityFieldTask
	 */
	protected function _getTask(array $params = []) {
		$params += [
			AbstractAnnotator::CONFIG_DRY_RUN => true,
			AbstractAnnotator::CONFIG_VERBOSE => true,
		];

		return new EntityFieldTask($params);
	}

}


================================================
FILE: tests/TestCase/Illuminator/Task/TableValidationLinkTaskTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Illuminator\Task;

use Cake\TestSuite\TestCase;
use IdeHelper\Annotator\AbstractAnnotator;
use IdeHelper\Illuminator\Task\TableValidationLinkTask;

class TableValidationLinkTaskTest extends TestCase {

	/**
	 * @return void
	 */
	public function testShouldRun(): void {
		$task = $this->getTask();

		$result = $task->shouldRun('src/Model/Table/WheelsTable.php');
		$this->assertTrue($result);

		$result = $task->shouldRun('src/Model/Table/Table.php');
		$this->assertFalse($result);

		$result = $task->shouldRun('src/Model/Entity/Wheel.php');
		$this->assertFalse($result);
	}

	/**
	 * @return void
	 */
	public function testRun(): void {
		$task = $this->getTask();

		$path = TEST_FILES . 'Model/Table/Validation/IpRulesTable.php';
		$content = file_get_contents($path);
		$this->assertIsString($content);

		$result = $task->run($content, $path);

		$this->assertStringContainsString('/** @link verifyIpRanges() */', $result);
		$this->assertStringContainsString('/** @link verifyDenyRanges() */', $result);

		$result = str_replace('    ', "\t", $result);
		$expected = file_get_contents(TEST_FILES . 'Model/Table/ValidationResult/IpRulesTable.php');
		$this->assertIsString($expected);
		$this->assertTextEquals($expected, $result);
	}

	/**
	 * @return void
	 */
	public function testRunNoChanges(): void {
		$task = $this->getTask();

		// Test with already annotated file
		$path = TEST_FILES . 'Model/Table/ValidationResult/IpRulesTable.php';
		$content = file_get_contents($path);
		$this->assertIsString($content);

		$result = $task->run($content, $path);

		// Should not add duplicate annotations
		$this->assertEquals($content, $result);
	}

	/**
	 * @return void
	 */
	public function testRunNoTableProvider(): void {
		$task = $this->getTask();

		$content = <<<'PHP'
<?php
class FooTable {
	public function validationDefault($validator) {
		$validator->add('email', 'valid', [
			'rule' => 'email',
		]);
		return $validator;
	}
}
PHP;

		$result = $task->run($content, 'src/Model/Table/FooTable.php');

		// No @link should be added (no table provider)
		$this->assertStringNotContainsString('@link', $result);
		$this->assertEquals($content, $result);
	}

	/**
	 * @param array<string, mixed> $params
	 * @return \IdeHelper\Illuminator\Task\TableValidationLinkTask
	 */
	protected function getTask(array $params = []): TableValidationLinkTask {
		$params += [
			AbstractAnnotator::CONFIG_DRY_RUN => true,
			AbstractAnnotator::CONFIG_VERBOSE => true,
		];

		return new TableValidationLinkTask($params);
	}

}


================================================
FILE: tests/TestCase/Utility/AppPathTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Utility;

use Cake\TestSuite\TestCase;
use IdeHelper\Utility\AppPath;

class AppPathTest extends TestCase {

	/**
	 * @return void
	 */
	public function testGet() {
		$result = AppPath::get('View/Helper');
		$this->assertCount(1, $result);

		$path = array_shift($result);
		$this->assertTextContains('/tests/test_app/src/View/Helper/', $path);
	}

}


================================================
FILE: tests/TestCase/Utility/AppTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Utility;

use Cake\TestSuite\TestCase;
use IdeHelper\Utility\App;
use IdeHelper\View\Helper\DocBlockHelper;

class AppTest extends TestCase {

	/**
	 * @return void
	 */
	public function testClassName() {
		$result = App::className('Foos', 'Bar', 'Baz');
		$this->assertNull($result);

		$result = App::className('IdeHelper.DocBlock', 'View/Helper', 'Helper');
		$this->assertSame(DocBlockHelper::class, $result);
	}

}


================================================
FILE: tests/TestCase/Utility/GenericStringTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Utility;

use Cake\Core\Configure;
use Cake\TestSuite\TestCase;
use IdeHelper\Utility\GenericString;

class GenericStringTest extends TestCase {

	/**
	 * @return void
	 */
	public function testClassName() {
		$result = GenericString::generate('Foo');
		$this->assertSame('Foo[]', $result);

		Configure::write('IdeHelper.arrayAsGenerics', true);

		$result = GenericString::generate('Foo');

		Configure::delete('IdeHelper.arrayAsGenerics');

		$this->assertSame('array<Foo>', $result);
	}

	/**
	 * @return void
	 */
	public function testClassNameObject() {
		$result = GenericString::generate('\Foo', '\Bar');
		$this->assertSame('\Foo[]|\Bar', $result);

		Configure::write('IdeHelper.objectAsGenerics', true);

		$result = GenericString::generate('\Foo', '\Bar');

		Configure::delete('IdeHelper.objectAsGenerics');

		$this->assertSame('\Bar<\Foo>', $result);
	}

}


================================================
FILE: tests/TestCase/Utility/PluginPathTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Utility;

use Cake\Core\Plugin;
use Cake\TestSuite\TestCase;
use IdeHelper\Utility\PluginPath;

class PluginPathTest extends TestCase {

	/**
	 * @return void
	 */
	public function testGet() {
		$plugin = 'Shim';
		$result = PluginPath::get($plugin);
		$this->assertTextContains('cakephp-ide-helper/vendor/dereuromark/cakephp-shim/', $result);

		Plugin::getCollection()->remove('Awesome');

		$plugin = 'Awesome';
		$result = PluginPath::get($plugin);
		$this->assertTextContains('cakephp-ide-helper/tests/test_app/plugins/Awesome/', $result);
	}

}


================================================
FILE: tests/TestCase/Utility/PluginTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Utility;

use Cake\Core\Configure;
use Cake\TestSuite\TestCase;
use IdeHelper\Utility\Plugin;

class PluginTest extends TestCase {

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->loadPlugins(['IdeHelper', 'Awesome', 'MyNamespace/MyPlugin']);
		Configure::delete('IdeHelper.plugins');
	}

	/**
	 * @return void
	 */
	protected function tearDown(): void {
		parent::tearDown();

		Configure::delete('IdeHelper.plugins');
	}

	/**
	 * @return void
	 */
	public function testAll() {
		$result = Plugin::all();
		$this->assertArrayHasKey('IdeHelper', $result);
		$this->assertArrayHasKey('Awesome', $result);
		$this->assertArrayHasKey('MyNamespace/MyPlugin', $result);
		$this->assertArrayNotHasKey('FooBar', $result);

		Configure::write('IdeHelper.plugins', ['FooBar', '-MyNamespace/MyPlugin']);

		$result = Plugin::all();
		$this->assertArrayHasKey('FooBar', $result);
		$this->assertArrayNotHasKey('MyNamespace/MyPlugin', $result);
	}

}


================================================
FILE: tests/TestCase/Utility/TranslationParserTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\Utility;

use Cake\TestSuite\TestCase;
use IdeHelper\Utility\TranslationParser;

class TranslationParserTest extends TestCase {

	protected TranslationParser $translationParser;

	/**
	 * @return void
	 */
	protected function setUp(): void {
		parent::setUp();

		$this->translationParser = new TranslationParser();
	}

	/**
	 * @return void
	 */
	public function testParse() {
		$path = TEST_FILES . 'locales' . DS . 'default.po';

		$result = $this->translationParser->parse($path);

		$expected = [
			'A "quoted" string' => 'A "quoted" string',
			'A ""escape-quoted"" string' => 'A ""escape-quoted"" string',
			'A \\\'literally quoted\\\' string' => 'A \\\'literally quoted\\\' string',
			'A variable \\\'\\\'{0}\\\'\\\' be replaced.' => 'A variable \\\'\\\'{0}\\\'\\\' be replaced.',
		];
		$this->assertSame($expected, $result);
	}

}


================================================
FILE: tests/TestCase/ValueObject/ClassNameTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\ValueObject;

use Cake\TestSuite\TestCase;
use IdeHelper\ValueObject\ClassName;

class ClassNameTest extends TestCase {

	/**
	 * @return void
	 */
	public function testCreate(): void {
		$className = 'Foo\\Bar\\Baz';
		$result = ClassName::create($className);
		$this->assertSame($className, $result->raw());

		$result = ClassName::create('\\' . $className);
		$this->assertSame($className, $result->raw());
	}

	/**
	 * @return void
	 */
	public function testToString(): void {
		$className = 'Foo\\Bar\\Baz';
		$object = ClassName::create($className);

		$result = (string)$object;
		$this->assertSame('\\' . $className . '::class', $result);
	}

}


================================================
FILE: tests/TestCase/ValueObject/DoubleQuoteStringNameTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\ValueObject;

use Cake\TestSuite\TestCase;
use TestApp\ValueObject\DoubleQuoteStringName;

class DoubleQuoteStringNameTest extends TestCase {

	/**
	 * @return void
	 */
	public function testCreate(): void {
		$stringName = 'Foo.Baz';
		$result = DoubleQuoteStringName::create($stringName);
		$this->assertSame($stringName, $result->raw());
	}

	/**
	 * @return void
	 */
	public function testToString(): void {
		$stringName = 'Foo.Baz';
		$object = DoubleQuoteStringName::create($stringName);

		$result = (string)$object;
		$this->assertSame('"' . $stringName . '"', $result);
	}

}


================================================
FILE: tests/TestCase/ValueObject/KeyValueTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\ValueObject;

use Cake\TestSuite\TestCase;
use IdeHelper\ValueObject\ClassName;
use IdeHelper\ValueObject\KeyValue;

class KeyValueTest extends TestCase {

	/**
	 * @return void
	 */
	public function testCreate(): void {
		$key = ClassName::create(KeyValue::class);

		$value = ClassName::create(KeyValue::class);
		$result = KeyValue::create($key, $value);

		$this->assertSame($key, $result->key());
		$this->assertSame($value, $result->value());
	}

}


================================================
FILE: tests/TestCase/ValueObject/LiteralNameTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\ValueObject;

use Cake\TestSuite\TestCase;
use IdeHelper\ValueObject\LiteralName;

class LiteralNameTest extends TestCase {

	/**
	 * @return void
	 */
	public function testCreate(): void {
		$stringName = 'Foo.Baz';
		$result = LiteralName::create($stringName);
		$this->assertSame($stringName, $result->raw());
	}

	/**
	 * @return void
	 */
	public function testToString(): void {
		$stringName = 'Foo.Baz';
		$object = LiteralName::create($stringName);

		$result = (string)$object;
		$this->assertSame($stringName, $result);
	}

}


================================================
FILE: tests/TestCase/ValueObject/StringNameTest.php
================================================
<?php

namespace IdeHelper\Test\TestCase\ValueObject;

use Cake\TestSuite\TestCase;
use IdeHelper\ValueObject\StringName;

class StringNameTest extends TestCase {

	/**
	 * @return void
	 */
	public function testCreate(): void {
		$stringName = 'Foo.Baz';
		$result = StringName::create($stringName);
		$this->assertSame($stringName, $result->raw());
	}

	/**
	 * @return void
	 */
	public function testToString(): void {
		$stringName = 'Foo.Baz';
		$object = StringName::create($stringName);

		$result = (string)$object;
		$this->assertSame('\'' . $stringName . '\'', $result);
	}

}


================================================
FILE: tests/TestCase/View/Helper/DocBlockHelperTest.php
================================================
<?php
declare(strict_types=1);

namespace IdeHelper\Test\TestCase\View\Helper;

use Bake\View\BakeView;
use Cake\Http\Response;
use Cake\Http\ServerRequest as Request;
use Cake\TestSuite\TestCase;
use IdeHelper\View\Helper\DocBlockHelper;
use PHPUnit\Framework\Attributes\CoversClass;

/**
 * DocBlockHelper Test
 */
#[CoversClass(DocBlockHelper::class)]
class DocBlockHelperTest extends TestCase {

	/**
	 * @var \IdeHelper\View\Helper\DocBlockHelper
	 */
	protected $DocBlockHelper;

	/**
	 * setUp method
	 *
	 * @return void
	 */
	public function setUp(): void {
		parent::setUp();

		$request = new Request();
		$response = new Response();
		$View = new BakeView($request, $response);
		$this->DocBlockHelper = new DocBlockHelper($View);
	}

	/**
	 * tearDown method
	 *
	 * @return void
	 */
	public function tearDown(): void {
		parent::tearDown();
		unset($this->DocBlockHelper);
	}

	/**
	 * Tests the classDescription method including annotation spacing
	 *
	 * @return void
	 */
	public function testBuildTableAnnotations(): void {
		$associations = [];
		$associationInfo = [
			'BelongsTo' => [
				'User' => [
					'className' => 'Users',
					'foreignKey' => 'user_id',
				],
			],
		];
		$behaviors = [];
		$entity = 'Foo';
		$namespace = 'Bar';

		$result = $this->DocBlockHelper->buildTableAnnotations($associations, $associationInfo, $behaviors, $entity, $namespace);

		$expected = [
			'@method \\Bar\\Model\\Entity\\Foo newEmptyEntity()',
			'@method \\Bar\\Model\\Entity\\Foo newEntity(array $data, array $options = [])',
			'@method \\Bar\\Model\\Entity\\Foo[] newEntities(array $data, array $options = [])',
			'@method \\Bar\\Model\\Entity\\Foo get(mixed $primaryKey, array|string $finder = \'all\', \\Psr\\SimpleCache\\CacheInterface|string|null $cache = null, \\Closure|string|null $cacheKey = null, mixed ...$args)',
			'@method \\Bar\\Model\\Entity\\Foo findOrCreate(\\Cake\\ORM\\Query\\SelectQuery|callable|array $search, ?callable $callback = null, array $options = [])',
			'@method \\Bar\\Model\\Entity\\Foo patchEntity(\\Cake\\Datasource\\EntityInterface $entity, array $data, array $options = [])',
			'@method \\Bar\\Model\\Entity\\Foo[] patchEntities(iterable $entities, array $data, array $options = [])',
			'@method \\Bar\\Model\\Entity\\Foo|false save(\\Cake\\Datasource\\EntityInterface $entity, array $options = [])',
			'@method \\Bar\\Model\\Entity\\Foo saveOrFail(\\Cake\\Datasource\\EntityInterface $entity, array $options = [])',
			'@method \\Bar\\Model\\Entity\\Foo[]|\\Cake\\Datasource\\ResultSetInterface<\\Bar\\Model\\Entity\\Foo>|false saveMany(iterable $entities, array $options = [])',
			'@method \\Bar\\Model\\Entity\\Foo[]|\\Cake\\Datasource\\ResultSetInterface<\\Bar\\Model\\Entity\\Foo> saveManyOrFail(iterable $entities, array $options = [])',
			'@method \\Bar\\Model\\Entity\\Foo[]|\\Cake\\Datasource\\ResultSetInterface<\\Bar\\Model\\Entity\\Foo>|false deleteMany(iterable $entities, array $options = [])',
			'@method \\Bar\\Model\\Entity\\Foo[]|\\Cake\\Datasource\\ResultSetInterface<\\Bar\\Model\\Entity\\Foo> deleteManyOrFail(iterable $entities, array $options = [])',
		];
		$this->assertEquals($expected, $result);
	}

}


================================================
FILE: tests/bootstrap.php
================================================
<?php

use Cake\Cache\Cache;
use Cake\Controller\Controller;
use Cake\Core\Configure;
use Cake\Database\TypeFactory;
use Cake\Datasource\ConnectionManager;
use Cake\TestSuite\Fixture\SchemaLoader;

if (!defined('DS')) {
	define('DS', DIRECTORY_SEPARATOR);
}

define('PLUGIN_ROOT', dirname(__DIR__));
define('APP_DIR', 'src');

// Point app constants to the test app.
define('APP_ROOT', PLUGIN_ROOT . DS . 'tests' . DS . 'test_app');
define('ROOT', APP_ROOT);
define('APP', APP_ROOT . DS . APP_DIR . DS);
define('PLUGINS', APP_ROOT . DS . 'plugins' . DS);
define('TEST_FILES', PLUGIN_ROOT . DS . 'tests' . DS . 'test_files' . DS);

define('TMP', PLUGIN_ROOT . DS . 'tmp' . DS);
if (!is_dir(TMP)) {
	mkdir(TMP, 0770, true);
}
define('CONFIG', PLUGIN_ROOT . DS . 'config' . DS);

define('LOGS', TMP . 'logs' . DS);
define('CACHE', TMP . 'cache' . DS);

define('CAKE_CORE_INCLUDE_PATH', PLUGIN_ROOT . '/vendor/cakephp/cakephp');
define('CORE_PATH', CAKE_CORE_INCLUDE_PATH . DS);
define('CAKE', CORE_PATH . APP_DIR . DS);

require dirname(__DIR__) . '/vendor/autoload.php';
require CORE_PATH . 'config/bootstrap.php';
require CAKE . 'functions.php';

Configure::write('App', [
	'namespace' => 'TestApp',
	'encoding' => 'utf-8',
	'paths' => [
		'templates' => [APP_ROOT . DS . 'templates' . DS],
	],
]);
Configure::write('debug', true);

$cache = [
	'default' => [
		'engine' => 'File',
	],
	'_cake_translations_' => [
		'className' => 'File',
		'prefix' => 'myapp_cake_translations_',
		'path' => CACHE . 'persistent/',
		'serialize' => true,
		'duration' => '+10 seconds',
	],
	'_cake_model_' => [
		'className' => 'File',
		'prefix' => 'myapp_cake_model_',
		'path' => CACHE . 'models/',
		'serialize' => 'File',
		'duration' => '+10 seconds',
	],
];

Cache::setConfig($cache);

TypeFactory::build('time');
TypeFactory::build('date');
TypeFactory::build('datetime');
TypeFactory::build('timestamp');

class_alias(Controller::class, 'App\Controller\AppController');

// Ensure default test connection is defined
if (!getenv('DB_URL')) {
	putenv('DB_URL=sqlite:///:memory:');
}

ConnectionManager::setConfig('test', [
	'url' => getenv('DB_URL'),
	'timezone' => 'UTC',
	'quoteIdentifiers' => true,
	'cacheMetadata' => true,
]);

if (env('FIXTURE_SCHEMA_METADATA')) {
	$loader = new SchemaLoader();
	$loader->loadInternalFile(env('FIXTURE_SCHEMA_METADATA'));
}


================================================
FILE: tests/phpstan.neon
================================================
parameters:
	level: 6
	paths:
		- TestCase/
	bootstrapFiles:
		- bootstrap.php
		- shim.php
	earlyTerminatingMethodCalls:
		Cake\Console\BaseCommand:
			- abort
	ignoreErrors:
		- identifier: missingType.iterableValue


================================================
FILE: tests/schema.php
================================================
<?php

use Cake\Utility\Inflector;

$tables = [];

/**
 * @var \DirectoryIterator<\DirectoryIterator> $iterator
 */
$iterator = new DirectoryIterator(__DIR__ . DS . 'Fixture');
foreach ($iterator as $file) {
	if (!preg_match('/(\w+)Fixture.php$/', (string)$file, $matches)) {
		continue;
	}

	$name = $matches[1];
	$tableName = Inflector::underscore($name);
	$class = 'IdeHelper\\Test\\Fixture\\' . $name . 'Fixture';
	try {
		$object = (new ReflectionClass($class))->getProperty('fields');
	} catch (ReflectionException $e) {
		continue;
	}

	$array = $object->getDefaultValue();
	$constraints = $array['_constraints'] ?? [];
	$indexes = $array['_indexes'] ?? [];
	unset($array['_constraints'], $array['_indexes'], $array['_options']);
	$table = [
		'table' => $tableName,
		'columns' => $array,
		'constraints' => $constraints,
		'indexes' => $indexes,
	];
	$tables[$tableName] = $table;
}

return $tables;


================================================
FILE: tests/shim.php
================================================
<?php

use PHP_CodeSniffer\Config;
use PHPUnit\Framework\TestCase;

$manualAutoload = getcwd() . '/vendor/squizlabs/php_codesniffer/autoload.php';
if (!class_exists(Config::class) && file_exists($manualAutoload)) {
	require $manualAutoload;
}

error_reporting(E_ALL & ~E_USER_DEPRECATED);

if (!defined('T_NULLABLE')) {
	define('T_NULLABLE', 'PHPCS_T_NULLABLE');
}
if (!defined('T_DOC_COMMENT_TAG')) {
	define('T_DOC_COMMENT_TAG', 'PHPCS_T_DOC_COMMENT_TAG');
}
if (!defined('T_SEMICOLON')) {
	define('T_SEMICOLON', 'PHPCS_T_SEMICOLON');
}

if (!class_exists(TestCase::class)) {
	require 'TestCase.php';
}


================================================
FILE: tests/test_app/locales/de/default.po
================================================

msgid "my foo and bar"
msgstr "mein foo und bar"

msgid "A {0} placeholder"
msgstr "Ein {0} Platzhalter"


================================================
FILE: tests/test_app/locales/de/my_plugin.po
================================================

msgid "A plugin translation"
msgstr "Eine Plugin Übersetzung"


================================================
FILE: tests/test_app/locales/en/default.po
================================================

msgid "my foo and bar"
msgstr ""

msgid "Some ' special case"
msgstr "Ein ' besonderer Fall"


================================================
FILE: tests/test_app/plugins/Awesome/src/AwesomePlugin.php
================================================
<?php
namespace Awesome;

use Cake\Core\BasePlugin;

class AwesomePlugin extends BasePlugin {
}


================================================
FILE: tests/test_app/plugins/Awesome/src/Controller/Admin/AwesomeHousesController.php
================================================
<?php
namespace Awesome\Controller\Admin;

use Cake\Controller\Controller;

class AwesomeHousesController extends Controller {

	/**
	 * @return void
	 */
	public function openDoor() {
	}

}


================================================
FILE: tests/test_app/plugins/Awesome/src/Model/Table/HousesTable.php
================================================
<?php
namespace Awesome\Model\Table;

use Cake\ORM\Table;

/**
 * @property \Cake\ORM\Association\HasMany<\Awesome\Model\Table\WindowsTable> $Windows
 */
class HousesTable extends Table {

	/**
	 * @param array $config
	 * @return void
	 */
	public function initialize(array $config): void {
		parent::initialize($config);

		$this->hasMany('Awesome.Windows');
	}

}


================================================
FILE: tests/test_app/plugins/Awesome/src/Model/Table/WindowsTable.php
================================================
<?php
namespace Awesome\Model\Table;

use Cake\ORM\Table;

/**
 * @property \Cake\ORM\Association\BelongsTo<\Awesome\Model\Table\HousesTable> $Houses
 */
class WindowsTable extends Table {

	/**
	 * @param array $config
	 * @return void
	 */
	public function initialize(array $config): void {
		parent::initialize($config);

		$this->belongsTo('Awesome.Houses');
	}

}


================================================
FILE: tests/test_app/plugins/Awesome/templates/element/pagination.php
================================================
<?php
/**
 * @var \TestApp\View\AppView $this
 */
?>
<p>Pagination</p>


================================================
FILE: tests/test_app/plugins/Controllers/src/Controller/GenericController.php
================================================
<?php
namespace Controllers\Controller;

use Cake\Controller\Controller;

#[\AllowDynamicProperties]
class GenericController extends Controller {

	protected ?string $defaultTable = '';

}


================================================
FILE: tests/test_app/plugins/Controllers/src/Controller/HousesController.php
================================================
<?php
namespace Controllers\Controller;

use Cake\Controller\Controller;

class HousesController extends Controller {
}


================================================
FILE: tests/test_app/plugins/Controllers/src/Controller/WindowsController.php
================================================
<?php
namespace Controllers\Controller;

use Cake\Controller\Controller;

class WindowsController extends Controller {

	protected ?string $defaultTable = 'Awesome.Windows';

}


================================================
FILE: tests/test_app/plugins/Controllers/src/ControllersPlugin.php
================================================
<?php
namespace Controllers;

use Cake\Core\BasePlugin;

class ControllersPlugin extends BasePlugin {
}


================================================
FILE: tests/test_app/plugins/Controllers/src/Model/Table/HousesTable.php
================================================
<?php
namespace Controllers\Model\Table;

use Cake\ORM\Table;

class HousesTable extends Table {
}


================================================
FILE: tests/test_app/plugins/MyNamespace/MyPlugin/src/Controller/Component/MyComponent.php
================================================
<?php
namespace MyNamespace\MyPlugin\Controller\Component;

use Cake\Controller\Component;

class MyComponent extends Component {
}


================================================
FILE: tests/test_app/plugins/MyNamespace/MyPlugin/src/Model/Behavior/MyBehavior.php
================================================
<?php
namespace MyNamespace\MyPlugin\Model\Behavior;

use Cake\ORM\Behavior;

class MyBehavior extends Behavior {
}


================================================
FILE: tests/test_app/plugins/MyNamespace/MyPlugin/src/Model/Table/MyTable.php
================================================
<?php

namespace MyNamespace\MyPlugin\Model\Table;

use Cake\ORM\Table;

class MyTable extends Table {
}


================================================
FILE: tests/test_app/plugins/MyNamespace/MyPlugin/src/MyPluginPlugin.php
================================================
<?php
namespace MyNamespace\MyPlugin;

use Cake\Core\BasePlugin;

class MyPluginPlugin extends BasePlugin {
}


================================================
FILE: tests/test_app/plugins/MyNamespace/MyPlugin/tests/Fixture/Sub/MyFixture.php
================================================
<?php

namespace MyNamespace\MyPlugin\Test\TestCase\Fixture\Sub;

use Cake\TestSuite\Fixture\TestFixture;

class MyFixture extends TestFixture {

	public array $fields = [
		'id' => ['type' => 'integer', 'length' => 11, 'unsigned' => false, 'null' => false, 'default' => null, 'comment' => '', 'autoIncrement' => true, 'precision' => null],
	];

}


================================================
FILE: tests/test_app/plugins/Relations/src/Model/Entity/Bar.php
================================================
<?php
namespace Relations\Model\Entity;

use Cake\ORM\Entity;

class Bar extends Entity {
}


================================================
FILE: tests/test_app/plugins/Relations/src/Model/Entity/Foo.php
================================================
<?php
namespace Relations\Model\Entity;

use Cake\ORM\Entity;

class Foo extends Entity {
}


================================================
FILE: tests/test_app/plugins/Relations/src/Model/Entity/User.php
================================================
<?php
namespace Relations\Model\Entity;

use Cake\ORM\Entity;

class User extends Entity {
}


================================================
FILE: tests/test_app/plugins/Relations/src/Model/Table/BarsTable.php
================================================
<?php
namespace Relations\Model\Table;

use Cake\Database\Schema\TableSchema;
use Cake\Database\Schema\TableSchemaInterface;
use Cake\ORM\Table;

class BarsTable extends Table {

	protected array $_fields = [
		'id' => ['type' => 'integer', 'length' => 11, 'unsigned' => false, 'null' => false, 'default' => null, 'autoIncrement' => true],
		'name' => ['type' => 'string', 'length' => 255, 'null' => false, 'default' => null],
		'user_id' => ['type' => 'integer', 'length' => 11, 'unsigned' => false, 'null' => true, 'default' => null],
	];

	/**
	 * @param array $config
	 * @return void
	 */
	public function initialize(array $config): void {
		parent::initialize($config);

		// Nullable relation
		$this->belongsTo('Relations.Users');
	}

	/**
	 * @return \Cake\Database\Schema\TableSchemaInterface
	 */
	public function getSchema(): TableSchemaInterface {
		$tableSchema = new TableSchema($this->getTable());

		foreach ($this->_fields as $field => $attributes) {
			$tableSchema->addColumn($field, $attributes);
		}

		return $tableSchema;
	}

}


================================================
FILE: tests/test_app/plugins/Relations/src/Model/Table/FoosTable.php
================================================
<?php
namespace Relations\Model\Table;

use Cake\Database\Schema\TableSchema;
use Cake\Database\Schema\TableSchemaInterface;
use Cake\ORM\Table;

class FoosTable extends Table {

	protected array $_fields = [
		'id' => ['type' => 'integer', 'length' => 11, 'unsigned' => false, 'null' => false, 'default' => null, 'autoIncrement' => true],
		'name' => ['type' => 'string', 'length' => 255, 'null' => false, 'default' => null],
		'user_id' => ['type' => 'integer', 'length' => 11, 'unsigned' => false, 'null' => false, 'default' => null],
		'params' => ['type' => 'json', 'length' => null, 'null' => true, 'default' => null, 'comment' => '', 'precision' => null],
	];

	/**
	 * @param array $config
	 * @return void
	 */
	public function initialize(array $config): void {
		parent::initialize($config);

		// Required relation
		$this->belongsTo('Relations.Users');
	}

	/**
	 * @return \Cake\Database\Schema\TableSchemaInterface
	 */
	public function getSchema(): TableSchemaInterface {
		$tableSchema = new TableSchema($this->getTable());

		foreach ($this->_fields as $field => $attributes) {
			$tableSchema->addColumn($field, $attributes);
		}

		return $tableSchema;
	}

}


================================================
FILE: tests/test_app/plugins/Relations/src/Model/Table/UsersTable.php
================================================
<?php
namespace Relations\Model\Table;

use Cake\Database\Schema\TableSchema;
use Cake\Database\Schema\TableSchemaInterface;
use Cake\ORM\Table;

class UsersTable extends Table {

	protected array $_fields = [
		'id' => ['type' => 'integer', 'length' => 11, 'unsigned' => false, 'null' => false, 'default' => null, 'autoIncrement' => true],
		'name' => ['type' => 'string', 'length' => 255, 'null' => false, 'default' => null],
	];

	/**
	 * @param array $config
	 * @return void
	 */
	public function initialize(array $config): void {
		parent::initialize($config);

		$this->hasOne('Relations.Foos');
		$this->hasOne('Relations.Bars');
	}

	/**
	 * @return \Cake\Database\Schema\TableSchemaInterface
	 */
	public function getSchema(): TableSchemaInterface {
		$tableSchema = new TableSchema($this->getTable());

		foreach ($this->_fields as $field => $attributes) {
			$tableSchema->addColumn($field, $attributes);
		}

		return $tableSchema;
	}

}


================================================
FILE: tests/test_app/plugins/Relations/src/RelationsPlugin.php
================================================
<?php
namespace Relations;

use Cake\Core\BasePlugin;

class RelationsPlugin extends BasePlugin {
}


================================================
FILE: tests/test_app/src/Application.php
================================================
<?php

namespace TestApp;

use Cake\Http\BaseApplication;
use Cake\Http\MiddlewareQueue;
use Cake\Routing\RouteBuilder;

class Application extends BaseApplication
{
	public function bootstrap(): void
	{
	}

	public function routes(RouteBuilder $routes): void
	{
	}

	public function middleware(MiddlewareQueue $middlewareQueue): MiddlewareQueue
	{
		return $middlewareQueue;
	}
}


================================================
FILE: tests/test_app/src/Command/MyCommand.php
================================================
<?php
namespace TestApp\Command;

use Shim\Command\Command;

class MyCommand extends Command {

	protected ?string $defaultTable = 'Cars';

	/** @var \Relations\Model\Table\BarsTable */
	protected $Bars;

	/**
	 * @return void
	 */
	public function main() {
		$this->Wheels = $this->fetchTable('Wheels');
		$this->Bars = $this->fetchTable('Relations.Bars');
	}

}


================================================
FILE: tests/test_app/src/Controller/AppController.php
================================================
<?php
namespace TestApp\Controller;

use Cake\Controller\Controller;

/**
 * @property \TestApp\Controller\Component\MyOtherComponent $MyOther
 */
class AppController extends Controller {

	/**
	 * @return void
	 */
	public function initialize(): void {
		parent::initialize();

		$this->loadComponent('Flash');
		$this->loadComponent('CheckHttpCache');
		$this->loadComponent('MyOther');
	}

}


================================================
FILE: tests/test_app/src/Controller/BarController.php
================================================
<?php
namespace TestApp\Controller;

use TestApp\Model\Table\WheelsTable;

class BarController extends AppController {

	protected ?string $defaultTable = 'BarBars';

	protected WheelsTable $Wheels;

	/**
	 * @return void
	 */
	public function initialize(): void {
		parent::initialize();

		$this->loadComponent('Flash');
		$this->loadComponent('MyNamespace/MyPlugin.My');

		$this->Wheels = $this->fetchTable('Wheels');
	}

	/**
	 * @return \Cake\Http\Response|null|void
	 */
	public function index() {
		$this->paginate($this->BarBars);
	}

}


================================================
FILE: tests/test_app/src/Controller/Component/CheckHttpCacheComponent.php
================================================
<?php
namespace TestApp\Controller\Component;

use Cake\Controller\Component\CheckHttpCacheComponent as CoreCheckHttpCacheComponent;

class CheckHttpCacheComponent extends CoreCheckHttpCacheComponent {
}


================================================
FILE: tests/test_app/src/Controller/Component/MyComponent.php
================================================
<?php
namespace TestApp\Controller\Component;

use Cake\Controller\Component;

class MyComponent extends Component {

	public array $components = ['Flash', 'CheckHttpCache', 'MyNamespace/MyPlugin.My'];

}


================================================
FILE: tests/test_app/src/Controller/Component/MyControllerComponent.php
================================================
<?php
namespace TestApp\Controller\Component;

use Cake\Controller\Component;
use Cake\Event\EventInterface;

class MyControllerComponent extends Component {

	/**
	 * @param \Cake\Event\EventInterface $event
	 *
	 * @return void
	 */
	public function beforeFilter(EventInterface $event): void {
		$user = (bool)$this->getController()->AuthUser->user();
	}

}


================================================
FILE: tests/test_app/src/Controller/Component/MyOtherComponent.php
================================================
<?php
namespace TestApp\Controller\Component;

use Cake\Controller\Component;

/**
 * @property \TestApp\Controller\Component\CheckHttpCacheComponent $CheckHttpCache
 * @property \Cake\Controller\Component\FormProtectionComponent $FormProtection
 */
class MyOtherComponent extends Component {

	public array $components = ['Flash', 'CheckHttpCache', 'SomeInvalidOneWillBeIgnored', 'FormProtection'];

}


================================================
FILE: tests/test_app/src/Controller/DynamicPropertiesController.php
================================================
<?php
namespace TestApp\Controller;

#[\AllowDynamicProperties]
class DynamicPropertiesController extends AppController {

	protected ?string $defaultTable = 'BarBars';

}


================================================
FILE: tests/test_app/src/Controller/DynamicPropertiesExistingDocblockController.php
================================================
<?php
namespace TestApp\Controller;

/**
 * Existing docblock
 */
#[\AllowDynamicProperties]
class DynamicPropertiesExistingDocblockController extends AppController {

	protected ?string $defaultTable = 'BarBars';

}


================================================
FILE: tests/test_app/src/Controller/FoosController.php
================================================
<?php
namespace TestApp\Controller;

class FoosController extends AppController {
}


================================================
FILE: tests/test_app/src/Custom/CustomClass.php
================================================
<?php
namespace TestApp\Custom;

use Cake\Datasource\ModelAwareTrait;

/**
 * @property \TestApp\Model\Table\BarBarsTable $BarBars
 */
class CustomClass {

	use ModelAwareTrait;

	/**
	 * @return void
	 */
	public function initialize() {
		$this->fetchModel('Foos');
	}

}


================================================
FILE: tests/test_app/src/Custom/Nested/NestedClass.php
================================================
<?php
namespace TestApp\Custom\Nested;

use Cake\Datasource\ModelAwareTrait;

class NestedClass {

	use ModelAwareTrait;

	/**
	 * @return void
	 */
	public function initialize() {
		$this->fetchModel('Foos');
	}

}


================================================
FILE: tests/test_app/src/Database/Type/UuidType.php
================================================
<?php
/**
 * CakePHP(tm) : Rapid Development Framework (https://cakephp.org)
 * Copyright (c) Cake Software Foundation, Inc. (https://cakefoundation.org)
 *
 * Licensed under The MIT License
 * For full copyright and license information, please see the LICENSE.txt
 * Redistributions of files must retain the above copyright notice.
 *
 * @copyright     Copyright (c) Cake Software Foundation, Inc. (https://cakefoundation.org)
 * @link          https://cakephp.org CakePHP(tm) Project
 * @since         3.0.0
 * @license       https://opensource.org/licenses/mit-license.php MIT License
 */
namespace TestApp\Database\Type;

use Cake\Database\Type\UuidType as CoreUuidType;

/**
 * Provides behavior for the UUID type
 */
class UuidType extends CoreUuidType {
}


================================================
FILE: tests/test_app/src/Generator/Task/TestDatabaseTableColumnTypeTask.php
================================================
<?php

namespace TestApp\Generator\Task;

use IdeHelper\Generator\Task\DatabaseTableColumnTypeTask;

class TestDatabaseTableColumnTypeTask extends DatabaseTableColumnTypeTask
{
	/**
	 * @param string $name
	 *
	 * @return \Phinx\Db\Adapter\AdapterInterface|\Migrations\Db\Adapter\AdapterInterface
	 */
	protected function getAdapter(string $name = 'test') {
		return parent::getAdapter($name);
	}

}


================================================
FILE: tests/test_app/src/Generator/Task/TestEnvTask.php
================================================
<?php

namespace TestApp\Generator\Task;

use IdeHelper\Generator\Directive\ExpectedArguments;
use IdeHelper\Generator\Task\EnvTask;
use IdeHelper\ValueObject\StringName;

class TestEnvTask extends EnvTask {

	/**
	 * @return \IdeHelper\ValueObject\StringName[]
	 */
	protected function envKeys(): array {
		$list = parent::envKeys();

		$list = [
			'HTTP_HOST' => $list['HTTP_HOST'],
		];

		return $list;
	}

}


================================================
FILE: tests/test_app/src/Generator/Task/TestFixtureTask.php
================================================
<?php

namespace TestApp\Generator\Task;

use IdeHelper\Generator\Task\FixtureTask;

class TestFixtureTask extends FixtureTask {

	/**
	 * @return \IdeHelper\ValueObject\StringName[]
	 */
	protected function getFixtures(): array {
		$list = parent::getFixtures();

		$list = [
			'app.SmallWindows' => $list['app.SmallWindows'],
			'core.Posts' => $list['core.Posts'],
			'plugin.IdeHelper.Cars' => $list['plugin.IdeHelper.Cars'],
			'plugin.MyNamespace/MyPlugin.Sub/My' => $list['plugin.MyNamespace/MyPlugin.Sub/My'],
		];

		return $list;
	}

}


================================================
FILE: tests/test_app/src/Mailer/UserMailer.php
================================================
<?php

namespace TestApp\Mailer;

use Cake\Mailer\Mailer;

class UserMailer extends Mailer {
}


================================================
FILE: tests/test_app/src/Model/Entity/BarBar.php
================================================
<?php
namespace TestApp\Model\Entity;

use Cake\ORM\Entity;

class BarBar extends Entity {
}


================================================
FILE: tests/test_app/src/Model/Entity/BarBarsAbstract.php
================================================
<?php
namespace TestApp\Model\Entity;

use Cake\ORM\Entity;

class BarBarsAbstract extends Entity {
}


================================================
FILE: tests/test_app/src/Model/Entity/Callback.php
================================================
<?php
namespace TestApp\Model\Entity;

use Cake\ORM\Entity;

class Callback extends Entity {
}


================================================
FILE: tests/test_app/src/Model/Entity/Car.php
================================================
<?php
namespace TestApp\Model\Entity;

use Cake\ORM\Entity;

/**
 * My car entity which is very cool.
 */
class Car extends Entity {
}


================================================
FILE: tests/test_app/src/Model/Entity/Complex/Wheel.php
================================================
<?php
namespace TestApp\Model\Entity;

use Cake\ORM\Entity;

/**
 * @property array{user?: int, account?: int|string, newContacts?: array<mixed>}|null $params !
 * @property int $id
 * @property string $name
 * @property string $content
 * @property \Cake\I18n\Date $offer_date
 * @property \Cake\I18n\DateTime $created
 * @property \Cake\I18n\DateTime|null $modified
 * @property \TestApp\Model\Entity\Wheel[] $wheels
 *
 * @property-read string|null $virtual_one
 */
class Wheel extends Entity {

	protected array $_virtual = [
		'virtual_one',
	];

	/**
	 * @return string|null
	 */
	protected function _getVirtualOne() {
		return 'Virtual One';
	}

}


================================================
FILE: tests/test_app/src/Model/Entity/Complex2/Wheel.php
================================================
<?php
namespace TestApp\Model\Entity;

use Cake\ORM\Entity;

/**
 * @property array{utm_tags: array<mixed>|null}|null $params !
 * @property int $id
 * @property string $name
 * @property string $content
 * @property \Cake\I18n\Date $offer_date
 * @property \Cake\I18n\DateTime $created
 * @property \Cake\I18n\DateTime|null $modified
 * @property \TestApp\Model\Entity\Wheel[] $wheels
 *
 * @property-read string|null $virtual_one
 */
class Wheel extends Entity {

	protected array $_virtual = [
		'virtual_one',
	];

	/**
	 * @return string|null
	 */
	protected function _getVirtualOne() {
		return 'Virtual One';
	}

}


================================================
FILE: tests/test_app/src/Model/Entity/Foo.php
================================================
<?php
namespace TestApp\Model\Entity;

use Cake\ORM\Entity;

/**
 * @property array|null $params
 * @property int $id
 * @property \Cake\I18n\OldTime $created
 */
class Foo extends Entity {
}


================================================
FILE: tests/test_app/src/Model/Entity/PHP/ComplexType.php
================================================
<?php
namespace TestApp\Model\Entity\PHP;

use Cake\ORM\Entity;

/**
 * @property int $id
 * @property string $name
 * @property string $content
 * @property \Cake\I18n\DateTime $created
 * @property \Cake\I18n\DateTime|null $modified
 * @property array{foo: array<mixed>|null}|null $params !
 * @property \Cake\I18n\Date $offer_date
 */
class ComplexType extends Entity {
}


================================================
FILE: tests/test_app/src/Model/Entity/PHP/Duplicates.php
================================================
<?php
namespace TestApp\Model\Entity\PHP;

use Cake\ORM\Entity;

/**
 * @property int $id
 * @property string $name
 * @property string $content
 * @property \Cake\I18n\DateTime $created
 * @property \Cake\I18n\DateTime|null $modified
 * @property \Cake\I18n\Date $offer_date
 * @property array|null $params
 * @property int $content
 */
class Duplicates extends Entity {
}


================================================
FILE: tests/test_app/src/Model/Entity/PHP/Generics.php
================================================
<?php
namespace TestApp\Model\Entity\PHP;

use Cake\ORM\Entity;

/**
 * @property array|null $params
 * @property int $id
 * @property string $name
 * @property string $content
 * @property \Cake\I18n\DateTime $created
 * @property \Cake\I18n\DateTime|null $modified
 * @property \TestApp\Model\Entity\Wheel[] $wheels
 */
class Generics extends Entity {
}


================================================
FILE: tests/test_app/src/Model/Entity/PHP7/Virtual.php
================================================
<?php
namespace TestApp\Model\Entity\PHP7;

use Cake\ORM\Entity;

class Virtual extends Entity {

	protected function _getVirtualOne(): ?string {
		return 'Virtual One';
	}

	protected function _getVirtualTwo(): string {
		return 'Virtual Two';
	}

	/**
	 * @return array<int, array<string>>
	 */
	protected function _getNestedGeneric(): array {
		return [[1 => ['a', 'b']]];
	}

}


================================================
FILE: tests/test_app/src/Model/Entity/Virtual.php
================================================
<?php
namespace TestApp\Model\Entity;

use Cake\ORM\Entity;

/**
 * @property-read bool $virtual_read_only This should be kept.
 */
class Virtual extends Entity {

	protected array $_virtual = [
		'virtual_one',
	];

	/**
	 * @return string|null
	 */
	protected function _getVirtualOne() {
		return 'Virtual One';
	}

	protected function _getVirtualTwo() {
		// Missing return type and docblock means mixed as result
		return 'Virtual Two';
	}

	/**
	 * @return bool
	 */
	protected function _getVirtualReadOnly() {
		return true;
	}

	/**
	 * @param \TestApp\Model\Entity\Wheel[] $wheels
	 *
	 * @return \TestApp\Model\Entity\Wheel[]
	 */
	protected function _getWheels($wheels = []) {
		return $wheels;
	}

}


================================================
FILE: tests/test_app/src/Model/Entity/Wheel.php
================================================
<?php
namespace TestApp\Model\Entity;

use Cake\ORM\Entity;

class Wheel extends Entity {

	protected array $_virtual = [
		'virtual_one',
	];

	/**
	 * @return string|null
	 */
	protected function _getVirtualOne() {
		return 'Virtual One';
	}

}


================================================
FILE: tests/test_app/src/Model/Enum/CarStatus.php
================================================
<?php
declare(strict_types=1);

namespace TestApp\Model\Enum;

enum CarStatus: int
{
	case NEW = 0;
	case USED = 1;

	public function label(): string {
		return match($this) {
			self::NEW => 'new',
			self::USED => 'used',
		};
	}
}


================================================
FILE: tests/test_app/src/Model/Table/AbstractTable.php
================================================
<?php

namespace TestApp\Model\Table;

use Cake\ORM\Table;

/**
 * Class AbstractTable
 */
abstract class AbstractTable extends Table
{
	/**
	 * @param array $config
	 * @return void
	 */
	public function initialize(array $config): void
	{
		parent::initialize($config);

		$this->addBehavior('Timestamp');
	}
}


================================================
FILE: tests/test_app/src/Model/Table/BarBarsAbstractTable.php
================================================
<?php
namespace TestApp\Model\Table;

class BarBarsAbstractTable extends AbstractTable {

	/**
	 * @param array $config
	 * @return void
	 */
	public function initialize(array $config): void {
		parent::initialize($config);

		$this->setTable('bar_bars');
		$this->belongsTo('Foos');
		$this->belongsToMany('Houses', [
			'className' => 'Awesome.Houses',
			'through' => 'Awesome.Windows',
		]);
		$this->addBehavior('MyMy', [
			'className' => 'MyNamespace/MyPlugin.My',
		]);
	}

}


================================================
FILE: tests/test_app/src/Model/Table/BarBarsTable.php
================================================
<?php
namespace TestApp\Model\Table;

use Cake\ORM\Table;

class BarBarsTable extends Table {

	/**
	 * @param array $config
	 * @return void
	 */
	public function initialize(array $config): void {
		parent::initialize($config);

		$this->belongsTo('Foos');
		$this->belongsToMany('Houses', [
			'className' => 'Awesome.Houses',
			'through' => 'Awesome.Windows',
		]);
		$this->addBehavior('Timestamp');
		$this->addBehavior('MyNamespace/MyPlugin.My');
	}

}


================================================
FILE: tests/test_app/src/Model/Table/CallbacksTable.php
================================================
<?php
namespace TestApp\Model\Table;

use ArrayObject;
use Cake\Datasource\EntityInterface;
use Cake\Event\Event;
use Cake\Event\EventInterface;
use Cake\ORM\Table;

class CallbacksTable extends Table {

	/**
	 * @param \Cake\Event\Event $event Event
	 * @param \Cake\Datasource\EntityInterface $entity Entity
	 * @param \ArrayObject $options Options
	 * @return void
	 */
	public function beforeSave(Event $event, EntityInterface $entity, ArrayObject $options) {
	}

	/**
	 * @param \Cake\Event\EventInterface $event
	 * @param \Cake\Datasource\EntityInterface $entity
	 * @param \ArrayObject $options
	 * @return void
	 */
	public function afterSave(EventInterface $event, EntityInterface $entity, ArrayObject $options) {
	}

	public function beforeDelete(Event $event, EntityInterface $entity, ArrayObject $options) {
	}

}


================================================
FILE: tests/test_app/src/Model/Table/CarsTable.php
================================================
<?php
namespace TestApp\Model\Table;

use Cake\Database\Type\EnumType;
use Cake\ORM\Table;
use TestApp\Model\Enum\CarStatus;

class CarsTable extends Table {

	/**
	 * @param array $config
	 * @return void
	 */
	public function initialize(array $config): void {
		parent::initialize($config);

		$this->hasMany('Wheels');

		$this->getSchema()->setColumnType('status', EnumType::from(CarStatus::class));
	}

}


================================================
FILE: tests/test_app/src/Model/Table/CustomFinderTable.php
================================================
<?php
namespace TestApp\Model\Table;

use Cake\ORM\Query\SelectQuery;
use Cake\ORM\Table;

class CustomFinderTable extends Table {

	/**
	 * @param \Cake\ORM\Query $query
	 *
	 * @return \Cake\ORM\Query
	 */
	public function findSomethingCustom(SelectQuery $query): SelectQuery {
		return $query;
	}

}


================================================
FILE: tests/test_app/src/Model/Table/ExceptionsTable.php
================================================
<?php
namespace TestApp\Model\Table;

use Cake\ORM\Table;

class ExceptionsTable extends Table {

	/**
	 * @param array $config
	 * @return void
	 */
	public function initialize(array $config): void {
		parent::initialize($config);

		$this->setTable('invalid');

		$this->belongsTo('TotallyInvalid');
	}

}


================================================
FILE: tests/test_app/src/Model/Table/FoosTable.php
================================================
<?php
namespace TestApp\Model\Table;

use Cake\ORM\Table;

class FoosTable extends Table {

	/**
	 * @param array $config
	 * @return void
	 */
	public function initialize(array $config): void {
		parent::initialize($config);

		$this->addBehavior('Timestamp');
		$this->addBehavior('MyNamespace/MyPlugin.My');
	}

}


================================================
FILE: tests/test_app/src/Model/Table/SkipMeTable.php
================================================
<?php
namespace TestApp\Model\Table;

use Cake\ORM\Table;

/**
 * @inheritDoc
 */
class SkipMeTable extends Table {

	/**
	 * @param array $config
	 * @return void
	 */
	public function initialize(array $config): void {
		parent::initialize($config);

		$this->belongsTo('Cars');
	}

}


================================================
FILE: tests/test_app/src/Model/Table/SkipSomeTable.php
================================================
<?php
namespace TestApp\Model\Table;

use Cake\ORM\Table;

/**
 * @property \Cake\ORM\Association\BelongsTo<\TestApp\Model\Table\CarsTable> $Cars
 * @property \Cake\ORM\Association\BelongsTo<\TestApp\Model\Table\CarsTable> $CarsAwesome
 */
class SkipSomeTable extends Table {

	/**
	 * @param array $config
	 * @return void
	 */
	public function initialize(array $config): void {
		parent::initialize($config);

		$this->belongsTo('Cars');
	}

	/**
	 * @return void
	 */
	public function foo() {
		$this->CarsAwesome->doSthAwesome();
	}

}


================================================
FILE: tests/test_app/src/Model/Table/Specific/AbstractTable.php
================================================
<?php

namespace TestApp\Model\Table;

use Cake\ORM\Table;

/**
 * Class AbstractTable
 */
abstract class AbstractTable extends Table
{
	/**
	 * @param array $config
	 * @return void
	 */
	public function initialize(array $config): void
	{
		parent::initialize($config);

		$this->addBehavior('Timestamp');
	}
}


================================================
FILE: tests/test_app/src/Model/Table/Specific/BarBarsAbstractTable.php
================================================
<?php
namespace TestApp\Model\Table;

class BarBarsAbstractTable extends AbstractTable {

	/**
	 * @param array $config
	 * @return void
	 */
	public function initialize(array $config): void {
		parent::initialize($config);

		$this->setTable('bar_bars');
		$this->belongsTo('Foos');
		$this->belongsToMany('Houses', [
			'className' => 'Awesome.Houses',
			'through' => 'Awesome.Windows',
		]);
		$this->addBehavior('MyMy', [
			'className' => 'MyNamespace/MyPlugin.My',
		]);
	}

}


================================================
FILE: tests/test_app/src/Model/Table/Specific/BarBarsTable.php
================================================
<?php
namespace TestApp\Model\Table;

use Cake\ORM\Table;

class BarBarsTable extends Table {

	/**
	 * @param array $config
	 * @return void
	 */
	public function initialize(array $config): void {
		parent::initialize($config);

		$this->belongsTo('Foos');
		$this->belongsToMany('Houses', [
			'className' => 'Awesome.Houses',
			'through' => 'Awesome.Windows',
		]);
		$this->addBehavior('Timestamp');
		$this->addBehavior('MyNamespace/MyPlugin.My');
	}

}


================================================
FILE: tests/test_app/src/Model/Table/Specific/CallbacksTable.php
================================================
<?php
namespace TestApp\Model\Table;

use ArrayObject;
use Cake\Datasource\EntityInterface;
use Cake\Event\Event;
use Cake\Event\EventInterface;
use Cake\ORM\Table;

class CallbacksTable extends Table {

	/**
	 * @param \Cake\Event\Event $event Event
	 * @param \Cake\Datasource\EntityInterface $entity Entity
	 * @param \ArrayObject $options Options
	 * @return void
	 */
	public function beforeSave(Event $event, EntityInterface $entity, ArrayObject $options) {
	}

	/**
	 * @param \Cake\Event\EventInterface $event
	 * @param \Cake\Datasource\EntityInterface $entity
	 * @param \ArrayObject $options
	 * @return void
	 */
	public function afterSave(EventInterface $event, EntityInterface $entity, ArrayObject $options) {
	}

	public function beforeDelete(Event $event, EntityInterface $entity, ArrayObject $options) {
	}

}


================================================
FILE: tests/test_app/src/Model/Table/Specific/CarsTable.php
================================================
<?php
namespace TestApp\Model\Table;

use Cake\Database\Type\EnumType;
use Cake\ORM\Table;
use TestApp\Model\Enum\CarStatus;

class CarsTable extends Table {

	/**
	 * @param array $config
	 * @return void
	 */
	public function initialize(array $config): void {
		parent::initialize($config);

		$this->hasMany('Wheels');

		$this->getSchema()->setColumnType('status', EnumType::from(CarStatus::class));
	}

}


================================================
FILE: tests/test_app/src/Model/Table/Specific/CustomFinderTable.php
================================================
<?php
namespace TestApp\Model\Table;

use Cake\ORM\Query\SelectQuery;
use Cake\ORM\Table;

class CustomFinderTable extends Table {

	/**
	 * @param \Cake\ORM\Query\SelectQuery $query
	 *
	 * @return \Cake\ORM\Query\SelectQuery
	 */
	public function findSomethingCustom(SelectQuery $query): SelectQuery {
		return $query;
	}

}


================================================
FILE: tests/test_app/src/Model/Table/Specific/ExceptionsTable.php
================================================
<?php
namespace TestApp\Model\Table;

use Cake\ORM\Table;

class ExceptionsTable extends Table {

	/**
	 * @param array $config
	 * @return void
	 */
	public function initialize(array $config): void {
		parent::initialize($config);

		$this->setTable('invalid');

		$this->belongsTo('TotallyInvalid');
	}

}


================================================
FILE: tests/test_app/src/Model/Table/Specific/FoosTable.php
================================================
<?php
namespace TestApp\Model\Table;

use Cake\ORM\Table;

class FoosTable extends Table {

	/**
	 * @param array $config
	 * @return void
	 */
	public function initialize(array $config): void {
		parent::initialize($config);

		$this->addBehavior('Timestamp');
		$this->addBehavior('MyNamespace/MyPlugin.My');
	}

}


================================================
FILE: tests/test_app/src/Model/Table/Specific/SkipMeTable.php
================================================
<?php
namespace TestApp\Model\Table;

use Cake\ORM\Table;

/**
 * @inheritDoc
 */
class SkipMeTable extends Table {

	/**
	 * @param array $config
	 * @return void
	 */
	public function initialize(array $config): void {
		parent::initialize($config);

		$this->belongsTo('Cars');
	}

}


================================================
FILE: tests/test_app/src/Model/Table/Specific/SkipSomeTable.php
================================================
<?php
namespace TestApp\Model\Table;

use Cake\ORM\Table;

/**
 * @property \Cake\ORM\Association\BelongsTo<\TestApp\Model\Table\CarsTable> $Cars
 * @property \Cake\ORM\Association\BelongsTo<\TestApp\Model\Table\CarsTable> $CarsAwesome
 */
class SkipSomeTable extends Table {

	/**
	 * @param array $config
	 * @return void
	 */
	public function initialize(array $config): void {
		parent::initialize($config);

		$this->belongsTo('Cars');
	}

	/**
	 * @return void
	 */
	public function foo() {
		$this->CarsAwesome->doSthAwesome();
	}

}


================================================
FILE: tests/test_app/src/Model/Table/Specific/WheelsExtraTable.php
================================================
<?php
namespace TestApp\Model\Table;

use Cake\ORM\Table;

/**
 * @property \Cake\ORM\Association\BelongsTo<\TestApp\Model\Table\CarsOldTable> $Cars
 */
class WheelsExtraTable extends Table {

	/**
	 * @param array $config
	 * @return void
	 */
	public function initialize(array $config): void {
		parent::initialize($config);

		$this->setTable('wheels');
		$this->belongsTo('Cars');
	}

}


================================================
FILE: tests/test_app/src/Model/Table/Specific/WheelsTable.php
================================================
<?php
namespace TestApp\Model\Table;

use Cake\ORM\Table;

/**
 * @method \TestApp\Model\Entity\Wheeeeeeeel newEntity($data = null, array $options = [])
 */
class WheelsTable extends Table {

	/**
	 * @param array $config
	 * @return void
	 */
	public function initialize(array $config): void {
		parent::initialize($config);

		$this->belongsTo('Cars');

		$this->addBehavior('Tree');
	}

}


================================================
FILE: tests/test_app/src/Model/Table/WheelsExtraTable.php
================================================
<?php
namespace TestApp\Model\Table;

use Cake\ORM\Table;

/**
 * @property \Cake\ORM\Association\BelongsTo<\TestApp\Model\Table\CarsOldTable> $Cars
 */
class WheelsExtraTable extends Table {

	/**
	 * @param array $config
	 * @return void
	 */
	public function initialize(array $config): void {
		parent::initialize($config);

		$this->setTable('wheels');
		$this->belongsTo('Cars');
	}

}


================================================
FILE: tests/test_app/src/Model/Table/WheelsTable.php
================================================
<?php
namespace TestApp\Model\Table;

use Cake\ORM\Table;

/**
 * @method \TestApp\Model\Entity\Wheeeeeeeel newEntity($data = null, array $options = [])
 */
class WheelsTable extends Table {

	/**
	 * @param array $config
	 * @return void
	 */
	public function initialize(array $config): void {
		parent::initialize($config);

		$this->belongsTo('Cars');

		$this->addBehavior('Tree');
	}

}


================================================
FILE: tests/test_app/src/ValueObject/DoubleQuoteStringName.php
================================================
<?php

namespace TestApp\ValueObject;

use IdeHelper\ValueObject\StringName;

/**
 * Let's use " instead of ' here.
 */
class DoubleQuoteStringName extends StringName {

	/**
	 * @return string
	 */
	public function __toString(): string {
		return '"' . $this->value . '"';
	}

}


================================================
FILE: tests/test_app/src/View/AppView.php
================================================
<?php
namespace TestApp\View;

use Cake\View\View;

/**
 * @link https://book.cakephp.org/5/en/views.html#the-app-view
 */
class AppView extends View {
}


================================================
FILE: tests/test_app/src/View/Cell/TestCell.php
================================================
<?php
declare( strict_types = 1 );

namespace TestApp\View\Cell;

use Cake\View\Cell;

class TestCell extends Cell {

	/**
	 * Default display method.
	 *
	 * @return void
	 */
	public function display() {

	}

	/**
	 * Custom display method.
	 *
	 * @return void
	 */
	public function custom() {

	}

}


================================================
FILE: tests/test_app/src/View/CustomView.php
================================================
<?php

namespace TestApp\View;

/**
 * Custom View class for testing view annotation preservation.
 */
class CustomView extends AppView {
}


================================================
FILE: tests/test_app/src/View/Helper/HtmlHelper.php
================================================
<?php
namespace TestApp\View\Helper;

use Cake\View\Helper\HtmlHelper as CoreHtmlHelper;

class HtmlHelper extends CoreHtmlHelper {
}


================================================
FILE: tests/test_app/src/View/Helper/MyHelper.php
================================================
<?php
namespace TestApp\View\Helper;

use Cake\View\Helper;

class MyHelper extends Helper {

	protected array $helpers = [
		'Html',
		'Form',
		'Shim.Configure',
		'SomeInvalidOneWillBeIgnored',
	];

}


================================================
FILE: tests/test_app/src/View/Helper/MyMethodHelper.php
================================================
<?php
namespace TestApp\View\Helper;

use Cake\View\Helper;

/**
 * @property \Cake\View\Helper\FormHelper $Form
 * @method bool isAdmin()
 * @method bool isStaff()
 */
class MyMethodHelper extends Helper {

	protected array $helpers = [
		'Html',
		'Form',
		'Shim.Configure',
		'SomeInvalidOneWillBeIgnored',
	];

}


================================================
FILE: tests/test_app/templates/Foos/anonymous.php
================================================
<?php
/**
 * @var \Cake\View\View $this
 * @var array<\App\Model\Entity\ParticipantMood> $participantMoods
 */
?>
<div>
	<?php
	// This should NOT trigger an annotation for $m
	$yourMoodIds = array_map(function($m) { return $m->mood_id; }, $participantMoods ?? []);

	// This should NOT trigger an annotation for $item
	$filtered = array_filter($items, function($item) {
		return $item->active;
	});

	// This should NOT trigger annotations for $a and $b
	usort($data, function($a, $b) {
		return $a->sort_order <=> $b->sort_order;
	});

	// Arrow function - should NOT trigger annotation for $x
	$doubled = array_map(fn($x) => $x * 2, $numbers);

	// Variables with 'use' clause - $multiplier should still get annotation
	$multiplier = 5;
	$result = array_map(function($n) use ($multiplier) {
		return $n * $multiplier;
	}, $values);
	?>

	<ul>
		<?php foreach ($yourMoodIds as $id): ?>
			<li><?= h($id) ?></li>
		<?php endforeach; ?>
	</ul>
</div>

================================================
FILE: tests/test_app/templates/Foos/array.php
================================================
<?php
/**
 * @var \TestApp\View\AppView $this
 * @var array $x
 * @var array<int> $ints
 * @var array{a: int, b: string|null}|null $shaped
 */
	foreach ($x as $y) {
		echo $y;
	}
	foreach ($foo as $int) {
		echo $int;
	}
?>
<div>
	<?php foreach ($ints as $int) {
		echo $int;
	} ?>
	<?php foreach ($shaped as $x) {
		echo h($x);
	} ?>
</div>


================================================
FILE: tests/test_app/templates/Foos/custom_view.php
================================================
<?php
/**
 * @var \TestApp\View\CustomView $this
 */
?>
<div>
	<?php foreach ($cars as $car) {} ?>
</div>


================================================
FILE: tests/test_app/templates/Foos/edit.php
================================================
<div>
	<?php echo $this->Form->create($foo, []); ?>
</div>


================================================
FILE: tests/test_app/templates/Foos/empty.php
================================================


================================================
FILE: tests/test_app/templates/Foos/existing.php
================================================
<?php
/**
 * @license MIT
 */

/**
 * @var \TestApp\View\AppView $this
 * @var array<int, int> $things
 */
?>
<div>
	<?php foreach ($cars as $car) {} ?>
	<?php echo h($wheel->id); ?>

	<?php foreach ($things as $keyInt => $valueInt) {
		echo h($keyInt + $valueInt);
	} ?>
</div>


================================================
FILE: tests/test_app/templates/Foos/existing_strict.php
================================================
<?php declare(strict_types=1);
/**
 * @license MIT
 */

/**
 * @var \TestApp\View\AppView $this
 */
?>
<div>
	<?php echo h($wheel->id); ?>
</div>


================================================
FILE: tests/test_app/templates/Foos/following_inline.php
================================================
<?php
/**
 * @license MIT
 * @var \TestApp\View\AppView $this
 */

/** @var \Authorization\Identity $identity */
$identity = $this->getRequest()
	->getAttribute('identity');
?>
<div>
	<?php echo h($wheel->id); ?>
</div>


================================================
FILE: tests/test_app/templates/Foos/inline.php
================================================
<?php
/** @var \TestApp\Model\Entity\Wheel $wheel */
?>
<div>
	<?php echo h($wheel->id); ?>
</div>


================================================
FILE: tests/test_app/templates/Foos/loop.php
================================================
<?php
use Something;
?>
<div>
	<?php foreach ($cars as $car) {} ?>
	<?php echo h($wheel->id); ?>

	<?php foreach ($wheel->foos as $foos): ?>
		<tr>
			<td><?= h($foos->x) ?></td>
		</tr>
	<?php endforeach; ?>
</div>


================================================
FILE: tests/test_app/templates/Foos/multiline.php
================================================
<?php
/**
 * @var \TestApp\View\AppView $this
 * @var array $x
 * @var array<int> $ints
 * @var array{
 * 		a: int,
 * 		b: string|null
 * }|null $shaped
 * @var array{
 * 		c: array{
 * 			d: int|string,
 * 			e: string|null
 * 		}
 * } $nested
 */
	foreach ($x as $y) {
		echo $y;
	}
	foreach ($foo as $int) {
		echo $int;
	}
?>
<div>
	<?php foreach ($ints as $int) {
		echo $int;
	} ?>
	<?php foreach ($shaped as $x) {
		echo h($x);
	} ?>
	<?php foreach ($nested['c'] as $subArray) {
		echo h($x);
	} ?>
</div>


================================================
FILE: tests/test_app/templates/Foos/outdated.php
================================================
<?php
/**
 * @var \Cake\View\View $this
 * @var \Cake\ORM\Entity $car !
 * @var \Cake\ORM\Entity[]|\Cake\Collection\CollectionInterface $wheels
 * @var bool $bool
 * @var \Really\Outdated $outdated
 */
?>
<div>
	<?php echo $this->Form->sth(); ?>
	<?php echo $car->id; ?>
	<?php foreach ($wheels as $wheel); ?>

	<?php echo $bool ? 'yes' : 'no'; ?>
</div>


================================================
FILE: tests/test_app/templates/Foos/phpline.php
================================================
<?php echo $this->MyHelper->foo(); ?>
<div>
	<?php foreach ($cars as $car) {} ?>
	<?php echo h($wheel->id); ?>
</div>


================================================
FILE: tests/test_app/templates/Foos/string_interpolation.php
================================================
<?php
/**
 * @var \TestApp\View\AppView $this
 */
$url = "/some/path?param={$this->request->getData('field')}";
?>
<div>
	<a href="<?php echo $url; ?>">Test</a>
	<?php echo h($name); ?>
</div>


================================================
FILE: tests/test_app/templates/Foos/vars.php
================================================
<?php
	if ($obj) {
		echo $obj->foo();
	}
	echo $this->Generator->generate(['obj' => $obj]);
?>
<div>
	<?php foreach ($allCars as $car) {
		$finalCarTime = $this->Helper->out($car->created);
		echo $finalCarTime;
	} ?>
	<?php echo h($wheel->id); ?>
	<p>
		<?= $date->format(); ?>
	</p>
	<?php foreach ($allCars->engines as $i => $engine) {
		echo h($engine);
	} ?>
	<?php foreach ($foos as $foo) {
		echo h($foo->prop);
	} ?>
</div>


================================================
FILE: tests/test_app/templates/Helpers/helpers.php
================================================
<div>
	<?php echo $this->My->foo($bar); ?>
	<?php if ($this->Configure->baz()) {} ?>
</div>


================================================
FILE: tests/test_app/templates/View/view.php
================================================
<div>
	<?php echo $this->My->foo($bar); ?>
	<?php if ($this->Configure->baz()) {} ?>
</div>


================================================
FILE: tests/test_app/templates/element/deeply/nested.php
================================================


================================================
FILE: tests/test_app/templates/element/example.php
================================================


================================================
FILE: tests/test_app/templates/layout/ajax.php
================================================
<?php


================================================
FILE: tests/test_app/tests/Fixture/SmallWindowsFixture.php
================================================
<?php

namespace TestApp\Test\Fixture;

use Cake\TestSuite\Fixture\TestFixture;

class SmallWindowsFixture extends TestFixture {

	/**
	 * Fields
	 */
	public array $fields = [
		'id' => ['type' => 'integer', 'length' => 11, 'unsigned' => false, 'null' => false, 'default' => null, 'comment' => '', 'autoIncrement' => true, 'precision' => null],
		'name' => ['type' => 'string', 'length' => 255, 'null' => false, 'default' => null, 'comment' => '', 'precision' => null, 'fixed' => null],
		'_constraints' => [
			'primary' => ['type' => 'primary', 'columns' => ['id'], 'length' => []],
		],
		'_options' => [
			'engine' => 'InnoDB',
			'collation' => 'utf8_general_ci',
		],
	];

	/**
	 * Records
	 */
	public array $records = [
		[
			'id' => 1,
			'name' => 'Lorem ipsum dolor sit amet',
		],
	];

}


================================================
FILE: tests/test_app/vendor/cakephp/cakephp/tests/Fixture/PostsFixture.php
================================================
<?php

namespace Cake\Test\Fixture;

use Cake\TestSuite\Fixture\TestFixture;

class PostsFixture extends TestFixture
{
    /**
     * @var array
     */
    public array $records = [
        ['author_id' => 1, 'title' => 'First Post', 'body' => 'First Post Body', 'published' => 'Y'],
        ['author_id' => 3, 'title' => 'Second Post', 'body' => 'Second Post Body', 'published' => 'Y'],
        ['author_id' => 1, 'title' => 'Third Post', 'body' => 'Third Post Body', 'published' => 'Y'],
    ];
}


================================================
FILE: tests/test_files/ClassAnnotation/TableFind/before.php
================================================
<?php

namespace App\Controller;

use Cake\ORM\Locator\LocatorAwareTrait;

/** @property \Cake\ORM\Table $Residents */
class TestMeController
{
	use LocatorAwareTrait;

	public function test(): void {
		$residentsTable = $this->fetchTable('Residents');
		$resident = $residentsTable->find(
			'all',
			[
				'contain' => ['Units', 'Rooms'],
			],
		)->first();

		$residentOther = $residentsTable->find(
			'all',
			[
				'contain' => ['Units', 'Rooms'],
			],
		)->firstOrFail();

		$residentX = $this->Residents->find(
			'all',
			[
				'contain' => ['Units', 'Rooms'],
			],
		)->first();

		$residentY = $this->Residents->find(
			'all',
			[
				'contain' => ['Units', 'Rooms'],
			],
		)->firstOrFail();
	}

}


================================================
FILE: tests/test_files/Command/MyCommand.php
================================================
<?php
namespace TestApp\Command;

use Shim\Command\Command;

/**
 * @property \TestApp\Model\Table\WheelsTable $Wheels
 * @property \TestApp\Model\Table\CarsTable $Cars
 */
class MyCommand extends Command {

	protected ?string $defaultTable = 'Cars';

	/** @var \Relations\Model\Table\BarsTable */
	protected $Bars;

	/**
	 * @return void
	 */
	public function main() {
		$this->Wheels = $this->fetchTable('Wheels');
		$this->Bars = $this->fetchTable('Relations.Bars');
	}

}


================================================
FILE: tests/test_files/Controller/AppController.php
================================================
<?php
namespace TestApp\Controller;

use Cake\Controller\Controller;

/**
 * @property \TestApp\Controller\Component\MyOtherComponent $MyOther
 * @property \TestApp\Controller\Component\CheckHttpCacheComponent $CheckHttpCache
 */
class AppController extends Controller {

	/**
	 * @return void
	 */
	public function initialize(): void {
		parent::initialize();

		$this->loadComponent('Flash');
		$this->loadComponent('CheckHttpCache');
		$this->loadComponent('MyOther');
	}

}


================================================
FILE: tests/test_files/Controller/BarController.php
================================================
<?php
namespace TestApp\Controller;

use TestApp\Model\Table\WheelsTable;

/**
 * @property \TestApp\Model\Table\BarBarsTable $BarBars
 * @property \MyNamespace\MyPlugin\Controller\Component\MyComponent $My
 *
 * @method \TestApp\Model\Entity\BarBar[]|\Cake\Datasource\ResultSetInterface<\TestApp\Model\Entity\BarBar> paginate(\Cake\Datasource\RepositoryInterface|\Cake\Datasource\QueryInterface|string|null $object = null, array $settings = [])
 */
class BarController extends AppController {

	protected ?string $defaultTable = 'BarBars';

	protected WheelsTable $Wheels;

	/**
	 * @return void
	 */
	public function initialize(): void {
		parent::initialize();

		$this->loadComponent('Flash');
		$this->loadComponent('MyNamespace/MyPlugin.My');

		$this->Wheels = $this->fetchTable('Wheels');
	}

	/**
	 * @return \Cake\Http\Response|null|void
	 */
	public function index() {
		$this->paginate($this->BarBars);
	}

}


================================================
FILE: tests/test_files/Controller/Component/MyComponent.php
================================================
<?php
namespace TestApp\Controller\Component;

use Cake\Controller\Component;

/**
 * @property \Cake\Controller\Component\FlashComponent $Flash
 * @property \TestApp\Controller\Component\CheckHttpCacheComponent $CheckHttpCache
 * @property \MyNamespace\MyPlugin\Controller\Component\MyComponent $My
 */
class MyComponent extends Component {

	public array $components = ['Flash', 'CheckHttpCache', 'MyNamespace/MyPlugin.My'];

}


================================================
FILE: tests/test_files/Controller/Component/MyControllerComponent.php
================================================
<?php
namespace TestApp\Controller\Component;

use Cake\Controller\Component;
use Cake\Event\EventInterface;

/**
 * @method \TestApp\Controller\AppController getController()
 */
class MyControllerComponent extends Component {

	/**
	 * @param \Cake\Event\EventInterface $event
	 *
	 * @return void
	 */
	public function beforeFilter(EventInterface $event): void {
		$user = (bool)$this->getController()->AuthUser->user();
	}

}


================================================
FILE: tests/test_files/Controller/Component/MyOtherComponent.php
================================================
<?php
namespace TestApp\Controller\Component;

use Cake\Controller\Component;

/**
 * @property \TestApp\Controller\Component\CheckHttpCacheComponent $CheckHttpCache
 * @property \Cake\Controller\Component\FormProtectionComponent $FormProtection
 * @property \Cake\Controller\Component\FlashComponent $Flash
 */
class MyOtherComponent extends Component {

	public array $components = ['Flash', 'CheckHttpCache', 'SomeInvalidOneWillBeIgnored', 'FormProtection'];

}


================================================
FILE: tests/test_files/Controller/DynamicPropertiesController.php
================================================
<?php
namespace TestApp\Controller;

/**
 * @property \TestApp\Model\Table\BarBarsTable $BarBars
 */
#[\AllowDynamicProperties]
class DynamicPropertiesController extends AppController {

	protected ?string $defaultTable = 'BarBars';

}


================================================
FILE: tests/test_files/Controller/DynamicPropertiesExistingDocblockController.php
================================================
<?php
namespace TestApp\Controller;

/**
 * Existing docblock
 *
 * @property \TestApp\Model\Table\BarBarsTable $BarBars
 */
#[\AllowDynamicProperties]
class DynamicPropertiesExistingDocblockController extends AppController {

	protected ?string $defaultTable = 'BarBars';

}


================================================
FILE: tests/test_files/Controller/FoosController.php
================================================
<?php
namespace TestApp\Controller;

/**
 * @property \TestApp\Model\Table\FoosTable $Foos
 */
class FoosController extends AppController {
}


================================================
FILE: tests/test_files/Controller/HousesController.php
================================================
<?php
namespace Controllers\Controller;

use Cake\Controller\Controller;

/**
 * @property \Controllers\Model\Table\HousesTable $Houses
 */
class HousesController extends Controller {
}


================================================
FILE: tests/test_files/Controller/WindowsController.php
================================================
<?php
namespace Controllers\Controller;

use Cake\Controller\Controller;

/**
 * @property \Awesome\Model\Table\WindowsTable $Windows
 */
class WindowsController extends Controller {

	protected ?string $defaultTable = 'Awesome.Windows';

}


================================================
FILE: tests/test_files/Custom/CustomClass.php
================================================
<?php
namespace TestApp\Custom;

use Cake\Datasource\ModelAwareTrait;

/**
 * @property \TestApp\Model\Table\FoosTable $Foos
 */
class CustomClass {

	use ModelAwareTrait;

	/**
	 * @return void
	 */
	public function initialize() {
		$this->fetchModel('Foos');
	}

}


================================================
FILE: tests/test_files/Custom/Nested/NestedClass.php
================================================
<?php
namespace TestApp\Custom\Nested;

use Cake\Datasource\ModelAwareTrait;

/**
 * @property \TestApp\Model\Table\FoosTable $Foos
 */
class NestedClass {

	use ModelAwareTrait;

	/**
	 * @return void
	 */
	public function initialize() {
		$this->loadModel('Foos');
	}

}


================================================
FILE: tests/test_files/FormAnnotation/FormAnnotation.existing.php
================================================
<?php
namespace TestApp\Foo;

use TestApp\Form\DocForm;

class FormAnnotation {

	public function test() {
		$docForm = new DocForm();
		/** @uses \TestApp\Form\DocForm::_execute() */
		$docForm->execute();
	}
}


================================================
FILE: tests/test_files/FormAnnotation/FormAnnotation.missing.php
================================================
<?php
namespace TestApp\Foo;

use TestApp\Form\DocForm;

class FormAnnotation {

	public function test() {
		$docForm = new DocForm();
		$docForm->execute();
	}
}


================================================
FILE: tests/test_files/MailerAnnotation/MailerAnnotation.existing.php
================================================
<?php
namespace TestApp\Foo;

use TestApp\Mailer\NotificationMailer;

class MailerAnnotation {

	public function test($notificationMailer) {
		/** @uses \TestApp\Mailer\NotificationMailer::notify() */
		$notificationMailer->send('notify', []);
	}
}


================================================
FILE: tests/test_files/MailerAnnotation/MailerAnnotation.invalid.php
================================================
<?php
namespace TestApp\Mailer;

class DebugMailer {

	/**
	 * Usage: $this->getMailer('Debug')->send('test');
	 *
	 * @return self
	 */
	public function test(): self {
		$this->setTransport('gmail')
			->setTo('info@pfiff.me')
			->setSubject('Debug Email')
			->setEmailFormat('html')
			->viewBuilder()
			->setTemplate('default');

		return $this;
	}

}


================================================
FILE: tests/test_files/MailerAnnotation/MailerAnnotation.missing.php
================================================
<?php
namespace TestApp\Foo;

class MailerAnnotation {

	public function test() {
		$notificationMailer = $this->getMailer('Notification');

		$notificationMailer->send('notify', []);
	}
}


================================================
FILE: tests/test_files/MailerAnnotation/MailerAnnotation.missing2.php
================================================
<?php
namespace TestApp\Foo;

class MailerAnnotation {

	public function test() {
		$this->getMailer('Notification')->send('notify', []);
	}
}


================================================
FILE: tests/test_files/MailerAnnotation/MailerAnnotation.missing3.php
================================================
<?php
namespace TestApp\Foo;

class MailerAnnotation {

	public function test() {
		$this->getMailer('Notification')
			->send('notify', []);
	}
}


================================================
FILE: tests/test_files/Model/Entity/Car.php
================================================
<?php
namespace TestApp\Model\Entity;

use Cake\ORM\Entity;

/**
 * My car entity which is very cool.
 *
 * @property int $id
 * @property string $name
 * @property string $content
 * @property \Cake\I18n\DateTime $created
 * @property \Cake\I18n\DateTime|null $modified
 * @property \TestApp\Model\Enum\CarStatus $status
 * @property \TestApp\Model\Entity\Wheel[] $wheels
 */
class Car extends Entity {
}


================================================
FILE: tests/test_files/Model/Entity/Complex/Wheel.php
================================================
<?php
namespace TestApp\Model\Entity;

use Cake\ORM\Entity;

/**
 * @property array{user?: int, account?: int|string, newContacts?: array<mixed>}|null $params !
 * @property int $id
 * @property string $name
 * @property string $content
 * @property \Cake\I18n\DateTime $created
 *
 * @property-read string|null $virtual_one
 * @property \TestApp\Model\Entity\Car $car
 */
class Wheel extends Entity {

	protected array $_virtual = [
		'virtual_one',
	];

	/**
	 * @return string|null
	 */
	protected function _getVirtualOne() {
		return 'Virtual One';
	}

}


================================================
FILE: tests/test_files/Model/Entity/Constants/Wheel.php
================================================
<?php
namespace TestApp\Model\Entity;

use Cake\ORM\Entity;

/**
 * @property array{user?: int, account?: int|string, newContacts?: array<mixed>}|null $params !
 * @property int $id
 * @property string $name
 * @property string $content
 * @property \Cake\I18n\Date $offer_date
 * @property \Cake\I18n\DateTime $created
 * @property \Cake\I18n\DateTime|null $modified
 * @property \TestApp\Model\Entity\Wheel[] $wheels
 *
 * @property-read string|null $virtual_one
 */
class Wheel extends Entity {

	protected array $_virtual = [
		'virtual_one',
	];

	/**
	 * @return string|null
	 */
	protected function _getVirtualOne() {
		return 'Virtual One';
	}

	const FIELD_PARAMS = 'params';
	const FIELD_ID = 'id';
	const FIELD_NAME = 'name';
	const FIELD_CONTENT = 'content';
	const FIELD_OFFER_DATE = 'offer_date';
	const FIELD_CREATED = 'created';
	const FIELD_MODIFIED = 'modified';
	const FIELD_WHEELS = 'wheels';
	const FIELD_VIRTUAL_ONE = 'virtual_one';

}


================================================
FILE: tests/test_files/Model/Entity/Constants/WheelComplex.php
================================================
<?php
namespace TestApp\Model\Entity;

use Cake\ORM\Entity;

/**
 * @property array{utm_tags: array<mixed>|null}|null $params !
 * @property int $id
 * @property string $name
 * @property string $content
 * @property \Cake\I18n\Date $offer_date
 * @property \Cake\I18n\DateTime $created
 * @property \Cake\I18n\DateTime|null $modified
 * @property \TestApp\Model\Entity\Wheel[] $wheels
 *
 * @property-read string|null $virtual_one
 */
class Wheel extends Entity {

	protected array $_virtual = [
		'virtual_one',
	];

	/**
	 * @return string|null
	 */
	protected function _getVirtualOne() {
		return 'Virtual One';
	}

	const FIELD_PARAMS = 'params';
	const FIELD_ID = 'id';
	const FIELD_NAME = 'name';
	const FIELD_CONTENT = 'content';
	const FIELD_OFFER_DATE = 'offer_date';
	const FIELD_CREATED = 'created';
	const FIELD_MODIFIED = 'modified';
	const FIELD_WHEELS = 'wheels';
	const FIELD_VIRTUAL_ONE = 'virtual_one';

}


================================================
FILE: tests/test_files/Model/Entity/ConstantsPartial/Wheel.php
================================================
<?php
namespace TestApp\Model\Entity;

use Cake\ORM\Entity;

/**
 * @property int $id
 * @property string $name
 * @property string $content
 * @property \Cake\I18n\DateTime $created
 * @property \Cake\I18n\DateTime|null $modified
 * @property-read string|null $virtual_one
 * @property mixed $virtual_two
 * @property \TestApp\Model\Entity\Wheel[] $wheels
 */
class Wheel extends Entity {

	const OTHER_NAME = 'unrelated';

	const FIELD_ID = 'id';
	const FIELD_NAME = 'name';
	const FIELD_CONTENT = 'content';
	const FIELD_CREATED = 'created';
	const FIELD_WHEELS = 'wheels';
	const FIELD_VIRTUAL_TWO = 'virtual_two';

	protected array $_virtual = [
		'virtual_one',
	];

	/**
	 * @return string|null
	 */
	protected function _getVirtualOne() {
		return 'Virtual One';
	}

	protected function _getVirtualTwo() {
		// Missing return type and docblock means mixed as result
		return 'Virtual Two';
	}

	/**
	 * @param \TestApp\Model\Entity\Wheel[] $wheels
	 *
	 * @return \TestApp\Model\Entity\Wheel[]
	 */
	protected function _getWheels($wheels = []) {
		return $wheels;
	}

}


================================================
FILE: tests/test_files/Model/Entity/ConstantsPartialResult/Wheel.php
================================================
<?php
namespace TestApp\Model\Entity;

use Cake\ORM\Entity;

/**
 * @property int $id
 * @property string $name
 * @property string $content
 * @property \Cake\I18n\DateTime $created
 * @property \Cake\I18n\DateTime|null $modified
 * @property-read string|null $virtual_one
 * @property mixed $virtual_two
 * @property \TestApp\Model\Entity\Wheel[] $wheels
 */
class Wheel extends Entity {

	const OTHER_NAME = 'unrelated';

	const FIELD_ID = 'id';
	const FIELD_NAME = 'name';
	const FIELD_CONTENT = 'content';
	const FIELD_CREATED = 'created';
	const FIELD_WHEELS = 'wheels';
	const FIELD_VIRTUAL_TWO = 'virtual_two';
	const FIELD_MODIFIED = 'modified';
	const FIELD_VIRTUAL_ONE = 'virtual_one';

	protected array $_virtual = [
		'virtual_one',
	];

	/**
	 * @return string|null
	 */
	protected function _getVirtualOne() {
		return 'Virtual One';
	}

	protected function _getVirtualTwo() {
		// Missing return type and docblock means mixed as result
		return 'Virtual Two';
	}

	/**
	 * @param \TestApp\Model\Entity\Wheel[] $wheels
	 *
	 * @return \TestApp\Model\Entity\Wheel[]
	 */
	protected function _getWheels($wheels = []) {
		return $wheels;
	}

}


================================================
FILE: tests/test_files/Model/Entity/Foo.php
================================================
<?php
namespace TestApp\Model\Entity;

use Cake\ORM\Entity;

/**
 * @property array|null $params
 * @property int $id
 * @property \Cake\I18n\DateTime $created
 * @property string $name
 * @property string $content
 * @property \Cake\I18n\Date $offer_date
 * @property \Cake\I18n\DateTime|null $modified
 */
class Foo extends Entity {
}


================================================
FILE: tests/test_files/Model/Entity/PHP/ComplexType.php
================================================
<?php
namespace TestApp\Model\Entity\PHP;

use Cake\ORM\Entity;

/**
 * @property int $id
 * @property string $name
 * @property string $content
 * @property \Cake\I18n\DateTime $created
 * @property \Cake\I18n\DateTime|null $modified
 * @property array{foo: array<mixed>|null}|null $params !
 * @property \Cake\I18n\Date $offer_date
 */
class ComplexType extends Entity {
}


================================================
FILE: tests/test_files/Model/Entity/PHP/Duplicates.php
================================================
<?php
namespace TestApp\Model\Entity\PHP;

use Cake\ORM\Entity;

/**
 * @property int $id
 * @property string $name
 * @property string $content
 * @property \Cake\I18n\DateTime $created
 * @property \Cake\I18n\DateTime|null $modified
 * @property \Cake\I18n\Date $offer_date
 * @property array|null $params
 */
class Duplicates extends Entity {
}


================================================
FILE: tests/test_files/Model/Entity/PHP/Generics.php
================================================
<?php
namespace TestApp\Model\Entity\PHP;

use Cake\ORM\Entity;

/**
 * @property array|null $params
 * @property int $id
 * @property string $name
 * @property string $content
 * @property \Cake\I18n\DateTime $created
 * @property \Cake\I18n\DateTime|null $modified
 * @property array<\TestApp\Model\Entity\Wheel> $wheels
 * @property \Cake\I18n\Date $offer_date
 */
class Generics extends Entity {
}


================================================
FILE: tests/test_files/Model/Entity/PHP7/Virtual.php
================================================
<?php
namespace TestApp\Model\Entity\PHP7;

use Cake\ORM\Entity;

/**
 * @property array|null $params
 * @property int $id
 * @property string $name
 * @property string $content
 * @property \Cake\I18n\Date $offer_date
 * @property \Cake\I18n\DateTime $created
 * @property \Cake\I18n\DateTime|null $modified
 * @property string $virtual_two
 * @property array<int, array<string>> $nested_generic
 * @property \TestApp\Model\Entity\Wheel[] $wheels
 *
 * @property-read string|null $virtual_one
 */
class Virtual extends Entity {

	protected function _getVirtualOne(): ?string {
		return 'Virtual One';
	}

	protected function _getVirtualTwo(): string {
		return 'Virtual Two';
	}

	/**
	 * @return array<int, array<string>>
	 */
	protected function _getNestedGeneric(): array {
		return [[1 => ['a', 'b']]];
	}

}


================================================
FILE: tests/test_files/Model/Entity/Relations/Bar.php
================================================
<?php
namespace Relations\Model\Entity;

use Cake\ORM\Entity;

/**
 * @property int $id
 * @property string $name
 * @property int|null $user_id
 * @property \Relations\Model\Entity\User|null $user
 */
class Bar extends Entity {
}


================================================
FILE: tests/test_files/Model/Entity/Relations/Foo.php
================================================
<?php
namespace Relations\Model\Entity;

use Cake\ORM\Entity;

/**
 * @property array|null $params
 * @property int $id
 * @property string $name
 * @property int $user_id
 * @property \Relations\Model\Entity\User $user
 */
class Foo extends Entity {
}


================================================
FILE: tests/test_files/Model/Entity/Relations/User.php
================================================
<?php
namespace Relations\Model\Entity;

use Cake\ORM\Entity;

/**
 * @property int $id
 * @property string $name
 * @property \Relations\Model\Entity\Foo|null $foo
 * @property \Relations\Model\Entity\Bar|null $bar
 */
class User extends Entity {
}


================================================
FILE: tests/test_files/Model/Entity/Virtual.php
================================================
<?php
namespace TestApp\Model\Entity;

use Cake\ORM\Entity;

/**
 * @property-read bool $virtual_read_only This should be kept.
 * @property array|null $params
 * @property int $id
 * @property string $name
 * @property string $content
 * @property \Cake\I18n\Date $offer_date
 * @property \Cake\I18n\DateTime $created
 * @property \Cake\I18n\DateTime|null $modified
 * @property mixed $virtual_two
 * @property \TestApp\Model\Entity\Wheel[] $wheels
 * @property-read string|null $virtual_one
 */
class Virtual extends Entity {

	protected array $_virtual = [
		'virtual_one',
	];

	/**
	 * @return string|null
	 */
	protected function _getVirtualOne() {
		return 'Virtual One';
	}

	protected function _getVirtualTwo() {
		// Missing return type and docblock means mixed as result
		return 'Virtual Two';
	}

	/**
	 * @return bool
	 */
	protected function _getVirtualReadOnly() {
		return true;
	}

	/**
	 * @param \TestApp\Model\Entity\Wheel[] $wheels
	 *
	 * @return \TestApp\Model\Entity\Wheel[]
	 */
	protected function _getWheels($wheels = []) {
		return $wheels;
	}

}


================================================
FILE: tests/test_files/Model/Entity/Wheel.php
================================================
<?php
namespace TestApp\Model\Entity;

use Cake\ORM\Entity;

/**
 * @property array|null $params
 * @property int $id
 * @property string $name
 * @property string $content
 * @property \Cake\I18n\Date $offer_date
 * @property \Cake\I18n\DateTime $created
 * @property \Cake\I18n\DateTime|null $modified
 * @property \TestApp\Model\Entity\Wheel[] $wheels
 *
 * @property-read string|null $virtual_one
 */
class Wheel extends Entity {

	protected array $_virtual = [
		'virtual_one',
	];

	/**
	 * @return string|null
	 */
	protected function _getVirtualOne() {
		return 'Virtual One';
	}

}


================================================
FILE: tests/test_files/Model/Table/BarBarsAbstractTable.php
================================================
<?php
namespace TestApp\Model\Table;

/**
 * @property \Cake\ORM\Association\BelongsTo<\TestApp\Model\Table\FoosTable> $Foos
 * @property \Cake\ORM\Association\BelongsToMany<\Awesome\Model\Table\HousesTable> $Houses
 *
 * @method \TestApp\Model\Entity\BarBarsAbstract newEmptyEntity()
 * @method \TestApp\Model\Entity\BarBarsAbstract newEntity(array $data, array $options = [])
 * @method \TestApp\Model\Entity\BarBarsAbstract[] newEntities(array $data, array $options = [])
 * @method \TestApp\Model\Entity\BarBarsAbstract get(mixed $primaryKey, array|string $finder = 'all', \Psr\SimpleCache\CacheInterface|string|null $cache = null, \Closure|string|null $cacheKey = null, mixed ...$args)
 * @method \TestApp\Model\Entity\BarBarsAbstract findOrCreate(\Cake\ORM\Query\SelectQuery|callable|array $search, ?callable $callback = null, array $options = [])
 * @method \TestApp\Model\Entity\BarBarsAbstract patchEntity(\Cake\Datasource\EntityInterface $entity, array $data, array $options = [])
 * @method \TestApp\Model\Entity\BarBarsAbstract[] patchEntities(iterable $entities, array $data, array $options = [])
 * @method \TestApp\Model\Entity\BarBarsAbstract|false save(\Cake\Datasource\EntityInterface $entity, array $options = [])
 * @method \TestApp\Model\Entity\BarBarsAbstract saveOrFail(\Cake\Datasource\EntityInterface $entity, array $options = [])
 * @method \TestApp\Model\Entity\BarBarsAbstract[]|\Cake\Datasource\ResultSetInterface<\TestApp\Model\Entity\BarBarsAbstract>|false saveMany(iterable $entities, array $options = [])
 * @method \TestApp\Model\Entity\BarBarsAbstract[]|\Cake\Datasource\ResultSetInterface<\TestApp\Model\Entity\BarBarsAbstract> saveManyOrFail(iterable $entities, array $options = [])
 * @method \TestApp\Model\Entity\BarBarsAbstract[]|\Cake\Datasource\ResultSetInterface<\TestApp\Model\Entity\BarBarsAbstract>|false deleteMany(iterable $entities, array $options = [])
 * @method \TestApp\Model\Entity\BarBarsAbstract[]|\Cake\Datasource\ResultSetInterface<\TestApp\Model\Entity\BarBarsAbstract> deleteManyOrFail(iterable $entities, array $options = [])
 *
 * @mixin \Cake\ORM\Behavior\TimestampBehavior
 * @mixin \MyNamespace\MyPlugin\Model\Behavior\MyBehavior
 *
 * @extends \TestApp\Model\Table\AbstractTable<array{MyMy: \MyNamespace\MyPlugin\Model\Behavior\MyBehavior, Timestamp: \Cake\ORM\Behavior\TimestampBehavior}>
 */
class BarBarsAbstractTable extends AbstractTable {

	/**
	 * @param array $config
	 * @return void
	 */
	public function initialize(array $config): void {
		parent::initialize($config);

		$this->setTable('bar_bars');
		$this->belongsTo('Foos');
		$this->belongsToMany('Houses', [
			'className' => 'Awesome.Houses',
			'through' => 'Awesome.Windows',
		]);
		$this->addBehavior('MyMy', [
			'className' => 'MyNamespace/MyPlugin.My',
		]);
	}

}


================================================
FILE: tests/test_files/Model/Table/BarBarsDetailedTable.php
================================================
<?php
namespace TestApp\Model\Table;

use Cake\ORM\Table;

/**
 * @property \Cake\ORM\Association\BelongsTo<\TestApp\Model\Table\FoosTable> $Foos
 * @property \Cake\ORM\Association\BelongsToMany<\Awesome\Model\Table\HousesTable> $Houses
 *
 * @method \TestApp\Model\Entity\BarBar newEmptyEntity()
 * @method \TestApp\Model\Entity\BarBar newEntity(array<string, mixed> $data, array<string, mixed> $options = [])
 * @method array<\TestApp\Model\Entity\BarBar> newEntities(array<array<string, mixed>> $data, array<string, mixed> $options = [])
 * @method \TestApp\Model\Entity\BarBar get(mixed $primaryKey, array<string, mixed>|string $finder = 'all', \Psr\SimpleCache\CacheInterface|string|null $cache = null, \Closure|string|null $cacheKey = null, mixed ...$args)
 * @method \TestApp\Model\Entity\BarBar findOrCreate(\Cake\ORM\Query\SelectQuery<\TestApp\Model\Entity\BarBar>|callable|array<string, mixed> $search, ?callable $callback = null, array<string, mixed> $options = [])
 * @method \TestApp\Model\Entity\BarBar patchEntity(\Cake\Datasource\EntityInterface $entity, array<string, mixed> $data, array<string, mixed> $options = [])
 * @method array<\TestApp\Model\Entity\BarBar> patchEntities(iterable<\TestApp\Model\Entity\BarBar> $entities, array<array<string, mixed>> $data, array<string, mixed> $options = [])
 * @method \TestApp\Model\Entity\BarBar|false save(\Cake\Datasource\EntityInterface $entity, array<string, mixed> $options = [])
 * @method \TestApp\Model\Entity\BarBar saveOrFail(\Cake\Datasource\EntityInterface $entity, array<string, mixed> $options = [])
 * @method \Cake\Datasource\ResultSetInterface<int, \TestApp\Model\Entity\BarBar>|false saveMany(iterable<\TestApp\Model\Entity\BarBar> $entities, array<string, mixed> $options = [])
 * @method \Cake\Datasource\ResultSetInterface<int, \TestApp\Model\Entity\BarBar> saveManyOrFail(iterable<\TestApp\Model\Entity\BarBar> $entities, array<string, mixed> $options = [])
 * @method \Cake\Datasource\ResultSetInterface<int, \TestApp\Model\Entity\BarBar>|false deleteMany(iterable<\TestApp\Model\Entity\BarBar> $entities, array<string, mixed> $options = [])
 * @method \Cake\Datasource\ResultSetInterface<int, \TestApp\Model\Entity\BarBar> deleteManyOrFail(iterable<\TestApp\Model\Entity\BarBar> $entities, array<string, mixed> $options = [])
 *
 * @mixin \Cake\ORM\Behavior\TimestampBehavior
 * @mixin \MyNamespace\MyPlugin\Model\Behavior\MyBehavior
 *
 * @extends \Cake\ORM\Table<array{My: \MyNamespace\MyPlugin\Model\Behavior\MyBehavior, Timestamp: \Cake\ORM\Behavior\TimestampBehavior}>
 */
class BarBarsTable extends Table {

	/**
	 * @param array $config
	 * @return void
	 */
	public function initialize(array $config): void {
		parent::initialize($config);

		$this->belongsTo('Foos');
		$this->belongsToMany('Houses', [
			'className' => 'Awesome.Houses',
			'through' => 'Awesome.Windows',
		]);
		$this->addBehavior('Timestamp');
		$this->addBehavior('MyNamespace/MyPlugin.My');
	}

}


================================================
FILE: tests/test_files/Model/Table/BarBarsEntityTemplateTable.php
================================================
<?php
namespace TestApp\Model\Table;

use Cake\ORM\Table;

/**
 * @property \Cake\ORM\Association\BelongsTo<\TestApp\Model\Table\FoosTable> $Foos
 * @property \Cake\ORM\Association\BelongsToMany<\Awesome\Model\Table\HousesTable> $Houses
 *
 * @method \TestApp\Model\Entity\BarBar newEmptyEntity()
 * @method \TestApp\Model\Entity\BarBar newEntity(array $data, array $options = [])
 * @method \TestApp\Model\Entity\BarBar[] newEntities(array $data, array $options = [])
 * @method \TestApp\Model\Entity\BarBar get(mixed $primaryKey, array|string $finder = 'all', \Psr\SimpleCache\CacheInterface|string|null $cache = null, \Closure|string|null $cacheKey = null, mixed ...$args)
 * @method \TestApp\Model\Entity\BarBar findOrCreate(\Cake\ORM\Query\SelectQuery|callable|array $search, ?callable $callback = null, array $options = [])
 * @method \TestApp\Model\Entity\BarBar patchEntity(\Cake\Datasource\EntityInterface $entity, array $data, array $options = [])
 * @method \TestApp\Model\Entity\BarBar[] patchEntities(iterable $entities, array $data, array $options = [])
 * @method \TestApp\Model\Entity\BarBar|false save(\Cake\Datasource\EntityInterface $entity, array $options = [])
 * @method \TestApp\Model\Entity\BarBar saveOrFail(\Cake\Datasource\EntityInterface $entity, array $options = [])
 * @method \TestApp\Model\Entity\BarBar[]|\Cake\Datasource\ResultSetInterface<\TestApp\Model\Entity\BarBar>|false saveMany(iterable $entities, array $options = [])
 * @method \TestApp\Model\Entity\BarBar[]|\Cake\Datasource\ResultSetInterface<\TestApp\Model\Entity\BarBar> saveManyOrFail(iterable $entities, array $options = [])
 * @method \TestApp\Model\Entity\BarBar[]|\Cake\Datasource\ResultSetInterface<\TestApp\Model\Entity\BarBar>|false deleteMany(iterable $entities, array $options = [])
 * @method \TestApp\Model\Entity\BarBar[]|\Cake\Datasource\ResultSetInterface<\TestApp\Model\Entity\BarBar> deleteManyOrFail(iterable $entities, array $options = [])
 *
 * @mixin \Cake\ORM\Behavior\TimestampBehavior
 * @mixin \MyNamespace\MyPlugin\Model\Behavior\MyBehavior
 *
 * @extends \Cake\ORM\Table<array{My: \MyNamespace\MyPlugin\Model\Behavior\MyBehavior, Timestamp: \Cake\ORM\Behavior\TimestampBehavior}, \TestApp\Model\Entity\BarBar>
 */
class BarBarsTable extends Table {

	/**
	 * @param array $config
	 * @return void
	 */
	public function initialize(array $config): void {
		parent::initialize($config);

		$this->belongsTo('Foos');
		$this->belongsToMany('Houses', [
			'className' => 'Awesome.Houses',
			'through' => 'Awesome.Windows',
		]);
		$this->addBehavior('Timestamp');
		$this->addBehavior('MyNamespace/MyPlugin.My');
	}

}


================================================
FILE: tests/test_files/Model/Table/BarBarsTable.php
================================================
<?php
namespace TestApp\Model\Table;

use Cake\ORM\Table;

/**
 * @property \Cake\ORM\Association\BelongsTo<\TestApp\Model\Table\FoosTable> $Foos
 * @property \Cake\ORM\Association\BelongsToMany<\Awesome\Model\Table\HousesTable> $Houses
 *
 * @method \TestApp\Model\Entity\BarBar newEmptyEntity()
 * @method \TestApp\Model\Entity\BarBar newEntity(array $data, array $options = [])
 * @method \TestApp\Model\Entity\BarBar[] newEntities(array $data, array $options = [])
 * @method \TestApp\Model\Entity\BarBar get(mixed $primaryKey, array|string $finder = 'all', \Psr\SimpleCache\CacheInterface|string|null $cache = null, \Closure|string|null $cacheKey = null, mixed ...$args)
 * @method \TestApp\Model\Entity\BarBar findOrCreate(\Cake\ORM\Query\SelectQuery|callable|array $search, ?callable $callback = null, array $options = [])
 * @method \TestApp\Model\Entity\BarBar patchEntity(\Cake\Datasource\EntityInterface $entity, array $data, array $options = [])
 * @method \TestApp\Model\Entity\BarBar[] patchEntities(iterable $entities, array $data, array $options = [])
 * @method \TestApp\Model\Entity\BarBar|false save(\Cake\Datasource\EntityInterface $entity, array $options = [])
 * @method \TestApp\Model\Entity\BarBar saveOrFail(\Cake\Datasource\EntityInterface $entity, array $options = [])
 * @method \TestApp\Model\Entity\BarBar[]|\Cake\Datasource\ResultSetInterface<\TestApp\Model\Entity\BarBar>|false saveMany(iterable $entities, array $options = [])
 * @method \TestApp\Model\Entity\BarBar[]|\Cake\Datasource\ResultSetInterface<\TestApp\Model\Entity\BarBar> saveManyOrFail(iterable $entities, array $options = [])
 * @method \TestApp\Model\Entity\BarBar[]|\Cake\Datasource\ResultSetInterface<\TestApp\Model\Entity\BarBar>|false deleteMany(iterable $entities, array $options = [])
 * @method \TestApp\Model\Entity\BarBar[]|\Cake\Datasource\ResultSetInterface<\TestApp\Model\Entity\BarBar> deleteManyOrFail(iterable $entities, array $options = [])
 *
 * @mixin \Cake\ORM\Behavior\TimestampBehavior
 * @mixin \MyNamespace\MyPlugin\Model\Behavior\MyBehavior
 *
 * @extends \Cake\ORM\Table<array{My: \MyNamespace\MyPlugin\Model\Behavior\MyBehavior, Timestamp: \Cake\ORM\Behavior\TimestampBehavior}>
 */
class BarBarsTable extends Table {

	/**
	 * @param array $config
	 * @return void
	 */
	public function initialize(array $config): void {
		parent::initialize($config);

		$this->belongsTo('Foos');
		$this->belongsToMany('Houses', [
			'className' => 'Awesome.Houses',
			'through' => 'Awesome.Windows',
		]);
		$this->addBehavior('Timestamp');
		$this->addBehavior('MyNamespace/MyPlugin.My');
	}

}


================================================
FILE: tests/test_files/Model/Table/CallbacksTable.php
================================================
<?php
namespace TestApp\Model\Table;

use ArrayObject;
use Cake\Datasource\EntityInterface;
use Cake\Event\Event;
use Cake\Event\EventInterface;
use Cake\ORM\Table;

class CallbacksTable extends Table {

	/**
	 * @param \Cake\Event\Event $event Event
	 * @param \TestApp\Model\Entity\Callback $entity Entity
	 * @param \ArrayObject $options Options
	 * @return void
	 */
	public function beforeSave(Event $event, EntityInterface $entity, ArrayObject $options) {
	}

	/**
	 * @param \Cake\Event\EventInterface $event
	 * @param \TestApp\Model\Entity\Callback $entity
	 * @param \ArrayObject $options
	 * @return void
	 */
	public function afterSave(EventInterface $event, EntityInterface $entity, ArrayObject $options) {
	}

	public function beforeDelete(Event $event, EntityInterface $entity, ArrayObject $options) {
	}

}


================================================
FILE: tests/test_files/Model/Table/FooTable.php
================================================
<?php
namespace TestApp\Model\Table;

use Cake\ORM\Table;

/**
 * @method \TestApp\Model\Entity\Foo get(mixed $primaryKey, array|string $finder = 'all', \Psr\SimpleCache\CacheInterface|string|null $cache = null, \Closure|string|null $cacheKey = null, mixed ...$args)
 * @method \TestApp\Model\Entity\Foo newEntity($data = null, array $options = [])
 * @method \TestApp\Model\Entity\Foo[] newEntities(array $data, array $options = [])
 * @method \TestApp\Model\Entity\Foo|false save(\Cake\Datasource\EntityInterface $entity, array $options = [])
 * @method \TestApp\Model\Entity\Foo saveOrFail(\Cake\Datasource\EntityInterface $entity, array $options = [])
 * @method \TestApp\Model\Entity\Foo patchEntity(\Cake\Datasource\EntityInterface $entity, array $data, array $options = [])
 * @method \TestApp\Model\Entity\Foo[] patchEntities($entities, array $data, array $options = [])
 * @method \TestApp\Model\Entity\Foo findOrCreate(\Cake\ORM\Query\SelectQuery|callable|array $search, callable $callback = null, array $options = [])
 *
 * @mixin \Cake\ORM\Behavior\TimestampBehavior
 * @mixin \MyNamespace\MyPlugin\Model\Behavior\MyBehavior
 */
class FooTable extends Table {

	/**
	 * @param array $config
	 * @return void
	 */
	public function initialize(array $config): void {
		parent::initialize($config);

		$this->belongsTo('BarBars');
		$this->belongsTo('Houses', [
			'className' => 'Awesome.Houses'
		]);
		$this->addBehavior('Timestamp');
		$this->addBehavior('MyNamespace/MyPlugin.My');
	}

}


================================================
FILE: tests/test_files/Model/Table/SkipMeTable.php
================================================
<?php
namespace TestApp\Model\Table;

use Cake\ORM\Table;

/**
 * @inheritDoc
 */
class SkipMeTable extends Table {

	/**
	 * @param array $config
	 * @return void
	 */
	public function initialize(array $config): void {
		parent::initialize($config);

		$this->belongsTo('Cars');
	}

}


================================================
FILE: tests/test_files/Model/Table/SkipSomeTable.php
================================================
<?php
namespace TestApp\Model\Table;

use Cake\ORM\Table;

/**
 * @property \Cake\ORM\Association\BelongsTo<\TestApp\Model\Table\CarsTable> $Cars
 * @property \Cake\ORM\Association\BelongsTo<\TestApp\Model\Table\CarsTable> $CarsAwesome
 */
class SkipSomeTable extends Table {

	/**
	 * @param array $config
	 * @return void
	 */
	public function initialize(array $config): void {
		parent::initialize($config);

		$this->belongsTo('Cars');
	}

	/**
	 * @return void
	 */
	public function foo() {
		$this->CarsAwesome->doSthAwesome();
	}

}


================================================
FILE: tests/test_files/Model/Table/Specific/BarBarsAbstractTable.php
================================================
<?php
namespace TestApp\Model\Table;

/**
 * @property \Cake\ORM\Association\BelongsTo<\TestApp\Model\Table\FoosTable> $Foos
 * @property \Cake\ORM\Association\BelongsToMany<\Awesome\Model\Table\HousesTable> $Houses
 *
 * @method \TestApp\Model\Entity\BarBarsAbstract newEmptyEntity()
 * @method \TestApp\Model\Entity\BarBarsAbstract newEntity(array<mixed> $data, array<string, mixed> $options = [])
 * @method \TestApp\Model\Entity\BarBarsAbstract[] newEntities(array<mixed> $data, array<string, mixed> $options = [])
 * @method \TestApp\Model\Entity\BarBarsAbstract get(mixed $primaryKey, array|string $finder = 'all', \Psr\SimpleCache\CacheInterface|string|null $cache = null, \Closure|string|null $cacheKey = null, mixed ...$args)
 * @method \TestApp\Model\Entity\BarBarsAbstract findOrCreate(\Cake\ORM\Query\SelectQuery|callable|array $search, ?callable $callback = null, array<string, mixed> $options = [])
 * @method \TestApp\Model\Entity\BarBarsAbstract patchEntity(\TestApp\Model\Entity\BarBarsAbstract $entity, array<mixed> $data, array<string, mixed> $options = [])
 * @method \TestApp\Model\Entity\BarBarsAbstract[] patchEntities(iterable<\TestApp\Model\Entity\BarBarsAbstract> $entities, array<mixed> $data, array<string, mixed> $options = [])
 * @method \TestApp\Model\Entity\BarBarsAbstract|false save(\TestApp\Model\Entity\BarBarsAbstract $entity, array<string, mixed> $options = [])
 * @method \TestApp\Model\Entity\BarBarsAbstract saveOrFail(\TestApp\Model\Entity\BarBarsAbstract $entity, array<string, mixed> $options = [])
 * @method \Cake\Datasource\ResultSetInterface<\TestApp\Model\Entity\BarBarsAbstract>|false saveMany(iterable<\TestApp\Model\Entity\BarBarsAbstract> $entities, array<string, mixed> $options = [])
 * @method \Cake\Datasource\ResultSetInterface<\TestApp\Model\Entity\BarBarsAbstract> saveManyOrFail(iterable<\TestApp\Model\Entity\BarBarsAbstract> $entities, array<string, mixed> $options = [])
 * @method \Cake\Datasource\ResultSetInterface<\TestApp\Model\Entity\BarBarsAbstract>|false deleteMany(iterable<\TestApp\Model\Entity\BarBarsAbstract> $entities, array<string, mixed> $options = [])
 * @method \Cake\Datasource\ResultSetInterface<\TestApp\Model\Entity\BarBarsAbstract> deleteManyOrFail(iterable<\TestApp\Model\Entity\BarBarsAbstract> $entities, array<string, mixed> $options = [])
 *
 * @mixin \Cake\ORM\Behavior\TimestampBehavior
 * @mixin \MyNamespace\MyPlugin\Model\Behavior\MyBehavior
 */
class BarBarsAbstractTable extends AbstractTable {

	/**
	 * @param array $config
	 * @return void
	 */
	public function initialize(array $config): void {
		parent::initialize($config);

		$this->setTable('bar_bars');
		$this->belongsTo('Foos');
		$this->belongsToMany('Houses', [
			'className' => 'Awesome.Houses',
			'through' => 'Awesome.Windows',
		]);
		$this->addBehavior('MyMy', [
			'className' => 'MyNamespace/MyPlugin.My',
		]);
	}

}


================================================
FILE: tests/test_files/Model/Table/Specific/BarBarsDetailedTable.php
================================================
<?php
namespace TestApp\Model\Table;

use Cake\ORM\Table;

/**
 * @property \Cake\ORM\Association\BelongsTo<\TestApp\Model\Table\FoosTable> $Foos
 * @property \Cake\ORM\Association\BelongsToMany<\Awesome\Model\Table\HousesTable> $Houses
 *
 * @method \TestApp\Model\Entity\BarBar newEmptyEntity()
 * @method \TestApp\Model\Entity\BarBar newEntity(array<string, mixed> $data, array<string, mixed> $options = [])
 * @method \TestApp\Model\Entity\BarBar[] newEntities(array<array<string, mixed>> $data, array<string, mixed> $options = [])
 * @method \TestApp\Model\Entity\BarBar get(mixed $primaryKey, array<string, mixed>|string $finder = 'all', \Psr\SimpleCache\CacheInterface|string|null $cache = null, \Closure|string|null $cacheKey = null, mixed ...$args)
 * @method \TestApp\Model\Entity\BarBar findOrCreate(\Cake\ORM\Query\SelectQuery<\TestApp\Model\Entity\BarBar>|callable|array<string, mixed> $search, ?callable $callback = null, array<string, mixed> $options = [])
 * @method \TestApp\Model\Entity\BarBar patchEntity(\TestApp\Model\Entity\BarBar $entity, array<string, mixed> $data, array<string, mixed> $options = [])
 * @method \TestApp\Model\Entity\BarBar[] patchEntities(iterable<\TestApp\Model\Entity\BarBar> $entities, array<array<string, mixed>> $data, array<string, mixed> $options = [])
 * @method \TestApp\Model\Entity\BarBar|false save(\TestApp\Model\Entity\BarBar $entity, array<string, mixed> $options = [])
 * @method \TestApp\Model\Entity\BarBar saveOrFail(\TestApp\Model\Entity\BarBar $entity, array<string, mixed> $options = [])
 * @method \Cake\Datasource\ResultSetInterface<int, \TestApp\Model\Entity\BarBar>|false saveMany(iterable<\TestApp\Model\Entity\BarBar> $entities, array<string, mixed> $options = [])
 * @method \Cake\Datasource\ResultSetInterface<int, \TestApp\Model\Entity\BarBar> saveManyOrFail(iterable<\TestApp\Model\Entity\BarBar> $entities, array<string, mixed> $options = [])
 * @method \Cake\Datasource\ResultSetInterface<int, \TestApp\Model\Entity\BarBar>|false deleteMany(iterable<\TestApp\Model\Entity\BarBar> $entities, array<string, mixed> $options = [])
 * @method \Cake\Datasource\ResultSetInterface<int, \TestApp\Model\Entity\BarBar> deleteManyOrFail(iterable<\TestApp\Model\Entity\BarBar> $entities, array<string, mixed> $options = [])
 *
 * @mixin \Cake\ORM\Behavior\TimestampBehavior
 * @mixin \MyNamespace\MyPlugin\Model\Behavior\MyBehavior
 */
class BarBarsTable extends Table {

	/**
	 * @param array $config
	 * @return void
	 */
	public function initialize(array $config): void {
		parent::initialize($config);

		$this->belongsTo('Foos');
		$this->belongsToMany('Houses', [
			'className' => 'Awesome.Houses',
			'through' => 'Awesome.Windows',
		]);
		$this->addBehavior('Timestamp');
		$this->addBehavior('MyNamespace/MyPlugin.My');
	}

}


================================================
FILE: tests/test_files/Model/Table/Specific/BarBarsTable.php
================================================
<?php
namespace TestApp\Model\Table;

use Cake\ORM\Table;

/**
 * @property \Cake\ORM\Association\BelongsTo<\TestApp\Model\Table\FoosTable> $Foos
 * @property \Cake\ORM\Association\BelongsToMany<\Awesome\Model\Table\HousesTable> $Houses
 *
 * @method \TestApp\Model\Entity\BarBar newEmptyEntity()
 * @method \TestApp\Model\Entity\BarBar newEntity(array<mixed> $data, array<string, mixed> $options = [])
 * @method \TestApp\Model\Entity\BarBar[] newEntities(array<mixed> $data, array<string, mixed> $options = [])
 * @method \TestApp\Model\Entity\BarBar get(mixed $primaryKey, array|string $finder = 'all', \Psr\SimpleCache\CacheInterface|string|null $cache = null, \Closure|string|null $cacheKey = null, mixed ...$args)
 * @method \TestApp\Model\Entity\BarBar findOrCreate(\Cake\ORM\Query\SelectQuery|callable|array $search, ?callable $callback = null, array<string, mixed> $options = [])
 * @method \TestApp\Model\Entity\BarBar patchEntity(\TestApp\Model\Entity\BarBar $entity, array<mixed> $data, array<string, mixed> $options = [])
 * @method \TestApp\Model\Entity\BarBar[] patchEntities(iterable<\TestApp\Model\Entity\BarBar> $entities, array<mixed> $data, array<string, mixed> $options = [])
 * @method \TestApp\Model\Entity\BarBar|false save(\TestApp\Model\Entity\BarBar $entity, array<string, mixed> $options = [])
 * @method \TestApp\Model\Entity\BarBar saveOrFail(\TestApp\Model\Entity\BarBar $entity, array<string, mixed> $options = [])
 * @method \Cake\Datasource\ResultSetInterface<\TestApp\Model\Entity\BarBar>|false saveMany(iterable<\TestApp\Model\Entity\BarBar> $entities, array<string, mixed> $options = [])
 * @method \Cake\Datasource\ResultSetInterface<\TestApp\Model\Entity\BarBar> saveManyOrFail(iterable<\TestApp\Model\Entity\BarBar> $entities, array<string, mixed> $options = [])
 * @method \Cake\Datasource\ResultSetInterface<\TestApp\Model\Entity\BarBar>|false deleteMany(iterable<\TestApp\Model\Entity\BarBar> $entities, array<string, mixed> $options = [])
 * @method \Cake\Datasource\ResultSetInterface<\TestApp\Model\Entity\BarBar> deleteManyOrFail(iterable<\TestApp\Model\Entity\BarBar> $entities, array<string, mixed> $options = [])
 *
 * @mixin \Cake\ORM\Behavior\TimestampBehavior
 * @mixin \MyNamespace\MyPlugin\Model\Behavior\MyBehavior
 */
class BarBarsTable extends Table {

	/**
	 * @param array $config
	 * @return void
	 */
	public function initialize(array $config): void {
		parent::initialize($config);

		$this->belongsTo('Foos');
		$this->belongsToMany('Houses', [
			'className' => 'Awesome.Houses',
			'through' => 'Awesome.Windows',
		]);
		$this->addBehavior('Timestamp');
		$this->addBehavior('MyNamespace/MyPlugin.My');
	}

}


================================================
FILE: tests/test_files/Model/Table/Specific/CallbacksTable.php
================================================
<?php
namespace TestApp\Model\Table;

use ArrayObject;
use Cake\Datasource\EntityInterface;
use Cake\Event\Event;
use Cake\Event\EventInterface;
use Cake\ORM\Table;

class CallbacksTable extends Table {

	/**
	 * @param \Cake\Event\Event $event Event
	 * @param \TestApp\Model\Entity\Callback $entity Entity
	 * @param \ArrayObject $options Options
	 * @return void
	 */
	public function beforeSave(Event $event, EntityInterface $entity, ArrayObject $options) {
	}

	/**
	 * @param \Cake\Event\EventInterface $event
	 * @param \TestApp\Model\Entity\Callback $entity
	 * @param \ArrayObject $options
	 * @return void
	 */
	public function afterSave(EventInterface $event, EntityInterface $entity, ArrayObject $options) {
	}

	public function beforeDelete(Event $event, EntityInterface $entity, ArrayObject $options) {
	}

}


================================================
FILE: tests/test_files/Model/Table/Specific/FooTable.php
================================================
<?php
namespace TestApp\Model\Table;

use Cake\ORM\Table;

/**
 * @method \TestApp\Model\Entity\Foo get(mixed $primaryKey, array|string $finder = 'all', \Psr\SimpleCache\CacheInterface|string|null $cache = null, \Closure|string|null $cacheKey = null, mixed ...$args)
 * @method \TestApp\Model\Entity\Foo newEntity($data = null, array $options = [])
 * @method \TestApp\Model\Entity\Foo[] newEntities(array $data, array $options = [])
 * @method \TestApp\Model\Entity\Foo|false save(\TestApp\Model\Entity\Foo $entity, array $options = [])
 * @method \TestApp\Model\Entity\Foo saveOrFail(\TestApp\Model\Entity\Foo $entity, array $options = [])
 * @method \TestApp\Model\Entity\Foo patchEntity(\TestApp\Model\Entity\Foo $entity, array $data, array $options = [])
 * @method \TestApp\Model\Entity\Foo[] patchEntities($entities, array $data, array $options = [])
 * @method \TestApp\Model\Entity\Foo findOrCreate(\Cake\ORM\Query\SelectQuery|callable|array $search, callable $callback = null, array $options = [])
 *
 * @mixin \Cake\ORM\Behavior\TimestampBehavior
 * @mixin \MyNamespace\MyPlugin\Model\Behavior\MyBehavior
 */
class FooTable extends Table {

	/**
	 * @param array $config
	 * @return void
	 */
	public function initialize(array $config): void {
		parent::initialize($config);

		$this->belongsTo('BarBars');
		$this->belongsTo('Houses', [
			'className' => 'Awesome.Houses'
		]);
		$this->addBehavior('Timestamp');
		$this->addBehavior('MyNamespace/MyPlugin.My');
	}

}


================================================
FILE: tests/test_files/Model/Table/Specific/SkipMeTable.php
================================================
<?php
namespace TestApp\Model\Table;

use Cake\ORM\Table;

/**
 * @inheritDoc
 */
class SkipMeTable extends Table {

	/**
	 * @param array $config
	 * @return void
	 */
	public function initialize(array $config): void {
		parent::initialize($config);

		$this->belongsTo('Cars');
	}

}


================================================
FILE: tests/test_files/Model/Table/Specific/SkipSomeTable.php
================================================
<?php
namespace TestApp\Model\Table;

use Cake\ORM\Table;

/**
 * @property \Cake\ORM\Association\BelongsTo<\TestApp\Model\Table\CarsTable> $Cars
 * @property \Cake\ORM\Association\BelongsTo<\TestApp\Model\Table\CarsTable> $CarsAwesome
 */
class SkipSomeTable extends Table {

	/**
	 * @param array $config
	 * @return void
	 */
	public function initialize(array $config): void {
		parent::initialize($config);

		$this->belongsTo('Cars');
	}

	/**
	 * @return void
	 */
	public function foo() {
		$this->CarsAwesome->doSthAwesome();
	}

}


================================================
FILE: tests/test_files/Model/Table/Specific/WheelsExtraTable.php
================================================
<?php
namespace TestApp\Model\Table;

use Cake\ORM\Table;

/**
 * @property \Cake\ORM\Association\BelongsTo<\TestApp\Model\Table\CarsTable> $Cars
 */
class WheelsExtraTable extends Table {

	/**
	 * @param array $config
	 * @return void
	 */
	public function initialize(array $config): void {
		parent::initialize($config);

		$this->setTable('wheels');
		$this->belongsTo('Cars');
	}

}


================================================
FILE: tests/test_files/Model/Table/Specific/WheelsTable.php
================================================
<?php
namespace TestApp\Model\Table;

use Cake\ORM\Table;

/**
 * @method \TestApp\Model\Entity\Wheel newEntity(array<mixed> $data, array<string, mixed> $options = [])
 * @property \Cake\ORM\Association\BelongsTo<\TestApp\Model\Table\CarsTable> $Cars
 * @method \TestApp\Model\Entity\Wheel newEmptyEntity()
 * @method \TestApp\Model\Entity\Wheel[] newEntities(array<mixed> $data, array<string, mixed> $options = [])
 * @method \TestApp\Model\Entity\Wheel get(mixed $primaryKey, array|string $finder = 'all', \Psr\SimpleCache\CacheInterface|string|null $cache = null, \Closure|string|null $cacheKey = null, mixed ...$args)
 * @method \TestApp\Model\Entity\Wheel findOrCreate(\Cake\ORM\Query\SelectQuery|callable|array $search, ?callable $callback = null, array<string, mixed> $options = [])
 * @method \TestApp\Model\Entity\Wheel patchEntity(\TestApp\Model\Entity\Wheel $entity, array<mixed> $data, array<string, mixed> $options = [])
 * @method \TestApp\Model\Entity\Wheel[] patchEntities(iterable<\TestApp\Model\Entity\Wheel> $entities, array<mixed> $data, array<string, mixed> $options = [])
 * @method \TestApp\Model\Entity\Wheel|false save(\TestApp\Model\Entity\Wheel $entity, array<string, mixed> $options = [])
 * @method \TestApp\Model\Entity\Wheel saveOrFail(\TestApp\Model\Entity\Wheel $entity, array<string, mixed> $options = [])
 * @method \Cake\Datasource\ResultSetInterface<\TestApp\Model\Entity\Wheel>|false saveMany(iterable<\TestApp\Model\Entity\Wheel> $entities, array<string, mixed> $options = [])
 * @method \Cake\Datasource\ResultSetInterface<\TestApp\Model\Entity\Wheel> saveManyOrFail(iterable<\TestApp\Model\Entity\Wheel> $entities, array<string, mixed> $options = [])
 * @method \Cake\Datasource\ResultSetInterface<\TestApp\Model\Entity\Wheel>|false deleteMany(iterable<\TestApp\Model\Entity\Wheel> $entities, array<string, mixed> $options = [])
 * @method \Cake\Datasource\ResultSetInterface<\TestApp\Model\Entity\Wheel> deleteManyOrFail(iterable<\TestApp\Model\Entity\Wheel> $entities, array<string, mixed> $options = [])
 * @mixin \Cake\ORM\Behavior\TreeBehavior
 */
class WheelsTable extends Table {

	/**
	 * @param array $config
	 * @return void
	 */
	public function initialize(array $config): void {
		parent::initialize($config);

		$this->belongsTo('Cars');

		$this->addBehavior('Tree');
	}

}


================================================
FILE: tests/test_files/Model/Table/Validation/IpRulesTable.php
================================================
<?php

namespace TestApp\Model\Table;

use Cake\ORM\Table;
use Cake\Validation\Validator;

class IpRulesTable extends Table {

	/**
	 * @param \Cake\Validation\Validator $validator
	 * @return \Cake\Validation\Validator
	 */
	public function validationDefault(Validator $validator): Validator {
		$validator->add('allow', 'range', [
			'rule' => ['verifyIpRanges', 'allow'],
			'provider' => 'table',
			'message' => 'Please provide valid ip ranges',
		]);

		$validator->add('deny', 'range', [
			'rule' => 'verifyDenyRanges',
			'provider' => 'table',
		]);

		// This should NOT get a link (no table provider)
		$validator->add('email', 'valid', [
			'rule' => 'email',
			'message' => 'Please provide a valid email',
		]);

		return $validator;
	}

	/**
	 * @param string $value
	 * @param array $context
	 * @return bool
	 */
	public function verifyIpRanges(string $value, array $context): bool {
		return true;
	}

	/**
	 * @param string $value
	 * @param array $context
	 * @return bool
	 */
	public function verifyDenyRanges(string $value, array $context): bool {
		return true;
	}

}


================================================
FILE: tests/test_files/Model/Table/ValidationResult/IpRulesTable.php
================================================
<?php

namespace TestApp\Model\Table;

use Cake\ORM\Table;
use Cake\Validation\Validator;

class IpRulesTable extends Table {

	/**
	 * @param \Cake\Validation\Validator $validator
	 * @return \Cake\Validation\Validator
	 */
	public function validationDefault(Validator $validator): Validator {
		$validator->add('allow', 'range', [
			/** @link verifyIpRanges() */
			'rule' => ['verifyIpRanges', 'allow'],
			'provider' => 'table',
			'message' => 'Please provide valid ip ranges',
		]);

		$validator->add('deny', 'range', [
			/** @link verifyDenyRanges() */
			'rule' => 'verifyDenyRanges',
			'provider' => 'table',
		]);

		// This should NOT get a link (no table provider)
		$validator->add('email', 'valid', [
			'rule' => 'email',
			'message' => 'Please provide a valid email',
		]);

		return $validator;
	}

	/**
	 * @param string $value
	 * @param array $context
	 * @return bool
	 */
	public function verifyIpRanges(string $value, array $context): bool {
		return true;
	}

	/**
	 * @param string $value
	 * @param array $context
	 * @return bool
	 */
	public function verifyDenyRanges(string $value, array $context): bool {
		return true;
	}

}


================================================
FILE: tests/test_files/Model/Table/WheelsExtraTable.php
================================================
<?php
namespace TestApp\Model\Table;

use Cake\ORM\Table;

/**
 * @property \Cake\ORM\Association\BelongsTo<\TestApp\Model\Table\CarsTable> $Cars
 */
class WheelsExtraTable extends Table {

	/**
	 * @param array $config
	 * @return void
	 */
	public function initialize(array $config): void {
		parent::initialize($config);

		$this->setTable('wheels');
		$this->belongsTo('Cars');
	}

}


================================================
FILE: tests/test_files/Model/Table/WheelsTable.php
================================================
<?php
namespace TestApp\Model\Table;

use Cake\ORM\Table;

/**
 * @method \TestApp\Model\Entity\Wheel newEntity(array $data, array $options = [])
 * @property \Cake\ORM\Association\BelongsTo<\TestApp\Model\Table\CarsTable> $Cars
 * @method \TestApp\Model\Entity\Wheel newEmptyEntity()
 * @method \TestApp\Model\Entity\Wheel[] newEntities(array $data, array $options = [])
 * @method \TestApp\Model\Entity\Wheel get(mixed $primaryKey, array|string $finder = 'all', \Psr\SimpleCache\CacheInterface|string|null $cache = null, \Closure|string|null $cacheKey = null, mixed ...$args)
 * @method \TestApp\Model\Entity\Wheel findOrCreate(\Cake\ORM\Query\SelectQuery|callable|array $search, ?callable $callback = null, array $options = [])
 * @method \TestApp\Model\Entity\Wheel patchEntity(\Cake\Datasource\EntityInterface $entity, array $data, array $options = [])
 * @method \TestApp\Model\Entity\Wheel[] patchEntities(iterable $entities, array $data, array $options = [])
 * @method \TestApp\Model\Entity\Wheel|false save(\Cake\Datasource\EntityInterface $entity, array $options = [])
 * @method \TestApp\Model\Entity\Wheel saveOrFail(\Cake\Datasource\EntityInterface $entity, array $options = [])
 * @method \TestApp\Model\Entity\Wheel[]|\Cake\Datasource\ResultSetInterface<\TestApp\Model\Entity\Wheel>|false saveMany(iterable $entities, array $options = [])
 * @method \TestApp\Model\Entity\Wheel[]|\Cake\Datasource\ResultSetInterface<\TestApp\Model\Entity\Wheel> saveManyOrFail(iterable $entities, array $options = [])
 * @method \TestApp\Model\Entity\Wheel[]|\Cake\Datasource\ResultSetInterface<\TestApp\Model\Entity\Wheel>|false deleteMany(iterable $entities, array $options = [])
 * @method \TestApp\Model\Entity\Wheel[]|\Cake\Datasource\ResultSetInterface<\TestApp\Model\Entity\Wheel> deleteManyOrFail(iterable $entities, array $options = [])
 * @mixin \Cake\ORM\Behavior\TreeBehavior
 * @extends \Cake\ORM\Table<array{Tree: \Cake\ORM\Behavior\TreeBehavior}>
 */
class WheelsTable extends Table {

	/**
	 * @param array $config
	 * @return void
	 */
	public function initialize(array $config): void {
		parent::initialize($config);

		$this->belongsTo('Cars');

		$this->addBehavior('Tree');
	}

}


================================================
FILE: tests/test_files/View/AppView.php
================================================
<?php
namespace TestApp\View;

use Cake\View\View;

/**
 * @link https://book.cakephp.org/5/en/views.html#the-app-view
 * @property \TestApp\View\Helper\HtmlHelper $Html
 * @property \TestApp\View\Helper\MyHelper $My
 * @property \TestApp\View\Helper\MyMethodHelper $MyMethod
 * @property \Shim\View\Helper\ConfigureHelper $Configure
 */
class AppView extends View {
}


================================================
FILE: tests/test_files/View/Helper/MyHelper.php
================================================
<?php
namespace TestApp\View\Helper;

use Cake\View\Helper;

/**
 * @property \TestApp\View\Helper\HtmlHelper $Html
 * @property \Cake\View\Helper\FormHelper $Form
 * @property \Shim\View\Helper\ConfigureHelper $Configure
 */
class MyHelper extends Helper {

	protected array $helpers = [
		'Html',
		'Form',
		'Shim.Configure',
		'SomeInvalidOneWillBeIgnored',
	];

}


================================================
FILE: tests/test_files/View/Helper/MyMethodHelper.php
================================================
<?php
namespace TestApp\View\Helper;

use Cake\View\Helper;

/**
 * @property \Cake\View\Helper\FormHelper $Form
 * @method bool isAdmin()
 * @method bool isStaff()
 * @property \TestApp\View\Helper\HtmlHelper $Html
 * @property \Shim\View\Helper\ConfigureHelper $Configure
 */
class MyMethodHelper extends Helper {

	protected array $helpers = [
		'Html',
		'Form',
		'Shim.Configure',
		'SomeInvalidOneWillBeIgnored',
	];

}


================================================
FILE: tests/test_files/VirtualFieldAnnotation/VirtualFieldAnnotation.existing.php
================================================
<?php
namespace TestApp\Model\Entity;

class Foo {

	/**
	 * @see \TestApp\Model\Entity\Foo::$expected_release_type
	 *
	 * @return int|null
	 */
	protected function _getExpectedReleaseType(): ?int {
		$expected = $this->something;

		return $expected ?? null;
	}

	/**
	 * @see $something
	 *
	 * @return string|null
	 */
	protected function _getSomething(): ?string {
		$expected = $this->something;

		return $expected ?? null;
	}
}


================================================
FILE: tests/test_files/VirtualFieldAnnotation/VirtualFieldAnnotation.missing.php
================================================
<?php
namespace TestApp\Model\Entity;

class Foo {

	/**
	 * @return int|null
	 */
	protected function _getExpectedReleaseType(): ?int
	{
		$expected = $this->something;

		return $expected ?? null;
	}
}


================================================
FILE: tests/test_files/locales/default.po
================================================

msgid "A \"quoted\" string"
msgstr "Ein \"quoted\" String"

msgid "A ""escape-quoted"" string"
msgstr "Ein ""escape-quoted"" String"

msgid "A 'literally quoted' string"
msgstr "Ein 'wörtlich quoted' String"

msgid "A variable ''{0}'' be replaced."
msgstr "Eine Variable ''{0}'' ersetzt."


================================================
FILE: tests/test_files/meta/phpstorm/.meta.php
================================================
<?php
// @link https://confluence.jetbrains.com/display/PhpStorm/PhpStorm+Advanced+Metadata
namespace PHPSTORM_META {

	expectedArguments(
		\Cake\Cache\Cache::add(),
		2,
		argumentsSet('cacheEngines'),
	);

	expectedArguments(
		\Cake\Cache\Cache::clear(),
		0,
		argumentsSet('cacheEngines'),
	);

	expectedArguments(
		\Cake\Cache\Cache::clearGroup(),
		1,
		argumentsSet('cacheEngines'),
	);

	expectedArguments(
		\Cake\Cache\Cache::decrement(),
		2,
		argumentsSet('cacheEngines'),
	);

	expectedArguments(
		\Cake\Cache\Cache::delete(),
		1,
		argumentsSet('cacheEngines'),
	);

	expectedArguments(
		\Cake\Cache\Cache::deleteMany(),
		1,
		argumentsSet('cacheEngines'),
	);

	expectedArguments(
		\Cake\Cache\Cache::increment(),
		2,
		argumentsSet('cacheEngines'),
	);

	expectedArguments(
		\Cake\Cache\Cache::read(),
		1,
		argumentsSet('cacheEngines'),
	);

	expectedArguments(
		\Cake\Cache\Cache::readMany(),
		1,
		argumentsSet('cacheEngines'),
	);

	expectedArguments(
		\Cake\Cache\Cache::remember(),
		2,
		argumentsSet('cacheEngines'),
	);

	expectedArguments(
		\Cake\Cache\Cache::write(),
		2,
		argumentsSet('cacheEngines'),
	);

	exitPoint(\Cake\Console\ConsoleIo::abort());

	override(
		\Cake\Console\ConsoleIo::helper(0),
		map([
			'Banner' => \Cake\Command\Helper\BannerHelper::class,
			'Progress' => \Cake\Command\Helper\ProgressHelper::class,
			'Table' => \Cake\Command\Helper\TableHelper::class,
			'Tree' => \Cake\Command\Helper\TreeHelper::class,
		]),
	);

	expectedArguments(
		\Cake\Controller\ComponentRegistry::unload(),
		0,
		'CheckHttpCache',
		'Flash',
		'FormProtection',
		'My',
		'MyController',
		'MyOther',
		'RequestHandler',
	);

	override(
		\Cake\Controller\Controller::loadComponent(0),
		map([
			'CheckHttpCache' => \TestApp\Controller\Component\CheckHttpCacheComponent::class,
			'Flash' => \Cake\Controller\Component\FlashComponent::class,
			'FormProtection' => \Cake\Controller\Component\FormProtectionComponent::class,
			'My' => \TestApp\Controller\Component\MyComponent::class,
			'MyController' => \TestApp\Controller\Component\MyControllerComponent::class,
			'MyNamespace/MyPlugin.My' => \MyNamespace\MyPlugin\Controller\Component\MyComponent::class,
			'MyOther' => \TestApp\Controller\Component\MyOtherComponent::class,
			'Shim.RequestHandler' => \Shim\Controller\Component\RequestHandlerComponent::class,
		]),
	);

	expectedArguments(
		\Cake\Core\Configure::check(),
		0,
		argumentsSet('configureKeys'),
	);

	expectedArguments(
		\Cake\Core\Configure::consume(),
		0,
		argumentsSet('configureKeys'),
	);

	expectedArguments(
		\Cake\Core\Configure::consumeOrFail(),
		0,
		argumentsSet('configureKeys'),
	);

	expectedArguments(
		\Cake\Core\Configure::delete(),
		0,
		argumentsSet('configureKeys'),
	);

	expectedArguments(
		\Cake\Core\Configure::read(),
		0,
		argumentsSet('configureKeys'),
	);

	expectedArguments(
		\Cake\Core\Configure::readOrFail(),
		0,
		argumentsSet('configureKeys'),
	);

	expectedArguments(
		\Cake\Core\Configure::write(),
		0,
		argumentsSet('configureKeys'),
	);

	override(
		\Cake\Core\PluginApplicationInterface::addPlugin(0),
		map([
			'Bake' => \Cake\Http\BaseApplication::class,
			'Cake/TwigView' => \Cake\Http\BaseApplication::class,
			'Migrations' => \Cake\Http\BaseApplication::class,
			'Shim' => \Cake\Http\BaseApplication::class,
		]),
	);

	override(
		\Cake\Database\TypeFactory::build(0),
		map([
			'biginteger' => \Cake\Database\Type\IntegerType::class,
			'binary' => \Cake\Database\Type\BinaryType::class,
			'binaryuuid' => \Cake\Database\Type\BinaryUuidType::class,
			'boolean' => \Cake\Database\Type\BoolType::class,
			'char' => \Cake\Database\Type\StringType::class,
			'cidr' => \Cake\Database\Type\StringType::class,
			'citext' => \Cake\Database\Type\StringType::class,
			'date' => \Cake\Database\Type\DateType::class,
			'datetime' => \Cake\Database\Type\DateTimeType::class,
			'datetimefractional' => \Cake\Database\Type\DateTimeFractionalType::class,
			'decimal' => \Cake\Database\Type\DecimalType::class,
			'float' => \Cake\Database\Type\FloatType::class,
			'geometry' => \Cake\Database\Type\StringType::class,
			'inet' => \Cake\Database\Type\StringType::class,
			'integer' => \Cake\Database\Type\IntegerType::class,
			'json' => \Cake\Database\Type\JsonType::class,
			'linestring' => \Cake\Database\Type\StringType::class,
			'macaddr' => \Cake\Database\Type\StringType::class,
			'nativeuuid' => \Cake\Database\Type\UuidType::class,
			'point' => \Cake\Database\Type\StringType::class,
			'polygon' => \Cake\Database\Type\StringType::class,
			'smallinteger' => \Cake\Database\Type\IntegerType::class,
			'string' => \Cake\Database\Type\StringType::class,
			'text' => \Cake\Database\Type\StringType::class,
			'time' => \Cake\Database\Type\TimeType::class,
			'timestamp' => \Cake\Database\Type\DateTimeType::class,
			'timestampfractional' => \Cake\Database\Type\DateTimeFractionalType::class,
			'timestamptimezone' => \Cake\Database\Type\DateTimeTimezoneType::class,
			'tinyinteger' => \Cake\Database\Type\IntegerType::class,
			'uuid' => \Cake\Database\Type\UuidType::class,
			'year' => \Cake\Database\Type\IntegerType::class,
		]),
	);

	expectedArguments(
		\Cake\Database\TypeFactory::map(),
		0,
		'biginteger',
		'binary',
		'binaryuuid',
		'boolean',
		'char',
		'cidr',
		'citext',
		'date',
		'datetime',
		'datetimefractional',
		'decimal',
		'float',
		'geometry',
		'inet',
		'integer',
		'json',
		'linestring',
		'macaddr',
		'nativeuuid',
		'point',
		'polygon',
		'smallinteger',
		'string',
		'text',
		'time',
		'timestamp',
		'timestampfractional',
		'timestamptimezone',
		'tinyinteger',
		'uuid',
		'year',
	);

	expectedArguments(
		\Cake\Datasource\ConnectionManager::get(),
		0,
		'test',
	);

	override(
		\Cake\Datasource\ModelAwareTrait::fetchModel(0),
		map([
			'Awesome.Houses' => \Awesome\Model\Table\HousesTable::class,
			'Awesome.Windows' => \Awesome\Model\Table\WindowsTable::class,
			'BarBars' => \TestApp\Model\Table\BarBarsTable::class,
			'BarBarsAbstract' => \TestApp\Model\Table\BarBarsAbstractTable::class,
			'Callbacks' => \TestApp\Model\Table\CallbacksTable::class,
			'Cars' => \TestApp\Model\Table\CarsTable::class,
			'Controllers.Houses' => \Controllers\Model\Table\HousesTable::class,
			'CustomFinder' => \TestApp\Model\Table\CustomFinderTable::class,
			'Exceptions' => \TestApp\Model\Table\ExceptionsTable::class,
			'Foos' => \TestApp\Model\Table\FoosTable::class,
			'MyNamespace/MyPlugin.My' => \MyNamespace\MyPlugin\Model\Table\MyTable::class,
			'Relations.Bars' => \Relations\Model\Table\BarsTable::class,
			'Relations.Foos' => \Relations\Model\Table\FoosTable::class,
			'Relations.Users' => \Relations\Model\Table\UsersTable::class,
			'SkipMe' => \TestApp\Model\Table\SkipMeTable::class,
			'SkipSome' => \TestApp\Model\Table\SkipSomeTable::class,
			'Wheels' => \TestApp\Model\Table\WheelsTable::class,
			'WheelsExtra' => \TestApp\Model\Table\WheelsExtraTable::class,
		]),
	);

	override(
		\Cake\Datasource\QueryInterface::find(0),
		map([
			'all' => \Cake\ORM\Query\SelectQuery::class,
			'children' => \Cake\ORM\Query\SelectQuery::class,
			'list' => \Cake\ORM\Query\SelectQuery::class,
			'path' => \Cake\ORM\Query\SelectQuery::class,
			'somethingCustom' => \Cake\ORM\Query\SelectQuery::class,
			'threaded' => \Cake\ORM\Query\SelectQuery::class,
			'treeList' => \Cake\ORM\Query\SelectQuery::class,
		]),
	);

	override(
		\Cake\Http\ServerRequest::getAttribute(0),
		map([
			'base' => 'string',
			'cspScriptNonce' => 'string',
			'cspStyleNonce' => 'string',
			'csrfToken' => 'string',
			'formTokenData' => 'array',
			'here' => 'string',
			'paging' => 'array',
			'params' => 'array',
			'route' => \Cake\Routing\Route\Route::class,
			'session' => \Cake\Http\Session::class,
			'webroot' => 'string',
		]),
	);

	expectedArguments(
		\Cake\Http\ServerRequest::getParam(),
		0,
		'_ext',
		'_matchedRoute',
		'action',
		'controller',
		'pass',
		'plugin',
		'prefix',
	);

	override(
		\Cake\Mailer\MailerAwareTrait::getMailer(0),
		map([
			'User' => \TestApp\Mailer\UserMailer::class,
		]),
	);

	override(
		\Cake\ORM\Association::find(0),
		map([
			'all' => \Cake\ORM\Query\SelectQuery::class,
			'children' => \Cake\ORM\Query\SelectQuery::class,
			'list' => \Cake\ORM\Query\SelectQuery::class,
			'path' => \Cake\ORM\Query\SelectQuery::class,
			'somethingCustom' => \Cake\ORM\Query\SelectQuery::class,
			'threaded' => \Cake\ORM\Query\SelectQuery::class,
			'treeList' => \Cake\ORM\Query\SelectQuery::class,
		]),
	);

	expectedArguments(
		\Cake\ORM\Entity::get(),
		0,
		argumentsSet('entityFields:Cake\ORM\Entity'),
	);

	expectedArguments(
		\Cake\ORM\Entity::getError(),
		0,
		argumentsSet('entityFields:Cake\ORM\Entity'),
	);

	expectedArguments(
		\Cake\ORM\Entity::getInvalidField(),
		0,
		argumentsSet('entityFields:Cake\ORM\Entity'),
	);

	expectedArguments(
		\Cake\ORM\Entity::getOriginal(),
		0,
		argumentsSet('entityFields:Cake\ORM\Entity'),
	);

	expectedArguments(
		\Cake\ORM\Entity::has(),
		0,
		argumentsSet('entityFields:Cake\ORM\Entity'),
	);

	expectedArguments(
		\Cake\ORM\Entity::hasValue(),
		0,
		argumentsSet('entityFields:Cake\ORM\Entity'),
	);

	expectedArguments(
		\Cake\ORM\Entity::isDirty(),
		0,
		argumentsSet('entityFields:Cake\ORM\Entity'),
	);

	expectedArguments(
		\Cake\ORM\Entity::isEmpty(),
		0,
		argumentsSet('entityFields:Cake\ORM\Entity'),
	);

	expectedArguments(
		\Cake\ORM\Entity::setDirty(),
		0,
		argumentsSet('entityFields:Cake\ORM\Entity'),
	);

	expectedArguments(
		\Cake\ORM\Entity::setError(),
		0,
		argumentsSet('entityFields:Cake\ORM\Entity'),
	);

	override(
		\Cake\ORM\Locator\LocatorAwareTrait::fetchTable(0),
		map([
			'Awesome.Houses' => \Awesome\Model\Table\HousesTable::class,
			'Awesome.Windows' => \Awesome\Model\Table\WindowsTable::class,
			'BarBars' => \TestApp\Model\Table\BarBarsTable::class,
			'BarBarsAbstract' => \TestApp\Model\Table\BarBarsAbstractTable::class,
			'Callbacks' => \TestApp\Model\Table\CallbacksTable::class,
			'Cars' => \TestApp\Model\Table\CarsTable::class,
			'Controllers.Houses' => \Controllers\Model\Table\HousesTable::class,
			'CustomFinder' => \TestApp\Model\Table\CustomFinderTable::class,
			'Exceptions' => \TestApp\Model\Table\ExceptionsTable::class,
			'Foos' => \TestApp\Model\Table\FoosTable::class,
			'MyNamespace/MyPlugin.My' => \MyNamespace\MyPlugin\Model\Table\MyTable::class,
			'Relations.Bars' => \Relations\Model\Table\BarsTable::class,
			'Relations.Foos' => \Relations\Model\Table\FoosTable::class,
			'Relations.Users' => \Relations\Model\Table\UsersTable::class,
			'SkipMe' => \TestApp\Model\Table\SkipMeTable::class,
			'SkipSome' => \TestApp\Model\Table\SkipSomeTable::class,
			'Wheels' => \TestApp\Model\Table\WheelsTable::class,
			'WheelsExtra' => \TestApp\Model\Table\WheelsExtraTable::class,
		]),
	);

	override(
		\Cake\ORM\Locator\LocatorInterface::get(0),
		map([
			'Awesome.Houses' => \Awesome\Model\Table\HousesTable::class,
			'Awesome.Windows' => \Awesome\Model\Table\WindowsTable::class,
			'BarBars' => \TestApp\Model\Table\BarBarsTable::class,
			'BarBarsAbstract' => \TestApp\Model\Table\BarBarsAbstractTable::class,
			'Callbacks' => \TestApp\Model\Table\CallbacksTable::class,
			'Cars' => \TestApp\Model\Table\CarsTable::class,
			'Controllers.Houses' => \Controllers\Model\Table\HousesTable::class,
			'CustomFinder' => \TestApp\Model\Table\CustomFinderTable::class,
			'Exceptions' => \TestApp\Model\Table\ExceptionsTable::class,
			'Foos' => \TestApp\Model\Table\FoosTable::class,
			'MyNamespace/MyPlugin.My' => \MyNamespace\MyPlugin\Model\Table\MyTable::class,
			'Relations.Bars' => \Relations\Model\Table\BarsTable::class,
			'Relations.Foos' => \Relations\Model\Table\FoosTable::class,
			'Relations.Users' => \Relations\Model\Table\UsersTable::class,
			'SkipMe' => \TestApp\Model\Table\SkipMeTable::class,
			'SkipSome' => \TestApp\Model\Table\SkipSomeTable::class,
			'Wheels' => \TestApp\Model\Table\WheelsTable::class,
			'WheelsExtra' => \TestApp\Model\Table\WheelsExtraTable::class,
		]),
	);

	expectedArguments(
		\Cake\ORM\Table::addBehavior(),
		0,
		'CounterCache',
		'MyNamespace/MyPlugin.My',
		'Shim.Nullable',
		'Timestamp',
		'Translate',
		'Tree',
	);

	override(
		\Cake\ORM\Table::belongToMany(0),
		map([
			'Awesome.Houses' => \Cake\ORM\Association\BelongsToMany::class,
			'Awesome.Windows' => \Cake\ORM\Association\BelongsToMany::class,
			'BarBars' => \Cake\ORM\Association\BelongsToMany::class,
			'BarBarsAbstract' => \Cake\ORM\Association\BelongsToMany::class,
			'Callbacks' => \Cake\ORM\Association\BelongsToMany::class,
			'Cars' => \Cake\ORM\Association\BelongsToMany::class,
			'Controllers.Houses' => \Cake\ORM\Association\BelongsToMany::class,
			'CustomFinder' => \Cake\ORM\Association\BelongsToMany::class,
			'Exceptions' => \Cake\ORM\Association\BelongsToMany::class,
			'Foos' => \Cake\ORM\Association\BelongsToMany::class,
			'MyNamespace/MyPlugin.My' => \Cake\ORM\Association\BelongsToMany::class,
			'Relations.Bars' => \Cake\ORM\Association\BelongsToMany::class,
			'Relations.Foos' => \Cake\ORM\Association\BelongsToMany::class,
			'Relations.Users' => \Cake\ORM\Association\BelongsToMany::class,
			'SkipMe' => \Cake\ORM\Association\BelongsToMany::class,
			'SkipSome' => \Cake\ORM\Association\BelongsToMany::class,
			'Wheels' => \Cake\ORM\Association\BelongsToMany::class,
			'WheelsExtra' => \Cake\ORM\Association\BelongsToMany::class,
		]),
	);

	override(
		\Cake\ORM\Table::belongsTo(0),
		map([
			'Awesome.Houses' => \Cake\ORM\Association\BelongsTo::class,
			'Awesome.Windows' => \Cake\ORM\Association\BelongsTo::class,
			'BarBars' => \Cake\ORM\Association\BelongsTo::class,
			'BarBarsAbstract' => \Cake\ORM\Association\BelongsTo::class,
			'Callbacks' => \Cake\ORM\Association\BelongsTo::class,
			'Cars' => \Cake\ORM\Association\BelongsTo::class,
			'Controllers.Houses' => \Cake\ORM\Association\BelongsTo::class,
			'CustomFinder' => \Cake\ORM\Association\BelongsTo::class,
			'Exceptions' => \Cake\ORM\Association\BelongsTo::class,
			'Foos' => \Cake\ORM\Association\BelongsTo::class,
			'MyNamespace/MyPlugin.My' => \Cake\ORM\Association\BelongsTo::class,
			'Relations.Bars' => \Cake\ORM\Association\BelongsTo::class,
			'Relations.Foos' => \Cake\ORM\Association\BelongsTo::class,
			'Relations.Users' => \Cake\ORM\Association\BelongsTo::class,
			'SkipMe' => \Cake\ORM\Association\BelongsTo::class,
			'SkipSome' => \Cake\ORM\Association\BelongsTo::class,
			'Wheels' => \Cake\ORM\Association\BelongsTo::class,
			'WheelsExtra' => \Cake\ORM\Association\BelongsTo::class,
		]),
	);

	override(
		\Cake\ORM\Table::find(0),
		map([
			'all' => \Cake\ORM\Query\SelectQuery::class,
			'children' => \Cake\ORM\Query\SelectQuery::class,
			'list' => \Cake\ORM\Query\SelectQuery::class,
			'path' => \Cake\ORM\Query\SelectQuery::class,
			'somethingCustom' => \Cake\ORM\Query\SelectQuery::class,
			'threaded' => \Cake\ORM\Query\SelectQuery::class,
			'treeList' => \Cake\ORM\Query\SelectQuery::class,
		]),
	);

	override(
		\Cake\ORM\Table::getBehavior(),
		map([
			'CounterCache' => \Cake\ORM\Behavior\CounterCacheBehavior::class,
			'My' => \MyNamespace\MyPlugin\Model\Behavior\MyBehavior::class,
			'Nullable' => \Shim\Model\Behavior\NullableBehavior::class,
			'Timestamp' => \Cake\ORM\Behavior\TimestampBehavior::class,
			'Translate' => \Cake\ORM\Behavior\TranslateBehavior::class,
			'Tree' => \Cake\ORM\Behavior\TreeBehavior::class,
		]),
	);

	expectedArguments(
		\Cake\ORM\Table::hasBehavior(),
		0,
		'CounterCache',
		'My',
		'Nullable',
		'Timestamp',
		'Translate',
		'Tree',
	);

	override(
		\Cake\ORM\Table::hasMany(0),
		map([
			'Awesome.Houses' => \Cake\ORM\Association\HasMany::class,
			'Awesome.Windows' => \Cake\ORM\Association\HasMany::class,
			'BarBars' => \Cake\ORM\Association\HasMany::class,
			'BarBarsAbstract' => \Cake\ORM\Association\HasMany::class,
			'Callbacks' => \Cake\ORM\Association\HasMany::class,
			'Cars' => \Cake\ORM\Association\HasMany::class,
			'Controllers.Houses' => \Cake\ORM\Association\HasMany::class,
			'CustomFinder' => \Cake\ORM\Association\HasMany::class,
			'Exceptions' => \Cake\ORM\Association\HasMany::class,
			'Foos' => \Cake\ORM\Association\HasMany::class,
			'MyNamespace/MyPlugin.My' => \Cake\ORM\Association\HasMany::class,
			'Relations.Bars' => \Cake\ORM\Association\HasMany::class,
			'Relations.Foos' => \Cake\ORM\Association\HasMany::class,
			'Relations.Users' => \Cake\ORM\Association\HasMany::class,
			'SkipMe' => \Cake\ORM\Association\HasMany::class,
			'SkipSome' => \Cake\ORM\Association\HasMany::class,
			'Wheels' => \Cake\ORM\Association\HasMany::class,
			'WheelsExtra' => \Cake\ORM\Association\HasMany::class,
		]),
	);

	override(
		\Cake\ORM\Table::hasOne(0),
		map([
			'Awesome.Houses' => \Cake\ORM\Association\HasOne::class,
			'Awesome.Windows' => \Cake\ORM\Association\HasOne::class,
			'BarBars' => \Cake\ORM\Association\HasOne::class,
			'BarBarsAbstract' => \Cake\ORM\Association\HasOne::class,
			'Callbacks' => \Cake\ORM\Association\HasOne::class,
			'Cars' => \Cake\ORM\Association\HasOne::class,
			'Controllers.Houses' => \Cake\ORM\Association\HasOne::class,
			'CustomFinder' => \Cake\ORM\Association\HasOne::class,
			'Exceptions' => \Cake\ORM\Association\HasOne::class,
			'Foos' => \Cake\ORM\Association\HasOne::class,
			'MyNamespace/MyPlugin.My' => \Cake\ORM\Association\HasOne::class,
			'Relations.Bars' => \Cake\ORM\Association\HasOne::class,
			'Relations.Foos' => \Cake\ORM\Association\HasOne::class,
			'Relations.Users' => \Cake\ORM\Association\HasOne::class,
			'SkipMe' => \Cake\ORM\Association\HasOne::class,
			'SkipSome' => \Cake\ORM\Association\HasOne::class,
			'Wheels' => \Cake\ORM\Association\HasOne::class,
			'WheelsExtra' => \Cake\ORM\Association\HasOne::class,
		]),
	);

	expectedArguments(
		\Cake\ORM\Table::removeBehavior(),
		0,
		'CounterCache',
		'My',
		'Nullable',
		'Timestamp',
		'Translate',
		'Tree',
	);

	expectedArguments(
		\Cake\Routing\Router::pathUrl(),
		0,
		argumentsSet('routePaths'),
	);

	expectedArguments(
		\Cake\TestSuite\TestCase::addFixture(),
		0,
		'app.SmallWindows',
		'core.Posts',
		'plugin.IdeHelper.Cars',
		'plugin.MyNamespace/MyPlugin.Sub/My',
	);

	expectedArguments(
		\Cake\Validation\Validator::allowEmptyArray(),
		2,
		argumentsSet('validationWhen'),
	);

	expectedArguments(
		\Cake\Validation\Validator::allowEmptyDate(),
		2,
		argumentsSet('validationWhen'),
	);

	expectedArguments(
		\Cake\Validation\Validator::allowEmptyDateTime(),
		2,
		argumentsSet('validationWhen'),
	);

	expectedArguments(
		\Cake\Validation\Validator::allowEmptyFile(),
		2,
		argumentsSet('validationWhen'),
	);

	expectedArguments(
		\Cake\Validation\Validator::allowEmptyFor(),
		2,
		argumentsSet('validationWhen'),
	);

	expectedArguments(
		\Cake\Validation\Validator::allowEmptyString(),
		2,
		argumentsSet('validationWhen'),
	);

	expectedArguments(
		\Cake\Validation\Validator::allowEmptyTime(),
		2,
		argumentsSet('validationWhen'),
	);

	expectedArguments(
		\Cake\Validation\Validator::notEmptyArray(),
		2,
		argumentsSet('validationWhen'),
	);

	expectedArguments(
		\Cake\Validation\Validator::notEmptyDate(),
		2,
		argumentsSet('validationWhen'),
	);

	expectedArguments(
		\Cake\Validation\Validator::notEmptyDateTime(),
		2,
		argumentsSet('validationWhen'),
	);

	expectedArguments(
		\Cake\Validation\Validator::notEmptyFile(),
		2,
		argumentsSet('validationWhen'),
	);

	expectedArguments(
		\Cake\Validation\Validator::notEmptyString(),
		2,
		argumentsSet('validationWhen'),
	);

	expectedArguments(
		\Cake\Validation\Validator::notEmptyTime(),
		2,
		argumentsSet('validationWhen'),
	);

	expectedArguments(
		\Cake\Validation\Validator::requirePresence(),
		1,
		argumentsSet('validationWhen'),
	);

	override(
		\Cake\View\CellTrait::cell(),
		map([
			'Test' => \TestApp\View\Cell\TestCell::class,
			'Test::custom' => \TestApp\View\Cell\TestCell::class,
		]),
	);

	expectedArguments(
		\Cake\View\Helper\FormHelper::control(),
		0,
		'content',
		'created',
		'id',
		'modified',
		'name',
		'params',
		'status',
		'user_id',
	);

	expectedArguments(
		\Cake\View\Helper\HtmlHelper::linkFromPath(),
		1,
		argumentsSet('routePaths'),
	);

	expectedArguments(
		\Cake\View\Helper\UrlHelper::buildFromPath(),
		0,
		argumentsSet('routePaths'),
	);

	override(
		\Cake\View\View::addHelper(0),
		map([
			'Breadcrumbs' => \Cake\View\Helper\BreadcrumbsHelper::class,
			'Flash' => \Cake\View\Helper\FlashHelper::class,
			'Form' => \Cake\View\Helper\FormHelper::class,
			'Html' => \TestApp\View\Helper\HtmlHelper::class,
			'IdeHelper.DocBlock' => \IdeHelper\View\Helper\DocBlockHelper::class,
			'My' => \TestApp\View\Helper\MyHelper::class,
			'MyMethod' => \TestApp\View\Helper\MyMethodHelper::class,
			'Number' => \Cake\View\Helper\NumberHelper::class,
			'Paginator' => \Cake\View\Helper\PaginatorHelper::class,
			'Shim.Configure' => \Shim\View\Helper\ConfigureHelper::class,
			'Shim.Cookie' => \Shim\View\Helper\CookieHelper::class,
			'Shim.Number' => \Shim\View\Helper\NumberHelper::class,
			'Text' => \Cake\View\Helper\TextHelper::class,
			'Time' => \Cake\View\Helper\TimeHelper::class,
			'Url' => \Cake\View\Helper\UrlHelper::class,
		]),
	);

	expectedArguments(
		\Cake\View\View::element(),
		0,
		'Awesome.pagination',
		'deeply/nested',
		'example',
	);

	override(
		\Cake\View\View::loadHelper(0),
		map([
			'Breadcrumbs' => \Cake\View\Helper\BreadcrumbsHelper::class,
			'Flash' => \Cake\View\Helper\FlashHelper::class,
			'Form' => \Cake\View\Helper\FormHelper::class,
			'Html' => \TestApp\View\Helper\HtmlHelper::class,
			'IdeHelper.DocBlock' => \IdeHelper\View\Helper\DocBlockHelper::class,
			'My' => \TestApp\View\Helper\MyHelper::class,
			'MyMethod' => \TestApp\View\Helper\MyMethodHelper::class,
			'Number' => \Cake\View\Helper\NumberHelper::class,
			'Paginator' => \Cake\View\Helper\PaginatorHelper::class,
			'Shim.Configure' => \Shim\View\Helper\ConfigureHelper::class,
			'Shim.Cookie' => \Shim\View\Helper\CookieHelper::class,
			'Shim.Number' => \Shim\View\Helper\NumberHelper::class,
			'Text' => \Cake\View\Helper\TextHelper::class,
			'Time' => \Cake\View\Helper\TimeHelper::class,
			'Url' => \Cake\View\Helper\UrlHelper::class,
		]),
	);

	expectedArguments(
		\Cake\View\ViewBuilder::addHelper(),
		0,
		'Breadcrumbs',
		'Flash',
		'Form',
		'Html',
		'IdeHelper.DocBlock',
		'My',
		'MyMethod',
		'Number',
		'Paginator',
		'Shim.Configure',
		'Shim.Cookie',
		'Shim.Number',
		'Text',
		'Time',
		'Url',
	);

	expectedArguments(
		\Cake\View\ViewBuilder::setLayout(),
		0,
		'ajax',
	);

	expectedArguments(
		\Migrations\BaseMigration::hasTable(),
		0,
		argumentsSet('tableNames'),
	);

	expectedArguments(
		\Migrations\BaseMigration::table(),
		0,
		argumentsSet('tableNames'),
	);

	expectedArguments(
		\Migrations\BaseSeed::hasTable(),
		0,
		argumentsSet('tableNames'),
	);

	expectedArguments(
		\Migrations\BaseSeed::table(),
		0,
		argumentsSet('tableNames'),
	);

	expectedArguments(
		\Migrations\Db\Table::addColumn(),
		0,
		argumentsSet('columnNames'),
	);

	expectedArguments(
		\Migrations\Db\Table::addColumn(),
		1,
		argumentsSet('columnTypes'),
	);

	expectedArguments(
		\Migrations\Db\Table::changeColumn(),
		0,
		argumentsSet('columnNames'),
	);

	expectedArguments(
		\Migrations\Db\Table::changeColumn(),
		1,
		argumentsSet('columnTypes'),
	);

	expectedArguments(
		\Migrations\Db\Table::hasColumn(),
		0,
		argumentsSet('columnNames'),
	);

	expectedArguments(
		\Migrations\Db\Table::removeColumn(),
		0,
		argumentsSet('columnNames'),
	);

	expectedArguments(
		\Migrations\Db\Table::renameColumn(),
		0,
		argumentsSet('columnNames'),
	);

	expectedArguments(
		\Migrations\Db\Table::renameColumn(),
		1,
		argumentsSet('columnNames'),
	);

	expectedArguments(
		\Relations\Model\Entity\Bar::get(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Bar'),
	);

	expectedArguments(
		\Relations\Model\Entity\Bar::getError(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Bar'),
	);

	expectedArguments(
		\Relations\Model\Entity\Bar::getInvalidField(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Bar'),
	);

	expectedArguments(
		\Relations\Model\Entity\Bar::getOriginal(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Bar'),
	);

	expectedArguments(
		\Relations\Model\Entity\Bar::has(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Bar'),
	);

	expectedArguments(
		\Relations\Model\Entity\Bar::hasValue(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Bar'),
	);

	expectedArguments(
		\Relations\Model\Entity\Bar::isDirty(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Bar'),
	);

	expectedArguments(
		\Relations\Model\Entity\Bar::isEmpty(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Bar'),
	);

	expectedArguments(
		\Relations\Model\Entity\Bar::setDirty(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Bar'),
	);

	expectedArguments(
		\Relations\Model\Entity\Bar::setError(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Bar'),
	);

	expectedArguments(
		\Relations\Model\Entity\Foo::get(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Foo'),
	);

	expectedArguments(
		\Relations\Model\Entity\Foo::getError(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Foo'),
	);

	expectedArguments(
		\Relations\Model\Entity\Foo::getInvalidField(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Foo'),
	);

	expectedArguments(
		\Relations\Model\Entity\Foo::getOriginal(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Foo'),
	);

	expectedArguments(
		\Relations\Model\Entity\Foo::has(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Foo'),
	);

	expectedArguments(
		\Relations\Model\Entity\Foo::hasValue(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Foo'),
	);

	expectedArguments(
		\Relations\Model\Entity\Foo::isDirty(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Foo'),
	);

	expectedArguments(
		\Relations\Model\Entity\Foo::isEmpty(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Foo'),
	);

	expectedArguments(
		\Relations\Model\Entity\Foo::setDirty(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Foo'),
	);

	expectedArguments(
		\Relations\Model\Entity\Foo::setError(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Foo'),
	);

	expectedArguments(
		\Relations\Model\Entity\User::get(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\User'),
	);

	expectedArguments(
		\Relations\Model\Entity\User::getError(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\User'),
	);

	expectedArguments(
		\Relations\Model\Entity\User::getInvalidField(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\User'),
	);

	expectedArguments(
		\Relations\Model\Entity\User::getOriginal(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\User'),
	);

	expectedArguments(
		\Relations\Model\Entity\User::has(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\User'),
	);

	expectedArguments(
		\Relations\Model\Entity\User::hasValue(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\User'),
	);

	expectedArguments(
		\Relations\Model\Entity\User::isDirty(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\User'),
	);

	expectedArguments(
		\Relations\Model\Entity\User::isEmpty(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\User'),
	);

	expectedArguments(
		\Relations\Model\Entity\User::setDirty(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\User'),
	);

	expectedArguments(
		\Relations\Model\Entity\User::setError(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\User'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBar::get(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBar'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBar::getError(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBar'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBar::getInvalidField(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBar'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBar::getOriginal(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBar'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBar::has(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBar'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBar::hasValue(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBar'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBar::isDirty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBar'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBar::isEmpty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBar'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBar::setDirty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBar'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBar::setError(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBar'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBarsAbstract::get(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBarsAbstract'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBarsAbstract::getError(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBarsAbstract'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBarsAbstract::getInvalidField(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBarsAbstract'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBarsAbstract::getOriginal(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBarsAbstract'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBarsAbstract::has(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBarsAbstract'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBarsAbstract::hasValue(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBarsAbstract'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBarsAbstract::isDirty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBarsAbstract'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBarsAbstract::isEmpty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBarsAbstract'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBarsAbstract::setDirty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBarsAbstract'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBarsAbstract::setError(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBarsAbstract'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Car::get(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Car'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Car::getError(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Car'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Car::getInvalidField(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Car'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Car::getOriginal(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Car'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Car::has(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Car'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Car::hasValue(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Car'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Car::isDirty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Car'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Car::isEmpty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Car'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Car::setDirty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Car'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Car::setError(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Car'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Foo::get(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Foo'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Foo::getError(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Foo'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Foo::getInvalidField(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Foo'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Foo::getOriginal(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Foo'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Foo::has(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Foo'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Foo::hasValue(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Foo'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Foo::isDirty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Foo'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Foo::isEmpty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Foo'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Foo::setDirty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Foo'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Foo::setError(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Foo'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Wheel::get(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Wheel'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Wheel::getError(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Wheel'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Wheel::getInvalidField(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Wheel'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Wheel::getOriginal(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Wheel'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Wheel::has(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Wheel'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Wheel::hasValue(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Wheel'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Wheel::isDirty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Wheel'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Wheel::isEmpty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Wheel'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Wheel::setDirty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Wheel'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Wheel::setError(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Wheel'),
	);

	expectedArguments(
		\__d(),
		0,
		'awesome',
		'cake',
		'controllers',
		'ide_helper',
		'my_namespace/my_plugin',
		'relations',
		'shim',
	);

	expectedArguments(
		\env(),
		0,
		'HTTP_HOST',
	);

	expectedArguments(
		\urlArray(),
		0,
		argumentsSet('routePaths'),
	);

	registerArgumentsSet(
		'cacheEngines',
		'_cake_model_',
		'_cake_translations_',
		'default',
	);

	registerArgumentsSet(
		'columnNames',
		'content',
		'created',
		'id',
		'name',
	);

	registerArgumentsSet(
		'columnTypes',
		'biginteger',
		'binary',
		'binaryuuid',
		'bit',
		'blob',
		'boolean',
		'char',
		'date',
		'datetime',
		'decimal',
		'double',
		'float',
		'integer',
		'json',
		'smallinteger',
		'string',
		'text',
		'time',
		'timestamp',
		'uuid',
		'year',
	);

	registerArgumentsSet(
		'configureKeys',
		'App',
		'App.encoding',
		'App.namespace',
		'App.paths',
		'App.paths.templates',
		'IdeHelper',
		'IdeHelper.skipDatabaseTables',
		'Shim',
		'Shim.deprecations',
		'debug',
		'plugins',
		'plugins.Bake',
		'plugins.Cake/TwigView',
		'plugins.Migrations',
		'plugins.Shim',
	);

	registerArgumentsSet(
		'entityFields:Cake\ORM\Entity',
		'id',
		'name',
	);

	registerArgumentsSet(
		'entityFields:Relations\Model\Entity\Bar',
		'id',
		'name',
		'user',
		'user_id',
	);

	registerArgumentsSet(
		'entityFields:Relations\Model\Entity\Foo',
		'id',
		'name',
		'params',
		'user',
		'user_id',
	);

	registerArgumentsSet(
		'entityFields:Relations\Model\Entity\User',
		'bar',
		'foo',
		'id',
		'name',
	);

	registerArgumentsSet(
		'entityFields:TestApp\Model\Entity\BarBar',
		'content',
		'created',
		'foo',
		'houses',
		'id',
		'name',
	);

	registerArgumentsSet(
		'entityFields:TestApp\Model\Entity\BarBarsAbstract',
		'content',
		'created',
		'foo',
		'houses',
		'id',
		'name',
	);

	registerArgumentsSet(
		'entityFields:TestApp\Model\Entity\Car',
		'content',
		'created',
		'id',
		'modified',
		'name',
		'status',
		'wheels',
	);

	registerArgumentsSet(
		'entityFields:TestApp\Model\Entity\Foo',
		'content',
		'created',
		'id',
		'name',
		'params',
	);

	registerArgumentsSet(
		'entityFields:TestApp\Model\Entity\Wheel',
		'car',
		'content',
		'created',
		'id',
		'name',
		'virtual_one',
	);

	registerArgumentsSet(
		'routePaths',
		'Awesome.Admin/AwesomeHouses::openDoor',
		'Bar::index',
	);

	registerArgumentsSet(
		'tableNames',
		'wheels',
	);

	registerArgumentsSet(
		'validationWhen',
		'create',
		'update',
	);

}


================================================
FILE: tests/test_files/meta/phpstorm/.meta_52.php
================================================
<?php
// @link https://confluence.jetbrains.com/display/PhpStorm/PhpStorm+Advanced+Metadata
namespace PHPSTORM_META {

	expectedArguments(
		\Cake\Cache\Cache::add(),
		2,
		argumentsSet('cacheEngines'),
	);

	expectedArguments(
		\Cake\Cache\Cache::clear(),
		0,
		argumentsSet('cacheEngines'),
	);

	expectedArguments(
		\Cake\Cache\Cache::clearGroup(),
		1,
		argumentsSet('cacheEngines'),
	);

	expectedArguments(
		\Cake\Cache\Cache::decrement(),
		2,
		argumentsSet('cacheEngines'),
	);

	expectedArguments(
		\Cake\Cache\Cache::delete(),
		1,
		argumentsSet('cacheEngines'),
	);

	expectedArguments(
		\Cake\Cache\Cache::deleteMany(),
		1,
		argumentsSet('cacheEngines'),
	);

	expectedArguments(
		\Cake\Cache\Cache::increment(),
		2,
		argumentsSet('cacheEngines'),
	);

	expectedArguments(
		\Cake\Cache\Cache::read(),
		1,
		argumentsSet('cacheEngines'),
	);

	expectedArguments(
		\Cake\Cache\Cache::readMany(),
		1,
		argumentsSet('cacheEngines'),
	);

	expectedArguments(
		\Cake\Cache\Cache::remember(),
		2,
		argumentsSet('cacheEngines'),
	);

	expectedArguments(
		\Cake\Cache\Cache::write(),
		2,
		argumentsSet('cacheEngines'),
	);

	exitPoint(\Cake\Console\ConsoleIo::abort());

	override(
		\Cake\Console\ConsoleIo::helper(0),
		map([
			'Banner' => \Cake\Command\Helper\BannerHelper::class,
			'Progress' => \Cake\Command\Helper\ProgressHelper::class,
			'Table' => \Cake\Command\Helper\TableHelper::class,
		]),
	);

	expectedArguments(
		\Cake\Controller\ComponentRegistry::unload(),
		0,
		'CheckHttpCache',
		'Flash',
		'FormProtection',
		'My',
		'MyController',
		'MyOther',
		'RequestHandler',
	);

	override(
		\Cake\Controller\Controller::loadComponent(0),
		map([
			'CheckHttpCache' => \TestApp\Controller\Component\CheckHttpCacheComponent::class,
			'Flash' => \Cake\Controller\Component\FlashComponent::class,
			'FormProtection' => \Cake\Controller\Component\FormProtectionComponent::class,
			'My' => \TestApp\Controller\Component\MyComponent::class,
			'MyController' => \TestApp\Controller\Component\MyControllerComponent::class,
			'MyNamespace/MyPlugin.My' => \MyNamespace\MyPlugin\Controller\Component\MyComponent::class,
			'MyOther' => \TestApp\Controller\Component\MyOtherComponent::class,
			'Shim.RequestHandler' => \Shim\Controller\Component\RequestHandlerComponent::class,
		]),
	);

	expectedArguments(
		\Cake\Core\Configure::check(),
		0,
		argumentsSet('configureKeys'),
	);

	expectedArguments(
		\Cake\Core\Configure::consume(),
		0,
		argumentsSet('configureKeys'),
	);

	expectedArguments(
		\Cake\Core\Configure::consumeOrFail(),
		0,
		argumentsSet('configureKeys'),
	);

	expectedArguments(
		\Cake\Core\Configure::delete(),
		0,
		argumentsSet('configureKeys'),
	);

	expectedArguments(
		\Cake\Core\Configure::read(),
		0,
		argumentsSet('configureKeys'),
	);

	expectedArguments(
		\Cake\Core\Configure::readOrFail(),
		0,
		argumentsSet('configureKeys'),
	);

	expectedArguments(
		\Cake\Core\Configure::write(),
		0,
		argumentsSet('configureKeys'),
	);

	override(
		\Cake\Core\PluginApplicationInterface::addPlugin(0),
		map([
			'Bake' => \Cake\Http\BaseApplication::class,
			'Cake/TwigView' => \Cake\Http\BaseApplication::class,
			'Migrations' => \Cake\Http\BaseApplication::class,
			'Shim' => \Cake\Http\BaseApplication::class,
		]),
	);

	override(
		\Cake\Database\TypeFactory::build(0),
		map([
			'biginteger' => \Cake\Database\Type\IntegerType::class,
			'binary' => \Cake\Database\Type\BinaryType::class,
			'binaryuuid' => \Cake\Database\Type\BinaryUuidType::class,
			'boolean' => \Cake\Database\Type\BoolType::class,
			'char' => \Cake\Database\Type\StringType::class,
			'date' => \Cake\Database\Type\DateType::class,
			'datetime' => \Cake\Database\Type\DateTimeType::class,
			'datetimefractional' => \Cake\Database\Type\DateTimeFractionalType::class,
			'decimal' => \Cake\Database\Type\DecimalType::class,
			'float' => \Cake\Database\Type\FloatType::class,
			'geometry' => \Cake\Database\Type\StringType::class,
			'integer' => \Cake\Database\Type\IntegerType::class,
			'json' => \Cake\Database\Type\JsonType::class,
			'linestring' => \Cake\Database\Type\StringType::class,
			'nativeuuid' => \Cake\Database\Type\UuidType::class,
			'point' => \Cake\Database\Type\StringType::class,
			'polygon' => \Cake\Database\Type\StringType::class,
			'smallinteger' => \Cake\Database\Type\IntegerType::class,
			'string' => \Cake\Database\Type\StringType::class,
			'text' => \Cake\Database\Type\StringType::class,
			'time' => \Cake\Database\Type\TimeType::class,
			'timestamp' => \Cake\Database\Type\DateTimeType::class,
			'timestampfractional' => \Cake\Database\Type\DateTimeFractionalType::class,
			'timestamptimezone' => \Cake\Database\Type\DateTimeTimezoneType::class,
			'tinyinteger' => \Cake\Database\Type\IntegerType::class,
			'uuid' => \Cake\Database\Type\UuidType::class,
		]),
	);

	expectedArguments(
		\Cake\Database\TypeFactory::map(),
		0,
		'biginteger',
		'binary',
		'binaryuuid',
		'boolean',
		'char',
		'date',
		'datetime',
		'datetimefractional',
		'decimal',
		'float',
		'geometry',
		'integer',
		'json',
		'linestring',
		'nativeuuid',
		'point',
		'polygon',
		'smallinteger',
		'string',
		'text',
		'time',
		'timestamp',
		'timestampfractional',
		'timestamptimezone',
		'tinyinteger',
		'uuid',
	);

	expectedArguments(
		\Cake\Datasource\ConnectionManager::get(),
		0,
		'test',
	);

	override(
		\Cake\Datasource\ModelAwareTrait::fetchModel(0),
		map([
			'Awesome.Houses' => \Awesome\Model\Table\HousesTable::class,
			'Awesome.Windows' => \Awesome\Model\Table\WindowsTable::class,
			'BarBars' => \TestApp\Model\Table\BarBarsTable::class,
			'BarBarsAbstract' => \TestApp\Model\Table\BarBarsAbstractTable::class,
			'Callbacks' => \TestApp\Model\Table\CallbacksTable::class,
			'Cars' => \TestApp\Model\Table\CarsTable::class,
			'Controllers.Houses' => \Controllers\Model\Table\HousesTable::class,
			'CustomFinder' => \TestApp\Model\Table\CustomFinderTable::class,
			'Exceptions' => \TestApp\Model\Table\ExceptionsTable::class,
			'Foos' => \TestApp\Model\Table\FoosTable::class,
			'MyNamespace/MyPlugin.My' => \MyNamespace\MyPlugin\Model\Table\MyTable::class,
			'Relations.Bars' => \Relations\Model\Table\BarsTable::class,
			'Relations.Foos' => \Relations\Model\Table\FoosTable::class,
			'Relations.Users' => \Relations\Model\Table\UsersTable::class,
			'SkipMe' => \TestApp\Model\Table\SkipMeTable::class,
			'SkipSome' => \TestApp\Model\Table\SkipSomeTable::class,
			'Wheels' => \TestApp\Model\Table\WheelsTable::class,
			'WheelsExtra' => \TestApp\Model\Table\WheelsExtraTable::class,
		]),
	);

	override(
		\Cake\Datasource\QueryInterface::find(0),
		map([
			'all' => \Cake\ORM\Query\SelectQuery::class,
			'children' => \Cake\ORM\Query\SelectQuery::class,
			'list' => \Cake\ORM\Query\SelectQuery::class,
			'path' => \Cake\ORM\Query\SelectQuery::class,
			'somethingCustom' => \Cake\ORM\Query\SelectQuery::class,
			'threaded' => \Cake\ORM\Query\SelectQuery::class,
			'treeList' => \Cake\ORM\Query\SelectQuery::class,
		]),
	);

	override(
		\Cake\Http\ServerRequest::getAttribute(0),
		map([
			'base' => 'string',
			'cspScriptNonce' => 'string',
			'cspStyleNonce' => 'string',
			'csrfToken' => 'string',
			'formTokenData' => 'array',
			'here' => 'string',
			'paging' => 'array',
			'params' => 'array',
			'route' => \Cake\Routing\Route\Route::class,
			'session' => \Cake\Http\Session::class,
			'webroot' => 'string',
		]),
	);

	expectedArguments(
		\Cake\Http\ServerRequest::getParam(),
		0,
		'_ext',
		'_matchedRoute',
		'action',
		'controller',
		'pass',
		'plugin',
		'prefix',
	);

	override(
		\Cake\Mailer\MailerAwareTrait::getMailer(0),
		map([
			'User' => \TestApp\Mailer\UserMailer::class,
		]),
	);

	override(
		\Cake\ORM\Association::find(0),
		map([
			'all' => \Cake\ORM\Query\SelectQuery::class,
			'children' => \Cake\ORM\Query\SelectQuery::class,
			'list' => \Cake\ORM\Query\SelectQuery::class,
			'path' => \Cake\ORM\Query\SelectQuery::class,
			'somethingCustom' => \Cake\ORM\Query\SelectQuery::class,
			'threaded' => \Cake\ORM\Query\SelectQuery::class,
			'treeList' => \Cake\ORM\Query\SelectQuery::class,
		]),
	);

	expectedArguments(
		\Cake\ORM\Entity::get(),
		0,
		argumentsSet('entityFields:Cake\ORM\Entity'),
	);

	expectedArguments(
		\Cake\ORM\Entity::getError(),
		0,
		argumentsSet('entityFields:Cake\ORM\Entity'),
	);

	expectedArguments(
		\Cake\ORM\Entity::getInvalidField(),
		0,
		argumentsSet('entityFields:Cake\ORM\Entity'),
	);

	expectedArguments(
		\Cake\ORM\Entity::getOriginal(),
		0,
		argumentsSet('entityFields:Cake\ORM\Entity'),
	);

	expectedArguments(
		\Cake\ORM\Entity::has(),
		0,
		argumentsSet('entityFields:Cake\ORM\Entity'),
	);

	expectedArguments(
		\Cake\ORM\Entity::hasValue(),
		0,
		argumentsSet('entityFields:Cake\ORM\Entity'),
	);

	expectedArguments(
		\Cake\ORM\Entity::isDirty(),
		0,
		argumentsSet('entityFields:Cake\ORM\Entity'),
	);

	expectedArguments(
		\Cake\ORM\Entity::isEmpty(),
		0,
		argumentsSet('entityFields:Cake\ORM\Entity'),
	);

	expectedArguments(
		\Cake\ORM\Entity::setDirty(),
		0,
		argumentsSet('entityFields:Cake\ORM\Entity'),
	);

	expectedArguments(
		\Cake\ORM\Entity::setError(),
		0,
		argumentsSet('entityFields:Cake\ORM\Entity'),
	);

	override(
		\Cake\ORM\Locator\LocatorAwareTrait::fetchTable(0),
		map([
			'Awesome.Houses' => \Awesome\Model\Table\HousesTable::class,
			'Awesome.Windows' => \Awesome\Model\Table\WindowsTable::class,
			'BarBars' => \TestApp\Model\Table\BarBarsTable::class,
			'BarBarsAbstract' => \TestApp\Model\Table\BarBarsAbstractTable::class,
			'Callbacks' => \TestApp\Model\Table\CallbacksTable::class,
			'Cars' => \TestApp\Model\Table\CarsTable::class,
			'Controllers.Houses' => \Controllers\Model\Table\HousesTable::class,
			'CustomFinder' => \TestApp\Model\Table\CustomFinderTable::class,
			'Exceptions' => \TestApp\Model\Table\ExceptionsTable::class,
			'Foos' => \TestApp\Model\Table\FoosTable::class,
			'MyNamespace/MyPlugin.My' => \MyNamespace\MyPlugin\Model\Table\MyTable::class,
			'Relations.Bars' => \Relations\Model\Table\BarsTable::class,
			'Relations.Foos' => \Relations\Model\Table\FoosTable::class,
			'Relations.Users' => \Relations\Model\Table\UsersTable::class,
			'SkipMe' => \TestApp\Model\Table\SkipMeTable::class,
			'SkipSome' => \TestApp\Model\Table\SkipSomeTable::class,
			'Wheels' => \TestApp\Model\Table\WheelsTable::class,
			'WheelsExtra' => \TestApp\Model\Table\WheelsExtraTable::class,
		]),
	);

	override(
		\Cake\ORM\Locator\LocatorInterface::get(0),
		map([
			'Awesome.Houses' => \Awesome\Model\Table\HousesTable::class,
			'Awesome.Windows' => \Awesome\Model\Table\WindowsTable::class,
			'BarBars' => \TestApp\Model\Table\BarBarsTable::class,
			'BarBarsAbstract' => \TestApp\Model\Table\BarBarsAbstractTable::class,
			'Callbacks' => \TestApp\Model\Table\CallbacksTable::class,
			'Cars' => \TestApp\Model\Table\CarsTable::class,
			'Controllers.Houses' => \Controllers\Model\Table\HousesTable::class,
			'CustomFinder' => \TestApp\Model\Table\CustomFinderTable::class,
			'Exceptions' => \TestApp\Model\Table\ExceptionsTable::class,
			'Foos' => \TestApp\Model\Table\FoosTable::class,
			'MyNamespace/MyPlugin.My' => \MyNamespace\MyPlugin\Model\Table\MyTable::class,
			'Relations.Bars' => \Relations\Model\Table\BarsTable::class,
			'Relations.Foos' => \Relations\Model\Table\FoosTable::class,
			'Relations.Users' => \Relations\Model\Table\UsersTable::class,
			'SkipMe' => \TestApp\Model\Table\SkipMeTable::class,
			'SkipSome' => \TestApp\Model\Table\SkipSomeTable::class,
			'Wheels' => \TestApp\Model\Table\WheelsTable::class,
			'WheelsExtra' => \TestApp\Model\Table\WheelsExtraTable::class,
		]),
	);

	expectedArguments(
		\Cake\ORM\Table::addBehavior(),
		0,
		'CounterCache',
		'MyNamespace/MyPlugin.My',
		'Shim.Nullable',
		'Timestamp',
		'Translate',
		'Tree',
	);

	override(
		\Cake\ORM\Table::belongToMany(0),
		map([
			'Awesome.Houses' => \Cake\ORM\Association\BelongsToMany::class,
			'Awesome.Windows' => \Cake\ORM\Association\BelongsToMany::class,
			'BarBars' => \Cake\ORM\Association\BelongsToMany::class,
			'BarBarsAbstract' => \Cake\ORM\Association\BelongsToMany::class,
			'Callbacks' => \Cake\ORM\Association\BelongsToMany::class,
			'Cars' => \Cake\ORM\Association\BelongsToMany::class,
			'Controllers.Houses' => \Cake\ORM\Association\BelongsToMany::class,
			'CustomFinder' => \Cake\ORM\Association\BelongsToMany::class,
			'Exceptions' => \Cake\ORM\Association\BelongsToMany::class,
			'Foos' => \Cake\ORM\Association\BelongsToMany::class,
			'MyNamespace/MyPlugin.My' => \Cake\ORM\Association\BelongsToMany::class,
			'Relations.Bars' => \Cake\ORM\Association\BelongsToMany::class,
			'Relations.Foos' => \Cake\ORM\Association\BelongsToMany::class,
			'Relations.Users' => \Cake\ORM\Association\BelongsToMany::class,
			'SkipMe' => \Cake\ORM\Association\BelongsToMany::class,
			'SkipSome' => \Cake\ORM\Association\BelongsToMany::class,
			'Wheels' => \Cake\ORM\Association\BelongsToMany::class,
			'WheelsExtra' => \Cake\ORM\Association\BelongsToMany::class,
		]),
	);

	override(
		\Cake\ORM\Table::belongsTo(0),
		map([
			'Awesome.Houses' => \Cake\ORM\Association\BelongsTo::class,
			'Awesome.Windows' => \Cake\ORM\Association\BelongsTo::class,
			'BarBars' => \Cake\ORM\Association\BelongsTo::class,
			'BarBarsAbstract' => \Cake\ORM\Association\BelongsTo::class,
			'Callbacks' => \Cake\ORM\Association\BelongsTo::class,
			'Cars' => \Cake\ORM\Association\BelongsTo::class,
			'Controllers.Houses' => \Cake\ORM\Association\BelongsTo::class,
			'CustomFinder' => \Cake\ORM\Association\BelongsTo::class,
			'Exceptions' => \Cake\ORM\Association\BelongsTo::class,
			'Foos' => \Cake\ORM\Association\BelongsTo::class,
			'MyNamespace/MyPlugin.My' => \Cake\ORM\Association\BelongsTo::class,
			'Relations.Bars' => \Cake\ORM\Association\BelongsTo::class,
			'Relations.Foos' => \Cake\ORM\Association\BelongsTo::class,
			'Relations.Users' => \Cake\ORM\Association\BelongsTo::class,
			'SkipMe' => \Cake\ORM\Association\BelongsTo::class,
			'SkipSome' => \Cake\ORM\Association\BelongsTo::class,
			'Wheels' => \Cake\ORM\Association\BelongsTo::class,
			'WheelsExtra' => \Cake\ORM\Association\BelongsTo::class,
		]),
	);

	override(
		\Cake\ORM\Table::find(0),
		map([
			'all' => \Cake\ORM\Query\SelectQuery::class,
			'children' => \Cake\ORM\Query\SelectQuery::class,
			'list' => \Cake\ORM\Query\SelectQuery::class,
			'path' => \Cake\ORM\Query\SelectQuery::class,
			'somethingCustom' => \Cake\ORM\Query\SelectQuery::class,
			'threaded' => \Cake\ORM\Query\SelectQuery::class,
			'treeList' => \Cake\ORM\Query\SelectQuery::class,
		]),
	);

	override(
		\Cake\ORM\Table::getBehavior(),
		map([
			'CounterCache' => \Cake\ORM\Behavior\CounterCacheBehavior::class,
			'My' => \MyNamespace\MyPlugin\Model\Behavior\MyBehavior::class,
			'Nullable' => \Shim\Model\Behavior\NullableBehavior::class,
			'Timestamp' => \Cake\ORM\Behavior\TimestampBehavior::class,
			'Translate' => \Cake\ORM\Behavior\TranslateBehavior::class,
			'Tree' => \Cake\ORM\Behavior\TreeBehavior::class,
		]),
	);

	expectedArguments(
		\Cake\ORM\Table::hasBehavior(),
		0,
		'CounterCache',
		'My',
		'Nullable',
		'Timestamp',
		'Translate',
		'Tree',
	);

	override(
		\Cake\ORM\Table::hasMany(0),
		map([
			'Awesome.Houses' => \Cake\ORM\Association\HasMany::class,
			'Awesome.Windows' => \Cake\ORM\Association\HasMany::class,
			'BarBars' => \Cake\ORM\Association\HasMany::class,
			'BarBarsAbstract' => \Cake\ORM\Association\HasMany::class,
			'Callbacks' => \Cake\ORM\Association\HasMany::class,
			'Cars' => \Cake\ORM\Association\HasMany::class,
			'Controllers.Houses' => \Cake\ORM\Association\HasMany::class,
			'CustomFinder' => \Cake\ORM\Association\HasMany::class,
			'Exceptions' => \Cake\ORM\Association\HasMany::class,
			'Foos' => \Cake\ORM\Association\HasMany::class,
			'MyNamespace/MyPlugin.My' => \Cake\ORM\Association\HasMany::class,
			'Relations.Bars' => \Cake\ORM\Association\HasMany::class,
			'Relations.Foos' => \Cake\ORM\Association\HasMany::class,
			'Relations.Users' => \Cake\ORM\Association\HasMany::class,
			'SkipMe' => \Cake\ORM\Association\HasMany::class,
			'SkipSome' => \Cake\ORM\Association\HasMany::class,
			'Wheels' => \Cake\ORM\Association\HasMany::class,
			'WheelsExtra' => \Cake\ORM\Association\HasMany::class,
		]),
	);

	override(
		\Cake\ORM\Table::hasOne(0),
		map([
			'Awesome.Houses' => \Cake\ORM\Association\HasOne::class,
			'Awesome.Windows' => \Cake\ORM\Association\HasOne::class,
			'BarBars' => \Cake\ORM\Association\HasOne::class,
			'BarBarsAbstract' => \Cake\ORM\Association\HasOne::class,
			'Callbacks' => \Cake\ORM\Association\HasOne::class,
			'Cars' => \Cake\ORM\Association\HasOne::class,
			'Controllers.Houses' => \Cake\ORM\Association\HasOne::class,
			'CustomFinder' => \Cake\ORM\Association\HasOne::class,
			'Exceptions' => \Cake\ORM\Association\HasOne::class,
			'Foos' => \Cake\ORM\Association\HasOne::class,
			'MyNamespace/MyPlugin.My' => \Cake\ORM\Association\HasOne::class,
			'Relations.Bars' => \Cake\ORM\Association\HasOne::class,
			'Relations.Foos' => \Cake\ORM\Association\HasOne::class,
			'Relations.Users' => \Cake\ORM\Association\HasOne::class,
			'SkipMe' => \Cake\ORM\Association\HasOne::class,
			'SkipSome' => \Cake\ORM\Association\HasOne::class,
			'Wheels' => \Cake\ORM\Association\HasOne::class,
			'WheelsExtra' => \Cake\ORM\Association\HasOne::class,
		]),
	);

	expectedArguments(
		\Cake\ORM\Table::removeBehavior(),
		0,
		'CounterCache',
		'My',
		'Nullable',
		'Timestamp',
		'Translate',
		'Tree',
	);

	expectedArguments(
		\Cake\Routing\Router::pathUrl(),
		0,
		argumentsSet('routePaths'),
	);

	expectedArguments(
		\Cake\TestSuite\TestCase::addFixture(),
		0,
		'app.SmallWindows',
		'core.Posts',
		'plugin.IdeHelper.Cars',
		'plugin.MyNamespace/MyPlugin.Sub/My',
	);

	expectedArguments(
		\Cake\Validation\Validator::allowEmptyArray(),
		2,
		argumentsSet('validationWhen'),
	);

	expectedArguments(
		\Cake\Validation\Validator::allowEmptyDate(),
		2,
		argumentsSet('validationWhen'),
	);

	expectedArguments(
		\Cake\Validation\Validator::allowEmptyDateTime(),
		2,
		argumentsSet('validationWhen'),
	);

	expectedArguments(
		\Cake\Validation\Validator::allowEmptyFile(),
		2,
		argumentsSet('validationWhen'),
	);

	expectedArguments(
		\Cake\Validation\Validator::allowEmptyFor(),
		2,
		argumentsSet('validationWhen'),
	);

	expectedArguments(
		\Cake\Validation\Validator::allowEmptyString(),
		2,
		argumentsSet('validationWhen'),
	);

	expectedArguments(
		\Cake\Validation\Validator::allowEmptyTime(),
		2,
		argumentsSet('validationWhen'),
	);

	expectedArguments(
		\Cake\Validation\Validator::notEmptyArray(),
		2,
		argumentsSet('validationWhen'),
	);

	expectedArguments(
		\Cake\Validation\Validator::notEmptyDate(),
		2,
		argumentsSet('validationWhen'),
	);

	expectedArguments(
		\Cake\Validation\Validator::notEmptyDateTime(),
		2,
		argumentsSet('validationWhen'),
	);

	expectedArguments(
		\Cake\Validation\Validator::notEmptyFile(),
		2,
		argumentsSet('validationWhen'),
	);

	expectedArguments(
		\Cake\Validation\Validator::notEmptyString(),
		2,
		argumentsSet('validationWhen'),
	);

	expectedArguments(
		\Cake\Validation\Validator::notEmptyTime(),
		2,
		argumentsSet('validationWhen'),
	);

	expectedArguments(
		\Cake\Validation\Validator::requirePresence(),
		1,
		argumentsSet('validationWhen'),
	);

	override(
		\Cake\View\CellTrait::cell(),
		map([
			'Test' => \TestApp\View\Cell\TestCell::class,
			'Test::custom' => \TestApp\View\Cell\TestCell::class,
		]),
	);

	expectedArguments(
		\Cake\View\Helper\FormHelper::control(),
		0,
		'content',
		'created',
		'id',
		'modified',
		'name',
		'params',
		'status',
		'user_id',
	);

	expectedArguments(
		\Cake\View\Helper\HtmlHelper::linkFromPath(),
		1,
		argumentsSet('routePaths'),
	);

	expectedArguments(
		\Cake\View\Helper\UrlHelper::buildFromPath(),
		0,
		argumentsSet('routePaths'),
	);

	override(
		\Cake\View\View::addHelper(0),
		map([
			'Breadcrumbs' => \Cake\View\Helper\BreadcrumbsHelper::class,
			'Flash' => \Cake\View\Helper\FlashHelper::class,
			'Form' => \Cake\View\Helper\FormHelper::class,
			'Html' => \TestApp\View\Helper\HtmlHelper::class,
			'IdeHelper.DocBlock' => \IdeHelper\View\Helper\DocBlockHelper::class,
			'My' => \TestApp\View\Helper\MyHelper::class,
			'MyMethod' => \TestApp\View\Helper\MyMethodHelper::class,
			'Number' => \Cake\View\Helper\NumberHelper::class,
			'Paginator' => \Cake\View\Helper\PaginatorHelper::class,
			'Shim.Configure' => \Shim\View\Helper\ConfigureHelper::class,
			'Shim.Cookie' => \Shim\View\Helper\CookieHelper::class,
			'Shim.Number' => \Shim\View\Helper\NumberHelper::class,
			'Text' => \Cake\View\Helper\TextHelper::class,
			'Time' => \Cake\View\Helper\TimeHelper::class,
			'Url' => \Cake\View\Helper\UrlHelper::class,
		]),
	);

	expectedArguments(
		\Cake\View\View::element(),
		0,
		'Awesome.pagination',
		'deeply/nested',
		'example',
	);

	override(
		\Cake\View\View::loadHelper(0),
		map([
			'Breadcrumbs' => \Cake\View\Helper\BreadcrumbsHelper::class,
			'Flash' => \Cake\View\Helper\FlashHelper::class,
			'Form' => \Cake\View\Helper\FormHelper::class,
			'Html' => \TestApp\View\Helper\HtmlHelper::class,
			'IdeHelper.DocBlock' => \IdeHelper\View\Helper\DocBlockHelper::class,
			'My' => \TestApp\View\Helper\MyHelper::class,
			'MyMethod' => \TestApp\View\Helper\MyMethodHelper::class,
			'Number' => \Cake\View\Helper\NumberHelper::class,
			'Paginator' => \Cake\View\Helper\PaginatorHelper::class,
			'Shim.Configure' => \Shim\View\Helper\ConfigureHelper::class,
			'Shim.Cookie' => \Shim\View\Helper\CookieHelper::class,
			'Shim.Number' => \Shim\View\Helper\NumberHelper::class,
			'Text' => \Cake\View\Helper\TextHelper::class,
			'Time' => \Cake\View\Helper\TimeHelper::class,
			'Url' => \Cake\View\Helper\UrlHelper::class,
		]),
	);

	expectedArguments(
		\Cake\View\ViewBuilder::addHelper(),
		0,
		'Breadcrumbs',
		'Flash',
		'Form',
		'Html',
		'IdeHelper.DocBlock',
		'My',
		'MyMethod',
		'Number',
		'Paginator',
		'Shim.Configure',
		'Shim.Cookie',
		'Shim.Number',
		'Text',
		'Time',
		'Url',
	);

	expectedArguments(
		\Cake\View\ViewBuilder::setLayout(),
		0,
		'ajax',
	);

	expectedArguments(
		\Migrations\BaseMigration::hasTable(),
		0,
		argumentsSet('tableNames'),
	);

	expectedArguments(
		\Migrations\BaseMigration::table(),
		0,
		argumentsSet('tableNames'),
	);

	expectedArguments(
		\Migrations\BaseSeed::hasTable(),
		0,
		argumentsSet('tableNames'),
	);

	expectedArguments(
		\Migrations\BaseSeed::table(),
		0,
		argumentsSet('tableNames'),
	);

	expectedArguments(
		\Migrations\Db\Table::addColumn(),
		0,
		argumentsSet('columnNames'),
	);

	expectedArguments(
		\Migrations\Db\Table::addColumn(),
		1,
		argumentsSet('columnTypes'),
	);

	expectedArguments(
		\Migrations\Db\Table::changeColumn(),
		0,
		argumentsSet('columnNames'),
	);

	expectedArguments(
		\Migrations\Db\Table::changeColumn(),
		1,
		argumentsSet('columnTypes'),
	);

	expectedArguments(
		\Migrations\Db\Table::hasColumn(),
		0,
		argumentsSet('columnNames'),
	);

	expectedArguments(
		\Migrations\Db\Table::removeColumn(),
		0,
		argumentsSet('columnNames'),
	);

	expectedArguments(
		\Migrations\Db\Table::renameColumn(),
		0,
		argumentsSet('columnNames'),
	);

	expectedArguments(
		\Migrations\Db\Table::renameColumn(),
		1,
		argumentsSet('columnNames'),
	);

	expectedArguments(
		\Relations\Model\Entity\Bar::get(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Bar'),
	);

	expectedArguments(
		\Relations\Model\Entity\Bar::getError(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Bar'),
	);

	expectedArguments(
		\Relations\Model\Entity\Bar::getInvalidField(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Bar'),
	);

	expectedArguments(
		\Relations\Model\Entity\Bar::getOriginal(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Bar'),
	);

	expectedArguments(
		\Relations\Model\Entity\Bar::has(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Bar'),
	);

	expectedArguments(
		\Relations\Model\Entity\Bar::hasValue(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Bar'),
	);

	expectedArguments(
		\Relations\Model\Entity\Bar::isDirty(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Bar'),
	);

	expectedArguments(
		\Relations\Model\Entity\Bar::isEmpty(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Bar'),
	);

	expectedArguments(
		\Relations\Model\Entity\Bar::setDirty(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Bar'),
	);

	expectedArguments(
		\Relations\Model\Entity\Bar::setError(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Bar'),
	);

	expectedArguments(
		\Relations\Model\Entity\Foo::get(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Foo'),
	);

	expectedArguments(
		\Relations\Model\Entity\Foo::getError(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Foo'),
	);

	expectedArguments(
		\Relations\Model\Entity\Foo::getInvalidField(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Foo'),
	);

	expectedArguments(
		\Relations\Model\Entity\Foo::getOriginal(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Foo'),
	);

	expectedArguments(
		\Relations\Model\Entity\Foo::has(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Foo'),
	);

	expectedArguments(
		\Relations\Model\Entity\Foo::hasValue(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Foo'),
	);

	expectedArguments(
		\Relations\Model\Entity\Foo::isDirty(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Foo'),
	);

	expectedArguments(
		\Relations\Model\Entity\Foo::isEmpty(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Foo'),
	);

	expectedArguments(
		\Relations\Model\Entity\Foo::setDirty(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Foo'),
	);

	expectedArguments(
		\Relations\Model\Entity\Foo::setError(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Foo'),
	);

	expectedArguments(
		\Relations\Model\Entity\User::get(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\User'),
	);

	expectedArguments(
		\Relations\Model\Entity\User::getError(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\User'),
	);

	expectedArguments(
		\Relations\Model\Entity\User::getInvalidField(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\User'),
	);

	expectedArguments(
		\Relations\Model\Entity\User::getOriginal(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\User'),
	);

	expectedArguments(
		\Relations\Model\Entity\User::has(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\User'),
	);

	expectedArguments(
		\Relations\Model\Entity\User::hasValue(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\User'),
	);

	expectedArguments(
		\Relations\Model\Entity\User::isDirty(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\User'),
	);

	expectedArguments(
		\Relations\Model\Entity\User::isEmpty(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\User'),
	);

	expectedArguments(
		\Relations\Model\Entity\User::setDirty(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\User'),
	);

	expectedArguments(
		\Relations\Model\Entity\User::setError(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\User'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBar::get(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBar'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBar::getError(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBar'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBar::getInvalidField(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBar'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBar::getOriginal(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBar'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBar::has(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBar'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBar::hasValue(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBar'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBar::isDirty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBar'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBar::isEmpty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBar'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBar::setDirty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBar'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBar::setError(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBar'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBarsAbstract::get(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBarsAbstract'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBarsAbstract::getError(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBarsAbstract'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBarsAbstract::getInvalidField(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBarsAbstract'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBarsAbstract::getOriginal(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBarsAbstract'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBarsAbstract::has(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBarsAbstract'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBarsAbstract::hasValue(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBarsAbstract'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBarsAbstract::isDirty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBarsAbstract'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBarsAbstract::isEmpty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBarsAbstract'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBarsAbstract::setDirty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBarsAbstract'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBarsAbstract::setError(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBarsAbstract'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Car::get(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Car'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Car::getError(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Car'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Car::getInvalidField(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Car'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Car::getOriginal(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Car'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Car::has(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Car'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Car::hasValue(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Car'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Car::isDirty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Car'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Car::isEmpty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Car'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Car::setDirty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Car'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Car::setError(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Car'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Foo::get(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Foo'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Foo::getError(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Foo'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Foo::getInvalidField(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Foo'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Foo::getOriginal(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Foo'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Foo::has(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Foo'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Foo::hasValue(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Foo'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Foo::isDirty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Foo'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Foo::isEmpty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Foo'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Foo::setDirty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Foo'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Foo::setError(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Foo'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Wheel::get(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Wheel'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Wheel::getError(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Wheel'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Wheel::getInvalidField(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Wheel'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Wheel::getOriginal(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Wheel'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Wheel::has(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Wheel'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Wheel::hasValue(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Wheel'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Wheel::isDirty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Wheel'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Wheel::isEmpty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Wheel'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Wheel::setDirty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Wheel'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Wheel::setError(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Wheel'),
	);

	expectedArguments(
		\__d(),
		0,
		'awesome',
		'cake',
		'controllers',
		'ide_helper',
		'my_namespace/my_plugin',
		'relations',
		'shim',
	);

	expectedArguments(
		\env(),
		0,
		'HTTP_HOST',
	);

	expectedArguments(
		\urlArray(),
		0,
		argumentsSet('routePaths'),
	);

	registerArgumentsSet(
		'cacheEngines',
		'_cake_model_',
		'_cake_translations_',
		'default',
	);

	registerArgumentsSet(
		'columnNames',
		'content',
		'created',
		'id',
		'name',
	);

	registerArgumentsSet(
		'columnTypes',
		'biginteger',
		'binary',
		'binaryuuid',
		'bit',
		'blob',
		'boolean',
		'char',
		'date',
		'datetime',
		'decimal',
		'double',
		'float',
		'integer',
		'json',
		'smallinteger',
		'string',
		'text',
		'time',
		'timestamp',
		'uuid',
		'year',
	);

	registerArgumentsSet(
		'configureKeys',
		'App',
		'App.encoding',
		'App.namespace',
		'App.paths',
		'App.paths.templates',
		'IdeHelper',
		'IdeHelper.skipDatabaseTables',
		'Shim',
		'Shim.deprecations',
		'debug',
		'plugins',
		'plugins.Bake',
		'plugins.Cake/TwigView',
		'plugins.Migrations',
		'plugins.Shim',
	);

	registerArgumentsSet(
		'entityFields:Cake\ORM\Entity',
		'id',
		'name',
	);

	registerArgumentsSet(
		'entityFields:Relations\Model\Entity\Bar',
		'id',
		'name',
		'user',
		'user_id',
	);

	registerArgumentsSet(
		'entityFields:Relations\Model\Entity\Foo',
		'id',
		'name',
		'params',
		'user',
		'user_id',
	);

	registerArgumentsSet(
		'entityFields:Relations\Model\Entity\User',
		'bar',
		'foo',
		'id',
		'name',
	);

	registerArgumentsSet(
		'entityFields:TestApp\Model\Entity\BarBar',
		'content',
		'created',
		'foo',
		'houses',
		'id',
		'name',
	);

	registerArgumentsSet(
		'entityFields:TestApp\Model\Entity\BarBarsAbstract',
		'content',
		'created',
		'foo',
		'houses',
		'id',
		'name',
	);

	registerArgumentsSet(
		'entityFields:TestApp\Model\Entity\Car',
		'content',
		'created',
		'id',
		'modified',
		'name',
		'status',
		'wheels',
	);

	registerArgumentsSet(
		'entityFields:TestApp\Model\Entity\Foo',
		'content',
		'created',
		'id',
		'name',
		'params',
	);

	registerArgumentsSet(
		'entityFields:TestApp\Model\Entity\Wheel',
		'car',
		'content',
		'created',
		'id',
		'name',
		'virtual_one',
	);

	registerArgumentsSet(
		'routePaths',
		'Awesome.Admin/AwesomeHouses::openDoor',
		'Bar::index',
	);

	registerArgumentsSet(
		'tableNames',
		'wheels',
	);

	registerArgumentsSet(
		'validationWhen',
		'create',
		'update',
	);

}


================================================
FILE: tests/test_files/meta/phpstorm/.meta_lowest.php
================================================
<?php
// @link https://confluence.jetbrains.com/display/PhpStorm/PhpStorm+Advanced+Metadata
namespace PHPSTORM_META {

	expectedArguments(
		\Cake\Cache\Cache::add(),
		2,
		argumentsSet('cacheEngines'),
	);

	expectedArguments(
		\Cake\Cache\Cache::clear(),
		0,
		argumentsSet('cacheEngines'),
	);

	expectedArguments(
		\Cake\Cache\Cache::clearGroup(),
		1,
		argumentsSet('cacheEngines'),
	);

	expectedArguments(
		\Cake\Cache\Cache::decrement(),
		2,
		argumentsSet('cacheEngines'),
	);

	expectedArguments(
		\Cake\Cache\Cache::delete(),
		1,
		argumentsSet('cacheEngines'),
	);

	expectedArguments(
		\Cake\Cache\Cache::deleteMany(),
		1,
		argumentsSet('cacheEngines'),
	);

	expectedArguments(
		\Cake\Cache\Cache::increment(),
		2,
		argumentsSet('cacheEngines'),
	);

	expectedArguments(
		\Cake\Cache\Cache::read(),
		1,
		argumentsSet('cacheEngines'),
	);

	expectedArguments(
		\Cake\Cache\Cache::readMany(),
		1,
		argumentsSet('cacheEngines'),
	);

	expectedArguments(
		\Cake\Cache\Cache::remember(),
		2,
		argumentsSet('cacheEngines'),
	);

	expectedArguments(
		\Cake\Cache\Cache::write(),
		2,
		argumentsSet('cacheEngines'),
	);

	exitPoint(\Cake\Console\ConsoleIo::abort());

	override(
		\Cake\Console\ConsoleIo::helper(0),
		map([
			'Banner' => \Cake\Command\Helper\BannerHelper::class,
			'Progress' => \Cake\Command\Helper\ProgressHelper::class,
			'Table' => \Cake\Command\Helper\TableHelper::class,
		]),
	);

	expectedArguments(
		\Cake\Controller\ComponentRegistry::unload(),
		0,
		'CheckHttpCache',
		'Flash',
		'FormProtection',
		'My',
		'MyController',
		'MyOther',
		'RequestHandler',
	);

	override(
		\Cake\Controller\Controller::loadComponent(0),
		map([
			'CheckHttpCache' => \TestApp\Controller\Component\CheckHttpCacheComponent::class,
			'Flash' => \Cake\Controller\Component\FlashComponent::class,
			'FormProtection' => \Cake\Controller\Component\FormProtectionComponent::class,
			'My' => \TestApp\Controller\Component\MyComponent::class,
			'MyController' => \TestApp\Controller\Component\MyControllerComponent::class,
			'MyNamespace/MyPlugin.My' => \MyNamespace\MyPlugin\Controller\Component\MyComponent::class,
			'MyOther' => \TestApp\Controller\Component\MyOtherComponent::class,
			'Shim.RequestHandler' => \Shim\Controller\Component\RequestHandlerComponent::class,
		]),
	);

	expectedArguments(
		\Cake\Core\Configure::check(),
		0,
		argumentsSet('configureKeys'),
	);

	expectedArguments(
		\Cake\Core\Configure::consume(),
		0,
		argumentsSet('configureKeys'),
	);

	expectedArguments(
		\Cake\Core\Configure::consumeOrFail(),
		0,
		argumentsSet('configureKeys'),
	);

	expectedArguments(
		\Cake\Core\Configure::delete(),
		0,
		argumentsSet('configureKeys'),
	);

	expectedArguments(
		\Cake\Core\Configure::read(),
		0,
		argumentsSet('configureKeys'),
	);

	expectedArguments(
		\Cake\Core\Configure::readOrFail(),
		0,
		argumentsSet('configureKeys'),
	);

	expectedArguments(
		\Cake\Core\Configure::write(),
		0,
		argumentsSet('configureKeys'),
	);

	override(
		\Cake\Core\PluginApplicationInterface::addPlugin(0),
		map([
			'Bake' => \Cake\Http\BaseApplication::class,
			'Cake/TwigView' => \Cake\Http\BaseApplication::class,
			'Migrations' => \Cake\Http\BaseApplication::class,
			'Shim' => \Cake\Http\BaseApplication::class,
		]),
	);

	override(
		\Cake\Database\TypeFactory::build(0),
		map([
			'biginteger' => \Cake\Database\Type\IntegerType::class,
			'binary' => \Cake\Database\Type\BinaryType::class,
			'binaryuuid' => \Cake\Database\Type\BinaryUuidType::class,
			'boolean' => \Cake\Database\Type\BoolType::class,
			'char' => \Cake\Database\Type\StringType::class,
			'date' => \Cake\Database\Type\DateType::class,
			'datetime' => \Cake\Database\Type\DateTimeType::class,
			'datetimefractional' => \Cake\Database\Type\DateTimeFractionalType::class,
			'decimal' => \Cake\Database\Type\DecimalType::class,
			'float' => \Cake\Database\Type\FloatType::class,
			'geometry' => \Cake\Database\Type\StringType::class,
			'integer' => \Cake\Database\Type\IntegerType::class,
			'json' => \Cake\Database\Type\JsonType::class,
			'linestring' => \Cake\Database\Type\StringType::class,
			'point' => \Cake\Database\Type\StringType::class,
			'polygon' => \Cake\Database\Type\StringType::class,
			'smallinteger' => \Cake\Database\Type\IntegerType::class,
			'string' => \Cake\Database\Type\StringType::class,
			'text' => \Cake\Database\Type\StringType::class,
			'time' => \Cake\Database\Type\TimeType::class,
			'timestamp' => \Cake\Database\Type\DateTimeType::class,
			'timestampfractional' => \Cake\Database\Type\DateTimeFractionalType::class,
			'timestamptimezone' => \Cake\Database\Type\DateTimeTimezoneType::class,
			'tinyinteger' => \Cake\Database\Type\IntegerType::class,
			'uuid' => \Cake\Database\Type\UuidType::class,
		]),
	);

	expectedArguments(
		\Cake\Database\TypeFactory::map(),
		0,
		'biginteger',
		'binary',
		'binaryuuid',
		'boolean',
		'char',
		'date',
		'datetime',
		'datetimefractional',
		'decimal',
		'float',
		'geometry',
		'integer',
		'json',
		'linestring',
		'point',
		'polygon',
		'smallinteger',
		'string',
		'text',
		'time',
		'timestamp',
		'timestampfractional',
		'timestamptimezone',
		'tinyinteger',
		'uuid',
	);

	expectedArguments(
		\Cake\Datasource\ConnectionManager::get(),
		0,
		'test',
	);

	override(
		\Cake\Datasource\ModelAwareTrait::fetchModel(0),
		map([
			'Awesome.Houses' => \Awesome\Model\Table\HousesTable::class,
			'Awesome.Windows' => \Awesome\Model\Table\WindowsTable::class,
			'BarBars' => \TestApp\Model\Table\BarBarsTable::class,
			'BarBarsAbstract' => \TestApp\Model\Table\BarBarsAbstractTable::class,
			'Callbacks' => \TestApp\Model\Table\CallbacksTable::class,
			'Cars' => \TestApp\Model\Table\CarsTable::class,
			'Controllers.Houses' => \Controllers\Model\Table\HousesTable::class,
			'CustomFinder' => \TestApp\Model\Table\CustomFinderTable::class,
			'Exceptions' => \TestApp\Model\Table\ExceptionsTable::class,
			'Foos' => \TestApp\Model\Table\FoosTable::class,
			'MyNamespace/MyPlugin.My' => \MyNamespace\MyPlugin\Model\Table\MyTable::class,
			'Relations.Bars' => \Relations\Model\Table\BarsTable::class,
			'Relations.Foos' => \Relations\Model\Table\FoosTable::class,
			'Relations.Users' => \Relations\Model\Table\UsersTable::class,
			'SkipMe' => \TestApp\Model\Table\SkipMeTable::class,
			'SkipSome' => \TestApp\Model\Table\SkipSomeTable::class,
			'Wheels' => \TestApp\Model\Table\WheelsTable::class,
			'WheelsExtra' => \TestApp\Model\Table\WheelsExtraTable::class,
		]),
	);

	override(
		\Cake\Datasource\QueryInterface::find(0),
		map([
			'all' => \Cake\ORM\Query\SelectQuery::class,
			'children' => \Cake\ORM\Query\SelectQuery::class,
			'list' => \Cake\ORM\Query\SelectQuery::class,
			'path' => \Cake\ORM\Query\SelectQuery::class,
			'somethingCustom' => \Cake\ORM\Query\SelectQuery::class,
			'threaded' => \Cake\ORM\Query\SelectQuery::class,
			'treeList' => \Cake\ORM\Query\SelectQuery::class,
		]),
	);

	override(
		\Cake\Http\ServerRequest::getAttribute(0),
		map([
			'base' => 'string',
			'cspScriptNonce' => 'string',
			'cspStyleNonce' => 'string',
			'csrfToken' => 'string',
			'formTokenData' => 'array',
			'here' => 'string',
			'paging' => 'array',
			'params' => 'array',
			'route' => \Cake\Routing\Route\Route::class,
			'session' => \Cake\Http\Session::class,
			'webroot' => 'string',
		]),
	);

	expectedArguments(
		\Cake\Http\ServerRequest::getParam(),
		0,
		'_ext',
		'_matchedRoute',
		'action',
		'controller',
		'pass',
		'plugin',
		'prefix',
	);

	override(
		\Cake\Mailer\MailerAwareTrait::getMailer(0),
		map([
			'User' => \TestApp\Mailer\UserMailer::class,
		]),
	);

	override(
		\Cake\ORM\Association::find(0),
		map([
			'all' => \Cake\ORM\Query\SelectQuery::class,
			'children' => \Cake\ORM\Query\SelectQuery::class,
			'list' => \Cake\ORM\Query\SelectQuery::class,
			'path' => \Cake\ORM\Query\SelectQuery::class,
			'somethingCustom' => \Cake\ORM\Query\SelectQuery::class,
			'threaded' => \Cake\ORM\Query\SelectQuery::class,
			'treeList' => \Cake\ORM\Query\SelectQuery::class,
		]),
	);

	expectedArguments(
		\Cake\ORM\Entity::get(),
		0,
		argumentsSet('entityFields:Cake\ORM\Entity'),
	);

	expectedArguments(
		\Cake\ORM\Entity::getError(),
		0,
		argumentsSet('entityFields:Cake\ORM\Entity'),
	);

	expectedArguments(
		\Cake\ORM\Entity::getInvalidField(),
		0,
		argumentsSet('entityFields:Cake\ORM\Entity'),
	);

	expectedArguments(
		\Cake\ORM\Entity::getOriginal(),
		0,
		argumentsSet('entityFields:Cake\ORM\Entity'),
	);

	expectedArguments(
		\Cake\ORM\Entity::has(),
		0,
		argumentsSet('entityFields:Cake\ORM\Entity'),
	);

	expectedArguments(
		\Cake\ORM\Entity::hasValue(),
		0,
		argumentsSet('entityFields:Cake\ORM\Entity'),
	);

	expectedArguments(
		\Cake\ORM\Entity::isDirty(),
		0,
		argumentsSet('entityFields:Cake\ORM\Entity'),
	);

	expectedArguments(
		\Cake\ORM\Entity::isEmpty(),
		0,
		argumentsSet('entityFields:Cake\ORM\Entity'),
	);

	expectedArguments(
		\Cake\ORM\Entity::setDirty(),
		0,
		argumentsSet('entityFields:Cake\ORM\Entity'),
	);

	expectedArguments(
		\Cake\ORM\Entity::setError(),
		0,
		argumentsSet('entityFields:Cake\ORM\Entity'),
	);

	override(
		\Cake\ORM\Locator\LocatorAwareTrait::fetchTable(0),
		map([
			'Awesome.Houses' => \Awesome\Model\Table\HousesTable::class,
			'Awesome.Windows' => \Awesome\Model\Table\WindowsTable::class,
			'BarBars' => \TestApp\Model\Table\BarBarsTable::class,
			'BarBarsAbstract' => \TestApp\Model\Table\BarBarsAbstractTable::class,
			'Callbacks' => \TestApp\Model\Table\CallbacksTable::class,
			'Cars' => \TestApp\Model\Table\CarsTable::class,
			'Controllers.Houses' => \Controllers\Model\Table\HousesTable::class,
			'CustomFinder' => \TestApp\Model\Table\CustomFinderTable::class,
			'Exceptions' => \TestApp\Model\Table\ExceptionsTable::class,
			'Foos' => \TestApp\Model\Table\FoosTable::class,
			'MyNamespace/MyPlugin.My' => \MyNamespace\MyPlugin\Model\Table\MyTable::class,
			'Relations.Bars' => \Relations\Model\Table\BarsTable::class,
			'Relations.Foos' => \Relations\Model\Table\FoosTable::class,
			'Relations.Users' => \Relations\Model\Table\UsersTable::class,
			'SkipMe' => \TestApp\Model\Table\SkipMeTable::class,
			'SkipSome' => \TestApp\Model\Table\SkipSomeTable::class,
			'Wheels' => \TestApp\Model\Table\WheelsTable::class,
			'WheelsExtra' => \TestApp\Model\Table\WheelsExtraTable::class,
		]),
	);

	override(
		\Cake\ORM\Locator\LocatorInterface::get(0),
		map([
			'Awesome.Houses' => \Awesome\Model\Table\HousesTable::class,
			'Awesome.Windows' => \Awesome\Model\Table\WindowsTable::class,
			'BarBars' => \TestApp\Model\Table\BarBarsTable::class,
			'BarBarsAbstract' => \TestApp\Model\Table\BarBarsAbstractTable::class,
			'Callbacks' => \TestApp\Model\Table\CallbacksTable::class,
			'Cars' => \TestApp\Model\Table\CarsTable::class,
			'Controllers.Houses' => \Controllers\Model\Table\HousesTable::class,
			'CustomFinder' => \TestApp\Model\Table\CustomFinderTable::class,
			'Exceptions' => \TestApp\Model\Table\ExceptionsTable::class,
			'Foos' => \TestApp\Model\Table\FoosTable::class,
			'MyNamespace/MyPlugin.My' => \MyNamespace\MyPlugin\Model\Table\MyTable::class,
			'Relations.Bars' => \Relations\Model\Table\BarsTable::class,
			'Relations.Foos' => \Relations\Model\Table\FoosTable::class,
			'Relations.Users' => \Relations\Model\Table\UsersTable::class,
			'SkipMe' => \TestApp\Model\Table\SkipMeTable::class,
			'SkipSome' => \TestApp\Model\Table\SkipSomeTable::class,
			'Wheels' => \TestApp\Model\Table\WheelsTable::class,
			'WheelsExtra' => \TestApp\Model\Table\WheelsExtraTable::class,
		]),
	);

	expectedArguments(
		\Cake\ORM\Table::addBehavior(),
		0,
		'CounterCache',
		'MyNamespace/MyPlugin.My',
		'Shim.Nullable',
		'Timestamp',
		'Translate',
		'Tree',
	);

	override(
		\Cake\ORM\Table::belongToMany(0),
		map([
			'Awesome.Houses' => \Cake\ORM\Association\BelongsToMany::class,
			'Awesome.Windows' => \Cake\ORM\Association\BelongsToMany::class,
			'BarBars' => \Cake\ORM\Association\BelongsToMany::class,
			'BarBarsAbstract' => \Cake\ORM\Association\BelongsToMany::class,
			'Callbacks' => \Cake\ORM\Association\BelongsToMany::class,
			'Cars' => \Cake\ORM\Association\BelongsToMany::class,
			'Controllers.Houses' => \Cake\ORM\Association\BelongsToMany::class,
			'CustomFinder' => \Cake\ORM\Association\BelongsToMany::class,
			'Exceptions' => \Cake\ORM\Association\BelongsToMany::class,
			'Foos' => \Cake\ORM\Association\BelongsToMany::class,
			'MyNamespace/MyPlugin.My' => \Cake\ORM\Association\BelongsToMany::class,
			'Relations.Bars' => \Cake\ORM\Association\BelongsToMany::class,
			'Relations.Foos' => \Cake\ORM\Association\BelongsToMany::class,
			'Relations.Users' => \Cake\ORM\Association\BelongsToMany::class,
			'SkipMe' => \Cake\ORM\Association\BelongsToMany::class,
			'SkipSome' => \Cake\ORM\Association\BelongsToMany::class,
			'Wheels' => \Cake\ORM\Association\BelongsToMany::class,
			'WheelsExtra' => \Cake\ORM\Association\BelongsToMany::class,
		]),
	);

	override(
		\Cake\ORM\Table::belongsTo(0),
		map([
			'Awesome.Houses' => \Cake\ORM\Association\BelongsTo::class,
			'Awesome.Windows' => \Cake\ORM\Association\BelongsTo::class,
			'BarBars' => \Cake\ORM\Association\BelongsTo::class,
			'BarBarsAbstract' => \Cake\ORM\Association\BelongsTo::class,
			'Callbacks' => \Cake\ORM\Association\BelongsTo::class,
			'Cars' => \Cake\ORM\Association\BelongsTo::class,
			'Controllers.Houses' => \Cake\ORM\Association\BelongsTo::class,
			'CustomFinder' => \Cake\ORM\Association\BelongsTo::class,
			'Exceptions' => \Cake\ORM\Association\BelongsTo::class,
			'Foos' => \Cake\ORM\Association\BelongsTo::class,
			'MyNamespace/MyPlugin.My' => \Cake\ORM\Association\BelongsTo::class,
			'Relations.Bars' => \Cake\ORM\Association\BelongsTo::class,
			'Relations.Foos' => \Cake\ORM\Association\BelongsTo::class,
			'Relations.Users' => \Cake\ORM\Association\BelongsTo::class,
			'SkipMe' => \Cake\ORM\Association\BelongsTo::class,
			'SkipSome' => \Cake\ORM\Association\BelongsTo::class,
			'Wheels' => \Cake\ORM\Association\BelongsTo::class,
			'WheelsExtra' => \Cake\ORM\Association\BelongsTo::class,
		]),
	);

	override(
		\Cake\ORM\Table::find(0),
		map([
			'all' => \Cake\ORM\Query\SelectQuery::class,
			'children' => \Cake\ORM\Query\SelectQuery::class,
			'list' => \Cake\ORM\Query\SelectQuery::class,
			'path' => \Cake\ORM\Query\SelectQuery::class,
			'somethingCustom' => \Cake\ORM\Query\SelectQuery::class,
			'threaded' => \Cake\ORM\Query\SelectQuery::class,
			'treeList' => \Cake\ORM\Query\SelectQuery::class,
		]),
	);

	override(
		\Cake\ORM\Table::getBehavior(),
		map([
			'CounterCache' => \Cake\ORM\Behavior\CounterCacheBehavior::class,
			'My' => \MyNamespace\MyPlugin\Model\Behavior\MyBehavior::class,
			'Nullable' => \Shim\Model\Behavior\NullableBehavior::class,
			'Timestamp' => \Cake\ORM\Behavior\TimestampBehavior::class,
			'Translate' => \Cake\ORM\Behavior\TranslateBehavior::class,
			'Tree' => \Cake\ORM\Behavior\TreeBehavior::class,
		]),
	);

	expectedArguments(
		\Cake\ORM\Table::hasBehavior(),
		0,
		'CounterCache',
		'My',
		'Nullable',
		'Timestamp',
		'Translate',
		'Tree',
	);

	override(
		\Cake\ORM\Table::hasMany(0),
		map([
			'Awesome.Houses' => \Cake\ORM\Association\HasMany::class,
			'Awesome.Windows' => \Cake\ORM\Association\HasMany::class,
			'BarBars' => \Cake\ORM\Association\HasMany::class,
			'BarBarsAbstract' => \Cake\ORM\Association\HasMany::class,
			'Callbacks' => \Cake\ORM\Association\HasMany::class,
			'Cars' => \Cake\ORM\Association\HasMany::class,
			'Controllers.Houses' => \Cake\ORM\Association\HasMany::class,
			'CustomFinder' => \Cake\ORM\Association\HasMany::class,
			'Exceptions' => \Cake\ORM\Association\HasMany::class,
			'Foos' => \Cake\ORM\Association\HasMany::class,
			'MyNamespace/MyPlugin.My' => \Cake\ORM\Association\HasMany::class,
			'Relations.Bars' => \Cake\ORM\Association\HasMany::class,
			'Relations.Foos' => \Cake\ORM\Association\HasMany::class,
			'Relations.Users' => \Cake\ORM\Association\HasMany::class,
			'SkipMe' => \Cake\ORM\Association\HasMany::class,
			'SkipSome' => \Cake\ORM\Association\HasMany::class,
			'Wheels' => \Cake\ORM\Association\HasMany::class,
			'WheelsExtra' => \Cake\ORM\Association\HasMany::class,
		]),
	);

	override(
		\Cake\ORM\Table::hasOne(0),
		map([
			'Awesome.Houses' => \Cake\ORM\Association\HasOne::class,
			'Awesome.Windows' => \Cake\ORM\Association\HasOne::class,
			'BarBars' => \Cake\ORM\Association\HasOne::class,
			'BarBarsAbstract' => \Cake\ORM\Association\HasOne::class,
			'Callbacks' => \Cake\ORM\Association\HasOne::class,
			'Cars' => \Cake\ORM\Association\HasOne::class,
			'Controllers.Houses' => \Cake\ORM\Association\HasOne::class,
			'CustomFinder' => \Cake\ORM\Association\HasOne::class,
			'Exceptions' => \Cake\ORM\Association\HasOne::class,
			'Foos' => \Cake\ORM\Association\HasOne::class,
			'MyNamespace/MyPlugin.My' => \Cake\ORM\Association\HasOne::class,
			'Relations.Bars' => \Cake\ORM\Association\HasOne::class,
			'Relations.Foos' => \Cake\ORM\Association\HasOne::class,
			'Relations.Users' => \Cake\ORM\Association\HasOne::class,
			'SkipMe' => \Cake\ORM\Association\HasOne::class,
			'SkipSome' => \Cake\ORM\Association\HasOne::class,
			'Wheels' => \Cake\ORM\Association\HasOne::class,
			'WheelsExtra' => \Cake\ORM\Association\HasOne::class,
		]),
	);

	expectedArguments(
		\Cake\ORM\Table::removeBehavior(),
		0,
		'CounterCache',
		'My',
		'Nullable',
		'Timestamp',
		'Translate',
		'Tree',
	);

	expectedArguments(
		\Cake\Routing\Router::pathUrl(),
		0,
		argumentsSet('routePaths'),
	);

	expectedArguments(
		\Cake\TestSuite\TestCase::addFixture(),
		0,
		'app.SmallWindows',
		'core.Posts',
		'plugin.IdeHelper.Cars',
		'plugin.MyNamespace/MyPlugin.Sub/My',
	);

	expectedArguments(
		\Cake\Validation\Validator::allowEmptyArray(),
		2,
		argumentsSet('validationWhen'),
	);

	expectedArguments(
		\Cake\Validation\Validator::allowEmptyDate(),
		2,
		argumentsSet('validationWhen'),
	);

	expectedArguments(
		\Cake\Validation\Validator::allowEmptyDateTime(),
		2,
		argumentsSet('validationWhen'),
	);

	expectedArguments(
		\Cake\Validation\Validator::allowEmptyFile(),
		2,
		argumentsSet('validationWhen'),
	);

	expectedArguments(
		\Cake\Validation\Validator::allowEmptyFor(),
		2,
		argumentsSet('validationWhen'),
	);

	expectedArguments(
		\Cake\Validation\Validator::allowEmptyString(),
		2,
		argumentsSet('validationWhen'),
	);

	expectedArguments(
		\Cake\Validation\Validator::allowEmptyTime(),
		2,
		argumentsSet('validationWhen'),
	);

	expectedArguments(
		\Cake\Validation\Validator::notEmptyArray(),
		2,
		argumentsSet('validationWhen'),
	);

	expectedArguments(
		\Cake\Validation\Validator::notEmptyDate(),
		2,
		argumentsSet('validationWhen'),
	);

	expectedArguments(
		\Cake\Validation\Validator::notEmptyDateTime(),
		2,
		argumentsSet('validationWhen'),
	);

	expectedArguments(
		\Cake\Validation\Validator::notEmptyFile(),
		2,
		argumentsSet('validationWhen'),
	);

	expectedArguments(
		\Cake\Validation\Validator::notEmptyString(),
		2,
		argumentsSet('validationWhen'),
	);

	expectedArguments(
		\Cake\Validation\Validator::notEmptyTime(),
		2,
		argumentsSet('validationWhen'),
	);

	expectedArguments(
		\Cake\Validation\Validator::requirePresence(),
		1,
		argumentsSet('validationWhen'),
	);

	override(
		\Cake\View\CellTrait::cell(),
		map([
			'Test' => \TestApp\View\Cell\TestCell::class,
			'Test::custom' => \TestApp\View\Cell\TestCell::class,
		]),
	);

	expectedArguments(
		\Cake\View\Helper\FormHelper::control(),
		0,
		'content',
		'created',
		'id',
		'modified',
		'name',
		'params',
		'status',
		'user_id',
	);

	expectedArguments(
		\Cake\View\Helper\HtmlHelper::linkFromPath(),
		1,
		argumentsSet('routePaths'),
	);

	expectedArguments(
		\Cake\View\Helper\UrlHelper::buildFromPath(),
		0,
		argumentsSet('routePaths'),
	);

	override(
		\Cake\View\View::addHelper(0),
		map([
			'Breadcrumbs' => \Cake\View\Helper\BreadcrumbsHelper::class,
			'Flash' => \Cake\View\Helper\FlashHelper::class,
			'Form' => \Cake\View\Helper\FormHelper::class,
			'Html' => \TestApp\View\Helper\HtmlHelper::class,
			'IdeHelper.DocBlock' => \IdeHelper\View\Helper\DocBlockHelper::class,
			'My' => \TestApp\View\Helper\MyHelper::class,
			'MyMethod' => \TestApp\View\Helper\MyMethodHelper::class,
			'Number' => \Cake\View\Helper\NumberHelper::class,
			'Paginator' => \Cake\View\Helper\PaginatorHelper::class,
			'Shim.Configure' => \Shim\View\Helper\ConfigureHelper::class,
			'Shim.Cookie' => \Shim\View\Helper\CookieHelper::class,
			'Text' => \Cake\View\Helper\TextHelper::class,
			'Time' => \Cake\View\Helper\TimeHelper::class,
			'Url' => \Cake\View\Helper\UrlHelper::class,
		]),
	);

	expectedArguments(
		\Cake\View\View::element(),
		0,
		'Awesome.pagination',
		'deeply/nested',
		'example',
	);

	override(
		\Cake\View\View::loadHelper(0),
		map([
			'Breadcrumbs' => \Cake\View\Helper\BreadcrumbsHelper::class,
			'Flash' => \Cake\View\Helper\FlashHelper::class,
			'Form' => \Cake\View\Helper\FormHelper::class,
			'Html' => \TestApp\View\Helper\HtmlHelper::class,
			'IdeHelper.DocBlock' => \IdeHelper\View\Helper\DocBlockHelper::class,
			'My' => \TestApp\View\Helper\MyHelper::class,
			'MyMethod' => \TestApp\View\Helper\MyMethodHelper::class,
			'Number' => \Cake\View\Helper\NumberHelper::class,
			'Paginator' => \Cake\View\Helper\PaginatorHelper::class,
			'Shim.Configure' => \Shim\View\Helper\ConfigureHelper::class,
			'Shim.Cookie' => \Shim\View\Helper\CookieHelper::class,
			'Text' => \Cake\View\Helper\TextHelper::class,
			'Time' => \Cake\View\Helper\TimeHelper::class,
			'Url' => \Cake\View\Helper\UrlHelper::class,
		]),
	);

	expectedArguments(
		\Cake\View\ViewBuilder::addHelper(),
		0,
		'Breadcrumbs',
		'Flash',
		'Form',
		'Html',
		'IdeHelper.DocBlock',
		'My',
		'MyMethod',
		'Number',
		'Paginator',
		'Shim.Configure',
		'Shim.Cookie',
		'Text',
		'Time',
		'Url',
	);

	expectedArguments(
		\Cake\View\ViewBuilder::setLayout(),
		0,
		'ajax',
	);

	expectedArguments(
		\Migrations\BaseMigration::hasTable(),
		0,
		argumentsSet('tableNames'),
	);

	expectedArguments(
		\Migrations\BaseMigration::table(),
		0,
		argumentsSet('tableNames'),
	);

	expectedArguments(
		\Migrations\BaseSeed::hasTable(),
		0,
		argumentsSet('tableNames'),
	);

	expectedArguments(
		\Migrations\BaseSeed::table(),
		0,
		argumentsSet('tableNames'),
	);

	expectedArguments(
		\Migrations\Db\Table::addColumn(),
		0,
		argumentsSet('columnNames'),
	);

	expectedArguments(
		\Migrations\Db\Table::addColumn(),
		1,
		argumentsSet('columnTypes'),
	);

	expectedArguments(
		\Migrations\Db\Table::changeColumn(),
		0,
		argumentsSet('columnNames'),
	);

	expectedArguments(
		\Migrations\Db\Table::changeColumn(),
		1,
		argumentsSet('columnTypes'),
	);

	expectedArguments(
		\Migrations\Db\Table::hasColumn(),
		0,
		argumentsSet('columnNames'),
	);

	expectedArguments(
		\Migrations\Db\Table::removeColumn(),
		0,
		argumentsSet('columnNames'),
	);

	expectedArguments(
		\Migrations\Db\Table::renameColumn(),
		0,
		argumentsSet('columnNames'),
	);

	expectedArguments(
		\Migrations\Db\Table::renameColumn(),
		1,
		argumentsSet('columnNames'),
	);

	expectedArguments(
		\Relations\Model\Entity\Bar::get(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Bar'),
	);

	expectedArguments(
		\Relations\Model\Entity\Bar::getError(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Bar'),
	);

	expectedArguments(
		\Relations\Model\Entity\Bar::getInvalidField(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Bar'),
	);

	expectedArguments(
		\Relations\Model\Entity\Bar::getOriginal(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Bar'),
	);

	expectedArguments(
		\Relations\Model\Entity\Bar::has(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Bar'),
	);

	expectedArguments(
		\Relations\Model\Entity\Bar::hasValue(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Bar'),
	);

	expectedArguments(
		\Relations\Model\Entity\Bar::isDirty(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Bar'),
	);

	expectedArguments(
		\Relations\Model\Entity\Bar::isEmpty(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Bar'),
	);

	expectedArguments(
		\Relations\Model\Entity\Bar::setDirty(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Bar'),
	);

	expectedArguments(
		\Relations\Model\Entity\Bar::setError(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Bar'),
	);

	expectedArguments(
		\Relations\Model\Entity\Foo::get(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Foo'),
	);

	expectedArguments(
		\Relations\Model\Entity\Foo::getError(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Foo'),
	);

	expectedArguments(
		\Relations\Model\Entity\Foo::getInvalidField(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Foo'),
	);

	expectedArguments(
		\Relations\Model\Entity\Foo::getOriginal(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Foo'),
	);

	expectedArguments(
		\Relations\Model\Entity\Foo::has(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Foo'),
	);

	expectedArguments(
		\Relations\Model\Entity\Foo::hasValue(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Foo'),
	);

	expectedArguments(
		\Relations\Model\Entity\Foo::isDirty(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Foo'),
	);

	expectedArguments(
		\Relations\Model\Entity\Foo::isEmpty(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Foo'),
	);

	expectedArguments(
		\Relations\Model\Entity\Foo::setDirty(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Foo'),
	);

	expectedArguments(
		\Relations\Model\Entity\Foo::setError(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\Foo'),
	);

	expectedArguments(
		\Relations\Model\Entity\User::get(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\User'),
	);

	expectedArguments(
		\Relations\Model\Entity\User::getError(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\User'),
	);

	expectedArguments(
		\Relations\Model\Entity\User::getInvalidField(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\User'),
	);

	expectedArguments(
		\Relations\Model\Entity\User::getOriginal(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\User'),
	);

	expectedArguments(
		\Relations\Model\Entity\User::has(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\User'),
	);

	expectedArguments(
		\Relations\Model\Entity\User::hasValue(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\User'),
	);

	expectedArguments(
		\Relations\Model\Entity\User::isDirty(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\User'),
	);

	expectedArguments(
		\Relations\Model\Entity\User::isEmpty(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\User'),
	);

	expectedArguments(
		\Relations\Model\Entity\User::setDirty(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\User'),
	);

	expectedArguments(
		\Relations\Model\Entity\User::setError(),
		0,
		argumentsSet('entityFields:Relations\Model\Entity\User'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBar::get(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBar'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBar::getError(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBar'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBar::getInvalidField(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBar'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBar::getOriginal(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBar'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBar::has(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBar'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBar::hasValue(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBar'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBar::isDirty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBar'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBar::isEmpty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBar'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBar::setDirty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBar'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBar::setError(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBar'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBarsAbstract::get(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBarsAbstract'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBarsAbstract::getError(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBarsAbstract'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBarsAbstract::getInvalidField(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBarsAbstract'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBarsAbstract::getOriginal(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBarsAbstract'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBarsAbstract::has(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBarsAbstract'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBarsAbstract::hasValue(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBarsAbstract'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBarsAbstract::isDirty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBarsAbstract'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBarsAbstract::isEmpty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBarsAbstract'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBarsAbstract::setDirty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBarsAbstract'),
	);

	expectedArguments(
		\TestApp\Model\Entity\BarBarsAbstract::setError(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\BarBarsAbstract'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Car::get(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Car'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Car::getError(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Car'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Car::getInvalidField(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Car'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Car::getOriginal(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Car'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Car::has(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Car'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Car::hasValue(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Car'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Car::isDirty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Car'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Car::isEmpty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Car'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Car::setDirty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Car'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Car::setError(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Car'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Foo::get(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Foo'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Foo::getError(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Foo'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Foo::getInvalidField(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Foo'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Foo::getOriginal(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Foo'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Foo::has(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Foo'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Foo::hasValue(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Foo'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Foo::isDirty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Foo'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Foo::isEmpty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Foo'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Foo::setDirty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Foo'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Foo::setError(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Foo'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Wheel::get(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Wheel'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Wheel::getError(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Wheel'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Wheel::getInvalidField(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Wheel'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Wheel::getOriginal(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Wheel'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Wheel::has(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Wheel'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Wheel::hasValue(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Wheel'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Wheel::isDirty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Wheel'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Wheel::isEmpty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Wheel'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Wheel::setDirty(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Wheel'),
	);

	expectedArguments(
		\TestApp\Model\Entity\Wheel::setError(),
		0,
		argumentsSet('entityFields:TestApp\Model\Entity\Wheel'),
	);

	expectedArguments(
		\__d(),
		0,
		'awesome',
		'cake',
		'controllers',
		'ide_helper',
		'my_namespace/my_plugin',
		'relations',
		'shim',
	);

	expectedArguments(
		\env(),
		0,
		'HTTP_HOST',
	);

	expectedArguments(
		\urlArray(),
		0,
		argumentsSet('routePaths'),
	);

	registerArgumentsSet(
		'cacheEngines',
		'_cake_model_',
		'_cake_translations_',
		'default',
	);

	registerArgumentsSet(
		'columnNames',
		'content',
		'created',
		'id',
		'name',
	);

	registerArgumentsSet(
		'columnTypes',
		'biginteger',
		'binary',
		'binaryuuid',
		'bit',
		'blob',
		'boolean',
		'char',
		'date',
		'datetime',
		'decimal',
		'double',
		'float',
		'integer',
		'json',
		'smallinteger',
		'string',
		'text',
		'time',
		'timestamp',
		'uuid',
		'year',
	);

	registerArgumentsSet(
		'configureKeys',
		'App',
		'App.encoding',
		'App.namespace',
		'App.paths',
		'App.paths.templates',
		'IdeHelper',
		'IdeHelper.skipDatabaseTables',
		'Shim',
		'Shim.deprecations',
		'debug',
		'plugins',
		'plugins.Bake',
		'plugins.Cake/TwigView',
		'plugins.Migrations',
		'plugins.Shim',
	);

	registerArgumentsSet(
		'entityFields:Cake\ORM\Entity',
		'id',
		'name',
	);

	registerArgumentsSet(
		'entityFields:Relations\Model\Entity\Bar',
		'id',
		'name',
		'user',
		'user_id',
	);

	registerArgumentsSet(
		'entityFields:Relations\Model\Entity\Foo',
		'id',
		'name',
		'params',
		'user',
		'user_id',
	);

	registerArgumentsSet(
		'entityFields:Relations\Model\Entity\User',
		'bar',
		'foo',
		'id',
		'name',
	);

	registerArgumentsSet(
		'entityFields:TestApp\Model\Entity\BarBar',
		'content',
		'created',
		'foo',
		'houses',
		'id',
		'name',
	);

	registerArgumentsSet(
		'entityFields:TestApp\Model\Entity\BarBarsAbstract',
		'content',
		'created',
		'foo',
		'houses',
		'id',
		'name',
	);

	registerArgumentsSet(
		'entityFields:TestApp\Model\Entity\Car',
		'content',
		'created',
		'id',
		'modified',
		'name',
		'status',
		'wheels',
	);

	registerArgumentsSet(
		'entityFields:TestApp\Model\Entity\Foo',
		'content',
		'created',
		'id',
		'name',
		'params',
	);

	registerArgumentsSet(
		'entityFields:TestApp\Model\Entity\Wheel',
		'car',
		'content',
		'created',
		'id',
		'name',
		'virtual_one',
	);

	registerArgumentsSet(
		'routePaths',
		'Awesome.Admin/AwesomeHouses::openDoor',
		'Bar::index',
	);

	registerArgumentsSet(
		'tableNames',
		'wheels',
	);

	registerArgumentsSet(
		'validationWhen',
		'create',
		'update',
	);

}


================================================
FILE: tests/test_files/routes/after/empty.php
================================================
<?php
/**
 * @var \Cake\Routing\RouteBuilder $routes
 */

$routes->prefix();


================================================
FILE: tests/test_files/routes/after/existing.php
================================================
<?php
/**
 * @var \Cake\Routing\RouteBuilder $routes
 */

$routes->prefix();


================================================
FILE: tests/test_files/routes/after/outdated.php
================================================
<?php
/**
 * @var \Cake\Routing\RouteBuilder $routes
 */

$routes->prefix();


================================================
FILE: tests/test_files/routes/before/empty.php
================================================
<?php

$routes->prefix();


================================================
FILE: tests/test_files/routes/before/existing.php
================================================
<?php
/**
 * @var \Cake\Routing\RouteBuilder $routes
 */

$routes->prefix();


================================================
FILE: tests/test_files/routes/before/outdated.php
================================================
<?php
/**
 * @var Outdated $routes
 */

$routes->prefix();


================================================
FILE: tests/test_files/templates/array.php
================================================
<?php
/**
 * @var \TestApp\View\AppView $this
 * @var array $x
 * @var array<int> $ints
 * @var array{a: int, b: string|null}|null $shaped
 * @var mixed $foo
 */
	foreach ($x as $y) {
		echo $y;
	}
	foreach ($foo as $int) {
		echo $int;
	}
?>
<div>
	<?php foreach ($ints as $int) {
		echo $int;
	} ?>
	<?php foreach ($shaped as $x) {
		echo h($x);
	} ?>
</div>


================================================
FILE: tests/test_files/templates/custom_view.php
================================================
<?php
/**
 * @var \TestApp\View\CustomView $this
 * @var \TestApp\Model\Entity\Car[]|\Cake\Collection\CollectionInterface $cars
 */
?>
<div>
	<?php foreach ($cars as $car) {} ?>
</div>


================================================
FILE: tests/test_files/templates/edit.php
================================================
<?php
/**
 * @var \TestApp\View\AppView $this
 * @var \TestApp\Model\Entity\Foo $foo
 */
?>
<div>
	<?php echo $this->Form->create($foo, []); ?>
</div>


================================================
FILE: tests/test_files/templates/empty.php
================================================
<?php
/**
 * @var \TestApp\View\AppView $this
 */
?>


================================================
FILE: tests/test_files/templates/existing.php
================================================
<?php
/**
 * @license MIT
 */

/**
 * @var \TestApp\View\AppView $this
 * @var array<int, int> $things
 * @var \TestApp\Model\Entity\Car[]|\Cake\Collection\CollectionInterface $cars
 * @var \TestApp\Model\Entity\Wheel $wheel
 */
?>
<div>
	<?php foreach ($cars as $car) {} ?>
	<?php echo h($wheel->id); ?>

	<?php foreach ($things as $keyInt => $valueInt) {
		echo h($keyInt + $valueInt);
	} ?>
</div>


================================================
FILE: tests/test_files/templates/existing_strict.php
================================================
<?php declare(strict_types=1);
/**
 * @license MIT
 */

/**
 * @var \TestApp\View\AppView $this
 * @var \TestApp\Model\Entity\Wheel $wheel
 */
?>
<div>
	<?php echo h($wheel->id); ?>
</div>


================================================
FILE: tests/test_files/templates/following_inline.php
================================================
<?php
/**
 * @license MIT
 * @var \TestApp\View\AppView $this
 * @var \TestApp\Model\Entity\Wheel $wheel
 */

/** @var \Authorization\Identity $identity */
$identity = $this->getRequest()
	->getAttribute('identity');
?>
<div>
	<?php echo h($wheel->id); ?>
</div>


================================================
FILE: tests/test_files/templates/inline.php
================================================
<?php
/**
 * @var \TestApp\View\AppView $this
 * @var \TestApp\Model\Entity\Wheel $wheel
 */
?>
<div>
	<?php echo h($wheel->id); ?>
</div>


================================================
FILE: tests/test_files/templates/loop.php
================================================
<?php
/**
 * @var \TestApp\View\AppView $this
 * @var \TestApp\Model\Entity\Car[]|\Cake\Collection\CollectionInterface $cars
 * @var \TestApp\Model\Entity\Wheel $wheel
 */
use Something;
?>
<div>
	<?php foreach ($cars as $car) {} ?>
	<?php echo h($wheel->id); ?>

	<?php foreach ($wheel->foos as $foos): ?>
		<tr>
			<td><?= h($foos->x) ?></td>
		</tr>
	<?php endforeach; ?>
</div>


================================================
FILE: tests/test_files/templates/multiline.php
================================================
<?php
/**
 * @var \TestApp\View\AppView $this
 * @var array $x
 * @var array<int> $ints
 * @var array{
 * 		a: int,
 * 		b: string|null
 * }|null $shaped
 * @var array{
 * 		c: array{
 * 			d: int|string,
 * 			e: string|null
 * 		}
 * } $nested
 *
 * @var mixed $foo
 */
	foreach ($x as $y) {
		echo $y;
	}
	foreach ($foo as $int) {
		echo $int;
	}
?>
<div>
	<?php foreach ($ints as $int) {
		echo $int;
	} ?>
	<?php foreach ($shaped as $x) {
		echo h($x);
	} ?>
	<?php foreach ($nested['c'] as $subArray) {
		echo h($x);
	} ?>
</div>


================================================
FILE: tests/test_files/templates/outdated.php
================================================
<?php
/**
 * @var \TestApp\View\AppView $this
 * @var \Cake\ORM\Entity $car !
 * @var \TestApp\Model\Entity\Wheel[]|\Cake\Collection\CollectionInterface $wheels
 * @var bool $bool
 */
?>
<div>
	<?php echo $this->Form->sth(); ?>
	<?php echo $car->id; ?>
	<?php foreach ($wheels as $wheel); ?>

	<?php echo $bool ? 'yes' : 'no'; ?>
</div>


================================================
FILE: tests/test_files/templates/phpline.php
================================================
<?php
/**
 * @var \TestApp\View\AppView $this
 * @var \TestApp\Model\Entity\Car[]|\Cake\Collection\CollectionInterface $cars
 * @var \TestApp\Model\Entity\Wheel $wheel
 */
?>
<?php echo $this->MyHelper->foo(); ?>
<div>
	<?php foreach ($cars as $car) {} ?>
	<?php echo h($wheel->id); ?>
</div>


================================================
FILE: tests/test_files/templates/string_interpolation.php
================================================
<?php
/**
 * @var \TestApp\View\AppView $this
 * @var mixed $name
 */
$url = "/some/path?param={$this->request->getData('field')}";
?>
<div>
	<a href="<?php echo $url; ?>">Test</a>
	<?php echo h($name); ?>
</div>


================================================
FILE: tests/test_files/templates/vars.php
================================================
<?php
/**
 * @var \TestApp\View\AppView $this
 * @var object $allCars
 * @var object $date
 * @var object $obj
 * @var \TestApp\Model\Entity\Foo[]|\Cake\Collection\CollectionInterface $foos
 * @var \TestApp\Model\Entity\Wheel $wheel
 */
	if ($obj) {
		echo $obj->foo();
	}
	echo $this->Generator->generate(['obj' => $obj]);
?>
<div>
	<?php foreach ($allCars as $car) {
		$finalCarTime = $this->Helper->out($car->created);
		echo $finalCarTime;
	} ?>
	<?php echo h($wheel->id); ?>
	<p>
		<?= $date->format(); ?>
	</p>
	<?php foreach ($allCars->engines as $i => $engine) {
		echo h($engine);
	} ?>
	<?php foreach ($foos as $foo) {
		echo h($foo->prop);
	} ?>
</div>


================================================
FILE: tests/test_files/tests/BarControllerTest.attribute.php
================================================
<?php
namespace TestApp\Test\TestCase\Controller;

use Cake\TestSuite\IntegrationTestCase;
use PHPUnit\Framework\Attributes\UsesClass;
use TestApp\Controller\BarController;

#[UsesClass(BarController::class)]
class BarControllerTest extends IntegrationTestCase {
}


================================================
FILE: tests/test_files/tests/BarControllerTest.existing.php
================================================
<?php
namespace TestApp\Test\TestCase\Controller;

use Cake\TestSuite\IntegrationTestCase;

/**
 * @uses \TestApp\Controller\BarController
 */
class BarControllerTest extends IntegrationTestCase {
}


================================================
FILE: tests/test_files/tests/BarControllerTest.link.php
================================================
<?php
namespace TestApp\Test\TestCase\Controller;

use Cake\TestSuite\IntegrationTestCase;

/**
 * @link \TestApp\Controller\BarController
 */
class BarControllerTest extends IntegrationTestCase {
}


================================================
FILE: tests/test_files/tests/BarControllerTest.missing.php
================================================
<?php
namespace TestApp\Test\TestCase\Controller;

use Cake\TestSuite\IntegrationTestCase;

class BarControllerTest extends IntegrationTestCase {
}