Added Guard documentation and updated execution context docs too

Author: eadwinCode

docs/basics/execution-context.md

@@ -194,20 +194,20 @@ Ellar provides the ability to attach **custom metadata** to route handlers throu
 We can then access this metadata from within our class to make certain decisions.
 
 ```python
-# project_name/apps/dogs/controllers.py
+# project_name/apps/cars/controllers.py
 
 from ellar.common import Body, Controller, post, set_metadata
 from ellar.core import ControllerBase
-from .schemas import CreateDogSerializer, DogListFilter
+from .schemas import CreateCarSerializer
 
 
-@Controller('/dogs')
-class DogsController(ControllerBase):
+@Controller('/car')
+class CarController(ControllerBase):
     @post()
     @set_metadata('role', ['admin'])
-    async def create(self, payload: CreateDogSerializer = Body()):
+    async def create(self, payload: CreateCarSerializer = Body()):
         result = payload.dict()
-        result.update(message='This action adds a new dog')
+        result.update(message='This action adds a new car')
         return result
 ```
 
@@ -216,24 +216,24 @@ to the `create()` method. While this works, it's not good practice to use `@set_
 Instead, create your own decorators, as shown below:
 
 ```python
-# project_name/apps/dogs/controllers.py
+# project_name/apps/cars/controllers.py
 import typing
 from ellar.common import Body, Controller, post, set_metadata
 from ellar.core import ControllerBase
-from .schemas import CreateDogSerializer, DogListFilter
+from .schemas import CreateCarSerializer
 
 
 def roles(*_roles: str) -> typing.Callable:
     return set_metadata('roles', list(_roles))
 
 
-@Controller('/dogs')
-class DogsController(ControllerBase):
+@Controller('/car')
+class CarController(ControllerBase):
     @post()
     @roles('admin', 'is_staff')
-    async def create(self, payload: CreateDogSerializer = Body()):
+    async def create(self, payload: CreateCarSerializer = Body()):
         result = payload.dict()
-        result.update(message='This action adds a new dog')
+        result.update(message='This action adds a new car')
         return result
 ```
 
@@ -244,7 +244,7 @@ To access the route's role(s) (custom metadata), we'll use the `Reflector` helpe
 `Reflector` can be injected into a class in the normal way:
 
 ```python
-# project_name/apps/dogs/guards.py
+# project_name/apps/cars/guards.py
 from ellar.di import injectable
 from ellar.core import GuardCanActivate, IExecutionContext
 from ellar.services import Reflector
@@ -259,30 +259,33 @@ class RoleGuard(GuardCanActivate):
         roles = self.reflector.get('roles', context.get_handler())
         # request = context.switch_to_http_connection().get_request()
         # check if user in request object has role
+        if not roles:
+            return True
         return 'user' in roles
 ```
 
-Next, we apply the `RoleGuard` to `DogsController`
+Next, we apply the `RoleGuard` to `CarController`
 
 ```python
-# project_name/apps/dogs/controllers.py
+# project_name/apps/cars/controllers.py
 import typing
-from ellar.common import Body, Controller, post, set_metadata
+from ellar.common import Body, Controller, post, set_metadata, Guards
 from ellar.core import ControllerBase
-from .schemas import CreateDogSerializer, DogListFilter
+from .schemas import CreateCarSerializer
 from .guards import RoleGuard
 
 def roles(*_roles: str) -> typing.Callable:
     return set_metadata('roles', list(_roles))
 
 
-@Controller('/dogs', guards=[RoleGuard, ])
-class DogsController(ControllerBase):
+@Controller('/car')
+@Guards(RoleGuard)
+class CarController(ControllerBase):
     @post()
     @roles('admin', 'is_staff')
-    async def create(self, payload: CreateDogSerializer = Body()):
+    async def create(self, payload: CreateCarSerializer = Body()):
         result = payload.dict()
-        result.update(message='This action adds a new dog')
+        result.update(message='This action adds a new car')
         return result
 ```
 

docs/index.md

@@ -31,11 +31,7 @@ To get started, you need to scaffold a project using [Ellar-CLI](https://eadwinc
 The scaffolded project is more like a guide to project setup.
 
 ```shell
-$(venv) pip install ellar[standard]
-```
-OR
-```shell
-$(venv) pip install ellar ellar-cli
+$(venv) pip install ellar
 ```
 
 After that, lets create a new project. 
@@ -44,12 +40,6 @@ Run the command below and change the `project-name` with whatever name you decid
 $(venv) ellar new project-name
 ```
 
-### NB:
-Some shells may treat square braces (`[` and `]`) as special characters. If that's the case here, then use a quote around the characters to prevent unexpected shell expansion.
-```shell
-pip install "ellar[standard]"
-```
-
 then, start the app with:
 ```shell
 $(venv) ellar runserver --reload

docs/overview/custom_decorators.md

@@ -388,10 +388,10 @@ More information on how to use this decorator can be found in the [Versioning do
 
 A quick example on how to use `version` decorator:
 ```python
-from ellar.common import post, version
+from ellar.common import post, Version
 
 @post("/create", name='v2_v3_list')
-@version('2', '3')
+@Version('2', '3')
 async def get_item_v2_v3(self):
     return {'message': 'for v2 and v3 request'}
 ```
@@ -401,18 +401,18 @@ This indicates that the `get_item_v2_v3` route function will handle version 2 an
 This allows for multiple versions of the same endpoint to be handled by different route functions, each with their own logic and implementation.
 
 ### GUARDS
-**@guards()**  is a decorator that applies a protection class of type `GuardCanActivate` to a route function. 
+**@Guards()**  is a decorator that applies a protection class of type `GuardCanActivate` to a route function. 
 These protection classes have a `can_execute` function that is called to determine whether a route function should be executed. 
 
 This decorator allows you to apply certain conditions or checks before a route function is executed, such as `authentication` or `authorization` checks. 
 This can help to ensure that only authorized users can access certain resources. 
 
 More information on how to use this decorator can be found in the [Guard Documentation]()
 
-A quick example on how to use `guards` decorator:
+A quick example on how to use `Guards` decorator:
 ```python
 import typing as t
-from ellar.common import get, guards
+from ellar.common import get, Guards
 from ellar.core.guard import APIKeyQuery
 from ellar.core.connection import HTTPConnection
 
@@ -425,11 +425,11 @@ class MyAPIKeyQuery(APIKeyQuery):
 
 
 @get("/")
-@guards(MyAPIKeyQuery(), )
+@Guards(MyAPIKeyQuery(), )
 async def get_guarded_items(self):
     return {'message': 'worked fine with `key`=`supersecret`'}
 ```
-The `guards` decorator, like the `version` decorator, takes a list of values as an argument. 
+The `Guards` decorator, like the `version` decorator, takes a list of values as an argument. 
 During a request, the provided guards are called in the order in which they are provided. 
 
 This allows you to apply multiple guards to a single route function and have them executed in a specific order.