Move ParameterDelegate to ParameterizeScope.ParameterDelegate

The `ParameterDelegate` class is only used for the `parameterize` DSL, so nesting it in `ParameterizeScope` better indicates its purpose, and removes a likely common class name from the global namespace. Originally kept in a separate file since it was filled with complicated logic, so kept the old logic in place renaming it to `ParameterState`, and have the new `ParameterDelegate` be composed of it.
BenWoodworth · Nov 5, 2023 · 4875ae5 · 4875ae5
1 parent d8f47c0
commit 4875ae5
Show file tree

Hide file tree

Showing 7 changed files with 67 additions and 39 deletions.
diff --git a/api/parameterize.api b/api/parameterize.api
@@ -1,4 +1,4 @@
-public final class com/benwoodworth/parameterize/ParameterDelegate {
+public final class com/benwoodworth/parameterize/ParameterState {
 	public fun toString ()Ljava/lang/String;
 }
 
@@ -76,9 +76,9 @@ public final class com/benwoodworth/parameterize/ParameterizeKt {
 }
 
 public final class com/benwoodworth/parameterize/ParameterizeScope {
-	public final fun getValue (Lcom/benwoodworth/parameterize/ParameterDelegate;Ljava/lang/Object;Lkotlin/reflect/KProperty;)Ljava/lang/Object;
+	public final fun getValue (Lcom/benwoodworth/parameterize/ParameterizeScope$ParameterDelegate;Ljava/lang/Object;Lkotlin/reflect/KProperty;)Ljava/lang/Object;
 	public final fun parameter-xl7Lxic (Ljava/lang/Iterable;)Ljava/lang/Iterable;
-	public final fun provideDelegate-13mUnGw (Ljava/lang/Iterable;Ljava/lang/Object;Lkotlin/reflect/KProperty;)Lcom/benwoodworth/parameterize/ParameterDelegate;
+	public final fun provideDelegate-13mUnGw (Ljava/lang/Iterable;Ljava/lang/Object;Lkotlin/reflect/KProperty;)Lcom/benwoodworth/parameterize/ParameterizeScope$ParameterDelegate;
 	public fun toString ()Ljava/lang/String;
 }
 
@@ -94,3 +94,6 @@ public final class com/benwoodworth/parameterize/ParameterizeScope$Parameter {
 	public final synthetic fun unbox-impl ()Ljava/lang/Iterable;
 }
 
+public final class com/benwoodworth/parameterize/ParameterizeScope$ParameterDelegate {
+}
+
diff --git a/src/commonMain/kotlin/ParameterDelegate.kt → src/commonMain/kotlin/ParameterState.kt b/src/commonMain/kotlin/ParameterDelegate.kt → src/commonMain/kotlin/ParameterState.kt
@@ -32,8 +32,7 @@ import kotlin.reflect.KProperty
  *   through the current iterator.
  */
 
-/** @suppress */
-public class ParameterDelegate<@Suppress("unused") out T> internal constructor() {
+internal class ParameterState<@Suppress("unused") out T> internal constructor() {
     /*
      * The internal state does not use the generic type, so T is purely for
      * syntax, helping Kotlin infer a property type from the parameter through

diff --git a/src/commonMain/kotlin/Parameterize.kt b/src/commonMain/kotlin/Parameterize.kt
@@ -179,6 +179,14 @@ public class ParameterizeScope internal constructor(
     public value class Parameter<out T> internal constructor(
         internal val arguments: Iterable<T>
     )
+
+    /** @suppress */
+    public class ParameterDelegate<out T> internal constructor(
+        internal val parameterState: ParameterState<T>
+    ) {
+        override fun toString(): String =
+            parameterState.toString()
+    }
 }
 
 /**

diff --git a/src/commonMain/kotlin/ParameterizeState.kt b/src/commonMain/kotlin/ParameterizeState.kt
@@ -2,6 +2,7 @@ package com.benwoodworth.parameterize
 
 import com.benwoodworth.parameterize.ParameterizeConfiguration.OnCompleteScope
 import com.benwoodworth.parameterize.ParameterizeConfiguration.OnFailureScope
+import com.benwoodworth.parameterize.ParameterizeScope.ParameterDelegate
 import kotlin.contracts.InvocationKind
 import kotlin.contracts.contract
 import kotlin.reflect.KProperty
@@ -49,11 +50,11 @@ internal class ParameterizeState {
         val parameter = if (parameterIndex in parameters.indices) {
             parameters[parameterIndex]
         } else {
-            ParameterDelegate<Nothing>()
+            ParameterDelegate<Nothing>(ParameterState())
                 .also { parameters += it }
         }
 
-        parameter.declare(property, arguments)
+        parameter.parameterState.declare(property, arguments)
 
         return parameter
     }
@@ -70,11 +71,11 @@ internal class ParameterizeState {
     }
 
     fun <T> getParameterArgument(parameter: ParameterDelegate<*>, property: KProperty<T>): T {
-        val isFirstUse = !parameter.hasBeenUsed
+        val isFirstUse = !parameter.parameterState.hasBeenUsed
 
         return property
             .trackNestedUsage {
-                parameter.getArgument(property)
+                parameter.parameterState.getArgument(property)
             }
             .also {
                 if (isFirstUse) trackUsedParameter(parameter)
@@ -84,7 +85,7 @@ internal class ParameterizeState {
     private fun trackUsedParameter(parameter: ParameterDelegate<*>) {
         parametersUsed += parameter
 
-        if (!parameter.isLastArgument) {
+        if (!parameter.parameterState.isLastArgument) {
             parameterCountAfterAllUsed = parameterCount
         }
     }
@@ -106,21 +107,21 @@ internal class ParameterizeState {
         while (usedParameterIterator.hasPrevious()) {
             val parameter = usedParameterIterator.previous()
 
-            if (!parameter.isLastArgument) {
-                parameter.nextArgument()
+            if (!parameter.parameterState.isLastArgument) {
+                parameter.parameterState.nextArgument()
                 iterated = true
                 break
             }
 
             usedParameterIterator.remove()
-            parameter.reset()
+            parameter.parameterState.reset()
         }
 
         for (i in parameterCountAfterAllUsed..<parameterCount) {
             val parameter = parameters[i]
 
-            if (!parameter.hasBeenUsed) {
-                parameter.reset()
+            if (!parameter.parameterState.hasBeenUsed) {
+                parameter.parameterState.reset()
             }
         }
 
@@ -135,8 +136,8 @@ internal class ParameterizeState {
      */
     fun getFailureArguments(): List<ParameterizeFailure.Argument<*>> =
         parameters.take(parameterCount)
-            .filter { it.hasBeenUsed }
-            .mapNotNull { it.getFailureArgumentOrNull() }
+            .filter { it.parameterState.hasBeenUsed }
+            .mapNotNull { it.parameterState.getFailureArgumentOrNull() }
 
     fun handleFailure(onFailure: OnFailureScope.(Throwable) -> Unit, failure: Throwable) {
         failureCount++

diff --git a/...ommonTest/kotlin/ParameterDelegateSpec.kt → src/commonTest/kotlin/ParameterStateSpec.kt b/...ommonTest/kotlin/ParameterDelegateSpec.kt → src/commonTest/kotlin/ParameterStateSpec.kt
@@ -2,15 +2,15 @@ package com.benwoodworth.parameterize
 
 import kotlin.test.*
 
-class ParameterDelegateSpec {
+class ParameterStateSpec {
     private val property: String get() = error("${::property.name} is not meant to be used")
     private val differentProperty: String get() = error("${::differentProperty.name} is not meant to be used")
 
-    private lateinit var parameter: ParameterDelegate<String>
+    private lateinit var parameter: ParameterState<String>
 
     @BeforeTest
     fun beforeTest() {
-        parameter = ParameterDelegate()
+        parameter = ParameterState()
     }
 
 
@@ -228,25 +228,6 @@ class ParameterDelegateSpec {
         assertFalse(parameter.hasBeenUsed)
     }
 
-    @Test
-    fun to_string_when_not_initialized_should_match_message_from_lazy() {
-        parameter.declare(::property, emptyList())
-
-        val expectedToString = lazy { "unused" }
-            .toString()
-            .replace("Lazy value", "Parameter argument")
-
-        assertEquals(expectedToString, parameter.toString())
-    }
-
-    @Test
-    fun to_string_when_initialized_should_equal_that_of_the_current_argument() {
-        parameter.declare(::property, listOf("a"))
-
-        val argument = parameter.getArgument(::property)
-        assertEquals(argument, parameter.toString())
-    }
-
     @Test
     fun is_last_argument_before_initialized_should_throw() {
         val failure1 = assertFailsWith<IllegalStateException> {

diff --git a/src/commonTest/kotlin/ParameterizeExceptionSpec.kt b/src/commonTest/kotlin/ParameterizeExceptionSpec.kt
@@ -1,5 +1,6 @@
 package com.benwoodworth.parameterize
 
+import com.benwoodworth.parameterize.ParameterizeScope.ParameterDelegate
 import kotlin.properties.PropertyDelegateProvider
 import kotlin.test.Test
 import kotlin.test.assertEquals

diff --git a/src/commonTest/kotlin/ParameterizeScopeSpec.kt b/src/commonTest/kotlin/ParameterizeScopeSpec.kt
@@ -2,8 +2,11 @@
 
 package com.benwoodworth.parameterize
 
+import com.benwoodworth.parameterize.ParameterizeScope.ParameterDelegate
+import kotlin.properties.PropertyDelegateProvider
 import kotlin.test.Test
 import kotlin.test.assertEquals
+import kotlin.test.assertSame
 
 class ParameterizeScopeSpec {
     @Test
@@ -21,4 +24,36 @@ class ParameterizeScopeSpec {
 
         assertEquals("${ParameterizeScope::class.simpleName}(a = $a, b = $b, c = $c)", this.toString())
     }
+
+    @Test
+    fun parameter_delegate_string_representation_when_not_initialized_should_match_message_from_lazy() = parameterize {
+        lateinit var delegate: ParameterDelegate<Nothing>
+
+        val parameter by PropertyDelegateProvider { thisRef: Nothing?, property ->
+            parameterOf<Nothing>()
+                .provideDelegate(thisRef, property)
+                .also { delegate = it } // intercept delegate
+        }
+
+        val messageFromLazy = lazy { "unused" }
+            .toString()
+            .replace("Lazy value", "Parameter argument")
+
+        assertEquals(messageFromLazy, delegate.toString())
+    }
+
+    @Test
+    fun parameter_delegate_string_representation_when_initialized_should_equal_that_of_the_current_argument() = parameterize {
+        lateinit var delegate: ParameterDelegate<String>
+
+        val parameter by PropertyDelegateProvider { thisRef: Nothing?, property ->
+            parameterOf("argument")
+                .provideDelegate(thisRef, property)
+                .also { delegate = it } // intercept delegate
+        }
+
+        useParameter(parameter)
+
+        assertSame(parameter, delegate.toString())
+    }
 }