create interface groups for descriptive

core/api/atrium-core-api-common/src/main/kotlin/ch/tutteli/atrium/assertions/builders/AssertionBuilder.kt

@@ -56,7 +56,7 @@ interface AssertionBuilder {
      * [DescriptiveAssertion.description] (such as `is less than`) and a [DescriptiveAssertion.representation]
      * (which most of time corresponds to the expected value).
      */
-    val descriptive: DescriptiveAssertionHoldsOption
+    val descriptive: Descriptive.HoldsOption
 
     /**
      * Builder to create an [ExplanatoryAssertion] -- use it to explain something which is typically formatted by an

core/api/atrium-core-api-common/src/main/kotlin/ch/tutteli/atrium/assertions/builders/descriptive.kt

@@ -3,86 +3,99 @@ package ch.tutteli.atrium.assertions.builders
 import ch.tutteli.atrium.assertions.Assertion
 import ch.tutteli.atrium.assertions.AssertionGroup
 import ch.tutteli.atrium.assertions.DescriptiveAssertion
-import ch.tutteli.atrium.assertions.builders.impl.DescriptiveAssertionFinalStepImpl
-import ch.tutteli.atrium.assertions.builders.impl.DescriptiveLikeAssertionDescriptionOptionImpl
+import ch.tutteli.atrium.assertions.builders.impl.descriptive.DescriptionOptionImpl
+import ch.tutteli.atrium.assertions.builders.impl.descriptive.FinalStepImpl
+import ch.tutteli.atrium.assertions.builders.impl.descriptive.HoldsOptionImpl
 import ch.tutteli.atrium.reporting.RawString
 import ch.tutteli.atrium.reporting.translating.Translatable
 
 /**
- * Option step which allows to specify [DescriptiveAssertion.holds].
+ * Defines the contract to build a [DescriptiveAssertion].
  */
-interface DescriptiveAssertionHoldsOption {
+interface Descriptive {
 
     /**
-     * Defines a constant failing assertion.
+     * Option step which allows to specify [DescriptiveAssertion.holds].
      */
-    val failing: DescriptiveLikeAssertionDescriptionOption<DescriptiveAssertionFinalStep>
-    /**
-     * Defines a constant holding assertion.
-     */
-    val holding: DescriptiveLikeAssertionDescriptionOption<DescriptiveAssertionFinalStep>
+    interface HoldsOption {
+        /**
+         * Defines a constant failing assertion.
+         */
+        val failing: DescriptionOption<FinalStep>
+
+        /**
+         * Defines a constant holding assertion.
+         */
+        val holding: DescriptionOption<FinalStep>
+
+        /**
+         * Uses the given [test] as [DescriptiveAssertion.holds].
+         */
+        fun withTest(test: () -> Boolean): DescriptionOption<FinalStep>
+
+        companion object {
+            fun create(): HoldsOption = HoldsOptionImpl
+        }
+    }
 
     /**
-     * Uses the given [test] as [DescriptiveAssertion.holds].
+     * Option step which allows to specify the description of a descriptive like assertion (such as [DescriptiveAssertion]).
      */
-    fun withTest(test: () -> Boolean): DescriptiveLikeAssertionDescriptionOption<DescriptiveAssertionFinalStep>
-}
+    interface DescriptionOption<R> {
+        /**
+         * The previously defined test which is used to determine [Assertion.holds].
+         */
+        val test: () -> Boolean
+
+        /**
+         * Uses the given [description] as [DescriptiveAssertion.description] and [representation]
+         * as [DescriptiveAssertion.representation] unless [representation] is null in which case [RawString.NULL] is used.
+         */
+        fun withDescriptionAndNullableRepresentation(description: Translatable, representation: Any?): R
+            = withDescriptionAndRepresentation(description, representation ?: RawString.NULL)
+
+        /**
+         * Uses the given [description] as [AssertionGroup.description] and [representation] as [AssertionGroup.representation].
+         */
+        fun withDescriptionAndRepresentation(description: Translatable, representation: Any): R
+
+        companion object {
+            fun <R> create(
+                test: () -> Boolean,
+                factory: (() -> Boolean, Translatable, Any) -> R
+            ): DescriptionOption<R> = DescriptionOptionImpl(test, factory)
+        }
+    }
 
-/**
- * Option step which allows to specify the description of a descriptive like assertion (such as [DescriptiveAssertion]).
- */
-interface DescriptiveLikeAssertionDescriptionOption<R> {
-    /**
-     * The previously defined test which is used to determine [Assertion.holds].
-     */
-    val test: () -> Boolean
 
     /**
-     * Uses the given [description] as [DescriptiveAssertion.description] and [representation]
-     * as [DescriptiveAssertion.representation] unless [representation] is null in which case [RawString.NULL] is used.
+     * Final step which creates a [DescriptiveAssertion] based on the previously defined [test], [description]
+     * and [representation].
      */
-    fun withDescriptionAndNullableRepresentation(description: Translatable, representation: Any?): R
-        = withDescriptionAndRepresentation(description, representation ?: RawString.NULL)
+    interface FinalStep : AssertionBuilderFinalStep<DescriptiveAssertion> {
+        /**
+         * The previously defined test which is used to determine [DescriptiveAssertion.holds].
+         */
+        val test: () -> Boolean
 
-    /**
-     * Uses the given [description] as [AssertionGroup.description] and [representation] as [AssertionGroup.representation].
-     */
-    fun withDescriptionAndRepresentation(description: Translatable, representation: Any): R
+        /**
+         * The previously defined [DescriptiveAssertion.description].
+         */
+        val description: Translatable
 
-    companion object {
-        fun <R> create(
-            test: () -> Boolean,
-            factory: (() -> Boolean, Translatable, Any) -> R
-        ): DescriptiveLikeAssertionDescriptionOption<R> = DescriptiveLikeAssertionDescriptionOptionImpl(test, factory)
+        /**
+         * The previously defined [DescriptiveAssertion.representation].
+         */
+        val representation: Any
+
+        companion object {
+            fun create(
+                test: () -> Boolean,
+                description: Translatable,
+                representation: Any
+            ): FinalStep = FinalStepImpl(test, description, representation)
+        }
     }
 }
 
-/**
- * Final step which creates a [DescriptiveAssertion] based on the previously defined [test], [description]
- * and [representation].
- */
-interface DescriptiveAssertionFinalStep : AssertionBuilderFinalStep<DescriptiveAssertion> {
-    /**
-     * The previously defined test which is used to determine [DescriptiveAssertion.holds].
-     */
-    val test: () -> Boolean
-
-    /**
-     * The previously defined [DescriptiveAssertion.description].
-     */
-    val description: Translatable
-
-    /**
-     * The previously defined [DescriptiveAssertion.representation].
-     */
-    val representation: Any
-
-    companion object {
-        fun create(
-            test: () -> Boolean,
-            description: Translatable,
-            representation: Any
-        ): DescriptiveAssertionFinalStep = DescriptiveAssertionFinalStepImpl(test, description, representation)
-    }
-}
 

core/api/atrium-core-api-common/src/main/kotlin/ch/tutteli/atrium/assertions/builders/impl/AssertionBuilderImpl.kt

@@ -17,8 +17,8 @@ internal object AssertionBuilderImpl : AssertionBuilder {
     override val explanatoryGroup: ExplanatoryAssertionGroupTypeOption
         = ExplanatoryAssertionGroupTypeOptionImpl
 
-    override val descriptive: DescriptiveAssertionHoldsOption
-        = DescriptiveAssertionHoldsOptionImpl
+    override val descriptive: Descriptive.HoldsOption
+        = Descriptive.HoldsOption.create()
 
     override val explanatory: ExplanatoryAssertionExplanationOption
         = ExplanatoryAssertionExplanationOptionImpl

core/api/atrium-core-api-common/src/main/kotlin/ch/tutteli/atrium/assertions/builders/impl/DescriptiveAssertionHoldsOptionImpl.kt

@@ -1,21 +0,0 @@
-package ch.tutteli.atrium.assertions.builders.impl
-
-import ch.tutteli.atrium.assertions.builders.DescriptiveAssertionFinalStep
-import ch.tutteli.atrium.assertions.builders.DescriptiveAssertionHoldsOption
-import ch.tutteli.atrium.assertions.builders.DescriptiveLikeAssertionDescriptionOption
-import ch.tutteli.atrium.core.falseProvider
-import ch.tutteli.atrium.core.trueProvider
-
-internal object DescriptiveAssertionHoldsOptionImpl : DescriptiveAssertionHoldsOption {
-
-    override val failing: DescriptiveLikeAssertionDescriptionOption<DescriptiveAssertionFinalStep>
-        //TODO use falseProvider https://youtrack.jetbrains.com/issue/KT-27736
-        = DescriptiveLikeAssertionDescriptionOption.create({ false }, DescriptiveAssertionFinalStep.Companion::create)
-
-    override val holding: DescriptiveLikeAssertionDescriptionOption<DescriptiveAssertionFinalStep>
-        //TODO use trueProvider https://youtrack.jetbrains.com/issue/KT-27736
-        = DescriptiveLikeAssertionDescriptionOption.create({ true }, DescriptiveAssertionFinalStep.Companion::create)
-
-    override fun withTest(test: () -> Boolean): DescriptiveLikeAssertionDescriptionOption<DescriptiveAssertionFinalStep>
-        = DescriptiveLikeAssertionDescriptionOption.create(test, DescriptiveAssertionFinalStep.Companion::create)
-}

core/api/atrium-core-api-common/src/main/kotlin/ch/tutteli/atrium/assertions/builders/impl/descriptive/DescriptionOptionImpl.kt

@@ -1,12 +1,12 @@
-package ch.tutteli.atrium.assertions.builders.impl
+package ch.tutteli.atrium.assertions.builders.impl.descriptive
 
-import ch.tutteli.atrium.assertions.builders.DescriptiveLikeAssertionDescriptionOption
+import ch.tutteli.atrium.assertions.builders.Descriptive
 import ch.tutteli.atrium.reporting.translating.Translatable
 
-internal class DescriptiveLikeAssertionDescriptionOptionImpl<R>(
+internal class DescriptionOptionImpl<R>(
     override val test: () -> Boolean,
     private val factory: (()-> Boolean, Translatable, Any) -> R
-) : DescriptiveLikeAssertionDescriptionOption<R> {
+) : Descriptive.DescriptionOption<R> {
 
     override fun withDescriptionAndRepresentation(description: Translatable, representation: Any): R
         = factory(test, description, representation)

core/api/atrium-core-api-common/src/main/kotlin/ch/tutteli/atrium/assertions/builders/impl/descriptive/FinalStepImpl.kt

@@ -1,17 +1,16 @@
 @file:Suppress("DEPRECATION" /* TODO remove with 1.0.0 */)
-
-package ch.tutteli.atrium.assertions.builders.impl
+package ch.tutteli.atrium.assertions.builders.impl.descriptive
 
 import ch.tutteli.atrium.assertions.BasicDescriptiveAssertion
 import ch.tutteli.atrium.assertions.DescriptiveAssertion
-import ch.tutteli.atrium.assertions.builders.DescriptiveAssertionFinalStep
+import ch.tutteli.atrium.assertions.builders.Descriptive
 import ch.tutteli.atrium.reporting.translating.Translatable
 
-internal class DescriptiveAssertionFinalStepImpl(
+internal class FinalStepImpl(
     override val test: () -> Boolean,
     override val description: Translatable,
     override val representation: Any
-) : DescriptiveAssertionFinalStep {
+) : Descriptive.FinalStep {
 
     override fun build(): DescriptiveAssertion = BasicDescriptiveAssertion(description, representation, test)
 }

core/api/atrium-core-api-common/src/main/kotlin/ch/tutteli/atrium/assertions/builders/impl/descriptive/HoldsOptionImpl.kt

@@ -0,0 +1,17 @@
+package ch.tutteli.atrium.assertions.builders.impl.descriptive
+
+import ch.tutteli.atrium.assertions.builders.Descriptive
+
+internal object HoldsOptionImpl : Descriptive.HoldsOption {
+
+    override val failing: Descriptive.DescriptionOption<Descriptive.FinalStep>
+        //TODO use falseProvider https://youtrack.jetbrains.com/issue/KT-27736
+        = withTest { false }
+
+    override val holding: Descriptive.DescriptionOption<Descriptive.FinalStep>
+        //TODO use trueProvider https://youtrack.jetbrains.com/issue/KT-27736
+        = withTest { true }
+
+    override fun withTest(test: () -> Boolean): Descriptive.DescriptionOption<Descriptive.FinalStep>
+        = Descriptive.DescriptionOption.create(test, Descriptive.FinalStep.Companion::create)
+}

domain/builders/atrium-domain-builders-common/src/main/kotlin/ch/tutteli/atrium/domain/builders/assertions/builders/descriptiveWithFailureHint.kt

@@ -4,24 +4,23 @@ import ch.tutteli.atrium.assertions.Assertion
 import ch.tutteli.atrium.assertions.AssertionGroup
 import ch.tutteli.atrium.assertions.DescriptiveAssertion
 import ch.tutteli.atrium.assertions.builders.AssertionBuilderFinalStep
-import ch.tutteli.atrium.assertions.builders.DescriptiveAssertionFinalStep
-import ch.tutteli.atrium.assertions.builders.DescriptiveLikeAssertionDescriptionOption
+import ch.tutteli.atrium.assertions.builders.Descriptive
 import ch.tutteli.atrium.domain.builders.assertions.builders.impl.descriptiveWithFailureHint.FinalStepImpl
 import ch.tutteli.atrium.domain.builders.assertions.builders.impl.descriptiveWithFailureHint.ShowOptionImpl
 import ch.tutteli.atrium.reporting.translating.Translatable
 
 /**
  * Option to create a [DescriptiveAssertion] like assertion with an additional hint which might be shown if the
- * [DescriptiveLikeAssertionDescriptionOption.test] fails.
+ * [Descriptive.DescriptionOption.test] fails.
  */
-fun DescriptiveLikeAssertionDescriptionOption<DescriptiveAssertionFinalStep>.withFailureHint(
+fun Descriptive.DescriptionOption<Descriptive.FinalStep>.withFailureHint(
     failureHintFactory: () -> Assertion
 ): DescriptiveAssertionWithFailureHint.ShowOption
     = DescriptiveAssertionWithFailureHint.ShowOption.create(test, failureHintFactory)
 
 /**
  * Defines the contract to build a [DescriptiveAssertion] like assertion with an additional hint
- * which might be shown if the [DescriptiveLikeAssertionDescriptionOption.test] fails.
+ * which might be shown if the [Descriptive.DescriptionOption.test] fails.
  */
 interface DescriptiveAssertionWithFailureHint{
     /**
@@ -31,12 +30,12 @@ interface DescriptiveAssertionWithFailureHint{
         /**
          * Defines that the failure hint shall be shown in any case.
          */
-        val showForAnyFailure: DescriptiveLikeAssertionDescriptionOption<FinalStep>
+        val showForAnyFailure: Descriptive.DescriptionOption<FinalStep>
 
         /**
          * Defines that the failure hint shall only be shown if the given [predicate] holds.
          */
-        fun showOnlyIf(predicate: () -> Boolean): DescriptiveLikeAssertionDescriptionOption<FinalStep>
+        fun showOnlyIf(predicate: () -> Boolean): Descriptive.DescriptionOption<FinalStep>
 
         companion object {
             fun create(

domain/builders/atrium-domain-builders-common/src/main/kotlin/ch/tutteli/atrium/domain/builders/assertions/builders/impl/descriptiveWithFailureHint/ShowOptionImpl.kt

@@ -1,7 +1,7 @@
 package ch.tutteli.atrium.domain.builders.assertions.builders.impl.descriptiveWithFailureHint
 
 import ch.tutteli.atrium.assertions.Assertion
-import ch.tutteli.atrium.assertions.builders.DescriptiveLikeAssertionDescriptionOption
+import ch.tutteli.atrium.assertions.builders.Descriptive
 import ch.tutteli.atrium.core.trueProvider
 import ch.tutteli.atrium.domain.builders.assertions.builders.DescriptiveAssertionWithFailureHint
 
@@ -10,18 +10,18 @@ internal class ShowOptionImpl(
     private val failureHintFactory: () -> Assertion
 ): DescriptiveAssertionWithFailureHint.ShowOption {
 
-   override val showForAnyFailure get(): DescriptiveLikeAssertionDescriptionOption<DescriptiveAssertionWithFailureHint.FinalStep>
+   override val showForAnyFailure get(): Descriptive.DescriptionOption<DescriptiveAssertionWithFailureHint.FinalStep>
         = createDescriptiveLikeAssertionDescriptionOption(trueProvider)
 
     override fun showOnlyIf(
         predicate: () -> Boolean
-    ): DescriptiveLikeAssertionDescriptionOption<DescriptiveAssertionWithFailureHint.FinalStep>
+    ): Descriptive.DescriptionOption<DescriptiveAssertionWithFailureHint.FinalStep>
         = createDescriptiveLikeAssertionDescriptionOption(predicate)
 
     private fun createDescriptiveLikeAssertionDescriptionOption(
         predicate: () -> Boolean
-    ): DescriptiveLikeAssertionDescriptionOption<DescriptiveAssertionWithFailureHint.FinalStep>
-        = DescriptiveLikeAssertionDescriptionOption.create(
+    ): Descriptive.DescriptionOption<DescriptiveAssertionWithFailureHint.FinalStep>
+        = Descriptive.DescriptionOption.create(
             test,
             { t, d, r -> DescriptiveAssertionWithFailureHint.FinalStep.create(t, predicate, failureHintFactory, d, r) }
         )