Doc md error fixes

Author: eadwinCode

docs/overview/controllers.md

@@ -74,9 +74,10 @@ For example, a path prefix of `/users` combined with the decorator `@get('/profi
 `GET /users/profile`.
 
 
-Overview of HTTP function decorator parameters:
+#### Overview of HTTP function decorator parameters:
 
 `@get(path: str, name: str, include_in_schema: bool, response: t.Union[t.Dict[int, t.Type], t.List[t.Tuple[int, t.Type]], t.Type])`
+
 - `path`: defines path for route mapping. `default='/'`
 - `name`: defines a `name` that will be used to identify this route during URL reversing. default is function name eg: `get_all`
 - `include_in_schema`: indicates if an endpoint should be available in OPENAPI docs
@@ -108,6 +109,7 @@ class DogsController(ControllerBase):
 ```
 
 - injection (`parameter_name=Req()`)
+
 We can also inject request object to any handler by using `@Req` decorator in handler signature.
 ```python
 # project_name/apps/dogs/controllers.py
@@ -127,6 +129,7 @@ class DogsController(ControllerBase):
 ```
 
 - controllers context
+
 During request handler execution, `Execution Context` is available on the Controller instance and `request` object can be gotten from the context.
 ```python
 # project_name/apps/dogs/controllers.py
@@ -162,6 +165,7 @@ Other request `handler` signature injectors
 | `Provide()` | injects services                                                                                       |
 
 ## Resource
+
 Let add create endpoint to our `DogsController` resource.
 ```python
 # project_name/apps/dogs/controllers.py
@@ -181,7 +185,9 @@ class DogsController(ControllerBase):
         return 'This action returns all dogs'
     ...
 ```
+
 ### HTTP Methods
+
 Ellar provides decorators for all the standard HTTP methods:
 - `@get`  - `GET` HTTP method
 - `@post` - `POST` HTTP method
@@ -195,6 +201,7 @@ Ellar provides decorators for all the standard HTTP methods:
 
 
 ## Asynchronicity
+
 Ellar support modern asynchronous programming in python using `async` and `await` syntax.
 
 ```python
@@ -216,6 +223,7 @@ class DogsController(ControllerBase):
     ...
 ```
 ## Request Payload
+
 Let's use `@Body()` to defined required data to create a dog in our previous `create`(POST) endpoint. 
 Before that, we need to define our data input/output serializers
 
@@ -259,7 +267,8 @@ async def create(self, payload: CreateDogSerializer = Body()):
 `CreateDogSerializer`, a pydantic type, so fields(`name`, `age`, `breed`) validations according to defined types and
 specifications is supported out of the box. It's important to note the way we used `CreateDogSerializer` as a type annotation to `payload` parameter in `create` method. 
 During request Ellar computes the route handler signatures and validates them to the annotated types before executing the handler.
-![CreateDogSchema](img/create-dog-schema.png)
+
+![CreateDogSchema](../img/create-dog-schema.png)
 
 Let's add other endpoints
 
@@ -327,4 +336,4 @@ class DogsModule(ModuleBase):
         pass
 ```
 
-![controller_dog.gif](img/controller_dog.gif)
+![controller_dog.gif](../img/controller_dog.gif)

docs/overview/index.md

@@ -5,6 +5,7 @@ with features that covers a lot of ground at an introductory level.
 
 ## Library Dependencies
 Ellar core depends on:
+
 - `python >= 3.7`
 - `Starlette`
 - `Injector`
