Refactor (#4)

* WIP: Refactor Lexer * WIP: Refactor the Lexer * WIP: Refactor the Lexer * WIP: Refactor the Lexer * Simplify the Lexer * Rename `Token` -> `QuickCodeToken` * WIP: Refactor to ArrowKt * Refactor to Arrow (tests migrated) * Cleanup and reorganize * Extract classes from QuickCodeAst * Move `QCVariable` to `interpreter` * Remove unnecessary blank line * Refactor the `QuickCodeParser` and add one more test * Improve `Main` * Improve `Main`
Ivy-Apps · Oct 11, 2023 · b35317c · b35317c
1 parent 2e93673
commit b35317c
Show file tree

Hide file tree

Showing 27 changed files with 472 additions and 454 deletions.
diff --git a/build.gradle.kts b/build.gradle.kts
@@ -9,6 +9,12 @@ application {
     applicationName = "qc"
 }
 
+tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile>().configureEach {
+    kotlinOptions {
+        freeCompilerArgs += "-XXLanguage:+ContextReceivers"
+    }
+}
+
 group = "com.ivy"
 version = "1.0-SNAPSHOT"
 

diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
@@ -36,6 +36,7 @@ testing = [
     "kotest-assertions",
     "kotest-property",
     "kotest-property-arrow",
+    "kotest-assertions-arrow",
     "kotest-datatest",
     "kotlin-coroutines-test"
 ]

diff --git a/src/main/kotlin/com/ivy/quickcode/Main.kt b/src/main/kotlin/com/ivy/quickcode/Main.kt
@@ -1,6 +1,8 @@
 package com.ivy.quickcode
 
-import com.ivy.quickcode.data.QCVariableValue
+import arrow.core.Either
+import arrow.core.raise.either
+import com.ivy.quickcode.interpreter.model.QCVariableValue
 import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.JsonPrimitive
 import kotlinx.serialization.json.boolean
@@ -10,42 +12,60 @@ import java.nio.file.Paths
 import kotlin.io.path.name
 
 fun main(args: Array<String>) {
-    // TODO: Extract this as a class, handle errors cases and test it
+    either {
+        val input = parseInput(args).bind()
+        println("Input:")
+        println(input.variables)
+
+        val compiler = QuickCodeCompiler()
+        compiler.execute(input.templateText, input.variables)
+            .onRight { outputText ->
+                println("----------------")
+                produceOutputFile(
+                    templatePath = args[0],
+                    result = outputText,
+                )
+                println("----------------")
+                println(outputText)
+            }
+            .onLeft {
+                println("----------------")
+                println("Compilation error: $it")
+                println("----------------")
+            }
+    }.onLeft {
+        println("Input error: $it")
+    }
+}
+
+private fun parseInput(
+    args: Array<String>
+): Either<String, Input> = either {
     if (args.size != 2) {
-        println("Invalid arguments!")
-        return
+        raise("Invalid arguments! Pass exactly 2 arguments.")
     }
-    val template = readFileContent(args[0])
-    val inputJson = readFileContent(args[1])
+    val templateText = readFileContent(args[0]).bind()
+    val inputJson = readFileContent(args[1]).bind()
     val rawInput: Map<String, JsonPrimitive> = Json.decodeFromString(inputJson)
-    val input = rawInput.map { (key, value) ->
+    val variables = rawInput.map { (key, value) ->
         key to when {
             value.isString -> QCVariableValue.Str(value.content)
             value.booleanOrNull != null -> QCVariableValue.Bool(value.boolean)
             else -> error("Unsupported input type \"$key\"")
         }
     }.toMap()
-
-    println("Input:")
-    println(input)
-
-    val compiler = QuickCodeCompiler()
-    val result = compiler.execute(template, input)
-    println("----------------")
-    produceOutputFile(
-        templatePath = args[0],
-        result = result,
-    )
-    println("----------------")
-    println(result)
+    Input(templateText, variables)
 }
 
-fun readFileContent(relativePath: String): String {
+
+private fun readFileContent(
+    relativePath: String
+): Either<String, String> = Either.catch {
     val path = Paths.get(relativePath)
-    return Files.readString(path)
-}
+    Files.readString(path)
+}.mapLeft { it.toString() }
 
-fun produceOutputFile(templatePath: String, result: String) {
+private fun produceOutputFile(templatePath: String, result: String) {
     val path = Paths.get(templatePath)
     val fileName = path.fileName.name
     val outputFilename = fileName.dropLast(3)
@@ -54,4 +74,9 @@ fun produceOutputFile(templatePath: String, result: String) {
         result
     )
     println("'$outputFilename' created.")
-}
+}
+
+data class Input(
+    val templateText: String,
+    val variables: Map<String, QCVariableValue>
+)
diff --git a/src/main/kotlin/com/ivy/quickcode/QuickCodeCompiler.kt b/src/main/kotlin/com/ivy/quickcode/QuickCodeCompiler.kt
@@ -1,8 +1,16 @@
 package com.ivy.quickcode
 
-import com.ivy.quickcode.data.*
-import com.ivy.quickcode.parser.ParseResult
+import arrow.core.Either
+import arrow.core.raise.either
+import com.ivy.quickcode.interpreter.QuickCodeInterpreter
+import com.ivy.quickcode.interpreter.model.QCVariable
+import com.ivy.quickcode.interpreter.model.QCVariableValue
+import com.ivy.quickcode.lexer.QuickCodeLexer
 import com.ivy.quickcode.parser.QuickCodeParser
+import com.ivy.quickcode.parser.model.IfStatement
+import com.ivy.quickcode.parser.model.QuickCodeAst
+import com.ivy.quickcode.parser.model.RawText
+import com.ivy.quickcode.parser.model.Variable
 
 class QuickCodeCompiler {
     private val lexer = QuickCodeLexer()
@@ -11,29 +19,18 @@ class QuickCodeCompiler {
     fun execute(
         codeTemplate: String,
         vars: Map<String, QCVariableValue>
-    ): String {
+    ): Either<String, String> = either {
         val tokens = lexer.tokenize(codeTemplate)
-        return when (val res = parser.parse(tokens)) {
-            is ParseResult.Failure -> codeTemplate
-            is ParseResult.Success -> {
-                val interpreter = QuickCodeInterpreter(vars)
-                interpreter.evaluate(res.ast)
-            }
-        }
+        val ast = parser.parse(tokens).bind()
+        val interpreter = QuickCodeInterpreter(vars)
+        interpreter.evaluate(ast)
     }
 
-    fun compile(codeTemplate: String): CompilationResult {
+    fun compile(codeTemplate: String): Either<String, CompilationOutput> = either {
         val tokens = lexer.tokenize(codeTemplate)
-        return when (val res = parser.parse(tokens)) {
-            is ParseResult.Failure -> CompilationResult.Invalid(res.errorMsg)
-            is ParseResult.Success -> {
-                CompilationResult.Valid(
-                    ast = res.ast,
-                    variables = res.ast.extractAllVars()
-                        .fixVariableConflicts()
-                )
-            }
-        }
+        val ast = parser.parse(tokens).bind()
+        val variables = ast.extractAllVars().fixVariableConflicts()
+        CompilationOutput(ast, variables)
     }
 
     private fun List<QCVariable>.fixVariableConflicts(): List<QCVariable> {
@@ -95,12 +92,8 @@ class QuickCodeCompiler {
         }
     }
 
-    sealed interface CompilationResult {
-        data class Valid(
-            val ast: QuickCodeAst,
-            val variables: List<QCVariable>
-        ) : CompilationResult
-
-        data class Invalid(val errMsg: String) : CompilationResult
-    }
+    data class CompilationOutput(
+        val ast: QuickCodeAst,
+        val variables: List<QCVariable>
+    )
 }
diff --git a/src/main/kotlin/com/ivy/quickcode/QuickCodeDetector.kt b/src/main/kotlin/com/ivy/quickcode/QuickCodeDetector.kt
diff --git a/src/main/kotlin/com/ivy/quickcode/data/QuickCodeToken.kt b/src/main/kotlin/com/ivy/quickcode/data/QuickCodeToken.kt
diff --git a/...com/ivy/quickcode/QuickCodeInterpreter.kt → ...kcode/interpreter/QuickCodeInterpreter.kt b/...com/ivy/quickcode/QuickCodeInterpreter.kt → ...kcode/interpreter/QuickCodeInterpreter.kt
@@ -1,6 +1,10 @@
-package com.ivy.quickcode
+package com.ivy.quickcode.interpreter
 
-import com.ivy.quickcode.data.*
+import com.ivy.quickcode.interpreter.model.QCVariableValue
+import com.ivy.quickcode.parser.model.IfStatement
+import com.ivy.quickcode.parser.model.QuickCodeAst
+import com.ivy.quickcode.parser.model.RawText
+import com.ivy.quickcode.parser.model.Variable
 
 class QuickCodeInterpreter(
     private val variables: Map<String, QCVariableValue>,

diff --git a/...tlin/com/ivy/quickcode/data/QCVariable.kt → ...quickcode/interpreter/model/QCVariable.kt b/...tlin/com/ivy/quickcode/data/QCVariable.kt → ...quickcode/interpreter/model/QCVariable.kt
@@ -1,4 +1,4 @@
-package com.ivy.quickcode.data
+package com.ivy.quickcode.interpreter.model
 
 sealed interface QCVariable {
     val name: String

diff --git a/...com/ivy/quickcode/data/QCVariableValue.kt → ...code/interpreter/model/QCVariableValue.kt b/...com/ivy/quickcode/data/QCVariableValue.kt → ...code/interpreter/model/QCVariableValue.kt
@@ -1,4 +1,4 @@
-package com.ivy.quickcode.data
+package com.ivy.quickcode.interpreter.model
 
 sealed interface QCVariableValue {
     data class Str(val value: String) : QCVariableValue