Merge pull request #12 from kleis-technology/xp/datasource

Feature/datasource
kleis-technology · Jan 23, 2024 · f19daf9 · f19daf9
2 parents 0813677 + 1fa55e1
commit f19daf9
Show file tree

Hide file tree

Showing 58 changed files with 2,468 additions and 589 deletions.
diff --git a/cli/src/main/kotlin/ch/kleis/lcaac/cli/cmd/AssessCommand.kt b/cli/src/main/kotlin/ch/kleis/lcaac/cli/cmd/AssessCommand.kt
@@ -44,7 +44,7 @@ class AssessCommand : CliktCommand(name = "assess", help = "Returns the unitary
     override fun run() {
         val files = lcaFiles(path)
         val symbolTable = Loader(BasicOperations).load(files, listOf(LoaderOption.WITH_PRELUDE))
-        val processor = CsvProcessor(symbolTable)
+        val processor = CsvProcessor(path, symbolTable)
         val iterator = loadRequests()
         val writer = CsvResultWriter()
         var first = true

diff --git a/cli/src/main/kotlin/ch/kleis/lcaac/cli/cmd/TestCommand.kt b/cli/src/main/kotlin/ch/kleis/lcaac/cli/cmd/TestCommand.kt
@@ -1,5 +1,6 @@
 package ch.kleis.lcaac.cli.cmd
 
+import ch.kleis.lcaac.core.datasource.CsvSourceOperations
 import ch.kleis.lcaac.core.math.basic.BasicOperations
 import ch.kleis.lcaac.core.testing.BasicTestRunner
 import ch.kleis.lcaac.core.testing.GenericFailure
@@ -32,12 +33,15 @@ class TestCommand : CliktCommand(name = "test", help = "Run specified tests") {
 
     override fun run() {
         val files = lcaFiles(path)
-        val symbolTable = Loader(BasicOperations).load(files, listOf(LoaderOption.WITH_PRELUDE))
+        val ops = BasicOperations
+        val symbolTable = Loader(ops).load(files, listOf(LoaderOption.WITH_PRELUDE))
         val mapper = CoreTestMapper()
         val cases = files
             .flatMap { it.testDefinition() }
             .map { mapper.test(it) }
-        val runner = BasicTestRunner<LcaLangParser.TestDefinitionContext>(symbolTable)
+        val runner = BasicTestRunner<LcaLangParser.TestDefinitionContext>(
+            symbolTable,
+            CsvSourceOperations(path, ops))
         val results = cases.map { runner.run(it) }
 
         results.forEach { result ->

diff --git a/cli/src/main/kotlin/ch/kleis/lcaac/cli/cmd/Utils.kt b/cli/src/main/kotlin/ch/kleis/lcaac/cli/cmd/Utils.kt
@@ -3,8 +3,6 @@ package ch.kleis.lcaac.cli.cmd
 import ch.kleis.lcaac.core.lang.evaluator.EvaluatorException
 import ch.kleis.lcaac.core.lang.expression.DataExpression
 import ch.kleis.lcaac.core.lang.expression.EQuantityScale
-import ch.kleis.lcaac.core.lang.expression.EUnitOf
-import ch.kleis.lcaac.core.lang.expression.QuantityExpression
 import ch.kleis.lcaac.core.math.basic.BasicNumber
 import ch.kleis.lcaac.core.math.basic.BasicOperations
 import ch.kleis.lcaac.grammar.CoreMapper
@@ -34,31 +32,26 @@ private fun lcaFile(inputStream: InputStream): LcaLangParser.LcaFileContext {
     return parser.lcaFile()
 }
 
-fun parseQuantityWithDefaultUnit(s: String, defaultUnit: DataExpression<BasicNumber>): DataExpression<BasicNumber> {
+fun smartParseQuantityWithDefaultUnit(s: String, defaultUnit: DataExpression<BasicNumber>): DataExpression<BasicNumber> {
     val parts = s.split(" ")
-    return when (parts.size) {
-        1 -> {
-            val number = parts[0]
-            val amount = try {
-                parseDouble(number)
-            } catch (e: NumberFormatException) {
-                throw EvaluatorException("'$s' is not a valid quantity")
-            }
-            EQuantityScale(BasicNumber(amount), defaultUnit)
+    return if (parts.size == 1) {
+        val number = parts[0]
+        val amount = try {
+            parseDouble(number)
+        } catch (e: NumberFormatException) {
+            throw EvaluatorException("'$s' is not a valid quantity")
         }
-        2 -> {
-            val lexer = LcaLangLexer(CharStreams.fromString(s))
-            val tokens = CommonTokenStream(lexer)
-            val parser = LcaLangParser(tokens)
-            val ctx = parser.dataExpression()
-            try {
-                CoreMapper(BasicOperations).dataExpression(ctx)
-            } catch (e: IllegalStateException) {
-                throw EvaluatorException("'$s' is not a valid quantity")
-            }
+        EQuantityScale(BasicNumber(amount), defaultUnit)
+    } else {
+        val lexer = LcaLangLexer(CharStreams.fromString(s))
+        val tokens = CommonTokenStream(lexer)
+        val parser = LcaLangParser(tokens)
+        val ctx = parser.dataExpression()
+        try {
+            CoreMapper(BasicOperations).dataExpression(ctx)
+        } catch (e: IllegalStateException) {
+            throw EvaluatorException("'$s' is not a valid quantity")
         }
-        else -> throw EvaluatorException("'$s' is not a valid quantity")
     }
-
 }
 
diff --git a/cli/src/main/kotlin/ch/kleis/lcaac/cli/csv/CsvProcessor.kt b/cli/src/main/kotlin/ch/kleis/lcaac/cli/csv/CsvProcessor.kt
@@ -1,7 +1,8 @@
 package ch.kleis.lcaac.cli.csv
 
-import ch.kleis.lcaac.cli.cmd.parseQuantityWithDefaultUnit
+import ch.kleis.lcaac.cli.cmd.smartParseQuantityWithDefaultUnit
 import ch.kleis.lcaac.core.assessment.ContributionAnalysisProgram
+import ch.kleis.lcaac.core.datasource.CsvSourceOperations
 import ch.kleis.lcaac.core.lang.SymbolTable
 import ch.kleis.lcaac.core.lang.evaluator.Evaluator
 import ch.kleis.lcaac.core.lang.evaluator.EvaluatorException
@@ -11,49 +12,52 @@ import ch.kleis.lcaac.core.lang.expression.QuantityExpression
 import ch.kleis.lcaac.core.lang.expression.StringExpression
 import ch.kleis.lcaac.core.math.basic.BasicNumber
 import ch.kleis.lcaac.core.math.basic.BasicOperations
+import java.io.File
 
 class CsvProcessor(
-        private val symbolTable: SymbolTable<BasicNumber>,
+    path: File,
+    private val symbolTable: SymbolTable<BasicNumber>,
 ) {
     private val ops = BasicOperations
-    private val evaluator = Evaluator(symbolTable, ops)
+    private val sourceOps = CsvSourceOperations(path, ops)
+    private val evaluator = Evaluator(symbolTable, ops, sourceOps)
 
     fun process(request: CsvRequest): List<CsvResult> {
         val reqName = request.processName
         val reqLabels = request.matchLabels
         val template =
-                symbolTable.getTemplate(reqName, reqLabels)
-                        ?: throw EvaluatorException("Could not get template for ${reqName}${reqLabels}")
+            symbolTable.getTemplate(reqName, reqLabels)
+                ?: throw EvaluatorException("Could not get template for ${reqName}${reqLabels}")
 
         val arguments = template.params
-                .mapValues { entry ->
-                    when (val v = entry.value) {
-                        is QuantityExpression<*> -> request[entry.key]?.let {
-                            parseQuantityWithDefaultUnit(it, EUnitOf(v))
-                        } ?: entry.value
+            .mapValues { entry ->
+                when (val v = entry.value) {
+                    is QuantityExpression<*> -> request[entry.key]?.let {
+                        smartParseQuantityWithDefaultUnit(it, EUnitOf(v))
+                    } ?: entry.value
 
-                        is StringExpression -> request[entry.key]?.let {
-                            EStringLiteral(it)
-                        } ?: entry.value
+                    is StringExpression -> request[entry.key]?.let {
+                        EStringLiteral(it)
+                    } ?: entry.value
 
-                        else -> throw EvaluatorException("$v is not a supported data expression")
-                    }
+                    else -> throw EvaluatorException("$v is not a supported data expression")
                 }
+            }
 
         val trace = evaluator.trace(template, arguments)
         val systemValue = trace.getSystemValue()
         val entryPoint = trace.getEntryPoint()
         val program = ContributionAnalysisProgram(systemValue, entryPoint)
         val analysis = program.run()
         return entryPoint.products
-                .map { output ->
-                    val outputPort = output.product
-                    val impacts = analysis.getUnitaryImpacts(outputPort)
-                    CsvResult(
-                            request,
-                            outputPort,
-                            impacts,
-                    )
-                }
+            .map { output ->
+                val outputPort = output.product
+                val impacts = analysis.getUnitaryImpacts(outputPort)
+                CsvResult(
+                    request,
+                    outputPort,
+                    impacts,
+                )
+            }
     }
 }
diff --git a/cli/src/main/kotlin/ch/kleis/lcaac/cli/csv/Utils.kt b/cli/src/main/kotlin/ch/kleis/lcaac/cli/csv/Utils.kt
@@ -0,0 +1,10 @@
+package ch.kleis.lcaac.cli.csv
+
+import ch.kleis.lcaac.core.lang.evaluator.EvaluatorException
+import ch.kleis.lcaac.core.lang.expression.DataExpression
+import ch.kleis.lcaac.core.lang.expression.EQuantityScale
+import ch.kleis.lcaac.core.math.basic.BasicNumber
+import java.lang.Double
+import kotlin.NumberFormatException
+import kotlin.String
+
diff --git a/cli/src/test/kotlin/ch/kleis/lcaac/cli/cmd/UtilsKtTest.kt b/cli/src/test/kotlin/ch/kleis/lcaac/cli/cmd/UtilsKtTest.kt
@@ -2,6 +2,7 @@ package ch.kleis.lcaac.cli.cmd
 
 import ch.kleis.lcaac.core.lang.evaluator.EvaluatorException
 import ch.kleis.lcaac.core.lang.expression.EDataRef
+import ch.kleis.lcaac.core.lang.expression.EQuantityMul
 import ch.kleis.lcaac.core.lang.expression.EQuantityScale
 import ch.kleis.lcaac.core.math.basic.BasicNumber
 import ch.kleis.lcaac.core.prelude.Prelude
@@ -19,7 +20,7 @@ class UtilsKtTest {
         val defaultUnit = Prelude.unitMap<BasicNumber>()["kg"]!!
 
         // when/then
-        val actual = assertThrows<EvaluatorException> {  parseQuantityWithDefaultUnit(s, defaultUnit) }
+        val actual = assertThrows<EvaluatorException> { smartParseQuantityWithDefaultUnit(s, defaultUnit) }
         assertEquals("'a@bc' is not a valid quantity", actual.message)
     }
 
@@ -30,7 +31,7 @@ class UtilsKtTest {
         val defaultUnit = Prelude.unitMap<BasicNumber>()["kg"]!!
 
         // when/then
-        val actual = assertThrows<EvaluatorException> {  parseQuantityWithDefaultUnit(s, defaultUnit) }
+        val actual = assertThrows<EvaluatorException> { smartParseQuantityWithDefaultUnit(s, defaultUnit) }
         assertEquals("'12 3 4' is not a valid quantity", actual.message)
     }
 
@@ -41,7 +42,7 @@ class UtilsKtTest {
         val defaultUnit = Prelude.unitMap<BasicNumber>()["kg"]!!
 
         // when/then
-        val actual = assertThrows<EvaluatorException> {  parseQuantityWithDefaultUnit(s, defaultUnit) }
+        val actual = assertThrows<EvaluatorException> { smartParseQuantityWithDefaultUnit(s, defaultUnit) }
         assertEquals("'12 \$3' is not a valid quantity", actual.message)
     }
 
@@ -52,7 +53,7 @@ class UtilsKtTest {
         val defaultUnit = Prelude.unitMap<BasicNumber>()["kg"]!!
 
         // when
-        val actual = parseQuantityWithDefaultUnit(s, defaultUnit)
+        val actual = smartParseQuantityWithDefaultUnit(s, defaultUnit)
 
         // then
         assertEquals(EQuantityScale(BasicNumber(12.0), defaultUnit), actual)
@@ -65,9 +66,28 @@ class UtilsKtTest {
         val defaultUnit = Prelude.unitMap<BasicNumber>()["kg"]!!
 
         // when
-        val actual = parseQuantityWithDefaultUnit(s, defaultUnit)
+        val actual = smartParseQuantityWithDefaultUnit(s, defaultUnit)
 
         // then
         assertEquals(EQuantityScale(BasicNumber(12.0), EDataRef("kg")), actual)
     }
+
+    @Test
+    fun parseQuantityWithDefaultUnit_whenComplexExpression() {
+        // given
+        val s = "12.0 kg * hour"
+        val kg = Prelude.unitMap<BasicNumber>()["kg"]!!
+        val hour = Prelude.unitMap<BasicNumber>()["hour"]!!
+        val defaultUnit = EQuantityMul(kg, hour)
+
+        // when
+        val actual = smartParseQuantityWithDefaultUnit(s, defaultUnit)
+
+        // then
+        assertEquals(
+            EQuantityScale(
+                BasicNumber(12.0),
+                EQuantityMul(EDataRef("kg"), EDataRef("hour"))),
+            actual)
+    }
 }
diff --git a/cli/src/test/kotlin/ch/kleis/lcaac/cli/csv/CsvProcessorTest.kt b/cli/src/test/kotlin/ch/kleis/lcaac/cli/csv/CsvProcessorTest.kt
@@ -6,15 +6,16 @@ import ch.kleis.lcaac.core.lang.dimension.UnitSymbol
 import ch.kleis.lcaac.core.lang.value.*
 import ch.kleis.lcaac.core.math.basic.BasicNumber
 import ch.kleis.lcaac.core.math.basic.BasicOperations
-import ch.kleis.lcaac.core.prelude.Prelude
 import ch.kleis.lcaac.grammar.Loader
 import ch.kleis.lcaac.grammar.LoaderOption
 import ch.kleis.lcaac.grammar.parser.LcaLangLexer
 import ch.kleis.lcaac.grammar.parser.LcaLangParser
+import io.mockk.mockk
 import org.antlr.v4.runtime.CharStreams
 import org.antlr.v4.runtime.CommonTokenStream
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Test
+import java.io.File
 
 class CsvProcessorTest {
 
@@ -34,7 +35,8 @@ class CsvProcessorTest {
             }
         """.trimIndent()
         val symbolTable = load(content)
-        val processor = CsvProcessor(symbolTable)
+        val path = mockk<File>()
+        val processor = CsvProcessor(path, symbolTable)
         val request = CsvRequest(
             "main",
             emptyMap(),

diff --git a/core/build.gradle.kts b/core/build.gradle.kts
@@ -48,6 +48,8 @@ dependencies {
     implementation("org.apache.logging.log4j:log4j-core:$log4jVersion")
     implementation("org.apache.logging.log4j:log4j-slf4j-impl:$log4jVersion")
 
+    implementation("org.apache.commons:commons-csv:1.10.0")
+
     testImplementation(kotlin("test"))
 }