Added docs for static files

Author: eadwinCode

docs/basics/execution-context.md

@@ -7,7 +7,7 @@ This allows different components of the application like **exception handlers**,
 There are two class `HostContext` and `ExecutionContext` which provides set of methods and properties for accessing and manipulating the current context of execution.
 
 
-## HostContext
+## **HostContext**
 The `HostContext` class provides a wrapper around `ASGI` app parameters (`scope`, `receive` and `send`) and provides some methods that allows you choosing the appropriate context(e.g., HTTP or WebSockets).
 
 For example, the `catch()` method of an **exception handlers** is called with an IHostContext.
@@ -44,7 +44,7 @@ class MyCustomExceptionHandler(IExceptionHandler):
 
 ```
 
-## Switching to other Contexts
+## **Switching to other Contexts**
 
 Currently, in Ellar you can only switch between `http` and `websocket` context. And each context has `get_client` method that returns context session.
 
@@ -141,7 +141,7 @@ class IWebSocketConnectionHost(ABC):
         """Returns WebSocket instance"""
 ```
 
-## ExecutionContext Class
+## **ExecutionContext Class**
 `ExecutionContext` extends `HostContext` and provides extra information like `Controller` class and controller `function` 
 that will handler the current request.
 
@@ -189,7 +189,7 @@ In this example, the `get_user` method is decorated with the `@get` decorator to
 
 Once you have access to the `ExecutionContext` object, you can use its methods and properties to access information about the current request.
 
-## Reflector and Metadata
+## **Reflector and Metadata**
 Ellar provides the ability to attach **custom metadata** to route handlers through the `@set_metadata()` decorator. 
 We can then access this metadata from within our class to make certain decisions.
 

docs/overview/module-router.md

@@ -4,7 +4,7 @@ ModuleRouter allows you to define your route handlers as standalone functions, p
 This can be beneficial for python developers who prefer using functions. 
 It is important to note that using ModuleRouter does not limit your access to other features provided by Ellar.
 
-## Usage
+## **Usage**
 The Ellar CLI tool generates a `routers.py` file in every `create-module` scaffold command. 
 This file contains a quick guide on how to use the `ModuleRouter` class.
 
@@ -40,7 +40,7 @@ Each route takes two query parameters, 'a' and 'b' which are declared as int typ
 
 Next, we have to make the `math_router` visible to the application
 
-## Registering Module Router
+## **Registering Module Router**
 Like controllers, ModuleRouters also need to be registered to their root module in order to be used in a web application. 
 In the example provided above, the `math_router` would be registered under the `project_name/apps/dogs/module.py` file.
 
@@ -72,7 +72,7 @@ class DogsModule(ModuleBase):
 ![math_router.png](../img/math_router.png)
 
 
-## Accessing Other Request Object
+## **Accessing Other Request Object**
 In functional route handle, we can access request object and response object through custom decorators or type annotation as shown below.
 
 ### By Type Annotation
@@ -92,7 +92,7 @@ def addition(request: Request, res: Response, a:int, b:int):
 
 ```
 
-- By Custom decorators
+### **By Custom decorators**
 You can also achieve the same result by using custom decorator.
 
 ```python
@@ -111,7 +111,7 @@ def addition(*, request=Req(), res=Res(), a:int, b:int):
 
 ![math_router_with_request_object.png](../img/math_router_with_request_object.png)
 
