fixing issues from review

Author: claurospace

README.md

@@ -19,25 +19,25 @@ It provides base classes for action based controllers similar to Laminas control
 ## Installation
 
 Install `dot-controller` by executing the following Composer command:
+
 ```bash 
 $ composer require dotkernel/dot-controller
 ```
 
 ## Usage
 
 Middleware controllers act as a handler for multiple routes. Some conventions were made:
+
 - register controllers in the routes array just like any mezzio middleware. The requirement is that you should define an `action` route parameter(possibly optional) anywhere inside the route(e.g `/user[/{action}]`)
 - action parameter value is converted to a method name inside the controller. Underscore, dot and line characters are removed and the action name is converted to camel-case suffixed by the string `Action`. For example a route and action pair like `/user/forgot-password` will be converted to method `forgotPasswordAction`.
 - the default action value, if not present in the URI is `index`, so you should always define an `indexAction` within your controllers for displaying a default page or redirecting.
 
 In order to create your action based controllers, you must extend the abstract class `DotKernel\DotController\AbstractActionController`
 
-##### Example
+### Example
 Creating a UserController with default action and a register action. Will handle routes `/user` and `/user/register`
 
-##### UserController.php
 ```php
-
 use DotKernel\DotController\AbstractActionController;
 
 class UserController extends AbstractActionController
@@ -69,6 +69,7 @@ $app->route(
 ### Multiple controllers for the same route
 
 Use case: You have defined a controller inside some package, with default actions. You want to add actions that fall into the same controller name(or route name more exactly). You want to do this without extending the controller provided by the package. In this case you can do the following
+
 - create your own controller, independent of the package's controller which adds more actions
 - Mezzio lets you define an array of middleware for a route, so you can register this controller before the package's controller
 

SECURITY.md

@@ -0,0 +1,39 @@
+# Security Policy
+
+## Supported Versions
+
+
+| Version | Supported          | PHP Version                                                                                                    |
+|---------|--------------------|----------------------------------------------------------------------------------------------------------------|
+| 3.x     | :white_check_mark: | ![PHP from Packagist (specify version)](https://img.shields.io/packagist/php-v/dotkernel/dot-controller/3.4.3) |
+| <= 2.x  | :x:                |                                                                                                                |
+
+
+## Reporting Potential Security Issues
+
+If you have encountered a potential security vulnerability in this project,
+please report it to us at <security@dotkernel.com>. We will work with you to
+verify the vulnerability and patch it.
+
+When reporting issues, please provide the following information:
+
+- Component(s) affected
+- A description indicating how to reproduce the issue
+- A summary of the security vulnerability and impact
+
+We request that you contact us via the email address above and give the
+project contributors a chance to resolve the vulnerability and issue a new
+release prior to any public exposure; this helps protect the project's
+users, and provides them with a chance to upgrade and/or update in order to
+protect their applications.
+
+
+## Policy
+
+If we verify a reported security vulnerability, our policy is:
+
+- We will patch the current release branch, as well as the immediate prior minor
+  release branch.
+
+- After patching the release branches, we will immediately issue new security
+  fix releases for each patched release branch.

docs/book/index.md

@@ -1 +1 @@
-../../README.md
+../../README.md

docs/book/v3/configuration.md

@@ -2,4 +2,4 @@
 
 After installation, the package can be used immediately but if you want to use all features of the package, like plugins and events you need to register the `ConfigProvider` in your project by adding the below line to your configuration aggregator (usually: `config/config.php`):
 
-    \Dot\Controller\ConfigProvider::class
+    \Dot\Controller\ConfigProvider::class

docs/book/v3/events/events.md docs/book/v3/events.mddocs/book/v3/events/events.md renamed to docs/book/v3/events.md

@@ -1,18 +1,22 @@
 # Events
+
 DotKernel's controller package supports events and those events can be of 2 types: global events (middleware-like) or manually dispatch  events.
 
-# Getting started
- - Every event listener that is triggered from a controller 
- needs to implement `Dot\Controller\Event\ControllerEventListenerInterface` which actually extends `Laminas\EventManager\ListenerAggregateInterface`.
+## Getting started
+
+- Every event listener that is triggered from a controller 
+needs to implement `Dot\Controller\Event\ControllerEventListenerInterface` which actually extends `Laminas\EventManager\ListenerAggregateInterface`.
 - You can add the trait `Dot\Controller\Event\ControllerEventListenerTrait` to override the method of the interface.
 - Every event listener needs to be registered under the `['dot_controller']['event_listenenrs]` key in the ConfigProvider, and every key must be the class that you want to attach the events
 
 
-# Usage
+## Usage
+
 The events in a controller can be done in 2 different ways, a global way where an event is attached automatically to all the controllers action and works in the same way the middlewares works
 or a manually dispatchable way, where you can define to which controller the events is attached, and you can trigger the event where you want.
 
 For our example we have a UserController with some methods in it
+
 ```php
 use DotKernel\DotController\AbstractActionController;
 
@@ -34,10 +38,10 @@ class UserController extends AbstractActionController
 
     }
 }
-
 ```
 
 ### Example 1 - Global way
+
 First we will create the event listener
 ```php
 use Dot\Controller\Event\ControllerEvent;
@@ -64,6 +68,7 @@ class UserUpdatedListener implements ControllerEventListenerInterface
 ```
 
 We register the event listener in the configuration key
+
 ```php
 'dot_controller' => [
     'event_listeners' => [
@@ -82,6 +87,7 @@ With this it doesn't matter what action is accessed, the event it will run befor
 In addition, you can make use of the `event` variable to access information about the event. 
 
 For example: 
+
 ```php
 // UserUpdatedListener
 public function onAfterDispatch(ControllerEvent $e): void
@@ -94,10 +100,12 @@ public function onAfterDispatch(ControllerEvent $e): void
         }
     }
 ```
+
 So every time the `updateAction` is accessed and the method is post, right after the action is dispatched, we can log that the user was updated. <br>
 We can use the `onBeforeDispatch` in the same way, to log right before the user is updated. 
 
 ### Example 2 - Manually triggered way
+
 ```php
 use Dot\Controller\Event\ControllerEvent;
 use Dot\Controller\Event\ControllerEventListenerInterface;
