Rename extracting to eachHaving

willowtreeapps · Mar 20, 2024 · b3441bc · b3441bc
1 parent bbc79c1
commit b3441bc
Show file tree

Hide file tree

Showing 6 changed files with 31 additions and 31 deletions.
diff --git a/assertk/src/commonMain/kotlin/assertk/assertions/array.kt b/assertk/src/commonMain/kotlin/assertk/assertions/array.kt
@@ -204,7 +204,7 @@ fun <T> Assert<Array<T>>.each(f: (Assert<T>) -> Unit) = given { actual ->
  *   .containsExactly("Sue", "Bob")
  * ```
  */
-fun <E, R> Assert<Array<E>>.extracting(f1: (E) -> R): Assert<List<R>> = transform { actual ->
+fun <E, R> Assert<Array<E>>.eachHaving(f1: (E) -> R): Assert<List<R>> = transform { actual ->
     actual.map(f1)
 }
 
@@ -217,7 +217,7 @@ fun <E, R> Assert<Array<E>>.extracting(f1: (E) -> R): Assert<List<R>> = transfor
  *   .containsExactly("Sue" to 20, "Bob" to 22)
  * ```
  */
-fun <E, R1, R2> Assert<Array<E>>.extracting(f1: (E) -> R1, f2: (E) -> R2): Assert<List<Pair<R1, R2>>> =
+fun <E, R1, R2> Assert<Array<E>>.eachHaving(f1: (E) -> R1, f2: (E) -> R2): Assert<List<Pair<R1, R2>>> =
     transform { actual ->
         actual.map { f1(it) to f2(it) }
     }
@@ -231,7 +231,7 @@ fun <E, R1, R2> Assert<Array<E>>.extracting(f1: (E) -> R1, f2: (E) -> R2): Asser
  *   .contains(Triple("Sue", 20, "123 Street"), Triple("Bob", 22, "456 Street")
  * ```
  */
-fun <E, R1, R2, R3> Assert<Array<E>>.extracting(
+fun <E, R1, R2, R3> Assert<Array<E>>.eachHaving(
     f1: (E) -> R1,
     f2: (E) -> R2,
     f3: (E) -> R3

diff --git a/assertk/src/commonMain/kotlin/assertk/assertions/iterable.kt b/assertk/src/commonMain/kotlin/assertk/assertions/iterable.kt
@@ -157,7 +157,7 @@ fun <E> Assert<Iterable<E>>.each(f: (Assert<E>) -> Unit) = given { actual ->
  *   .containsOnly("Sue", "Bob")
  * ```
  */
-fun <E, R> Assert<Iterable<E>>.extracting(f1: (E) -> R): Assert<List<R>> = transform { actual ->
+fun <E, R> Assert<Iterable<E>>.eachHaving(f1: (E) -> R): Assert<List<R>> = transform { actual ->
     actual.map(f1)
 }
 
@@ -170,7 +170,7 @@ fun <E, R> Assert<Iterable<E>>.extracting(f1: (E) -> R): Assert<List<R>> = trans
  *   .containsOnly("Sue" to 20, "Bob" to 22)
  * ```
  */
-fun <E, R1, R2> Assert<Iterable<E>>.extracting(f1: (E) -> R1, f2: (E) -> R2): Assert<List<Pair<R1, R2>>> =
+fun <E, R1, R2> Assert<Iterable<E>>.eachHaving(f1: (E) -> R1, f2: (E) -> R2): Assert<List<Pair<R1, R2>>> =
     transform { actual ->
         actual.map { f1(it) to f2(it) }
     }
@@ -184,7 +184,7 @@ fun <E, R1, R2> Assert<Iterable<E>>.extracting(f1: (E) -> R1, f2: (E) -> R2): As
  *   .contains(Triple("Sue", 20, "123 Street"), Triple("Bob", 22, "456 Street")
  * ```
  */
-fun <E, R1, R2, R3> Assert<Iterable<E>>.extracting(
+fun <E, R1, R2, R3> Assert<Iterable<E>>.eachHaving(
     f1: (E) -> R1,
     f2: (E) -> R2,
     f3: (E) -> R3

diff --git a/assertk/src/commonMain/kotlin/assertk/assertions/sequence.kt b/assertk/src/commonMain/kotlin/assertk/assertions/sequence.kt
@@ -178,7 +178,7 @@ fun <E> Assert<Sequence<E>>.each(f: (Assert<E>) -> Unit) = given { actual ->
  *   .containsExactly("Sue", "Bob")
  * ```
  */
-fun <E, R> Assert<Sequence<E>>.extracting(f1: (E) -> R): Assert<Sequence<R>> = transform { actual ->
+fun <E, R> Assert<Sequence<E>>.eachHaving(f1: (E) -> R): Assert<Sequence<R>> = transform { actual ->
     actual.map(f1)
 }
 
@@ -191,7 +191,7 @@ fun <E, R> Assert<Sequence<E>>.extracting(f1: (E) -> R): Assert<Sequence<R>> = t
  *   .containsExactly("Sue" to 20, "Bob" to 22)
  * ```
  */
-fun <E, R1, R2> Assert<Sequence<E>>.extracting(f1: (E) -> R1, f2: (E) -> R2): Assert<Sequence<Pair<R1, R2>>> =
+fun <E, R1, R2> Assert<Sequence<E>>.eachHaving(f1: (E) -> R1, f2: (E) -> R2): Assert<Sequence<Pair<R1, R2>>> =
     transform { actual ->
         actual.map { f1(it) to f2(it) }
     }
@@ -205,7 +205,7 @@ fun <E, R1, R2> Assert<Sequence<E>>.extracting(f1: (E) -> R1, f2: (E) -> R2): As
  *   .contains(Triple("Sue", 20, "123 Street"), Triple("Bob", 22, "456 Street")
  * ```
  */
-fun <E, R1, R2, R3> Assert<Sequence<E>>.extracting(
+fun <E, R1, R2, R3> Assert<Sequence<E>>.eachHaving(
     f1: (E) -> R1,
     f2: (E) -> R2,
     f3: (E) -> R3

diff --git a/assertk/src/commonTest/kotlin/test/assertk/assertions/ArrayTest.kt b/assertk/src/commonTest/kotlin/test/assertk/assertions/ArrayTest.kt
@@ -376,13 +376,13 @@ class ArrayTest {
     //region extracting
     @Test
     fun single_extracting_function_passes() {
-        assertThat(arrayOf("one", "two")).extracting { it.length }.containsExactly(3, 3)
+        assertThat(arrayOf("one", "two")).eachHaving { it.length }.containsExactly(3, 3)
     }
 
     @Test
     fun single_extracting_function_fails() {
         val error = assertFailsWith<AssertionError> {
-            assertThat(arrayOf("one", "two")).extracting { it.length }.containsExactly(2, 2)
+            assertThat(arrayOf("one", "two")).eachHaving { it.length }.containsExactly(2, 2)
         }
         assertEquals(
             """expected to contain exactly:<[2, 2]> but was:<[3, 3]>
@@ -397,15 +397,15 @@ class ArrayTest {
     @Test
     fun pair_extracting_function_passes() {
         assertThat(listOf(Thing("one", 1, '1'), Thing("two", 2, '2')))
-            .extracting(Thing::one, Thing::two)
+            .eachHaving(Thing::one, Thing::two)
             .containsExactly("one" to 1, "two" to 2)
     }
 
     @Test
     fun pair_extracting_function_fails() {
         val error = assertFailsWith<AssertionError> {
             assertThat(arrayOf(Thing("one", 1, '1'), Thing("two", 2, '2')))
-                .extracting(Thing::one, Thing::two)
+                .eachHaving(Thing::one, Thing::two)
                 .containsExactly("one" to 2, "two" to 1)
         }
         assertEquals(
@@ -422,15 +422,15 @@ class ArrayTest {
     @Test
     fun triple_extracting_function_passes() {
         assertThat(arrayOf(Thing("one", 1, '1'), Thing("two", 2, '2')))
-            .extracting(Thing::one, Thing::two, Thing::three)
+            .eachHaving(Thing::one, Thing::two, Thing::three)
             .containsExactly(Triple("one", 1, '1'), Triple("two", 2, '2'))
     }
 
     @Test
     fun triple_extracting_function_fails() {
         val error = assertFailsWith<AssertionError> {
             assertThat(arrayOf(Thing("one", 1, '1'), Thing("two", 2, '2')))
-                .extracting(Thing::one, Thing::two, Thing::three)
+                .eachHaving(Thing::one, Thing::two, Thing::three)
                 .containsExactly(Triple("one", 1, '2'), Triple("two", 2, '3'))
         }
         assertEquals(

diff --git a/assertk/src/commonTest/kotlin/test/assertk/assertions/IterableTest.kt b/assertk/src/commonTest/kotlin/test/assertk/assertions/IterableTest.kt
@@ -14,7 +14,7 @@ import assertk.assertions.containsOnly
 import assertk.assertions.doesNotContain
 import assertk.assertions.each
 import assertk.assertions.exactly
-import assertk.assertions.extracting
+import assertk.assertions.eachHaving
 import assertk.assertions.first
 import assertk.assertions.isEmpty
 import assertk.assertions.isEqualTo
@@ -506,13 +506,13 @@ class IterableTest {
     //region extracting
     @Test
     fun single_extracting_function_passes() {
-        assertThat(iterableOf("one", "two")).extracting { it.length }.containsExactly(3, 3)
+        assertThat(iterableOf("one", "two")).eachHaving { it.length }.containsExactly(3, 3)
     }
 
     @Test
     fun single_extracting_function_fails() {
         val error = assertFailsWith<AssertionError> {
-            assertThat(iterableOf("one", "two")).extracting { it.length }.containsExactly(2, 2)
+            assertThat(iterableOf("one", "two")).eachHaving { it.length }.containsExactly(2, 2)
         }
         assertEquals(
             """expected to contain exactly:<[2, 2]> but was:<[3, 3]>
@@ -526,15 +526,15 @@ class IterableTest {
     @Test
     fun pair_extracting_function_passes() {
         assertThat(iterableOf(Thing("one", 1, '1'), Thing("two", 2, '2')))
-            .extracting(Thing::one, Thing::two)
+            .eachHaving(Thing::one, Thing::two)
             .containsExactly("one" to 1, "two" to 2)
     }
 
     @Test
     fun pair_extracting_function_fails() {
         val error = assertFailsWith<AssertionError> {
             assertThat(iterableOf(Thing("one", 1, '1'), Thing("two", 2, '2')))
-                .extracting(Thing::one, Thing::two)
+                .eachHaving(Thing::one, Thing::two)
                 .containsExactly("one" to 2, "two" to 1)
         }
         assertEquals(
@@ -550,15 +550,15 @@ class IterableTest {
     @Test
     fun triple_extracting_function_passes() {
         assertThat(iterableOf(Thing("one", 1, '1'), Thing("two", 2, '2')))
-            .extracting(Thing::one, Thing::two, Thing::three)
+            .eachHaving(Thing::one, Thing::two, Thing::three)
             .containsExactly(Triple("one", 1, '1'), Triple("two", 2, '2'))
     }
 
     @Test
     fun triple_extracting_function_fails() {
         val error = assertFailsWith<AssertionError> {
             assertThat(iterableOf(Thing("one", 1, '1'), Thing("two", 2, '2')))
-                .extracting(Thing::one, Thing::two, Thing::three)
+                .eachHaving(Thing::one, Thing::two, Thing::three)
                 .containsExactly(Triple("one", 1, '2'), Triple("two", 2, '3'))
         }
         assertEquals(
@@ -630,4 +630,4 @@ class IterableTest {
 }
 
 private fun <T> emptyIterable(): Iterable<T> = emptyList()
-private fun <T> iterableOf(vararg elements: T): Iterable<T> = elements.toList()
+private fun <T> iterableOf(vararg elements: T): Iterable<T> = elements.toList()
diff --git a/assertk/src/commonTest/kotlin/test/assertk/assertions/SequenceTest.kt b/assertk/src/commonTest/kotlin/test/assertk/assertions/SequenceTest.kt
@@ -14,7 +14,7 @@ import assertk.assertions.containsOnly
 import assertk.assertions.doesNotContain
 import assertk.assertions.each
 import assertk.assertions.exactly
-import assertk.assertions.extracting
+import assertk.assertions.eachHaving
 import assertk.assertions.isEmpty
 import assertk.assertions.isEqualTo
 import assertk.assertions.isGreaterThan
@@ -588,14 +588,14 @@ class SequenceTest {
     //region extracting
     @Test
     fun single_extracting_function_passes() {
-        assertThat(sequenceOf("one", "two")).extracting { it.length }
+        assertThat(sequenceOf("one", "two")).eachHaving { it.length }
             .containsOnly(3, 3)
     }
 
     @Test
     fun single_extracting_function_fails() {
         val error = assertFailsWith<AssertionError> {
-            assertThat(sequenceOf("one", "two")).extracting { it.length }.containsExactly(2, 2)
+            assertThat(sequenceOf("one", "two")).eachHaving { it.length }.containsExactly(2, 2)
         }
         assertEquals(
             """expected to contain exactly:<[2, 2]> but was:<[3, 3]>
@@ -609,15 +609,15 @@ class SequenceTest {
     @Test
     fun pair_extracting_function_passes() {
         assertThat(sequenceOf(Thing("one", 1, '1'), Thing("two", 2, '2')))
-            .extracting(Thing::one, Thing::two)
+            .eachHaving(Thing::one, Thing::two)
             .containsExactly("one" to 1, "two" to 2)
     }
 
     @Test
     fun pair_extracting_function_fails() {
         val error = assertFailsWith<AssertionError> {
             assertThat(sequenceOf(Thing("one", 1, '1'), Thing("two", 2, '2')))
-                .extracting(Thing::one, Thing::two)
+                .eachHaving(Thing::one, Thing::two)
                 .containsExactly("one" to 2, "two" to 1)
         }
         assertEquals(
@@ -633,15 +633,15 @@ class SequenceTest {
     @Test
     fun triple_extracting_function_passes() {
         assertThat(sequenceOf(Thing("one", 1, '1'), Thing("two", 2, '2')))
-            .extracting(Thing::one, Thing::two, Thing::three)
+            .eachHaving(Thing::one, Thing::two, Thing::three)
             .containsExactly(Triple("one", 1, '1'), Triple("two", 2, '2'))
     }
 
     @Test
     fun triple_extracting_function_fails() {
         val error = assertFailsWith<AssertionError> {
             assertThat(sequenceOf(Thing("one", 1, '1'), Thing("two", 2, '2')))
-                .extracting(Thing::one, Thing::two, Thing::three)
+                .eachHaving(Thing::one, Thing::two, Thing::three)
                 .containsExactly(Triple("one", 1, '2'), Triple("two", 2, '3'))
         }
         assertEquals(
@@ -661,4 +661,4 @@ class SequenceTest {
 private fun <T> oneshotSequenceOf(vararg elements: T): Sequence<T> {
     var i = 0
     return generateSequence { elements.getOrNull(i++) }
-}
+}