Rename instance as factory to be better reflect what it does (#22)

Author: mattmook

README.md

@@ -7,7 +7,7 @@
 
 ## Getting started
 
-Include the following dependencies in your build.gradle.kts file:
+Include the following dependencies in your `build.gradle.kts` file:
 
 ```kotlin
 testImplementation("com.appmattus.fixture:fixture:<latest-version>")
@@ -63,7 +63,7 @@ val listOfSevenItems = fixture<List<String>> {
 }
 ```
 
-repeatCount is a factory method so can be used to return lists and maps of
+`repeatCount` is a factory method so can be used to return lists and maps of
 different lengths each execution:
 
 ```kotlin
@@ -89,13 +89,14 @@ val alwaysFloat = fixture<Number>() {
 }
 ```
 
-#### instance
+#### factory
 
-Used to return the given instance for a particular class.
+Used to return the given instance for a particular class using a factory
+method.
 
 ```kotlin
 val fixture = kotlinFixture {
-    instance<Number> {
+    factory<Number> {
         41
     }
 }
@@ -104,44 +105,44 @@ val alwaysFortyOne = fixture<Number>()
 
 val alwaysOnePointFive = fixture<Number>() {
     // Overrides the parent configuration
-    instance<Number> {
+    factory<Number> {
         1.5
     }
 }
 ```
 
-instance is a factory method so can be used to return different values on every
+As `factory` is a factory method you can return different values on every
 execution:
 
 ```kotlin
-instance<Number> {
+factory<Number> {
     Random.nextInt(10, 50)
 }
 ```
 
 ##### Date and Calendar instances
 
-By default Date and Calendar instances pick a date within one year either side
-of now.
+By default `Date` and `Calendar` instances pick a date within one year either
+side of now.
 
-This can be overridden using `instance` which has some built in constructs:
+This can be overridden using `factory` which has some built in constructs:
 
 ```kotlin
 val fixture = kotlinFixture {
     // Generate between two dates
-    instance<Date> { between(startDate, endDate) }
+    factory<Date> { between(startDate, endDate) }
 }
 
 val betweenTwoDates = fixture<Date>()
 
 // You can also override at instance creation
 
 val pastDate = fixture<Date> {
-    instance<Date> { before(Date()) }
+    factory<Date> { before(Date()) }
 }
 
 val futureDate = fixture<Date> {
-    instance<Date> { after(Date()) }
+    factory<Date> { after(Date()) }
 }
 ```
 
@@ -201,8 +202,8 @@ val fixture = kotlinFixture {
 
 #### random
 
-By default a Random class is used that will generate unique values between runs.
-If you want repeatability you can specify a seeded Random instance.
+By default a `Random` class is used that will generate unique values between
+runs. If you want repeatability you can specify a seeded `Random` instance.
 
 ```kotlin
 val fixture = kotlinFixture {
@@ -277,7 +278,8 @@ provide.
 Including the `fixture-kotlintest` dependency in your project adds extension
 functions `assertAll`, `assertNone`, `forAll` and `forNone` to the fixture.
 These functions wrap the equivalent functions from KotlinTest while providing
-generation of all the classes KotlinFixture supports. For example:
+generation of all the classes [KotlinFixture](https://github.com/appmattus/kotlinfixture)
+supports. For example:
 
 ```kotlin
 data class Person(name: String, age: Int)

fixture/src/main/kotlin/com/appmattus/kotlinfixture/config/Configuration.kt

@@ -32,7 +32,7 @@ import com.appmattus.kotlinfixture.resolver.EnumResolver
 import com.appmattus.kotlinfixture.resolver.EnumSetResolver
 import com.appmattus.kotlinfixture.resolver.FactoryMethodResolver
 import com.appmattus.kotlinfixture.resolver.HashtableKTypeResolver
-import com.appmattus.kotlinfixture.resolver.InstanceResolver
+import com.appmattus.kotlinfixture.resolver.FactoryResolver
 import com.appmattus.kotlinfixture.resolver.IterableKTypeResolver
 import com.appmattus.kotlinfixture.resolver.KFunctionResolver
 import com.appmattus.kotlinfixture.resolver.KTypeResolver
@@ -59,7 +59,7 @@ data class Configuration(
     val repeatCount: () -> Int = defaultRepeatCount,
     val properties: Map<KClass<*>, Map<String, () -> Any?>> =
         emptyMap<KClass<*>, Map<String, () -> Any?>>().toUnmodifiableMap(),
-    val instances: Map<KType, Generator<Any?>.() -> Any?> =
+    val factories: Map<KType, Generator<Any?>.() -> Any?> =
         emptyMap<KType, Generator<Any?>.() -> Any?>().toUnmodifiableMap(),
     val subTypes: Map<KClass<*>, KClass<*>> = emptyMap<KClass<*>, KClass<*>>().toUnmodifiableMap(),
     val random: Random = defaultRandom,
@@ -76,7 +76,7 @@ data class Configuration(
         private val defaultDecorators = listOf(RecursionDecorator(), LoggingDecorator())
 
         private val defaultResolvers = listOf(
-            InstanceResolver(),
+            FactoryResolver(),
             SubTypeResolver(),
 
             CharResolver(),

fixture/src/main/kotlin/com/appmattus/kotlinfixture/config/ConfigurationBuilder.kt

@@ -38,17 +38,17 @@ class ConfigurationBuilder(configuration: Configuration = Configuration()) {
     private var repeatCount: () -> Int = configuration.repeatCount
     private val properties: MutableMap<KClass<*>, MutableMap<String, () -> Any?>> =
         configuration.properties.mapValues { it.value.toMutableMap() }.toMutableMap()
-    private val instances: MutableMap<KType, Generator<Any?>.() -> Any?> = configuration.instances.toMutableMap()
+    private val factories: MutableMap<KType, Generator<Any?>.() -> Any?> = configuration.factories.toMutableMap()
     private val subTypes: MutableMap<KClass<*>, KClass<*>> = configuration.subTypes.toMutableMap()
 
     internal val strategies: MutableMap<KClass<*>, Any> = configuration.strategies.toMutableMap()
 
     @Suppress("UNCHECKED_CAST")
-    inline fun <reified T> instance(noinline generator: Generator<T>.() -> T) =
-        instance(typeOf<T>(), generator as Generator<Any?>.() -> Any?)
+    inline fun <reified T> factory(noinline generator: Generator<T>.() -> T) =
+        factory(typeOf<T>(), generator as Generator<Any?>.() -> Any?)
 
-    fun instance(type: KType, generator: Generator<Any?>.() -> Any?) {
-        instances[type] = generator
+    fun factory(type: KType, generator: Generator<Any?>.() -> Any?) {
+        factories[type] = generator
     }
 
     inline fun <reified T, reified U : T> subType() = subType(T::class, U::class)
@@ -92,7 +92,7 @@ class ConfigurationBuilder(configuration: Configuration = Configuration()) {
     fun build() = Configuration(
         repeatCount = repeatCount,
         properties = properties.mapValues { it.value.toUnmodifiableMap() }.toUnmodifiableMap(),
-        instances = instances.toUnmodifiableMap(),
+        factories = factories.toUnmodifiableMap(),
         subTypes = subTypes.toUnmodifiableMap(),
         random = random,
         decorators = decorators.toUnmodifiableList(),

fixture/src/main/kotlin/com/appmattus/kotlinfixture/resolver/InstanceResolver.kt renamed to fixture/src/main/kotlin/com/appmattus/kotlinfixture/resolver/FactoryResolver.kt

@@ -21,20 +21,20 @@ import com.appmattus.kotlinfixture.Unresolved
 import com.appmattus.kotlinfixture.config.Generator
 import kotlin.reflect.KType
 
-internal class InstanceResolver : Resolver {
+internal class FactoryResolver : Resolver {
 
     override fun resolve(context: Context, obj: Any): Any? {
 
         if (obj is KType) {
-            context.configuration.instances[obj]?.let {
-                return with(InstanceGenerator(context)) { it() }
+            context.configuration.factories[obj]?.let {
+                return with(FactoryGenerator(context)) { it() }
             }
         }
 
         return Unresolved
     }
 
-    private class InstanceGenerator(context: Context) : Generator<Any?> {
+    private class FactoryGenerator(context: Context) : Generator<Any?> {
         override val random = context.random
     }
 }

fixture/src/test/kotlin/com/appmattus/kotlinfixture/FixtureTest.kt

@@ -168,7 +168,7 @@ class FixtureTest {
     @Test
     fun `can override instance in initialisation`() {
         val fixture = kotlinFixture {
-            instance<Number> { 10 }
+            factory<Number> { 10 }
         }
 
         repeat(100) {
@@ -179,7 +179,7 @@ class FixtureTest {
     @Test
     fun `overridden instance in initialisation is random`() {
         val fixture = kotlinFixture {
-            instance<Number> { Random.nextInt(1, 5) }
+            factory<Number> { Random.nextInt(1, 5) }
         }
 
         repeat(100) {
@@ -192,7 +192,7 @@ class FixtureTest {
         val fixture = kotlinFixture()
 
         val result = fixture<Number> {
-            instance<Number> { 20 }
+            factory<Number> { 20 }
         }
         assertEquals(20, result)
     }
@@ -203,7 +203,7 @@ class FixtureTest {
 
         repeat(100) {
             val result = fixture<Number> {
-                instance<Number> { Random.nextInt(6, 10) }
+                factory<Number> { Random.nextInt(6, 10) }
             }
 
             assertTrue { result in 6..10 }
@@ -213,11 +213,11 @@ class FixtureTest {
     @Test
     fun `can override instance in creation when overridden in initialisation`() {
         val fixture = kotlinFixture {
-            instance<Number> { 10 }
+            factory<Number> { 10 }
         }
 
         val result = fixture<Number> {
-            instance<Number> { 30 }
+            factory<Number> { 30 }
         }
         assertEquals(30, result)
     }

fixture/src/test/kotlin/com/appmattus/kotlinfixture/config/ConfigurationBuilderTest.kt

@@ -101,16 +101,16 @@ class ConfigurationBuilderTest {
         @Suppress("UNCHECKED_CAST")
         val configuration = ConfigurationBuilder(
             Configuration(
-                instances = mapOf(Properties::class.starProjectedType to original as Generator<Any?>.() -> Any?)
+                factories = mapOf(Properties::class.starProjectedType to original as Generator<Any?>.() -> Any?)
             )
         ).apply {
-            instance<Properties> { Properties("1") }
+            factory<Properties> { Properties("1") }
         }.build()
 
         with(TestGenerator) {
             assertEquals(
                 Properties("1"),
-                (configuration.instances.getValue(Properties::class.starProjectedType))()
+                (configuration.factories.getValue(Properties::class.starProjectedType))()
             )
         }
     }
@@ -122,16 +122,16 @@ class ConfigurationBuilderTest {
         @Suppress("UNCHECKED_CAST")
         val configuration = ConfigurationBuilder(
             Configuration(
-                instances = mapOf(Properties::class.starProjectedType to original as Generator<Any?>.() -> Any?)
+                factories = mapOf(Properties::class.starProjectedType to original as Generator<Any?>.() -> Any?)
             )
         ).apply {
-            instance(Properties::class.starProjectedType) { Properties("1") }
+            factory(Properties::class.starProjectedType) { Properties("1") }
         }.build()
 
         with(TestGenerator) {
             assertEquals(
                 Properties("1"),
-                (configuration.instances.getValue(Properties::class.starProjectedType))()
+                (configuration.factories.getValue(Properties::class.starProjectedType))()
             )
         }
     }
@@ -142,10 +142,8 @@ class ConfigurationBuilderTest {
 
         assertFailsWith<UnsupportedOperationException> {
             @Suppress("UNCHECKED_CAST", "ReplacePutWithAssignment")
-            (configuration.instances as MutableMap<KType, () -> Any?>).put(Properties::class.starProjectedType) {
-                Properties(
-                    "1"
-                )
+            (configuration.factories as MutableMap<KType, () -> Any?>).put(Properties::class.starProjectedType) {
+                Properties("1")
             }
         }
     }

fixture/src/test/kotlin/com/appmattus/kotlinfixture/config/GeneratorDateTest.kt

@@ -44,7 +44,7 @@ class GeneratorDateTest {
     fun `After specification gives date in the future`() {
 
         val fixture = kotlinFixture {
-            instance<Date> { after(now) }
+            factory<Date> { after(now) }
         }
 
         repeat(100) {
@@ -60,7 +60,7 @@ class GeneratorDateTest {
     fun `After specification is random`() {
 
         val fixture = kotlinFixture {
-            instance<Date> { after(now) }
+            factory<Date> { after(now) }
         }
 
         assertIsRandom {
@@ -71,7 +71,7 @@ class GeneratorDateTest {
     @Test
     fun `After specification uses seeded random`() {
         val fixture = kotlinFixture {
-            instance<Date> { after(now) }
+            factory<Date> { after(now) }
         }
 
         val value1 = fixture<Date> {
@@ -87,7 +87,7 @@ class GeneratorDateTest {
     @Test
     fun `Before specification gives date in the past`() {
         val fixture = kotlinFixture {
-            instance<Date> { before(now) }
+            factory<Date> { before(now) }
         }
 
         repeat(100) {
@@ -103,7 +103,7 @@ class GeneratorDateTest {
     fun `Before specification is random`() {
 
         val fixture = kotlinFixture {
-            instance<Date> { before(now) }
+            factory<Date> { before(now) }
         }
 
         assertIsRandom {
@@ -114,7 +114,7 @@ class GeneratorDateTest {
     @Test
     fun `Before specification uses seeded random`() {
         val fixture = kotlinFixture {
-            instance<Date> { before(now) }
+            factory<Date> { before(now) }
         }
 
         val value1 = fixture<Date> {
@@ -132,7 +132,7 @@ class GeneratorDateTest {
         val minTime = now.time - TimeUnit.HOURS.toMillis(1)
 
         val fixture = kotlinFixture {
-            instance<Date> { between(Date(minTime), now) }
+            factory<Date> { between(Date(minTime), now) }
         }
 
         repeat(100) {
@@ -150,7 +150,7 @@ class GeneratorDateTest {
         val minTime = now.time - TimeUnit.HOURS.toMillis(1)
 
         val fixture = kotlinFixture {
-            instance<Date> { between(Date(minTime), now) }
+            factory<Date> { between(Date(minTime), now) }
         }
 
         assertIsRandom {
@@ -163,7 +163,7 @@ class GeneratorDateTest {
         val minTime = now.time - TimeUnit.HOURS.toMillis(1)
 
         val fixture = kotlinFixture {
-            instance<Date> { between(Date(minTime), now) }
+            factory<Date> { between(Date(minTime), now) }
         }
 
         val value1 = fixture<Date> {

fixture/src/test/kotlin/com/appmattus/kotlinfixture/resolver/CalendarResolverTest.kt

@@ -32,8 +32,8 @@ class CalendarResolverTest {
     private val now = Date()
 
     private val context = TestContext(
-        ConfigurationBuilder().apply { instance<Date> { before(now) } }.build(),
-        CompositeResolver(CalendarResolver(), InstanceResolver())
+        ConfigurationBuilder().apply { factory<Date> { before(now) } }.build(),
+        CompositeResolver(CalendarResolver(), FactoryResolver())
     )
 
     @Test

fixture/src/test/kotlin/com/appmattus/kotlinfixture/resolver/DateResolverTest.kt

@@ -56,6 +56,6 @@ class DateResolverTest {
         val value1 = context.seedRandom().resolve(Date::class) as Date
         val value2 = context.seedRandom().resolve(Date::class) as Date
 
-        assertEquals(value1, value2)
+        assertEquals(value1.time, value2.time)
     }
 }