implement better inheritance

Author: memoizr

src/main/kotlin/com/memozr/assertk/AbstractAssertBuilder.kt

@@ -10,47 +10,51 @@ enum class ObjectStuff {
 
 inline fun <reified R : Any> of() = AbstractAssertBuilder.InstanceMatcher<R>()
 
-open class AbstractAssertBuilder<T : Any>(other: T?) {
+abstract class AbstractAssertBuilder<S : AbstractAssertBuilder<S, A>, A : Any> internal constructor(actual: A?, selfType: Class<*>) {
     class InstanceMatcher<R>
 
-    open protected val assertion: AbstractAssert<*, out T?> = Assertions.assertThat(other)
+    @Suppress("UNCHECKED_CAST", "LeakingThis")
+    protected val myself: S = selfType.cast(this) as S
 
-    infix fun isEqualTo(other: T): AbstractAssertBuilder<T> {
+    open protected val assertion: AbstractAssert<*, out A?> = Assertions.assertThat(actual)
+
+    infix fun isEqualTo(other: A): S {
         assertion.isEqualTo(other)
-        return this
+        return myself
     }
 
-    infix fun isNotEqualTo(other: T): AbstractAssertBuilder<T> {
+    infix fun isNotEqualTo(other: A): S {
         assertion.isNotEqualTo(other)
-        return this
+        return myself
     }
 
     @Suppress("UNUSED_PARAMETER")
-    inline infix fun <reified R: Any> isInstance(bar: InstanceMatcher<R>) : AbstractAssertBuilder<T> {
+    inline infix fun <reified R : Any> isInstance(bar: InstanceMatcher<R>): S {
         assertion.isInstanceOf(R::class.java)
-        return this
+        return myself
     }
 
-    infix fun _is(objectStuff: ObjectStuff?): AbstractAssertBuilder<T> {
+    infix fun _is(objectStuff: ObjectStuff?): S {
         return when (objectStuff) {
             notNull -> {
                 assertion.isNotNull()
-                this
+                myself
             }
             else -> {
                 assertion.isNull()
-                this
+                myself
             }
         }
     }
 
-    infix fun  describedAs(description: String): AbstractAssertBuilder<T> {
+    infix fun describedAs(description: String): S {
         assertion.`as`(description)
-        return this
+        return myself
     }
 
-    infix fun isSuchThat(assertionBlock: AbstractAssertBuilder<T>.(AbstractAssertBuilder<T>) -> Unit): AbstractAssertBuilder<T> {
-        assertionBlock(this)
-        return this
+    @Suppress("UNCHECKED_CAST")
+    infix fun isSuchThat(assertionBlock: S.(S) -> Unit): S {
+        (this as S).assertionBlock(this)
+        return myself
     }
-}
+}

src/main/kotlin/com/memozr/assertk/CharSequenceAssert.kt

@@ -11,8 +11,8 @@ enum class CharSequenceAssertTest {
 
 class CharSequenceAssert internal constructor(
         private val subject: String?,
-        override protected val assertion: AbstractCharSequenceAssert<*, String> = assertThat(subject))
-: AbstractAssertBuilder<String>(subject) {
+        override val assertion: AbstractCharSequenceAssert<*, String> = assertThat(subject))
+: AbstractAssertBuilder<CharSequenceAssert, String>(subject, CharSequenceAssert::class.java) {
 
     object onlyDigits
 

src/main/kotlin/com/memozr/assertk/General.kt

@@ -4,7 +4,7 @@ val assert: AssertionHook get() = RealAssertionHook()
 val expect: AssertionHook get() = RealAssertionHook()
 
 interface AssertionHook {
-    infix fun <T : Any> that(subjectUnderTest: T?) = AbstractAssertBuilder(subjectUnderTest)
+    infix fun <T : Any> that(subjectUnderTest: T?) = ObjectAssert(subjectUnderTest)
     infix fun that(subjectUnderTest: String?) = CharSequenceAssert(subjectUnderTest)
     infix fun thatThrownBy(expressionUnderTest: () -> Unit) = ThrowableAssertionBuilder(expressionUnderTest)
 }

src/main/kotlin/com/memozr/assertk/ObjectAssert.kt

@@ -0,0 +1,3 @@
+package com.memozr.assertk
+
+class ObjectAssert<A : Any>(actual: A?) : AbstractAssertBuilder<ObjectAssert<A>, A>(actual, ObjectAssert::class.java)

src/test/kotlin/com/memozr/assertk/Char sequence assert test.kt

@@ -193,4 +193,12 @@ class `Char sequence assert test` {
         _expect that "foo bar" containsPattern pattern canBe chained
         verify(mockAssertion).containsPattern(pattern)
     }
+
+    @Test
+    fun `Block syntax is supported`() {
+        _expect that "foo" isSuchThat {
+            it contains "foo"
+            it isSubstringOf "fooBar"
+        }
+    }
 }