-## Inject Services
+## **Inject Services**
 We can also inject service providers just like controller routes using the `Provide` function.
 
 ```python

docs/templating/staticfiles.md

@@ -0,0 +1,86 @@
+A static file is a type of file that does not change often and is not generated by a server-side script. Examples of static files include images, CSS and JavaScript files, audio and video files, and other types of media.
+
+Static files in Ellar are served using the `StaticFiles` ASGI class, which is an extension of the Starlette `StaticFiles` ASGI class. 
+This class uses the static files specified in the application's **modules** and **configuration**.
+
+In addition, Ellar creates a route that mounts the static server at the `/static` path. 
+The path can be modified by providing a new value for the `STATIC_MOUNT_PATH` configuration variable.
+
+## **Configuring static files**
+
+1. In your config file, define `STATIC_MOUNT_PATH`, for example:
+    ```python
+    
+   class Config:
+        STATIC_MOUNT_PATH = '/static'
+    ```
+
+2. Store your static files in a folder called **static** in your module. For example **my_module/static/my_module/example.jpg**.
+3. In your templates, use the `url_for` with `static` and `path` parameter to build the URL for the given relative path using the configured in `STATIC_DIRECTORIES`, `STATIC_FOLDER_PACKAGES` or Module.
+   ```html
+    <img src="{{url_for('static', path='my_module/example.jpg')}}" alt="My image">
+   ```
+   OR, visit `/static/my_app/example.jpg`
+
+
+## **Static File in Modules**
+
+Managing multiple sets of static files in larger projects can be challenging, 
+but by organizing each set of static files within a specific module, 
+it becomes easier to manage and maintain. 
+This approach allows for clear organization and separation of static assets, 
+making it more manageable in a large project.
+
+In our previous project, within the `dogs` module folder, we can create a following directories, `my_static/dogs`. 
+Inside this folder `my_static/dogs`, we can create a file named `example.txt`. 
+This allows us to keep all of the static files related to the dogs module organized in one location `my_static`.
+
+Next, we tell `DogModule` about our static folder.
+
+```python
+# project_name/apps/dogs/module.py
+
+from ellar.common import Module
+from ellar.core import ModuleBase
+from ellar.di import Container
+
+from .controllers import DogsController
+
+
+@Module(
+    controllers=[DogsController], static_folder='my_static'
+)
+class DogsModule(ModuleBase):
+    def register_providers(self, container: Container) -> None:
+        # for more complicated provider registrations
+        # container.register_instance(...)
+        pass
+```
+
+## **Other Static Configurations**
+In addition to setting static directories within modules, 
+it is also possible to manually specify additional static directories that are not located within a module by using the 
+`STATIC_FOLDER_PACKAGES` and `STATIC_DIRECTORIES` variables in the application's configuration. 
+These variables allow for even more flexibility in organizing and managing static files in a project. 
+These directories will be served by the StaticFiles ASGI class along with the module-scoped static files.
+
+### `STATIC_DIRECTORIES`
+`STATIC_DIRECTORIES` variable is a list of directories within the project that contain static files. 
+These directories are not necessarily scoped to a specific module and can be used to serve static files from any location within the project. 
+These directories can be added to the `STATIC_DIRECTORIES` list in the application's configuration.
+
+```python
+STATIC_DIRECTORIES =  ['project_name/static-files', 'project_name/path/to/static/files']
+```
+
+### `STATIC_FOLDER_PACKAGES`
+`STATIC_FOLDER_PACKAGES` variable is a list of tuples that contain python packages that hold some static files. 
+These packages should have a `static` folder and the **package name** should be passed as tuple `(package_name, package_path)`, 
+**package_path** is the relative path of static folder.
+
+```python
+
+STATIC_FOLDER_PACKAGES =  [('bootstrap', 'statics'), ('package-name', 'path/to/static/directory')]
+```
+
+Static files will respond with "404 Not found" or "405 Method not allowed" responses for requests which do not match. In `HTML` mode if `404.html` file exists it will be shown as 404 response.

docs/templating/templating.md

@@ -5,11 +5,11 @@ In Ellar, a Model-View-Controller (MVC) framework, Jinja2 templates are typicall
 while the Model and Controller layers handle the data and logic of the application.
 
 
-## Installation
+## **Installation**
 [`Jinja2`](https://jinja.palletsprojects.com/en/3.0.x/) package is installed alongside with Ellar.
 
 
-## Quick overview on jinja2 Usage
+## **Quick overview on jinja2 Usage**
 A Jinja2 template is a plain text file that contains dynamic content, represented using Jinja2 syntax. 
 Here's an example template that displays a list of items:
 
@@ -71,7 +71,7 @@ and returns the rendered template as the `HTTP` response to the request.
 This example also shows manual setup of using `jinja2` in Ellar.
 
 
-## Jinja2 usage in Ellar
+## **Jinja2 usage in Ellar**
 
 In Ellar, we use the `@render` decorator to convert the responses returned by the view to a Templated Response by creating an `HTMLResponseModel` with a status code of 200 to handle the response.
 Also, each registered `Module` is a `TemplateLoader` for loading templates available at `templates_folder`. And, a `Module` TemplateLoader object is created when the `template_folder` folder exists.
@@ -175,10 +175,10 @@ if __name__ == "__main__":
     - [`Starlette Recommendation`](https://www.starlette.io/templates/#asynchronous-template-rendering)
 
 
-## Jinja2 Configurations
+## **Jinja2 Configurations**
 If there are specific configurations you want to apply to your Jinja2 Environment, you can look at [JINJA_TEMPLATE_OPTIONS](https://eadwincode.github.io/ellar/configurations/#jinja_templates_options) configuration.
 
-## Default Jinja Template Context
+## **Default Jinja Template Context**
 
 Every jinja template in ellar receives two context, `url_for`, `config`, `request` object and other specific context defined to render a template.
 
@@ -187,7 +187,7 @@ Every jinja template in ellar receives two context, `url_for`, `config`, `reques
 - `request` is current request object.
 
 
-## Static Files
+## **Static Files In Template**
 
 As stated above, you can resolve file paths to static files using `url_for`.
 
@@ -205,7 +205,7 @@ The `url_for` takes `path` parameter, in the case of `static` files, to match th
 This `url_for('static', path='img/Icon.svg')` will search for `img/Icon.svg` in all registered static folders.
 
 
-### Reversing Controllers URL
+### Reversing Controllers URLs
 It is common to need to generate URLs for specific routes, particularly when returning a redirect response. 
 This can be achieved by using the `request.url_for` method in the request object, or in the case of templating, by using the `url_for()` function.
 
@@ -285,7 +285,7 @@ we can see that the `parameter_a` is used as a keyword argument to satisfy the d
     If the `url_for` function is called with a path that does not exist or with insufficient parameters to resolve an existing URL, 
     it will raise a `starlette.routing.NoMatchFound` exception.
 
-### Module Router
+### Reversing Module Router URLs
 
 Just like in controller, we can also reverse URLs that belongs to `ModuleRouter`. 
 
@@ -356,3 +356,7 @@ In this case, when reversing the URL, you would use `request.url_for('users:user
 which will generate `http://127.0.0.1:5000/template-reversing/profile/value_of_user_id` based on routing configuration.
 
 This allows for greater control and readability when reversing URLs, and makes it less prone to error if the function name of the route were to change in the future.
+
+
+### Adding template filters and template globals.
+Jinja template filter and global functions can be defined at module level as shown here: [Module Templating Filters](../overview/modules/#module-templating-filters)