[raise-dsl-assertions] Updated documentation

Author: rcardin

src/main/kotlin/in/rcard/assertj/arrowcore/AbstractEitherAssert.kt

@@ -18,6 +18,9 @@ import org.assertj.core.internal.StandardComparisonStrategy
  * @param LEFT type of the left value contained in the [Either].
  * @param RIGHT type of the right value contained in the [Either].
  * @author Riccardo Cardin
+ * @author Simon Frost
+ *
+ * @since 0.0.1
  */
 abstract class AbstractEitherAssert<
     SELF : AbstractEitherAssert<SELF, LEFT, RIGHT>, LEFT : Any, RIGHT : Any,

src/main/kotlin/in/rcard/assertj/arrowcore/AbstractOptionAssert.kt

@@ -15,6 +15,8 @@ import org.assertj.core.internal.StandardComparisonStrategy
  * @param SELF  the "self" type of this assertion class.
  * @param VALUE type of the value contained in the [Option].
  * @author Riccardo Cardin
+ * @author Simon Frost
+ * @since 0.0.1
  */
 abstract class AbstractOptionAssert<
     SELF : AbstractOptionAssert<SELF, VALUE>, VALUE : Any,

src/main/kotlin/in/rcard/assertj/arrowcore/AbstractRaiseAssert.kt

@@ -16,7 +16,6 @@ import org.assertj.core.internal.StandardComparisonStrategy
  * @param VALUE type of the value returned by the function.
  * @param ERROR type of the logical error raised by the function.
  * @author Riccardo Cardin
- *
  * @since 0.2.0
  */
 abstract class AbstractRaiseAssert<
@@ -26,6 +25,10 @@ abstract class AbstractRaiseAssert<
 
     private val comparisonStrategy: ComparisonStrategy = StandardComparisonStrategy.instance()
 
+    /**
+     * Verifies that the function in the [Raise] context succeeds with the given value.
+     * @param expectedValue the expected value returned by the function.
+     */
     fun succeedsWith(expectedValue: VALUE) {
         fold(
             block = actual,
@@ -38,6 +41,10 @@ abstract class AbstractRaiseAssert<
         )
     }
 
+    /**
+     * Verifies that the function in the [Raise] context fails with the given error.
+     * @param expectedError the expected error raised by the function.
+     */
     fun raises(expectedError: ERROR) {
         fold(
             block = actual,

src/main/kotlin/in/rcard/assertj/arrowcore/EitherAssert.kt

@@ -8,6 +8,7 @@ import arrow.core.Either
  * @param LEFT  type of the value on the left contained in the [Either].
  * @param RIGHT type of the value on the right contained in the [Either].
  * @author Riccardo Cardin
+ * @since 0.0.1
  */
 class EitherAssert<LEFT : Any, RIGHT : Any>(either: Either<LEFT, RIGHT>?) :
     AbstractEitherAssert<EitherAssert<LEFT, RIGHT>, LEFT, RIGHT>(either) {

src/main/kotlin/in/rcard/assertj/arrowcore/OptionAssert.kt

@@ -7,6 +7,7 @@ import arrow.core.Option
  *
  * @param VALUE type of the value contained in the [Option].
  * @author Riccardo Cardin
+ * @since 0.0.1
  */
 class OptionAssert<VALUE : Any>(option: Option<VALUE>?) :
     AbstractOptionAssert<OptionAssert<VALUE>, VALUE>(option) {

src/main/kotlin/in/rcard/assertj/arrowcore/RaiseAssert.kt

@@ -27,6 +27,11 @@ class RaiseAssert<ERROR : Any, VALUE : Any> private constructor(lambda: Raise<ER
         ): RaiseAssert<ERROR, VALUE> =
             RaiseAssert(lambda)
 
+        /**
+         * Verifies that the function in the [Raise] context throws an exception.
+         * @param shouldRaiseThrowable the function to be executed in the [Raise] context.
+         * @return the [AbstractThrowableAssert] to be used to verify the exception.
+         */
         fun <ERROR : Any, VALUE : Any> assertThatThrownBy(
             @BuilderInference shouldRaiseThrowable: Raise<ERROR>.() -> VALUE
         ): AbstractThrowableAssert<*, out Throwable> {

src/main/kotlin/in/rcard/assertj/arrowcore/errors/EitherShouldBeLeft.kt

@@ -7,6 +7,7 @@ import org.assertj.core.error.BasicErrorMessageFactory
  * Build error message when an [Either] should be left.
  *
  * @author Riccardo Cardin
+ * @since 0.0.1
  */
 internal class EitherShouldBeLeft(actual: Either<*, *>) :
     BasicErrorMessageFactory("%nExpecting an Either to be left but was <$actual>.") {

src/main/kotlin/in/rcard/assertj/arrowcore/errors/EitherShouldBeRight.kt

@@ -7,6 +7,7 @@ import org.assertj.core.error.BasicErrorMessageFactory
  * Build error message when an [Either] should be right.
  *
  * @author Riccardo Cardin
+ * @since 0.0.1
  */
 internal class EitherShouldBeRight(actual: Either<*, *>) :
     BasicErrorMessageFactory("%nExpecting an Either to be right but was <$actual>.") {

src/main/kotlin/in/rcard/assertj/arrowcore/errors/EitherShouldContain.kt

@@ -7,6 +7,7 @@ import org.assertj.core.error.BasicErrorMessageFactory
  * Build error message when an [Either] should contain a specific value.
  *
  * @author Riccardo Cardin
+ * @since 0.0.1
  */
 internal class EitherShouldContain(message: String, actual: Either<Any, Any>, expected: Any) :
     BasicErrorMessageFactory(message, actual, expected) {

src/main/kotlin/in/rcard/assertj/arrowcore/errors/EitherShouldContainInstanceOf.kt

@@ -8,6 +8,7 @@ import org.assertj.core.error.BasicErrorMessageFactory
  * class.
  *
  * @author Riccardo Cardin
+ * @since 0.0.1
  */
 internal class EitherShouldContainInstanceOf(message: String) : BasicErrorMessageFactory(message) {
     companion object {