@@ -131,6 +139,7 @@ with `onBeforeDispatch` and `onAfterDispatch` methods, but we can make our custo
 In this case we create attach an event called `user.profile.update` and bind it to the `userProfileUpdated`  method.
 
 Next we need to register the event
+
 ```php
 'dot_controller' => [
     'event_listeners' => [
@@ -142,6 +151,7 @@ Next we need to register the event
 ```
 
 Now you can manually trigger the event from the controller using build in `dispatchEvent` method.
+
 ```php
 // UserController
 // post method for updating the user
@@ -152,12 +162,13 @@ public function updateAction()
 
 }
 ```
+
 As you can see we attach the `user` key to the parameters, so we can actually access it.
+
 ```php
     public function userProfileUpdated(ControllerEvent $event): void
     {
         $user = $event->getParams()['user'];
         $this->logger->info('User profile updated', $user->toArray());
     }
 ```
-

docs/book/v3/installation.md

@@ -2,4 +2,4 @@
 
 Install `dot-controller` by executing the following Composer command:
 
-     composer require dotkernel/dot-controller
+    composer require dotkernel/dot-controller

docs/book/v3/overview.md

@@ -1,4 +1,4 @@
 # Overview
 
 `dot-controller` is DotKernel's controller package that can be use like middleware inside DotKernel or Mezzio application.
-It provides base classes for action based controllers similar to Laminas controller component. It is more lightweight though, but supports controller plugins and event listeners
+It provides base classes for action based controllers similar to Laminas controller component. It is more lightweight though, but supports controller plugins and event listeners

docs/book/v3/plugins/plugins.md docs/book/v3/plugins.mddocs/book/v3/plugins/plugins.md renamed to docs/book/v3/plugins.md

@@ -13,6 +13,7 @@ Controller plugins offer the advantage of globally accessible functionality in a
 ### Example
 
 First we create our desired plugin, for our example a string helper 
+
 ```php
 class StringPlugin implements PluginInterface
 {
@@ -26,6 +27,7 @@ class StringPlugin implements PluginInterface
 ```
 
 We create a factory for the plugin
