Merge pull request #206 from dotkernel/issue-204

Use only .md files

Author: arhimede

composer.json

@@ -36,12 +36,15 @@
         "dotkernel/dot-response-header": "^3.6",
         "laminas/laminas-component-installer": "^3.5.0",
         "laminas/laminas-config-aggregator": "^1.17.0",
+        "league/commonmark": "^2.10",
         "mezzio/mezzio": "^3.24.0",
         "mezzio/mezzio-fastroute": "^3.13.0",
         "mezzio/mezzio-twigrenderer": "^2.17.0",
         "ramsey/uuid": "^4.5.0",
         "ramsey/uuid-doctrine": "^2.1.0",
-        "roave/psr-container-doctrine": "^5.2.2 || ^6.0.0"
+        "roave/psr-container-doctrine": "^5.2.2 || ^6.0.0",
+        "symfony/yaml": "^8.1",
+        "twig/markdown-extra": "^3.28"
     },
     "require-dev": {
         "filp/whoops": "^2.17.0",

config/autoload/templates.global.php

@@ -2,6 +2,9 @@
 
 declare(strict_types=1);
 
+use Twig\Extra\Markdown\MarkdownExtension;
+use Twig\RuntimeLoader\RuntimeLoaderInterface;
+
 return [
     'templates' => [
         'extension' => 'html.twig',
@@ -12,10 +15,14 @@
         'autoescape'      => 'html',
         'auto_reload'     => true,
         'cache_dir'       => 'data/cache/twig',
-        'extensions'      => [],
+        'extensions'      => [
+            MarkdownExtension::class,
+        ],
         'globals'         => [],
         'optimizations'   => -1,
-        'runtime_loaders' => [],
+        'runtime_loaders' => [
+            RuntimeLoaderInterface::class,
+        ],
         'timezone'        => 'UTC',
     ],
 ];

public/md-articles/android/listen-for-android-install-referrer.md

@@ -12,15 +12,14 @@ language: "en"
 
 ## Getting Referrer Data at Install Time
 
-Android market sends information at the moment of app install, delivered as a broadcasted intent by Android market at install time - even before the app is opened for the first time.
-This can be used to create custom links to an Android application, including bits of information about the referrer, sent directly to the app for processing at install.
-It can be a simple and accurate solution for mobile app install tracking, among other uses.
+Have you ever wondered if Android market sends you information at the moment of app install? Wouldn't it be nice to create custom links to your Android application, including bits of information about the referrer, and send it directly to the app for processing at install? This could be a simple and accurate solution for mobile app install tracking, but I'm sure you can find this useful in many ways.
+
+With Android, you actually get this information as a broadcasted intent by Android market at install time - even before opening your app...
 
 ## FAQ
 
 **Q: Does Android send information when the app is installed?**
-A: Yes.
-Android market broadcasts an intent containing referrer information at the moment the app is installed.
+A: Yes. Android market broadcasts an intent containing referrer information at the moment the app is installed.
 
 **Q: When is this referrer information available to the app?**
 A: It's delivered as a broadcasted intent at install time, before the app is ever opened.

public/md-articles/android/multiple-broadcast-receivers-in-the-same-app-for-the-same-action.md

@@ -10,14 +10,9 @@ language: "en"
 
 # Multiple broadcast receivers in the same app, for the same action
 
-## The problem
+Did you come to a point where using multiple broadcast receivers to listen for the same intent, separatly, in the same android app, leads to unexpected results? If that's the case, one broadcast receiver might consume the broadcasted intent, [online casino](http://www.cillap.com/) leaving the others with nothing to receive. This can be the case where you use 3rd party libraries with broadcast receivers defined.
 
-When multiple broadcast receivers are registered separately to listen for the same intent within the same Android app, this can lead to unexpected results: one broadcast receiver might consume the broadcasted intent, leaving the others with nothing to receive.
-This can happen when using 3rd party libraries that define their own broadcast receivers alongside an app's own receivers.
-
-## The approach
-
-A solution for this kind of problem is a code snippet inspired by the way Admob for Android solves this, as shown in Admob's own documentation, using meta-data in the manifest file.
+The following is a solution for this kind of problem, a code snippet inspired by the way Admob for android seems to solve this, as shown in their [documentation](http://developer.admob.com/wiki/Android_App_Download_Tracking), using meta-data in manifest file...[[read more](http://n3vrax.wordpress.com/2011/07/15/multiple-broadcast-receivers-in-the-same-app-for-the-same-action/)].
 
 ## FAQ
 
@@ -26,7 +21,3 @@ A: When multiple broadcast receivers are registered separately to listen for the
 
 **Q: When is this issue most likely to occur?**
 A: This can happen when you use 3rd party libraries that already define their own broadcast receivers alongside your app's own receivers.
-
-## Resources
-
-- [Admob App Download Tracking documentation](http://developer.admob.com/wiki/Android_App_Download_Tracking)

public/md-articles/architecture/configprovider-bootstrap-modern-php-applications.md

@@ -11,81 +11,102 @@ language: "en"
 # ConfigProvider - Bootstrap Modern PHP Applications
 
 ## TL;DR
-
 In PHP, a `ConfigProvider` is a class or callable that is part of an application's bootstrap process, returning configuration data that tells the platform which middleware should run, in what order, and under what conditions.
 Frameworks like Mezzio, Laminas, Slim, and the Dotkernel Headless Platform use ConfigProviders to declare middleware pipeline configuration, dependency injection mappings, and request handlers, which get merged together automatically during bootstrap (except in Dotkernel, where new ConfigProviders must be registered manually).
 
+In PHP, the `ConfigProvider` is a class that is part of an application's bootstrap process. **It's a class or callable that returns configuration data telling the platform which middleware should run, in what order, and sometimes under what conditions.**
+
+If you're talking specifically about the ConfigProvider in the Laminas/Mezzio ecosystem, it's literally an array of configuration, settings, or anything else your application needs.
+
 ## Where Is the ConfigProvider Used?
 
-Mezzio (formerly Zend Expressive), Laminas, Slim, the Dotkernel Headless Platform, and other middleware-based frameworks often have a `ConfigProvider` class.
-In Laminas/Mezzio specifically, each module or package may contain a `ConfigProvider` that returns:
+Mezzio (formerly Zend Expressive), Laminas, Slim, the Dotkernel Headless Platform, or other middleware-based frameworks often have a `ConfigProvider` class. In Laminas/Mezzio specifically, each module or package may contain a `ConfigProvider` that returns:
 
-- Middleware pipeline configuration:
+- Middleware pipeline configuration.
   - Middleware classes or service names.
   - Error-handling middleware, which should have the lowest priority.
   - Middleware groups or nested arrays.
 - Dependency injection mappings.
 - Request Handlers.
 
-Example structure used in Dotkernel:
+Example in Dotkernel, which is an approach similar to Laminas/Mezzio:
 
-```php
+```
 class ConfigProvider
 {
     public function __invoke(): array
     {
-        return [ /* ... */ ];
+        return [
+            'dependencies' => $this->getDependencies(),
+            'templates'    => $this->getTemplates(),
+        ];
     }
 
     public function getDependencies(): array
     {
-        return [
-            'factories'  => [ /* ... */ ],
-            'invokables' => [ /* ... */ ],
+        return ,
+           'invokables'   => ,
         ];
     }
 
     public function getTemplates(): array
     {
-        return [
-            'paths' => [ /* ... */ ],
-            'error' => [ /* ... */ ],
+        return ,
+        'error'  => ,
         ];
     }
 }
 ```
 
-What each item means:
+What each item above means:
+
+- `dependencies` is used by the dependency injector (like [laminas-servicemanager](https://docs.mezzio.dev/mezzio/v3/features/container/laminas-servicemanager/)) to construct every requested service.
+  - `factories` will have the factory build the service.
+  - `invokables` will use `new` directly.
+  - You can also use `aliases` to redirect to another service name and `delegators` to wrap the original service.
+- `templates` defines the paths for the template files.
+
+## How the ConfigProvider works
 
-| Item | Meaning |
-|---|---|
-| `dependencies` | Used by the dependency injector (e.g. laminas-servicemanager) to construct every requested service. |
-| `factories` | The factory builds the service. |
-| `invokables` | The service is built with `new` directly. |
-| `aliases` | Redirects to another service name. |
-| `delegators` | Wraps the original service. |
-| `templates` | Defines the paths for the template files. |
+The ConfigProvider is automatically picked up by the framework during application bootstrap. Let's look at it step by step:
+
+- **Merge the global configuration** - All ConfigProviders are merged into one array.
+- **Read the configuration array** - The call is similar to the below and expects an array of entries:
+
+```
+$config = $container->get('config') ?? [];
+```
 
-## How the ConfigProvider Works
+- **Resolve item** - `$app->pipe()` is called to resolve one of the below instances:
+  - Resolve the service name from the container
+  - Wrap the middleware, if an array is provided
+  - Call the closure or invokable object.
+- **Handle errors** - This middleware is the last one in the pipeline to make sure it handles any exceptions.
+- **Execute at runtime** - [Laminas Stratigility](https://docs.laminas.dev/laminas-stratigility/) iterates over the pipeline in the order it was registered.
+  - Each middleware can **handle** the request and return a response, or **delegate** execution to the next middleware in the pipeline, until a `ResponseInterface` is returned to the client.
 
-The ConfigProvider is automatically picked up by the framework during application bootstrap:
+Below you can see how Mezzio and Dotkernel merge and use ConfigProviders to build the middleware pipeline and dependencies.
 
-1. **Merge the global configuration** - All ConfigProviders are merged into one array.
-2. **Read the configuration array** - A call similar to `$config = $container->get('config') ?? [];` reads an array of entries.
-3. **Resolve item** - `$app->pipe()` is called to resolve one of the following: resolve the service name from the container, wrap the middleware if an array is provided, or call the closure or invokable object.
-4. **Handle errors** - The error-handling middleware is the last one in the pipeline, to make sure it can handle any exceptions.
-5. **Execute at runtime** - Laminas Stratigility iterates over the pipeline in the order it was registered. Each middleware can handle the request and return a response, or delegate execution to the next middleware in the pipeline, until a `ResponseInterface` is returned to the client.
+![](/uploads/article/019f8a80-cc92-7277-92c8-c0e68d81615f/ConfigProvider2.png)
 
 ## Benefits
 
-- **Centralized setup** - Instead of hardcoding bootstrap code, it's declared in a config provider so it's easy to read, change, or extend.
-- **Modular** - Each package can ship with its own config without interfering with others.
-- **Container-friendly** - Works well with frameworks using DI containers like Laminas ServiceManager, PHP-DI, or Pimple.
-- **Standardized service definitions** - Consistent rules for object creation, separate from business logic.
-- **Auto-Discovery** - In Laminas/Mezzio, the ConfigAggregator automatically loads and merges all ConfigProviders.
-Dotkernel is an exception: new ConfigProviders have to be added manually in `config/config.php`, because all the initial ConfigProviders required to install the applications are already injected.
-- **Environment-agnostic** - Returns an array that defines dev, test, or prod environments.
-- **Testability** - The consistent, central configuration promotes isolated (e.g. per-module) testing, easier swapping of dependencies, and assertion of pipeline setup (e.g. checking if a config key is present).
+- Centralized setup – Instead of hardcoding bootstrap code, you declare it in a config provider so it's easy to read, change, or extend.
+- Modular – Each package can ship with its own config without interfering with others.
+- Container-friendly – It works well with frameworks using DI containers like Laminas ServiceManager, PHP-DI, or Pimple.
+- Standardized service definitions - It has consistent rules for object creation that are separate from business logic.
+- Auto-Discovery - In Laminas/Mezzio, the [ConfigAggregator](https://docs.laminas.dev/laminas-config-aggregator/) automatically loads and merges all ConfigProviders.
+
+> Dotkernel is an exception to this rule: new ConfigProviders have to be added manually in `config/config.php`, because all the initial ConfigProviders required to install the applications are already injected.
+
+- Environment-agnostic - It returns an array that defines dev, test, or prod environments.
+- Testability - The consistent, central configuration promotes isolated (e.g. per-module) testing, easier swapping of dependencies and the assertion of pipeline setup (e.g. check if a config key is present).
+
+## Additional Resources
+
+- [Mezzio Container](https://docs.mezzio.dev/mezzio/v3/features/container/config/)
+- [Laminas Config Aggregator](https://docs.laminas.dev/laminas-config-aggregator/config-providers/)
+- [PSR-15 (HTTP Server Request Handlers)](https://www.php-fig.org/psr/psr-15/)
 
 ## FAQ
 
@@ -96,20 +117,13 @@ A: It is a class that is part of an application's bootstrap process: a class or
 A: In the Laminas/Mezzio ecosystem, it's literally an array of configuration, settings, or anything else the application needs, and each module or package may contain its own ConfigProvider returning middleware pipeline configuration, dependency injection mappings, and request handlers.
 
 **Q: What is the difference between 'factories' and 'invokables' in the dependencies array?**
-A: `factories` will have the factory build the service, while `invokables` will use `new` directly.
-You can also use `aliases` to redirect to another service name and `delegators` to wrap the original service.
+A: factories will have the factory build the service, while invokables will use new directly. You can also use aliases to redirect to another service name and delegators to wrap the original service.
 
 **Q: How does the ConfigProvider get used during application bootstrap?**
-A: It is automatically picked up by the framework during bootstrap: all ConfigProviders are merged into one array, the configuration array is read, each item is resolved via `$app->pipe()`, the error-handling middleware is placed last in the pipeline, and at runtime Laminas Stratigility iterates over the pipeline in the order it was registered.
+A: It is automatically picked up by the framework during bootstrap: all ConfigProviders are merged into one array, the configuration array is read (similar to $config = $container->get('config') ?? [];), each item is resolved via $app->pipe(), the error-handling middleware is placed last in the pipeline, and at runtime Laminas Stratigility iterates over the pipeline in the order it was registered.
 
 **Q: Are new ConfigProviders auto-discovered in Dotkernel?**
-A: Dotkernel is an exception to the usual auto-discovery rule: new ConfigProviders have to be added manually in `config/config.php`, because all the initial ConfigProviders required to install the applications are already injected.
+A: Dotkernel is an exception to the usual auto-discovery rule: new ConfigProviders have to be added manually in config/config.php, because all the initial ConfigProviders required to install the applications are already injected.
 
 **Q: What are the benefits of using a ConfigProvider?**
 A: Benefits include centralized setup instead of hardcoded bootstrap code, modularity so each package can ship its own config, container-friendliness with DI containers like Laminas ServiceManager, PHP-DI or Pimple, standardized service definitions, environment-agnostic configuration for dev/test/prod, and better testability of the pipeline setup.
-
-## Resources
-
-- [Mezzio Container](https://docs.mezzio.dev/mezzio/v3/features/container/config/)
-- [Laminas Config Aggregator](https://docs.laminas.dev/laminas-config-aggregator/config-providers/)
-- [PSR-15 (HTTP Server Request Handlers)](https://www.php-fig.org/psr/psr-15/)