Merge pull request #16 from vacxe/release/1.0.2

release 1.0.2

README.md

@@ -45,11 +45,10 @@ PrimitiveDataClass(int=-160837378, double=0.2543439936127936, byte=125, short=75
 Konveyor generates for you every class which has primitives in base. But sometimes, we have to create classes with interfaces and with some irregular cases. We can resolve this issue by using `ObjectResolver`:
 
 ```kotlin
-val objectResolver = ObjectResolver()
-objectResolver.addCustomType(MyInterface::class.java, { MyInterfaceImpl() })
-val customParameters = CustomParameters(customObjectResolver = objectResolver)
+val resolver = ObjectResolver()
+resolver(MyInterface::class.java, { MyInterfaceImpl() })
 
-val nestedInterfaceDataClass: NestedInterfaceDataClass = randomBuild(customParameters = customParameters)
+val nestedInterfaceDataClass: NestedInterfaceDataClass = randomBuild(resolver = resolver)
 ```
 
 ### Compatibility with Java

build.gradle

@@ -50,7 +50,7 @@ ext {
     siteUrl = 'https://github.com/vacxe/Konveyor'
     gitUrl = 'https://github.com/vacxe/Konveyor.git'
 
-    libraryVersion = '1.0.1'
+    libraryVersion = '1.0.2'
 
     developerId = 'vacxe'
     developerName = 'Konstantin Aksenov'

src/main/kotlin/com/github/vacxe/konveyor/base/Konveyor.kt

@@ -1,24 +1,24 @@
 package konveyor.base
 
 import konveyor.generate.ObjectResolver
-import konveyor.generate.CustomParameters
 import konveyor.generate.Generator
 
 class Konveyor {
     companion object {
-        internal val objectResolver = ObjectResolver()
+        internal val GlobalObjectResolver = ObjectResolver()
 
         fun <T: Any> addCustomType(clazz: Class<T>, lambda: () -> T) =
-                objectResolver.addCustomType(clazz, lambda)
+                GlobalObjectResolver.addCustomType(clazz, lambda)
     }
 }
 fun <T> randomBuild(clazz: Class<T>): T = randomBuild(clazz, 0)
 
-fun <T> randomBuild(clazz: Class<T>, constructorNumber: Int): T = randomBuild(clazz, constructorNumber, CustomParameters())
+fun <T> randomBuild(clazz: Class<T>, resolver: ObjectResolver): T = randomBuild(clazz, resolver, 0)
 
-fun <T> randomBuild(clazz: Class<T>, constructorNumber: Int, customParameters: CustomParameters): T =
-        Generator(Konveyor.objectResolver.merge(customParameters.customObjectResolver),
-                customParameters).build(clazz, constructorNumber)
+fun <T> randomBuild(clazz: Class<T>, constructorNumber: Int): T = randomBuild(clazz, constructorNumber)
 
-inline fun <reified T : Any> randomBuild(constructorNumber: Int = 0, customParameters: CustomParameters = CustomParameters()): T =
-        randomBuild(T::class.java, constructorNumber, customParameters)
+fun <T> randomBuild(clazz: Class<T>, resolver: ObjectResolver, constructorNumber: Int): T =
+        Generator(Konveyor.GlobalObjectResolver.merge(resolver)).build(clazz, constructorNumber)
+
+inline fun <reified T : Any> randomBuild(resolver: ObjectResolver = ObjectResolver(), constructorNumber: Int = 0): T =
+        randomBuild(T::class.java, resolver, constructorNumber)

src/main/kotlin/com/github/vacxe/konveyor/generate/Generator.kt

@@ -6,16 +6,16 @@ import com.github.vacxe.konveyor.generate.InterfaceGenerator
 import konveyor.exceptions.KonveyorException
 import java.lang.reflect.Constructor
 
-internal class Generator(private val customObjectResolver: ObjectResolver = ObjectResolver(),
-                         private val parameters: CustomParameters = CustomParameters()) {
+internal class Generator(private val objectResolver: ObjectResolver = ObjectResolver()) {
 
+    private val MAX_NESTING = 100
     private val randomPrimitiveGenerator = PrimitiveGenerator()
     private val randomCollectionsGenerator = ImmutableCollectionGenerator()
     private val enumGenerator = EnumGenerator()
     private val interfaceGenerator = InterfaceGenerator()
 
     fun <T> build(clazz: Class<T>, constructorNumber: Int = 0, nestedLevel: Int = 0): T {
-        if (nestedLevel > parameters.nesting) {
+        if (nestedLevel > MAX_NESTING) {
             throw KonveyorException("Generation level out of possible nesting")
         }
 
@@ -58,7 +58,7 @@ internal class Generator(private val customObjectResolver: ObjectResolver = Obje
 
 
     private fun generateNestedClass(clazz: Class<*>, nestedLevel: Int = 0): Any {
-        customObjectResolver.resolve(clazz)?.let { return it }
+        objectResolver.resolve(clazz)?.let { return it }
         for (constructorNumber in 0..clazz.constructors.size) {
             try {
                 return build(clazz, constructorNumber, nestedLevel = nestedLevel)

src/main/kotlin/com/github/vacxe/konveyor/generate/ObjectResolver.kt

@@ -3,12 +3,13 @@ package konveyor.generate
 class ObjectResolver {
     private val customObjectResolverMap = HashMap<Class<*>, () -> Any>()
 
-    fun <C: Any> addCustomType(clazz: Class<C>, lambda: () -> C) {
+    fun <C: Any> addCustomType(clazz: Class<C>, lambda: () -> C) : ObjectResolver {
         customObjectResolverMap[clazz] = lambda
+        return this
     }
 
-    inline fun <reified C: Any> addCustomType(noinline lambda : () -> C) {
-        addCustomType(C::class.java, lambda)
+    inline fun <reified C: Any> addCustomType(noinline lambda : () -> C) : ObjectResolver {
+        return addCustomType(C::class.java, lambda)
     }
 
     internal fun resolve(clazz: Class<*>): Any? {

src/test/kotlin/GenerationTest.kt

@@ -1,12 +1,10 @@
 import konveyor.base.Konveyor
 import konveyor.base.randomBuild
 import konveyor.exceptions.KonveyorException
-import konveyor.generate.CustomParameters
 import konveyor.generate.ObjectResolver
 import objects.*
 import org.junit.Test
 import java.lang.Exception
-import java.util.*
 
 class GenerationTest {
 
@@ -31,17 +29,13 @@ class GenerationTest {
     @Test
     fun nestedGenerationTest() {
         val nestedDataClass: NestedDataClass = randomBuild()
-
         assert(nestedDataClass.first != null)
         assert(nestedDataClass.second != null)
     }
 
     @Test(expected = KonveyorException::class)
     fun nestedGenerationException() {
-        val customParameters = CustomParameters(nesting = 0)
-        val nestedDataClass: NestedDataClass = randomBuild(customParameters = customParameters)
-        assert(nestedDataClass.first != null)
-        assert(nestedDataClass.second != null)
+        val nestedDataClass: LoopNestedDataClass = randomBuild()
     }
 
     @Test
@@ -99,17 +93,14 @@ class GenerationTest {
             MyInterfaceImpl()
         }
 
-        val customParameters = CustomParameters(customObjectResolver = objectResolver)
-
-        val nestedInterfaceDataClass: NestedInterfaceDataClass = randomBuild(customParameters = customParameters)
+        val nestedInterfaceDataClass: NestedInterfaceDataClass = randomBuild(resolver = objectResolver)
     }
 
     @Test
     fun interfaceGenerationWithoutEffectiveImplementation() {
         val objectResolver = ObjectResolver()
         Konveyor.addCustomType(MyInterfaceImpl::class.java) { MyInterfaceImpl() }
         objectResolver.addCustomType { MyInterfaceImpl() }
-        val customParameters = CustomParameters(customObjectResolver = objectResolver)
-        val nestedInterfaceDataClass: NestedInterfaceDataClass = randomBuild(customParameters = customParameters)
+        val nestedInterfaceDataClass: NestedInterfaceDataClass = randomBuild(resolver = objectResolver)
     }
 }

src/test/kotlin/objects/LoopNestedDataClass.kt

@@ -0,0 +1,3 @@
+package objects
+
+data class LoopNestedDataClass(val inner: LoopNestedDataClass)