Add subject for CharSequence

src/commonMain/kotlin/com/varabyte/truthish/Truth.kt

@@ -14,6 +14,7 @@ fun assertThat(actual: Long) = LongSubject(actual)
 fun assertThat(actual: Float) = FloatSubject(actual)
 fun assertThat(actual: Double) = DoubleSubject(actual)
 fun assertThat(actual: String) = StringSubject(actual)
+fun assertThat(actual: CharSequence) = CharSequenceSubject(actual)
 fun <T, I: Iterable<T>> assertThat(actual: I) = IterableSubject(actual)
 fun <K, V, T: Map<K, V>> assertThat(actual: T) = MapSubject(actual)
 fun <T, S: Sequence<T>> assertThat(actual: S) = IterableSubject(actual.asIterable())
@@ -83,6 +84,7 @@ class AssertAllScope(summary: String?) {
     fun that(actual: Float) = FloatSubject(actual).withStrategy(deferredStrategy)
     fun that(actual: Double) = DoubleSubject(actual).withStrategy(deferredStrategy)
     fun that(actual: String) = StringSubject(actual).withStrategy(deferredStrategy)
+    fun that(actual: CharSequence) = CharSequenceSubject(actual).withStrategy(deferredStrategy)
     fun <T, I: Iterable<T>> that(actual: I) = IterableSubject(actual).withStrategy(deferredStrategy)
     fun <K, V, T: Map<K, V>> that(actual: T) = MapSubject(actual).withStrategy(deferredStrategy)
     fun <T, S: Sequence<T>> that(actual: S) = IterableSubject(actual.asIterable()).withStrategy(deferredStrategy)
@@ -146,6 +148,7 @@ class SummarizedSubjectBuilder(private val message: String, private val strategy
     fun that(actual: Float) = FloatSubject(actual).withMessage(message).withStrategyOverride()
     fun that(actual: Double) = DoubleSubject(actual).withMessage(message).withStrategyOverride()
     fun that(actual: String) = StringSubject(actual).withMessage(message).withStrategyOverride()
+    fun that(actual: CharSequence) = CharSequenceSubject(actual).withMessage(message).withStrategyOverride()
     fun <T, I: Iterable<T>> that(actual: I) = IterableSubject(actual).withMessage(message).withStrategyOverride()
     fun <K, V, T: Map<K, V>> that(actual: T) = MapSubject(actual).withMessage(message).withStrategyOverride()
     fun <T, S: Sequence<T>> that(actual: S) = IterableSubject(actual.asIterable()).withMessage(message).withStrategyOverride()

src/commonMain/kotlin/com/varabyte/truthish/subjects/StringSubject.kt → src/commonMain/kotlin/com/varabyte/truthish/subjects/TextSubjects.kt

@@ -4,10 +4,10 @@ import com.varabyte.truthish.failure.DetailsFor
 import com.varabyte.truthish.failure.Report
 import com.varabyte.truthish.failure.Summaries
 
-class StringSubject(private val actual: String) : ComparableSubject<String>(actual) {
+class CharSequenceSubject(private val actual: CharSequence) : NotNullSubject<CharSequence>(actual) {
 
     fun isEmpty() {
-        if (!actual.isEmpty()) {
+        if (actual.isNotEmpty()) {
             report(Report(Summaries.EXPECTED_EMPTY, DetailsFor.actual(actual)))
         }
     }
@@ -19,7 +19,7 @@ class StringSubject(private val actual: String) : ComparableSubject<String>(actu
     }
 
     fun isBlank() {
-        if (!actual.isBlank()) {
+        if (actual.isNotBlank()) {
             report(Report(Summaries.EXPECTED_BLANK, DetailsFor.actual(actual)))
         }
     }
@@ -148,4 +148,28 @@ class StringSubject(private val actual: String) : ComparableSubject<String>(actu
     fun doesNotContainMatch(regex: String) {
         doesNotContainMatch(Regex(regex))
     }
-}
+}
+
+class StringSubject(actual: String) : ComparableSubject<String>(actual) {
+    private val delegateSubject = CharSequenceSubject(actual)
+
+    fun isEmpty() { delegateSubject.isEmpty() }
+    fun isNotEmpty() { delegateSubject.isNotEmpty() }
+    fun isBlank() { delegateSubject.isBlank() }
+    fun isNotBlank() { delegateSubject.isNotBlank() }
+    fun hasLength(expectedLength: Int) { delegateSubject.hasLength(expectedLength) }
+    fun startsWith(expected: CharSequence) { delegateSubject.startsWith(expected) }
+    fun doesNotStartWith(expected: CharSequence) { delegateSubject.doesNotStartWith(expected) }
+    fun endsWith(expected: CharSequence) { delegateSubject.endsWith(expected) }
+    fun doesNotEndWith(expected: CharSequence) { delegateSubject.doesNotEndWith(expected) }
+    fun matches(regex: Regex) { delegateSubject.matches(regex) }
+    fun matches(regex: String) { delegateSubject.matches(regex) }
+    fun doesNotMatch(regex: Regex) { delegateSubject.doesNotMatch(regex) }
+    fun doesNotMatch(regex: String) { delegateSubject.doesNotMatch(regex) }
+    fun contains(expected: CharSequence) { delegateSubject.contains(expected) }
+    fun containsMatch(regex: Regex) { delegateSubject.containsMatch(regex) }
+    fun containsMatch(regex: String) { delegateSubject.containsMatch(regex) }
+    fun doesNotContain(expected: CharSequence) { delegateSubject.doesNotContain(expected) }
+    fun doesNotContainMatch(regex: Regex) { delegateSubject.doesNotContainMatch(regex) }
+    fun doesNotContainMatch(regex: String) { delegateSubject.doesNotContainMatch(regex) }
+}