Issue #4 - sealed classes

.gitignore

@@ -3,4 +3,6 @@
 build
 *~
 *.swp
-out
+out
+gradle.properties
+*.iml

build.gradle

@@ -51,6 +51,7 @@ repositories {
 dependencies {
     compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
     compile "org.jetbrains.kotlin:kotlin-reflect:$kotlin_version"
+    compile 'org.reflections:reflections:0.9.11'
 
     testCompile "com.winterbe:expekt:0.5.0"
     testCompile "org.jetbrains.spek:spek-api:$spek_version"

src/main/kotlin/me/ntrrgc/tsGenerator/unfold.kt

@@ -0,0 +1,14 @@
+package me.ntrrgc.tsGenerator
+
+fun <T,R> Iterable<T>.unfold(f: (Iterable<T>) -> Pair<R?, Iterable<T>>): Iterable<R> {
+    return if (iterator().hasNext()) {
+        val (first, remaining) = f(this)
+        if (first !== null) {
+            listOf(first) + remaining.unfold(f)
+        } else {
+            remaining.unfold(f)
+        }
+    } else {
+        emptyList()
+    }
+}

src/test/kotlin/me/ntrrgc/tsGenerator/tests/EnumDefinition.kt

@@ -16,20 +16,6 @@
 
 package me.ntrrgc.tsGenerator.tests
 
-class EnumDefinition(val code: String): TypeScriptDefinition {
-    override fun toString(): String {
-        return code
-    }
+import java.util.SortedSet
 
-    override fun equals(other: Any?): Boolean {
-        if (other !is EnumDefinition) {
-            return false
-        }
-
-        return this.code == other.code
-    }
-
-    override fun hashCode(): Int {
-        return code.hashCode()
-    }
-}
+data class EnumDefinition(val name: String, val union: SortedSet<String>): TypeScriptDefinition

src/test/kotlin/me/ntrrgc/tsGenerator/tests/SealedClassDefinition.kt

@@ -0,0 +1,52 @@
+package me.ntrrgc.tsGenerator.tests
+
+import java.util.SortedSet
+
+data class SealedClassDefinition(
+        val name: String,
+        val classes: SortedSet<ClassDefinition>,
+        val union: SortedSet<String>
+): TypeScriptDefinition, Comparable<SealedClassDefinition> {
+
+    private val eqHashList = listOf(classes, name, union)
+
+    override fun equals(other: Any?): Boolean =
+            if (other !is SealedClassDefinition) false
+            else {
+                eqHashList == other.eqHashList
+            }
+
+    override fun hashCode(): Int = eqHashList.hashCode()
+
+    override fun compareTo(other: SealedClassDefinition): Int {
+        classes.size.compareTo(other.classes.size).let {
+            if (it != 0) return@compareTo it
+        }
+
+        classes.zip(other.classes).asSequence()
+                .map { (c1, c2) -> c1.compareTo(c2) }
+                .firstOrNull { it != 0 }
+                .let {
+                    if (it != null) return@compareTo it
+                }
+
+        name.compareTo(other.name)
+                .let {
+                    if (it != 0) return@compareTo it
+                }
+
+        union.size.compareTo(other.union.size).let {
+            if (it != 0) return@compareTo it
+        }
+
+        union.zip(other.union).asSequence()
+                .map { (c1, c2) -> c1.compareTo(c2) }
+                .firstOrNull { it != 0 }
+                .let {
+                    if (it != null) return@compareTo it
+                }
+
+        return 0
+    }
+
+}

src/test/kotlin/me/ntrrgc/tsGenerator/tests/TypeDefinition.kt

@@ -0,0 +1,8 @@
+package me.ntrrgc.tsGenerator.tests
+
+import me.ntrrgc.tsGenerator.unfold
+import java.util.SortedSet
+
+object TypeDefinition {
+
+}

src/test/kotlin/me/ntrrgc/tsGenerator/tests/TypeScriptDefinition.kt

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2017 Alicia Boya García
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package me.ntrrgc.tsGenerator.tests
+
+import me.ntrrgc.tsGenerator.unfold
+
+interface TypeScriptDefinition {
+
+    companion object {
+        operator fun invoke(tsCode: String): TypeScriptDefinition {
+            val typedefs = tsCode.lines().unfold { lines ->
+                fun Iterable<String>.indexOfTypeDeclaration(): Int = indexOfFirst { it.trim().startsWith("interface") || it.trim().startsWith("type") }
+                        .takeIf { it >= 0 } ?: count()
+
+                val restOfLines = lines.drop(lines.indexOfTypeDeclaration())
+                val classDefLineCount = 1 + restOfLines.drop(1).indexOfTypeDeclaration()
+                Pair(
+                        restOfLines.take(classDefLineCount).filter { it.isNotBlank() },
+                        restOfLines.drop(classDefLineCount))
+            }
+            val classes = typedefs.mapNotNull { code ->
+                if (code.firstOrNull()?.trim()?.startsWith("interface") == true) {
+                    ClassDefinition(code.joinToString("\n"))
+                } else {
+                    null
+                }
+            }.toSortedSet()
+
+            val unionDefs = typedefs
+                    .filter { code ->
+                        code.firstOrNull()?.trim()?.startsWith("type") == true
+                    }
+                    .map { code -> code.joinToString("\n").trim() }
+                    .map { unionDef ->
+                        val (_, name, _, def) = unionDef.split(Regex("\\s+"), limit = 4)
+                        val union = def.trimStart('=', ' ', '\n', '(')
+                                .trimEnd(' ', '\n', ')', ';')
+                                .split(Regex("\\s*\\|\\s*"))
+                                .toSortedSet()
+                        name to union
+                    }
+
+            return if (classes.size == 1 && unionDefs.isEmpty()) {
+                classes.single()
+            } else if (classes.isEmpty() && unionDefs.size == 1 && unionDefs.single().second.all { it.startsWith('"') && it.endsWith('"') }) {
+                EnumDefinition(unionDefs.single().first, unionDefs.single().second)
+            } else if (unionDefs.size == 1 && unionDefs.single().second.none { it.startsWith('"') && it.endsWith('"') }) {
+                SealedClassDefinition(unionDefs.single().first, classes, unionDefs.single().second)
+            } else {
+                throw RuntimeException("Unknown definition type: ${tsCode.trim()}")
+            }
+        }
+    }
+
+}