Update documentation, fix formatting

Author: grkek

docs/advanced_routing.md

@@ -27,7 +27,9 @@ class DemoController
 end
 
 # Application configures and runs a Grip web application.
-class Application < Grip::Application
+class Application
+  include Grip::Application
+  
   # List of HTTP handlers for processing incoming requests.
   property handlers : Array(HTTP::Handler) = [
     Grip::Handlers::Pipeline.new, # Manages the request pipeline.

docs/application.md

@@ -3,7 +3,7 @@ Application module is a building block which initializes the crucial parts of th
 ```crystal
 # Application is a building class that initializes the core components of the Grip web framework.
 # It manages the main handler stack and the HTTP server.
-class Application < Grip::Application
+class Application
   include Grip::Application
 
   # List of HTTP handlers for processing incoming requests.
@@ -16,13 +16,7 @@ class Application < Grip::Application
   # Defines the host address of the server.
   # @return [String] The host address (e.g., "0.0.0.0").
   def host : String
-    DEFAULT_HOST
-  end
-
-  # Defines the root path for routing (placeholder for custom implementation).
-  # @return [String] The root path for the application.
-  def root : String
-    "/"
+    "0.0.0.0"
   end
 
   # Placeholder for custom configuration or logic.
@@ -34,13 +28,13 @@ class Application < Grip::Application
   # Defines the port on which the server listens.
   # @return [Int32] The port number (e.g., 4004).
   def port : Int32
-    DEFAULT_PORT
+    4004
   end
 
   # Determines if the server reuses the port.
   # @return [Bool] True if port reuse is enabled, false otherwise.
   def reuse_port : Bool
-    DEFAULT_REUSE_PORT
+    true
   end
 
   # Defines the SSL key file location for the application.

docs/basic_routing.md

@@ -14,11 +14,12 @@ class DemoController
 end
 
 # Application configures and runs a Grip web application.
-class Application < Grip::Application
+class Application
+  include Grip::Application
+
   # List of HTTP handlers for processing incoming requests.
   property handlers : Array(HTTP::Handler) = [
-    Grip::Handlers::Pipeline.new, # Manages the request pipeline.
-    Grip::Handlers::HTTP.new     # Handles core HTTP protocol logic.
+    Grip::Handlers::HTTP.new # Handles core HTTP protocol logic.
   ] of HTTP::Handler
 
   # Initializes the application and configures routes.

docs/error_handling.md

@@ -32,7 +32,9 @@ class ForbiddenController
 end
 
 # Application configures the Grip web application with error handlers and routes.
-class Application < Grip::Application
+class Application
+  include Grip::Application
+
   # Defines the array of HTTP handlers for processing requests.
   property handlers : Array(HTTP::Handler) = [
     Grip::Handlers::Exception.new, # Handles exceptions using defined error controllers.
@@ -91,7 +93,9 @@ class FallbackController
 end
 
 # Application configures the Grip web application with a fallback error handler.
-class Application < Grip::Application
+class Application
+  include Grip::Application
+
   # Defines the array of HTTP handlers for processing requests.
   property handlers : Array(HTTP::Handler) = [
     Grip::Handlers::Exception.new, # Handles exceptions using defined error controllers.

docs/forward.md

@@ -22,7 +22,9 @@ class Authorization
 end
 
 # Application configures the Grip web application with handlers and routes.
-class Application < Grip::Application
+class Application
+  include Grip::Application
+  
   # Defines the array of HTTP handlers for processing requests.
   property handlers : Array(HTTP::Handler) = [
     Grip::Handlers::HTTP.new, # Handles core HTTP protocol logic.

docs/getting_started.md

@@ -1,13 +1,14 @@
 This guide provides a complete setup for a Crystal web application using the Grip framework, including project initialization, dependency setup, application code, server execution, testing, and auto-restart configuration.
 
 ## 1. Initialize a Crystal Project
+
 ```shell
 # Initializes a new Crystal application named "demo" and navigates to its directory.
-# Creates a project structure with shard.yml, src/, and lib/ directories.
 crystal init app demo && cd demo
 ```
 
 ## 2. Add Dependency to `shard.yml` and Install
+
 ```yaml
 # shard.yml: Specifies project dependencies for the Crystal application.
 name: demo
@@ -24,11 +25,11 @@ crystal: 1.0.0
 
 dependencies:
   grip: # Adds the Grip web framework as a dependency.
-    github: grip-framework/grip # Points to the Grip repository on GitHub.
+    github: grip-framework/grip
 ```
 
 ```shell
-# Installs the dependencies listed in shard.yml, downloading Grip to lib/.
+# Installs the dependencies listed in shard.yml
 shards install
 ```
 
@@ -86,20 +87,23 @@ app.run
 ```
 
 ## 4. Run the Server
+
 ```shell
 # Compiles and runs the Crystal application, starting the Grip server.
 # The server listens on 0.0.0.0:4004 by default unless configured otherwise.
 crystal src/demo.cr
 ```
 
 ## 5. Send a Request
+
 ```shell
 # Sends an HTTP GET request to the root path of the running server.
 # Expects a 201 response with a JSON body {"id": 1} and a Server header.
 curl "http://0.0.0.0:4004/"
 ```
 
 ## 6. Auto-Restart Server
+
 ```shell
 # Installs nodemon globally to watch for file changes and auto-restart the server.
 sudo npm install -g nodemon

docs/index.md

@@ -3,9 +3,13 @@ Grip is a lightweight microframework for building RESTful web applications in th
 ## Framework Features
 
 - **Microframework Design**: Grip focuses on simplicity for building RESTful APIs, enabling rapid development while supporting complex applications through modular extensions.
+
 - **Middleware ("Pipes")**: Integrated middleware, implemented as `HTTP::Handler` classes, processes and modifies request/response contexts (e.g., adding headers, authentication) before forwarding to endpoints.
+
 - **Router**: Inspired by the [Phoenix framework](https://github.com/phoenixframework/phoenix), Grip’s router offers expressive routing with macros like `get`, `scope`, `pipe_through`, and `forward` for defining endpoints and pipelines.
+
 - **Extensibility**: Developers can create custom middleware, controllers, and error handlers to tailor functionality to specific needs.
+
 - **High Performance**: Optimized for speed, Grip delivers exceptional throughput, making it ideal for high-performance API development.
 
 ## Recommended Project Structure
@@ -28,23 +32,34 @@ Echo/                       # Project root directory
 ```
 
 ### Structure Details
+
 - **lib/**: Contains external libraries (e.g., Grip) installed via `shards install`, managed by Crystal’s dependency manager.
+
 - **src/application.cr**: The application entry point, defining the `Application` class (inheriting from `Grip::Application`). It configures middleware via a `property handlers` array and sets up routes using macros like `get` or `forward`.
+
 - **src/echo/**: Houses business logic, including database models, services, or other domain-specific functionality, ensuring separation from web concerns.
+
 - **src/echo_web/**: Manages HTTP interactions, with controllers (e.g., `DemoController`) handling requests and views defining response formats (e.g., JSON, HTML).
+
 - **shards.yml**: Specifies project metadata and dependencies, such as `grip: { github: grip-framework/grip }`.
 
 ## Example Setup
+
 To create a Grip application with the above structure:
+
 1. Initialize a Crystal project: `crystal init app echo && cd echo`.
+
 2. Add Grip to `shards.yml`:
    ```yaml
    dependencies:
      grip:
        github: grip-framework/grip
    ```
+
 3. Install dependencies: `shards install`.
+
 4. Define the application in `src/application.cr`, configuring handlers and routes (see previous examples for controller and route definitions).
+
 5. Run the server: `crystal src/application.cr`.
 
 This structure and Grip’s features provide a robust foundation for building scalable, high-performance RESTful applications in Crystal.

docs/installation.md

@@ -1,17 +1,19 @@
 To use the Grip framework in a Crystal application, you must add it as a dependency in the project’s `shard.yml` file and install it using the `shards` command. This ensures the framework is available for building RESTful web applications.
 
 ## 1. Update `shard.yml`
+
 Add the Grip dependency to your project’s `shard.yml` file, located in the project root directory. This file specifies the project’s metadata and dependencies.
 
 ```yaml
 # shard.yml: Configuration file for project dependencies and metadata.
 dependencies:
-  grip: # Specifies the Grip microframework for building RESTful APIs.
+  grip:
     github: grip-framework/grip # References the Grip repository on GitHub.
 ```
 
 ## 2. Install Dependencies
-Run the following command in your terminal to install the dependencies listed in `shard.yml`:
+
+Run the following command in your terminal:
 
 ```bash
 # Installs dependencies specified in shard.yml, downloading Grip to the lib/ directory.

docs/pipe_middleware.md

@@ -34,7 +34,9 @@ class DemoController
 end
 
 # Application configures and runs a Grip web application.
-class Application < Grip::Application
+class Application
+  include Grip::Application
+  
   # Defines the array of HTTP handlers for processing requests.
   property handlers : Array(HTTP::Handler) = [
     Grip::Handlers::Pipeline.new, # Manages the request pipeline for middleware execution.

docs/runtime_flags.md

@@ -1,4 +1,5 @@
 # Configuration flags
+
 1. Flag which enables HTTPS:
 
 ```bash