Refactor documentation: replace occurrences of Zemit with Phalcon Kit

Author: jturbide

docs/core/application.md

@@ -1,29 +1,29 @@
 # Application Component
 
-The MVC Application Component, `\Zemit\Mvc\Application`, plays a role in orchestrating the overall operation of your MVC
+The MVC Application Component, `\PhalconKit\Mvc\Application`, plays a role in orchestrating the overall operation of your MVC
 application. This component works by leveraging the `\Phalcon\Mvc\Application` from the Phalcon framework, thereby
 inheriting all of Phalcon's native advantages and features.
 
 ### Integration with Phalcon
 
-By utilizing the `\Phalcon\Mvc\Application`, Zemit ensures that the application has access to a robust and efficient
+By utilizing the `\Phalcon\Mvc\Application`, Phalcon Kit ensures that the application has access to a robust and efficient
 foundation for managing MVC operations. This integration brings several benefits:
 
 - **Comprehensive MVC Support**: Phalcon's application component provides a full-stack framework, complete with all
   necessary services to support the MVC pattern effectively.
-- **Optimized Performance**: As Phalcon is known for its performance efficiency, Zemit applications benefit from this
+- **Optimized Performance**: As Phalcon is known for its performance efficiency, Phalcon Kit applications benefit from this
   optimized operation, ensuring fast response times and lower resource consumption.
 
-### HMVC Enhancements in Zemit
+### HMVC Enhancements in Phalcon Kit
 
-A significant enhancement introduced by Zemit is the `request()` method, aimed at facilitating Hierarchical
+A significant enhancement introduced by Phalcon Kit is the `request()` method, aimed at facilitating Hierarchical
 Model-View-Controller (HMVC) architecture in applications:
 
 - **HMVC-Friendly Requests**: The `request()` method allows for inter-module communication, making it simpler to perform
   requests across different modules and namespaces within the application.
-- **Response Handling**: Instead of sending the response directly, Zemit's application component returns the response
+- **Response Handling**: Instead of sending the response directly, Phalcon Kit's application component returns the response
   content or value, providing more control over how responses are processed and presented.
-- **Dispatch State Preservation**: To ensure that the current dispatch state remains unaffected, Zemit creates a new
+- **Dispatch State Preservation**: To ensure that the current dispatch state remains unaffected, Phalcon Kit creates a new
   dispatcher based on the current one for handling these internal requests. This approach maintains application
   stability while supporting complex HMVC interactions.
 