@@ -70,6 +71,7 @@ Both provides all necessary parameter for creating Ellar application
 
 ## Run your project
 Ellar runs [UVICORN - ASGI Server](https://www.uvicorn.org/) under the hood.
+
 ```shell
 $(venv) cd project-name
 $(venv) ellar runserver --reload

docs/overview/middleware.md

@@ -101,7 +101,7 @@ This is how to apply any `ASGI` middlewares such as `GZipMiddleware`, `EllarASGI
 ## Starlette Middlewares
 Let's explore other Starlette middlewares and other third party ASGI Middlewares
 
-- ### `GZipMiddleware`
+### `GZipMiddleware`
 Handles GZip responses for any request that includes "gzip" in the Accept-Encoding header.
 The middleware will handle both standard and streaming responses.
 
@@ -121,11 +121,12 @@ class DevelopmentConfig(BaseConfig):
 ```
 
 The following arguments are supported:
+
 - `minimum_size` - Do not GZip responses that are smaller than this minimum size in bytes. Defaults to `500`.
 
 The middleware won't GZip responses that already have a Content-Encoding set, to prevent them from being encoded twice.
 
-- ### `HTTPSRedirectMiddleware`
+### `HTTPSRedirectMiddleware`
 Enforces that all incoming requests must either be `https` or `wss`.
 
 Any incoming requests to `http` or `ws` will be redirected to the secure scheme instead.
@@ -144,7 +145,8 @@ class DevelopmentConfig(BaseConfig):
     ]
 
 ```
-- ### `TrustedHostMiddleware`
+
+### `TrustedHostMiddleware`
 This middleware is already part of ellar application middlewares. The middleware takes an argument `allowed_host` which can be configured in the configuration class.
 
 
@@ -165,10 +167,11 @@ To allow any hostname either use `allowed_hosts=["*"]` or omit the middleware.
 
 If an incoming request does not validate correctly then a `400` response will be sent.
 
-- ### `CORSMiddleware`
+### `CORSMiddleware`
 Adds appropriate [`CORS headers`](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) to outgoing responses in order to allow cross-origin requests from browsers.
 
 Since `CORSMiddleware` is part of default application middleware, let's see how to configure CORS arguments in ellar application.
+
 ```python
 # project_name/config.py
 import typing as t
@@ -187,7 +190,9 @@ class DevelopmentConfig(BaseConfig):
     CORS_MAX_AGE: int = 600
 
 ```
+
 The following arguments are supported:
+
 - `CORS_ALLOW_ORIGINS` - A list of origins that should be permitted to make cross-origin requests. eg. `['https://example.org', 'https://www.example.org']`. You can use `['*']` to allow any origin.
 - `CORS_ALLOW_ORIGIN_REGEX` - A regex string to match against origins that should be permitted to make cross-origin requests. eg. `'https://.*\.example\.org'`.
 - `CORS_ALLOW_METHODS` - A list of HTTP methods that should be allowed for cross-origin requests. Defaults to `['GET']`. You can use `['*']` to allow all standard methods.
@@ -209,10 +214,11 @@ The middleware responds to two particular types of HTTP request
 Any request with an `Origin` header. In this case the middleware will pass the request through as normal, but will include appropriate CORS headers on the response.
 
 
-- ### `Other Middlewares`
+### `Other Middlewares`
 
 There are many other ASGI middlewares.
 For example:
+
 - [Sentry](https://docs.sentry.io/platforms/python/asgi/)
 - [Uvicorn's ProxyHeadersMiddleware](https://github.com/encode/uvicorn/blob/master/uvicorn/middleware/proxy_headers.py)
 - [MessagePack](https://github.com/florimondmanca/msgpack-asgi)

docs/overview/modules.md

@@ -32,7 +32,7 @@ the internal data structure used to resolve module and provider relationships an
 The best way to organize your components is to build your projects as `Modules`. 
 Thus, the architecture resulting from most applications will include multiple modules with closely related **functionality**.
 
-# `Feature modules`
+## `Feature modules`
 Module helps to organize code relevant for specific features, ensuring that the code is clear and organized.
 This will help to manage complexity and develop using SOLID especially as the application or team grows.
 
@@ -60,7 +60,7 @@ class DogsModule(ModuleBase):
         pass
 ```
 
-# `Module Parameters`
+## `Module Parameters`
 Let's create a Module and take a quick overview of its parameters.
 
 ```python
@@ -95,8 +95,8 @@ class BookModule(ModuleBase):
 | `static_folder`   | defines the static folder for this module                                                                                    |
 | `template_folder` | defines the template folder for this module                                                                                  |
 
-# `Additional Module Configurations`
-- ## `Module Events`
+## `Additional Module Configurations`
+### `Module Events`
 Every registered Module receives two event calls during its instantiation and when application is ready.
 
 ```python
@@ -115,7 +115,7 @@ class ModuleEventSample(ModuleBase):
 ```
 `before_init` receives current app `Config` as a parameter and `application_ready` function receives `App` instance as parameter.
 
-- ## `Module Exceptions`
+### `Module Exceptions`
 In Ellar, custom exceptions can be registered through modules. 
 During module meta-data computation, Ellar reads additional properties such as these from registered modules
 
@@ -131,7 +131,7 @@ class ModuleExceptionSample(ModuleBase):
 ```
 `exception_404_handler` will be register to the application at runtime during `ModuleExceptionSample` computation.
 
-- ## `Module Templating Filters`
+### `Module Templating Filters`
 We can also define `Jinja2` templating filters in project Modules or any `@Module()` module.
 The defined filters are be passed down to `Jinja2` **environment** instance alongside the `template_folder` 
 value when creating **TemplateLoader**.
@@ -155,7 +155,7 @@ class ModuleTemplateFilterSample(ModuleBase):
     def double_filter_dec(cls, n):
         return n * 2
 ```
-- ## `Module Request Events`
+### `Module Request Events`
 During application request handling, application router emits two events `start_up` and `shutdown` event.
 We can subscribe to those events in our modules. 
 ```python
@@ -185,7 +185,7 @@ These will be registered to the application router during `ModuleRequestEventsSa
 Also, the events can be `async` as in the case of `on_shutdown_func_2` and `on_startup_func_2`
 
 
-# `dependency injection`
+## `Dependency Injection`
 A module class can inject providers as well (e.g., for configuration purposes):
 
 For example, from our sample project, the can inject `Config` to the `DogModule`
@@ -214,7 +214,7 @@ class DogsModule(ModuleBase):
 ```
 
 
-# `Injector Module`
+## `Injector Module`
 Since `EllarInjector` is based on a python library [injector](https://injector.readthedocs.io/en/latest/index.html) both 
 share similar `Module` features with few distinct features. As an added support, you can create or reuse modules from `injector` Modules.
 

docs/overview/providers.md

@@ -1,8 +1,10 @@
 A provider is any class or object that is **injectable** as a dependency to another class, and it's required when creating an instance of that class.
+
 So, in a way, providers are like services, repositories, factories etc., classes that can manage complex tasks.
 This concept of class injection is known as [Dependency Injector](https://de.wikipedia.org/wiki/Dependency_Injection)
 
 You can easily create a provider class by decorating that class with the `@injectable()` mark
+
 ```python
 from ellar.di import injectable, singleton_scope
 
@@ -88,7 +90,7 @@ class DogsController(ControllerBase):
 We have defined `DogsRepository` as a dependency to `DogsController` which means Ellar will resolve `DogsRepository` instance when creating `DogsController` instance.
 This was made possible by type definition on `dog_repo` parameter and with the type defined, Ellar knows the provider to look for.
 
-!!info
+!!! info
     Every class dependencies should be defined in the class **constructor**, that way Ellar will resolve all the dependencies needed for an object instantiation.
 
 ## Provider registration