lcaac bump version 1.7.6

gradle.properties

@@ -2,4 +2,4 @@ javaVersion=17
 gradleVersion=7.6
 org.gradle.jvmargs=-Xmx4096m
 lcaacGroup=ch.kleis.lcaac
-lcaacVersion=1.6.8
+lcaacVersion=1.7.6

plugin/build.gradle.kts

@@ -47,7 +47,7 @@ sourceSets {
 }
 
 dependencies {
-    implementation("ch.kleis.lcaac:core:1.6.6")
+    implementation("ch.kleis.lcaac:core:1.7.6")
 
     implementation(files(layout.buildDirectory.dir("stdlib/ef3.1")) {
         builtBy("generateEmissionFactors31")

plugin/src/main/kotlin/ch/kleis/lcaac/plugin/actions/ActionHelper.kt

@@ -1,6 +1,9 @@
 package ch.kleis.lcaac.plugin.actions
 
+import ch.kleis.lcaac.core.datasource.ConnectorFactory
 import ch.kleis.lcaac.core.datasource.DefaultDataSourceOperations
+import ch.kleis.lcaac.core.datasource.csv.CsvConnectorBuilder
+import ch.kleis.lcaac.core.datasource.resilio_db.ResilioDbConnectorBuilder
 import ch.kleis.lcaac.core.lang.evaluator.EvaluationTrace
 import ch.kleis.lcaac.core.lang.evaluator.Evaluator
 import ch.kleis.lcaac.core.math.QuantityOperations
@@ -32,11 +35,17 @@ fun <Q> traceSystemWithIndicator(
     indicator.text = "Solving system"
     val template = symbolTable.getTemplate(processName, matchLabels)!! // We are called from a process, so it must exist
     val config = with(LcaacConfigExtensions()) { file.project.lcaacConfig() }
-    val sourceOps = DefaultDataSourceOperations(
+    val factory = ConnectorFactory(
+        file.project.basePath!!,
         config,
         ops,
-        file.project.basePath!!,
+        symbolTable,
+        listOf(
+            CsvConnectorBuilder(),
+            ResilioDbConnectorBuilder(),
+        )
     )
+    val sourceOps = DefaultDataSourceOperations(ops, config, factory.buildConnectors())
 
     return Evaluator(symbolTable, ops, sourceOps).trace(template)
 }

plugin/src/main/kotlin/ch/kleis/lcaac/plugin/actions/csv/CsvProcessor.kt

@@ -2,7 +2,10 @@ package ch.kleis.lcaac.plugin.actions.csv
 
 import ch.kleis.lcaac.core.assessment.ContributionAnalysisProgram
 import ch.kleis.lcaac.core.config.LcaacConfig
+import ch.kleis.lcaac.core.datasource.ConnectorFactory
 import ch.kleis.lcaac.core.datasource.DefaultDataSourceOperations
+import ch.kleis.lcaac.core.datasource.csv.CsvConnectorBuilder
+import ch.kleis.lcaac.core.datasource.resilio_db.ResilioDbConnectorBuilder
 import ch.kleis.lcaac.core.lang.SymbolTable
 import ch.kleis.lcaac.core.lang.evaluator.Evaluator
 import ch.kleis.lcaac.core.lang.evaluator.EvaluatorException
@@ -19,11 +22,18 @@ class CsvProcessor(
     lcaacConfigLoader: () -> LcaacConfig = { with(LcaacConfigExtensions()) { project.lcaacConfig() } },
 ) {
     private val ops = BasicOperations
-    private val sourceOps = DefaultDataSourceOperations(
-        lcaacConfigLoader(),
-        ops,
+    private val config = lcaacConfigLoader()
+    private val factory = ConnectorFactory(
         project.basePath ?: "",
+        config,
+        ops,
+        symbolTable,
+        listOf(
+            CsvConnectorBuilder(),
+            ResilioDbConnectorBuilder(),
+        )
     )
+    private val sourceOps = DefaultDataSourceOperations(ops, config, factory.buildConnectors())
     private val evaluator = Evaluator(symbolTable, ops, sourceOps)
 
     fun process(request: CsvRequest): List<CsvResult> {

plugin/src/main/kotlin/ch/kleis/lcaac/plugin/actions/tasks/SensitivityAnalysisTask.kt

@@ -4,8 +4,11 @@ import arrow.core.filterIsInstance
 import ch.kleis.lcaac.core.ParameterName
 import ch.kleis.lcaac.core.assessment.SensitivityAnalysis
 import ch.kleis.lcaac.core.assessment.SensitivityAnalysisProgram
+import ch.kleis.lcaac.core.datasource.ConnectorFactory
 import ch.kleis.lcaac.core.datasource.DataSourceOperations
 import ch.kleis.lcaac.core.datasource.DefaultDataSourceOperations
+import ch.kleis.lcaac.core.datasource.csv.CsvConnectorBuilder
+import ch.kleis.lcaac.core.datasource.resilio_db.ResilioDbConnectorBuilder
 import ch.kleis.lcaac.core.lang.SymbolTable
 import ch.kleis.lcaac.core.lang.evaluator.Evaluator
 import ch.kleis.lcaac.core.lang.evaluator.ToValue
@@ -88,11 +91,18 @@ class SensitivityAnalysisTask(
                 processName,
                 matchLabels
             ) ?: throw IllegalStateException("Symbol table: cannot find process '$processName$matchLabels'")
-        val sourceOps = DefaultDataSourceOperations(
-            with(LcaacConfigExtensions()) { project.lcaacConfig() },
+        val config = with(LcaacConfigExtensions()) { project.lcaacConfig() }
+        val factory = ConnectorFactory(
+            file.project.basePath!!,
+            config,
             ops,
-            project.basePath ?: throw IllegalStateException("Current project misses a base path"),
+            symbolTable,
+            listOf(
+                CsvConnectorBuilder(),
+                ResilioDbConnectorBuilder(),
+            )
         )
+        val sourceOps = DefaultDataSourceOperations(ops, config, factory.buildConnectors())
         val (arguments, parameters) =
             prepareArguments(ops, sourceOps, symbolTable, template.params)
         val trace = Evaluator(symbolTable, ops, sourceOps).trace(template, arguments)

plugin/src/main/kotlin/ch/kleis/lcaac/plugin/testing/LcaTestRunner.kt

@@ -1,7 +1,10 @@
 package ch.kleis.lcaac.plugin.testing
 
 import ch.kleis.lcaac.core.assessment.ContributionAnalysisProgram
+import ch.kleis.lcaac.core.datasource.ConnectorFactory
 import ch.kleis.lcaac.core.datasource.DefaultDataSourceOperations
+import ch.kleis.lcaac.core.datasource.csv.CsvConnectorBuilder
+import ch.kleis.lcaac.core.datasource.resilio_db.ResilioDbConnectorBuilder
 import ch.kleis.lcaac.core.lang.SymbolTable
 import ch.kleis.lcaac.core.lang.evaluator.Evaluator
 import ch.kleis.lcaac.core.lang.evaluator.EvaluatorException
@@ -30,11 +33,22 @@ class LcaTestRunner(
 ) {
     private val ops = BasicOperations
     private val mapper = LcaMapper(ops)
-    private val sourceOps = DefaultDataSourceOperations(
-        with(LcaacConfigExtensions()) { project.lcaacConfig() },
-        ops,
-        project.basePath!!,
-    )
+    private val config = with(LcaacConfigExtensions()) { project.lcaacConfig() }
+//    private val factory = ConnectorFactory(
+//        project.basePath!!,
+//        config,
+//        ops,
+//        symbolTable,
+//        listOf(
+//            CsvConnectorBuilder(),
+//            ResilioDbConnectorBuilder(),
+//        )
+//    )
+//    private val sourceOps = DefaultDataSourceOperations(
+//        ,
+//        ops,
+//        project.basePath!!,
+//    )
 
     // TODO: Use testing objects from core package
     fun run(test: LcaTest): LcaTestResult {
@@ -45,6 +59,17 @@ class LcaTestRunner(
                 val parser = LcaLoader(collector.collect(file), ops)
                 parser.load()
             }
+            val factory = ConnectorFactory(
+                project.basePath!!,
+                config,
+                ops,
+                symbolTable,
+                listOf(
+                    CsvConnectorBuilder(),
+                    ResilioDbConnectorBuilder(),
+                )
+            )
+            val sourceOps = DefaultDataSourceOperations(ops, config, factory.buildConnectors())
             val testCase = runReadAction { testCase(test) }
             val updatedSymbolTable = symbolTable
                 .copy(
@@ -55,7 +80,7 @@ class LcaTestRunner(
             val trace = evaluator.trace(testCase)
             val program = ContributionAnalysisProgram(trace.getSystemValue(), trace.getEntryPoint())
             val analysis = program.run()
-            val assertions = assertions(symbolTable, test)
+            val assertions = assertions(symbolTable, sourceOps, test)
             val target = trace.getEntryPoint().products.first().port()
             val results = assertions.map { assertion ->
                 val ports = analysis.findAllPortsByShortName(assertion.ref)
@@ -83,7 +108,11 @@ class LcaTestRunner(
         }
     }
 
-    private fun assertions(symbolTable: SymbolTable<BasicNumber>, test: LcaTest): List<RangeAssertion> {
+    private fun assertions(
+        symbolTable: SymbolTable<BasicNumber>,
+        sourceOps: DefaultDataSourceOperations<BasicNumber>,
+        test: LcaTest
+    ): List<RangeAssertion> {
         // mapper reads from psi, so we need runReadAction
         val data = runReadAction {
             Register(symbolTable.data)

plugin/src/test/kotlin/ch/kleis/lcaac/plugin/actions/sankey/SankeyGraphWindowBuilderTest.kt

@@ -499,176 +499,4 @@ class SankeyGraphWindowBuilderTest : BasePlatformTestCase() {
         assertEquals(expected.nodes.naturalSorted(), graph.nodes.naturalSorted())
         assertEquals(expected.links.naturalSorted(), graph.links.naturalSorted())
     }
-
-    @Test
-    fun test_whenCycle_thenAcyclicGraph() {
-        // given
-        val pkgName = {}.javaClass.enclosingMethod.name
-        val vf = myFixture.createFile(
-            "$pkgName.lca", """
-                process p1 {
-                    products {
-                        1 kg A
-                    }
-                    inputs {
-                        1 kg B
-                    }
-                }
-                process p2 {
-                    products {
-                        1 kg B
-                    }
-                    inputs {
-                        0.5 kg A
-                    }
-                    emissions {
-                        1 kg C
-                    }
-                }
-                """.trimIndent()
-        )
-        val (sankeyPort, analysis, comparator) = getRequiredInformation("p1", vf)
-        val sut = SankeyGraphBuilder(analysis, comparator)
-
-        // when
-        val graph = sut.buildContributionGraph(sankeyPort)
-
-        // then
-        val expected = Graph.empty().addNode(
-            GraphNode("A from p1{}{}", "A"),
-            GraphNode("B from p2{}{}", "B"),
-            GraphNode("C", "C"),
-        ).addLink(
-            GraphLink("A from p1{}{}", "B from p2{}{}", 4.0, "4 kg"),
-            GraphLink("B from p2{}{}", "C", 2.0, "2 kg"),
-        )
-        assertEquals(expected.nodes.naturalSorted(), graph.nodes.naturalSorted())
-        assertEquals(expected.links.naturalSorted(), graph.links.naturalSorted())
-    }
-
-    @Test
-    fun `When provided with a complex cyclic graph of processes, the generated sankey is acyclic`() {
-        // given
-        val pkgName = {}.javaClass.enclosingMethod.name
-        val vf = myFixture.createFile(
-            "$pkgName.lca", """
-                process pA {
-                    products {
-                        1 kg A
-                    }
-                    inputs {
-                        0.5 kg B
-                        0.5 kg C
-                    }
-                }
-
-                process pB {
-                    products {
-                        1 kg B
-                    }
-                    inputs {
-                        0.5 kg B
-                        1 kg D
-                        1 kg E
-                    }
-                }
-
-                process pC {
-                    products {
-                        1 kg C
-                    }
-                    inputs {
-                        1 kg F
-                    }
-                }
-
-                process pD {
-                    products {
-                        1 kg D
-                    }
-                    inputs {
-                        1 kg F
-                    }
-                }
-
-                process pE {
-                    products {
-                        1 kg E
-                    }
-                    inputs {
-                        1 kg G
-                    }
-                }
-
-                process pF {
-                    products {
-                        1 kg F
-                    }
-                    inputs {
-                        1 kg H
-                    }
-                }
-
-                process pG {
-                    products {
-                        1 kg G
-                    }
-                    inputs {
-                        0.5 kg E
-                        1 kg H
-                    }
-                }
-
-                process pH {
-                    products {
-                        1 kg H
-                    }
-                    emissions {
-                        1 kg my_emission
-                    }
-                } 
-                """.trimIndent()
-        )
-        val (sankeyPort, analysis, comparator) = getRequiredInformation("pA", vf)
-        val sut = SankeyGraphBuilder(analysis, comparator)
-
-        // when
-        val graph = sut.buildContributionGraph(sankeyPort)
-
-        // then
-        val expected = Graph.empty().addNode(
-            GraphNode("A from pA{}{}", "A"),
-            GraphNode("B from pB{}{}", "B"),
-            GraphNode("C from pC{}{}", "C"),
-            GraphNode("D from pD{}{}", "D"),
-            GraphNode("E from pE{}{}", "E"),
-            GraphNode("F from pF{}{}", "F"),
-            GraphNode("G from pG{}{}", "G"),
-            GraphNode("H from pH{}{}", "H"),
-            GraphNode("my_emission", "my_emission")
-        ).addLink(
-            GraphLink("F from pF{}{}", "H from pH{}{}", value = 1.5, "1.5 kg"),
-            GraphLink("C from pC{}{}", "F from pF{}{}", value = 0.5, "5E-1 kg"),
-            GraphLink("A from pA{}{}", "B from pB{}{}", value = 3.0, "3 kg"),
-            GraphLink("A from pA{}{}", "C from pC{}{}", value = 0.5, "5E-1 kg"),
-            GraphLink("D from pD{}{}", "F from pF{}{}", value = 1.0, "1 kg"),
-            GraphLink("H from pH{}{}", "my_emission", value = 3.5, "3.5 kg"),
-            GraphLink("B from pB{}{}", "D from pD{}{}", value = 1.0, "1 kg"),
-            GraphLink("B from pB{}{}", "E from pE{}{}", value = 2.0, "2 kg"),
-            GraphLink("E from pE{}{}", "G from pG{}{}", value = 4.0, "4 kg"),
-            GraphLink("G from pG{}{}", "H from pH{}{}", value = 2.0, "2 kg"),
-        )
-
-        assertEquals(expected.nodes.naturalSorted(), graph.nodes.naturalSorted())
-        expected.links.sortBySourceAndTarget().zip(graph.links.sortBySourceAndTarget()).forEach { (expected, actual) ->
-            assertEquals(expected.source, actual.source)
-            assertEquals(expected.target, actual.target)
-            assertEquals(expected.value, actual.value, 0.0001)
-            assertEquals(expected.name, actual.name)
-        }
-    }
-
-    private fun Set<GraphLink>.sortBySourceAndTarget(): List<GraphLink> {
-        return this.sortedBy { "${it.source}, ${it.target}" }
-    }
 }