@@ -34,6 +34,6 @@ To delve deeper into the capabilities and usage of the Phalcon MVC Application C
 - [Phalcon MVC Application API](https://docs.phalcon.io/latest/api/phalcon_mvc/#mvcapplication){:target="_blank"}
 - [Phalcon Application Component Documentation](https://docs.phalcon.io/latest/application/){:target="_blank"}
 
-With `\Zemit\Mvc\Application`, developers can build sophisticated and modular MVC applications that leverage both the
-power of Phalcon and the additional HMVC functionalities provided by Zemit, leading to more flexible, maintainable, and
+With `\PhalconKit\Mvc\Application`, developers can build sophisticated and modular MVC applications that leverage both the
+power of Phalcon and the additional HMVC functionalities provided by Phalcon Kit, leading to more flexible, maintainable, and
 scalable web applications.

docs/core/bootstrap.md

@@ -1,6 +1,6 @@
 # Bootstrap Component
 
-The Bootstrap feature in Zemit Core is responsible for setting up and handling the 
+The Bootstrap feature in Phalcon Kit is responsible for setting up and handling the 
 application using the Mvc design pattern or the Cli (console). It follows a series 
 of steps to ensure that the application is properly initialized and configured. 
 
@@ -12,8 +12,8 @@ The Bootstrap also prepares and loads the different modules of the application b
 finally handling it. By using the Bootstrap, you can easily set up and manage your application.
 
 ## Quick Start
-To create a customized bootstrap with the Zemit Core framework, you will need to create
-a new class that extends from the `\Zemit\Bootstrap` class. This will allow you to personalize
+To create a customized bootstrap with the Phalcon Kit, you will need to create
+a new class that extends from the `\PhalconKit\Bootstrap` class. This will allow you to personalize
 the bootstrap to your needs by overriding any of its methods as desired. For example, you
 may want to initialize the configuration with your own class. Keep in mind that you are 
 free to customize the bootstrap to fit your specific requirements and workflow.
@@ -24,7 +24,7 @@ free to customize the bootstrap to fit your specific requirements and workflow.
 ```php title="index.php"
 <?php
 
-use Zemit\Bootstrap;
+use PhalconKit\Bootstrap;
 
 $bootstrap = new Bootstrap();
 
@@ -34,9 +34,9 @@ echo $bootstrap->run();
 ### Customizable approach
 ```php title="index.php"
 <?php
-use Zemit\Bootstrap;
-use Zemit\Bootstrap\Config;
-use Zemit\Bootstrap\Router;
+use PhalconKit\Bootstrap;
+use PhalconKit\Bootstrap\Config;
+use PhalconKit\Bootstrap\Router;
 
 $config = new Config();
 $config->set('debug', true);
@@ -53,7 +53,7 @@ echo $bootstrap->run();
 
 ## Method #2: Extending
 
-Extending the `Zemit\Bootstrap` class will give you the most flexibility
+Extending the `PhalconKit\Bootstrap` class will give you the most flexibility
 because you can modify default behaviors at your convenience. There is mainly
 two phases that you can inject your own core components and services:
 The `initialization` phase and then the `registration` phase.
@@ -71,11 +71,11 @@ phase of the bootstrap.
 <?php
 namespace App;
 
-use Zemit\Bootstrap;
+use PhalconKit\Bootstrap;
 use App\Bootstrap\Config;
 use App\Bootstrap\Router;
 
-class Bootstrap extends \Zemit\Bootstrap
+class Bootstrap extends \PhalconKit\Bootstrap
 {
     public function initialize(): void
     {
@@ -103,17 +103,17 @@ echo (new Bootstrap())->run();
 ### Registration phase
 
 The registration phases are called after the `initialize()` method.
-This approach is considered more advanced and only needed if you want to keep the native Zemit
+This approach is considered more advanced and only needed if you want to keep the native Phalcon Kit
 behavior and allow sub-applications to initialize their own components and then add more business logic to it.
 
 ```php title="./app/Bootstrap.php"
 <?php
 namespace App;
 
 use App\Provider\Config\ServiceProvider as ConfigServiceProvider;
-use Zemit\Config\ConfigInterface;
+use PhalconKit\Config\ConfigInterface;
 
-class Bootstrap extends \Zemit\Bootstrap
+class Bootstrap extends \PhalconKit\Bootstrap
 {
     public function registerConfig(): void
     {

docs/core/console.md

@@ -1,10 +1,10 @@
 # Console Component
 
-The Console Component in Zemit is tailored for handling Command Line Interface (CLI) or Server API (SAPI) requests. It
+The Console Component in Phalcon Kit is tailored for handling Command Line Interface (CLI) or Server API (SAPI) requests. It
 is essentially a proxy class for
 [`\Phalcon\Cli\Console`](https://docs.phalcon.io/latest/api/phalcon_cli/#cliconsole){:target="_blank"}
 , crafted to streamline the management and execution of CLI-based
-tasks and operations in a Zemit application.
+tasks and operations in a Phalcon Kit application.
 
 CLI applications, standing for Command Line Interface applications, are executed via command line or shell prompt. They
 offer distinct advantages, particularly in the absence of a graphical user interface and the ability to execute multiple
@@ -21,24 +21,24 @@ operations without user interaction.
 
 ### Integration with Phalcon
 
-Zemit's Console Component inherits and capitalizes on all the functionalities and advantages offered by the
+ Phalcon kit's Console Component inherits and capitalizes on all the functionalities and advantages offered by the
 [Phalcon Console Component](https://docs.phalcon.io/latest/application-cli/){:target="_blank"}.
 This inheritance brings a robust set of features optimized for CLI operations, making the development
 of command-line applications more intuitive and efficient.
 
 ### Structure
 
-In Zemit, CLI applications leverage the
+In Phalcon Kit, CLI applications leverage the
 [`\Phalcon\Cli\Console`](https://docs.phalcon.io/latest/api/phalcon_cli/#cliconsole){:target="_blank"}
 class, following Phalcon's design principles. This
 approach entails:
 
 - **Task-Oriented Design**: The Console Component operates within a directory structure where Task scripts reside. These
   scripts are classes extending `Phalcon\Cli\Task`, containing executable code for specific command-line operations.
 
-- **Flexibility and Modularity**: Zemit's adaptation allows for a modular and flexible structure, accommodating a wide
+- **Flexibility and Modularity**: Phalcon Kit's adaptation allows for a modular and flexible structure, accommodating a wide
   range of command-line tasks, each encapsulated in its Task class.
 
-Utilizing the Console Component in Zemit enables developers to harness the power of CLI applications effectively,
+Utilizing the Console Component in Phalcon Kit enables developers to harness the power of CLI applications effectively,
 augmenting their applications with robust, background, or automated functionalities inherent to command-line
 environments.

docs/core/dispatcher.md

@@ -2,16 +2,16 @@
 
 ## Overview
 
-The Dispatcher component in Zemit is a dynamic and essential element that acts as a liaison between the routing layer
+The Dispatcher component in Phalcon Kit is a dynamic and essential element that acts as a liaison between the routing layer
 and the application's execution logic. Its primary function is to interpret and process requests as directed by the
 Router, ensuring each request is handled by the correct module, controller, task, or action, accompanied by relevant
-parameters. To cater to different operational environments, Zemit employs two specialized types of dispatchers:
+parameters. To cater to different operational environments, Phalcon Kit employs two specialized types of dispatchers:
 
-- **`\Zemit\Cli\Dispatcher`**: This dispatcher is specifically designed for handling command-line interfaces (CLI) and
+- **`\PhalconKit\Cli\Dispatcher`**: This dispatcher is specifically designed for handling command-line interfaces (CLI) and
   Server API (SAPI) interactions. It extends the functionality
   of [`\Phalcon\Cli\Dispatcher`](https://docs.phalcon.io/latest/api/phalcon_cli/#clidispatcher){:target="_blank"},
   providing a tailored experience for non-web-based applications.
-- **`\Zemit\Mvc\Dispatcher`**: Focused on web-based applications, this dispatcher manages web requests by
+- **`\PhalconKit\Mvc\Dispatcher`**: Focused on web-based applications, this dispatcher manages web requests by
   extending [`\Phalcon\Mvc\Dispatcher`](https://docs.phalcon.io/latest/api/phalcon_mvc/#mvcdispatcher){:target="_
   blank"}. It ensures that web requests are routed to the appropriate controllers and actions within the MVC framework.
 
@@ -27,9 +27,9 @@ For an in-depth understanding of the underlying concepts and capabilities, explo
     The issue arises from the potential mixing of parameter order, which can render the method parameters unreliable in
     various scenarios and use cases.
 
-!!! danger "Zemit's Approach to Parameter Passing"
-    To ensure stability and predictability in handling method parameters, Zemit modifies this behavior. Only parameters with
-    integer keys are passed to the action method parameters in Zemit's dispatcher. This approach mitigates the risk of
+!!! danger " Phalcon kit's Approach to Parameter Passing"
+    To ensure stability and predictability in handling method parameters, Phalcon Kit modifies this behavior. Only parameters with
+    integer keys are passed to the action method parameters in Phalcon Kit's dispatcher. This approach mitigates the risk of
     parameter order mix-up, enhancing the reliability of your application's routing and parameter handling mechanisms.
 
 ### Dispatching Process
@@ -42,28 +42,28 @@ At its core, dispatching in an MVC application, as facilitated by `\Phalcon\Mvc\
 3. **Controller Instantiation**: The corresponding controller is instantiated based on the extracted information.
 4. **Action Execution**: The designated action within the controller is executed, handling the request as intended.
 
-Zemit's Dispatcher enhances this process by integrating it seamlessly with the framework's architecture, ensuring
+ Phalcon kit's Dispatcher enhances this process by integrating it seamlessly with the framework's architecture, ensuring
 efficient and effective handling of both web and CLI requests.
 
 ## Benefits and Features
 
-By extending Phalcon's native dispatchers, Zemit inherits all the flexibility, performance, and features of the Phalcon
+By extending Phalcon's native dispatchers, Phalcon Kit inherits all the flexibility, performance, and features of the Phalcon
 framework while adding significant enhancements:
 
 ### Cyclic Routing Prevention
 
 A common issue in dispatching is "_Dispatcher has detected a cyclic routing causing
-stability problems._" This happens when there's an endless forwarding loop in the application. Zemit's Dispatcher can
+stability problems._" This happens when there's an endless forwarding loop in the application. Phalcon Kit's Dispatcher can
 automatically detect and prevent such single-hop cyclic routing issues, enhancing application stability. However, it's
 important to note that it doesn’t resolve multiple-hop cycling issues, as these often involve complex scenarios that
 require developer intervention.
 
-### Business Rule Implementation in Zemit Dispatcher
+### Business Rule Implementation in Phalcon Kit Dispatcher
 
-The Zemit Dispatcher Service Provider is designed to automate and handle several vital aspects of application management
+The Phalcon Kit Dispatcher Service Provider is designed to automate and handle several vital aspects of application management
 and routing. This configuration not only streamlines the development process but also ensures consistent and secure
 application behavior across different environments. Here's a breakdown of the key business rules automatically managed
-by the Zemit Dispatcher:
+by the Phalcon Kit Dispatcher:
 
 - **CORS and Preflight Requests**: The dispatcher is equipped to handle Cross-Origin Resource Sharing (CORS) and
   preflight requests, ensuring that your application can safely interact with resources from different domains as per
@@ -81,7 +81,7 @@ by the Zemit Dispatcher:
   debugging and monitoring. The dispatcher logs these events, providing valuable insights into the application's routing
   behavior and performance.
 
-- **Support for HMVC Architecture**: Zemit's dispatcher supports forwarding in multi-module architectures, making it
+- **Support for HMVC Architecture**: Phalcon Kit's dispatcher supports forwarding in multi-module architectures, making it
   ideal for applications following a Hierarchical Model-View-Controller (HMVC) pattern. This capability allows modules
   to request actions from other modules, fostering a highly modular and flexible application structure.
 
@@ -93,7 +93,7 @@ by the Zemit Dispatcher:
   by allowing default namespace settings. This feature streamlines the organization of controllers and models within
   various modules, enhancing the structure and readability of the codebase.
 
-The Zemit Dispatcher's automated approach to managing crucial business rules significantly enhances the application's
+The Phalcon Kit Dispatcher's automated approach to managing crucial business rules significantly enhances the application's
 architecture on multiple fronts:
 
 - **Simplified Development**: By automating complex processes like CORS handling, security enforcement, and maintenance
@@ -112,8 +112,8 @@ architecture on multiple fronts:
   reduces overhead and enhances efficiency. This efficiency is particularly beneficial in applications with complex
   routing needs, where minimizing performance bottlenecks is crucial.
 
-Incorporating these advanced features, Zemit’s Dispatcher not only makes request handling more efficient but also plays
+Incorporating these advanced features, Phalcon Kit’s Dispatcher not only makes request handling more efficient but also plays
 a vital role in reducing the complexity typically associated with routing and dispatching in web applications.
-Developers leveraging Zemit can expect a more intuitive, secure, and manageable routing process, enabling them to build
+Developers leveraging Phalcon Kit can expect a more intuitive, secure, and manageable routing process, enabling them to build
 sophisticated web solutions with ease.
 

docs/core/loader.md

@@ -7,15 +7,15 @@ criteria like file names, class names, and namespaces. One notable advantage of
 is its implementation in C, which ensures minimal overhead during the setup process. This inherent
 efficiency contributes to a performance boost for your application.
 
-Zemit Loader extends the native
+Phalcon Kit Loader extends the native
 [`\Phalcon\Autoload\Loader`](https://docs.phalcon.io/latest/api/phalcon_autoload/){:target="_blank"}.
-To further optimize speed, Zemit Loader has disabled the
+To further optimize speed, Phalcon Kit Loader has disabled the
 [file checking callback](https://docs.phalcon.io/latest/autoload/#file-checking-callback){:target="_blank"}
 used in Phalcon's native component, ensuring quicker response times.
 
 ## Constants
 
-This set of constants facilitate the loading process and form the backbone of the default Zemit configuration.
+This set of constants facilitate the loading process and form the backbone of the default Phalcon Kit configuration.
 These constants can be tailored to suit the specific needs of your project.
 
 | Constant      | Default Value | Description                                                          |
@@ -40,15 +40,15 @@ Below is the typical structure for `loader.php`, illustrating how to register th
 ```php title="./loader.php"
 <?php
 
-use Zemit\Autoload\Loader;
+use PhalconKit\Autoload\Loader;
 
 // Define the main constants used across the application
 const APP_NAMESPACE = 'App';
 const ROOT_PATH = __DIR__;
 const VENDOR_PATH = ROOT_PATH . '/vendor/';
 const APP_PATH = ROOT_PATH . '/app/';
 
-// Initialize the Zemit Loader
+// Initialize the Phalcon Kit Loader
 $loader = new Loader();
 
 // Register the Composer autoload file and the application namespace
@@ -66,7 +66,7 @@ This script ensures that all necessary files and namespaces are correctly autolo
 
 ### Global Entry Point
 
-The `./index.php` file acts as the global entry point for your Zemit application.
+The `./index.php` file acts as the global entry point for your Phalcon Kit application.
 It's strategically placed in the root of the project not for direct web server access, 
 but as a security measure to safeguard the application's root directory. 
 This setup is designed to prevent unauthorized directory listing or exposure 
@@ -81,7 +81,7 @@ Here's the typical implementation of the global entry point:
 ```php title="./index.php"
 <?php
 
-use Zemit\Bootstrap;
+use PhalconKit\Bootstrap;
 
 // Load the global autoloader
 $loader = require 'loader.php';
@@ -93,13 +93,13 @@ echo (new Bootstrap())->run();
 In this script:
 
 - We include the global loader.php to initialize the autoloading process.
-- An instance of Zemit\Bootstrap is created and executed, which kickstarts the application. This approach encapsulates 
+- An instance of PhalconKit\Bootstrap is created and executed, which kickstarts the application. This approach encapsulates 
 the initialization and routing in a structured manner, enhancing maintainability and security.
 
 ### Public Entry Point
 
 The `./public/index.php` file is designated as the primary entry point for **web server**
-interactions with your Zemit application. This file should reside in the `public` directory
+interactions with your Phalcon Kit application. This file should reside in the `public` directory
 of your project. The purpose of this configuration is to enhance security by restricting web
 server access solely to the `public` directory, thereby shielding the rest of your
 application's structure and critical files from direct exposure.