+
 ```php
 use Psr\Container\ContainerInterface;
 
@@ -41,6 +43,7 @@ class StringPluginFactory
 ```
 
 Register the factory under the `['dot_controller']['plugin_manager']['factories']` key.
+
 ```php
 'dot_controller' => [
     'plugin_manager' => [
@@ -50,21 +53,25 @@ Register the factory under the `['dot_controller']['plugin_manager']['factories'
     ]
 ]
 ```
+
 You don't need to register the plugin factory to a regular dependencies in a configuration because `AbstractPluginManager` actually extends `ServiceManager`
 
 Access it in a controller.
+
 ```php
 //inside a controller 
 $this->string(); // will return the StringPlugin class, so you can call any public method from it
 $this->string()->toUpper("test") // will return TEST
 ```
 
 ## Build-in plugins
+
 The package comes in with 2 default plugins ``template`` and `url`. You can use 
 them in the same way as our example above.
 
 - Url plugin
 - - the plugin is an instance of `Mezzio\Helper\UrlHelper`
+
 ```php
     //in a controller action 
     /** @var UrlHelper $url */
@@ -74,6 +81,7 @@ them in the same way as our example above.
 
 - Template plugin
 - - the plugin is an instance of `Mezzio\Template\TemplateRendererInterface`
+
 ```php
     // in a controller action
     return new HtmlResponse(

docs/book/v3/usage.md

@@ -1,18 +1,17 @@
 # Usage
 
 Middleware controllers act as a handler for multiple routes. Some conventions were made:
+
 - register controllers in the routes array just like any mezzio middleware. The requirement is that you should define an `action` route parameter(possibly optional) anywhere inside the route(e.g `/user[/{action}]`)
 - action parameter value is converted to a method name inside the controller. Underscore, dot and line characters are removed and the action name is converted to camel-case suffixed by the string `Action`. For example a route and action pair like `/user/forgot-password` will be converted to method `forgotPasswordAction`.
 - the default action value, if not present in the URI is `index`, so you should always define an `indexAction` within your controllers for displaying a default page or redirecting.
 
 In order to create your action based controllers, you must extend the abstract class `DotKernel\DotController\AbstractActionController`
 
-##### Example
+## Example
 Creating a UserController with default action and a register action. Will handle routes `/user` and `/user/register`
 
-##### UserController.php
 ```php
-
 use DotKernel\DotController\AbstractActionController;
 
 class UserController extends AbstractActionController
@@ -44,15 +43,17 @@ $app->route(
 ### Multiple controllers for the same route
 
 Use case: You have defined a controller inside some package, with default actions. You want to add actions that fall into the same controller name(or route name more exactly). You want to do this without extending the controller provided by the package. In this case you can do the following
+
 - create your own controller, independent of the package's controller which adds more actions
 - Mezzio lets you define an array of middleware for a route, so you can register this controller before the package's controller
 
 Now when a request for this route comes in, your controller will run first. DotKernel controllers are designed to ignore requests that cannot be matched to one of its methods, so if no action matches, it will call the next middleware, in our case, the second controller.
 If this is the last controller, and action does not match here, it will go to the default 404 Not found page(handled by NotFoundDelegate)
 
-# Plugins
-- [Plugins](plugins/plugins.md)
+## Plugins
+
+- [Plugins](plugins.md)
 
-# Events
+## Events
 
-- [Events](events/events.md)
+- [Events](events.md)

mkdocs.yml

@@ -8,12 +8,12 @@ extra:
 nav:
   - Home: index.md
   - v3:
-      - Overview: v5/overview.md
-      - Installation: v5/installation.md
-      - Configuration: v5/configuration.md
-      - Usage: v5/usage.md
-      - Plugins: v5/plugins/plugins.md
-      - Events: v5/events/events.md
+      - Overview: v3/overview.md
+      - Installation: v3/installation.md
+      - Configuration: v3/configuration.md
+      - Usage: v3/usage.md
+      - Plugins: v3/plugins.md
+      - Events: v3/events.md
 site_name: dot-controller
 site_description: "DotKernel's controller package"
 repo_url: "https://github.com/dotkernel/dot-controller"