docs(32): Added documentation for assertions on the Option and Either type

Author: rcardin

README.md

@@ -7,23 +7,64 @@
 
 # assertj-arrow-core
 
-This project provides a set of [AssertJ](https://assertj.github.io/doc/) assertions for the [Arrow](https://arrow-kt.io/) library. In detail, the project provides assertions for the following Arrow types:
+This project provides a set of [AssertJ](https://assertj.github.io/doc/) assertions for
+the [Arrow](https://arrow-kt.io/) library. In detail, the project provides assertions for the following Arrow types:
 
 - [x] `Either<E, A>`
 - [x] `Option<A>`
 - [x] `Raise<E>.() -> A`
 
-Maybe you're asking yourself: "Why do we need AssertJ assertions for Arrow types?". The answer is simple: We often use Kotlin and Arrow Kt inside a Java project using Spring Boot. In this case, we already have AssertJ in the classpath as an assertion library. So, why not use it to assert Arrow types?
+Maybe you're asking yourself: "Why do we need AssertJ assertions for Arrow types?". The answer is simple: We often use
+Kotlin and Arrow Kt inside a Java project using Spring Boot. In this case, we already have AssertJ in the classpath as
+an assertion library. So, why not use it to assert Arrow types?
 
 ## Usage
 
 The library is available on Maven Central. To use it, add the following dependency to your `pom.xml` file:
 
 ```xml
+
 <dependency>
-  <groupId>in.rcard</groupId>
-  <artifactId>assertj-arrow-core</artifactId>
-  <version>1.1.0</version>
-  <scope>test</scope>
+    <groupId>in.rcard</groupId>
+    <artifactId>assertj-arrow-core</artifactId>
+    <version>1.1.0</version>
+    <scope>test</scope>
 </dependency>
 ```
+
+Otherwise, if you're using Gradle, add the following dependency to your `build.gradle.kts` file:
+
+```kotlin
+testImplementation("in.rcard:assertj-arrow-core:1.1.0")
+```
+
+## Assertions Guide
+
+This section describes the assertions provided by the `assertj-arrow-core` library.
+
+### `Option<A>`
+
+Use the `in.rcard.assertj.arrowcore.OptionAssert` class as an entry point to assert `Option<A>` instances.
+
+| Assertions           | Description                                                                                                                                               |
+|----------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `isEmpty`            | Verifies that the actual `Option` is empty.                                                                                                               |
+| `contains`           | Verifies that the actual `Option` contains the given value.                                                                                               |
+| `containsInstanceOf` | Verifies that the actual `Option` contains a value that is an instance of the argument.                                                                   |
+| `get`                | Verifies that the actual Option is not null and not empty and returns an Object assertion that allows chaining (object) assertions on the optional value. |
+| `isDefined`          | Verifies that there is a value present in the actual `Option`.                                                                                            |
+
+### `Either<E, A>`
+
+Use the `in.rcard.assertj.arrowcore.EitherAssert` class as an entry point to assert `Either<E, A>` instances.
+
+| Assertions                | Description                                                                                                                                                               |
+|---------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `isRight`                 | Verifies that the actual `Either` is right.                                                                                                                               |
+| `isLeft`                  | Verifies that the actual `Either` is left.                                                                                                                                |
+| `containsOnRight`         | Verifies that the actual `Either` is `Either.Right` and contains the given value.                                                                                         |
+| `containsRightInstanceOf` | Verifies that the actual right-sided `Either` contains a value that is an instance of the argument.                                                                       |
+| `asRight`                 | Verifies that the actual `Either` is not `null` and contains a right-sided value and returns an `Object` assertion that allows chaining (object) assertions on the value. |
+| `containsOnLeft`          | Verifies that the actual `Either` is `Either.Left` and contains the given value.                                                                                          |
+| `containsLeftInstanceOf`  | Verifies that the actual left-sided `Either` contains a value that is an instance of the argument.                                                                        |
+| `asLeft`                  | Verifies that the actual `Either` is not `null` and contains a left-sided value and returns an `Object` assertion that allows chaining (object) assertions on the value.  |