From 799bcebfb2bc87d2e6b156a21df1a174b2557561 Mon Sep 17 00:00:00 2001
From: Hubert Van De Walle <huvw@odoo.com>
Date: Fri, 13 Sep 2024 16:44:49 +0200
Subject: [PATCH] Use delegates instead of recursive computes when generating
 args

---
 odoo/build.gradle.kts              |   1 -
 odoo/src/CliGenerator.kt           | 105 +++++++++++++
 odoo/src/ContextGenerator.kt       | 137 +++--------------
 odoo/src/Odoo.kt                   | 227 ++++++++++++++---------------
 odoo/src/actions/ActionProvider.kt |  10 +-
 odoo/src/actions/LaunchAction.kt   |  12 +-
 odoo/src/commands/LaunchCommand.kt |  42 +-----
 odoo/src/commands/Widgets.kt       |   8 +-
 8 files changed, 256 insertions(+), 286 deletions(-)
 create mode 100644 odoo/src/CliGenerator.kt

diff --git a/odoo/build.gradle.kts b/odoo/build.gradle.kts
index 9840ddc..17a5dc2 100644
--- a/odoo/build.gradle.kts
+++ b/odoo/build.gradle.kts
@@ -16,7 +16,6 @@ dependencies {
     implementation(libs.process)
     implementation(libs.xmlbuilder)
     implementation(libs.kodein.di)
-    implementation(libs.kotlin.reflect)
     implementation(libs.serialization.json)
 
     testImplementation(testFixtures(project(":workspace")))
diff --git a/odoo/src/CliGenerator.kt b/odoo/src/CliGenerator.kt
new file mode 100644
index 0000000..57824cc
--- /dev/null
+++ b/odoo/src/CliGenerator.kt
@@ -0,0 +1,105 @@
+package com.github.hubvd.odootools.odoo
+
+import kotlin.properties.PropertyDelegateProvider
+import kotlin.properties.ReadOnlyProperty
+import kotlin.reflect.KProperty
+
+class OptionCompute(
+    val name: String,
+    initialValue: String?,
+    private val block: (() -> String?)? = null,
+) : ReadOnlyProperty<CliGenerator, String?> {
+    private var value = initialValue
+    private var hasBeenCalled = false
+
+    fun get(): String? {
+        if (value == null && !hasBeenCalled && block != null) {
+            value = block()
+            hasBeenCalled = true
+        }
+        return value
+    }
+
+    override fun getValue(thisRef: CliGenerator, property: KProperty<*>) = get()
+}
+
+class EnvCompute(
+    val name: String,
+    private val block: (() -> String?)? = null,
+) : ReadOnlyProperty<CliGenerator, String?> {
+    private var value: String? = null
+    private var hasBeenCalled = false
+
+    fun get(): String? {
+        if (!hasBeenCalled && block != null) {
+            value = block()
+            hasBeenCalled = true
+        }
+        return value
+    }
+
+    override fun getValue(thisRef: CliGenerator, property: KProperty<*>) = get()
+}
+
+class FlagCompute(
+    val name: String,
+    initialValue: Boolean,
+    private val block: (() -> Boolean)? = null,
+) : ReadOnlyProperty<CliGenerator, Boolean> {
+    private var value = initialValue
+    private var hasBeenCalled = false
+
+    fun get(): Boolean {
+        if (!value && !hasBeenCalled && block != null) {
+            value = block()
+            hasBeenCalled = true
+        }
+        return value
+    }
+
+    override fun getValue(thisRef: CliGenerator, property: KProperty<*>) = get()
+}
+
+abstract class CliGenerator(
+    options: Map<String, String>,
+    flags: Set<String>,
+) {
+
+    private val options: MutableMap<String, String> = options.toMap(HashMap())
+    private val flags = flags.toHashSet()
+    private val camelCaseRe = Regex("([a-z0-9])([A-Z])")
+
+    val registeredOptions = ArrayList<OptionCompute>()
+    val registeredFlags = ArrayList<FlagCompute>()
+    val registeredEnv = ArrayList<EnvCompute>()
+    val registeredEffects = ArrayList<() -> Unit>()
+
+    fun effect(block: () -> Unit) {
+        registeredEffects += block
+    }
+
+    fun option(
+        block: (() -> String?)? = null,
+    ): PropertyDelegateProvider<CliGenerator, ReadOnlyProperty<CliGenerator, String?>> =
+        PropertyDelegateProvider { thisRef, property ->
+            val name = camelCaseRe.replace(property.name, "\$1-\$2").lowercase()
+            OptionCompute(name, options[name], block).also { registeredOptions += it }
+        }
+
+    fun flag(
+        block: (() -> Boolean)? = null,
+    ): PropertyDelegateProvider<CliGenerator, ReadOnlyProperty<CliGenerator, Boolean>> =
+        PropertyDelegateProvider { thisRef, property ->
+            val name = camelCaseRe.replace(property.name, "\$1-\$2").lowercase()
+            FlagCompute(name, flags.contains(name), block).also { registeredFlags += it }
+        }
+
+    fun env(
+        name: String? = null,
+        block: () -> String?,
+    ): PropertyDelegateProvider<CliGenerator, ReadOnlyProperty<CliGenerator, String?>> =
+        PropertyDelegateProvider { thisRef, property ->
+            val name = name ?: camelCaseRe.replace(property.name, "\$1_\$2").uppercase()
+            EnvCompute(name, block).also { registeredEnv += it }
+        }
+}
diff --git a/odoo/src/ContextGenerator.kt b/odoo/src/ContextGenerator.kt
index 1208547..c067fa1 100644
--- a/odoo/src/ContextGenerator.kt
+++ b/odoo/src/ContextGenerator.kt
@@ -5,11 +5,7 @@ import com.github.ajalt.clikt.parameters.options.OptionWithValues
 import com.github.hubvd.odootools.odoo.commands.*
 import com.github.hubvd.odootools.workspace.Workspace
 import com.github.hubvd.odootools.workspace.WorkspaceConfig
-import java.lang.reflect.Proxy
 import java.nio.file.Path
-import kotlin.reflect.full.declaredMemberProperties
-import kotlin.reflect.jvm.javaGetter
-import kotlin.reflect.typeOf
 
 private typealias StringOption = OptionWithValues<String?, String, String>
 private typealias Flag = OptionWithValues<Boolean, Boolean, Boolean>
@@ -18,15 +14,10 @@ data class RunConfiguration(
     val args: List<String>,
     val env: Map<String, String>,
     val cwd: Path,
-    val context: DslContext,
-    val effects: List<(DslContext) -> Unit>,
+    val odoo: Odoo,
+    val effects: List<() -> Unit>,
 )
 
-@DslMarker
-annotation class CmdComputeDsl
-
-typealias Effect = (DslContext) -> Unit
-
 class ContextGenerator(
     private val options: List<Option>,
     private val arguments: List<String>,
@@ -35,53 +26,7 @@ class ContextGenerator(
     private val config: WorkspaceConfig,
 ) {
 
-    private val graph = HashMap<String, List<String>>()
-    private val computes = HashMap<String, (MutableDslContext) -> Unit>()
-
-    private val effects = ArrayList<Effect>()
-    private val envs = HashMap<String, (MutableDslContext) -> String?>()
-
-    data class Depends(val depends: List<String>)
-
-    @CmdComputeDsl
-    fun effect(block: DslContext.() -> Unit) {
-        effects += block
-    }
-
-    @CmdComputeDsl
-    fun depends(vararg tmpl: String, block: Depends.() -> Unit) {
-        block(Depends(tmpl.toList()))
-    }
-
-    @CmdComputeDsl
-    fun flag(name: String, block: DslContext.() -> Boolean) {
-        computes[name] = { if (block(it)) it.flags += name }
-    }
-
-    @CmdComputeDsl
-    fun option(name: String, block: DslContext.() -> String?) {
-        computes[name] = { cmd -> block(cmd)?.let { cmd.options[name] = it } }
-    }
-
-    @CmdComputeDsl
-    fun Depends.flag(name: String, block: DslContext.() -> Boolean) {
-        graph[name] = depends
-        computes[name] = { if (block(it)) it.flags += name }
-    }
-
-    @CmdComputeDsl
-    fun Depends.option(name: String, block: DslContext.() -> String?) {
-        graph[name] = depends
-        computes[name] = { cmd -> block(cmd)?.let { cmd.options[name] = it } }
-    }
-
-    @CmdComputeDsl
-    fun env(name: String, block: DslContext.() -> String?) {
-        envs[name] = block
-    }
-
-    fun generate(generator: ContextGenerator.() -> Unit): RunConfiguration {
-        generator()
+    fun generate(): RunConfiguration {
         val flags = HashSet<String>()
         val options = HashMap<String, String>()
         val env = HashMap<String, String>()
@@ -106,75 +51,35 @@ class ContextGenerator(
             }
         }
 
-        val camelCaseRe = Regex("([a-z])([A-Z])")
-
-        val proxy = Proxy.newProxyInstance(
-            this.javaClass.classLoader,
-            arrayOf(OdooOptions::class.java),
-        ) { _, method, _ ->
-            val getter = method.declaringClass.kotlin.declaredMemberProperties
-                .find { it.javaGetter == method }
-                ?: error("Unsupported method ${method.name}")
-
-            val optionName = camelCaseRe.replace(getter.name, "\$1-\$2").lowercase()
-
-            when (getter.returnType) {
-                typeOf<String?>() -> options[optionName]
+        val odoo = Odoo(workspace, config, options, flags)
 
-                typeOf<Boolean>() -> flags.contains(optionName)
+        odoo.registeredFlags
+            .filter { it.get() }
+            .forEach { flags.add(it.name) }
 
-                else -> error("Unsupported property type")
-            }
-        } as OdooOptions
+        odoo.registeredOptions
+            .mapNotNull { it.get()?.let { value -> it.name to value } }
+            .forEach { options[it.first] = it.second }
 
-        if (proxy.restart) {
-            options.keys.removeAll(ignoreIfRestart)
-            flags.removeAll(ignoreIfRestart)
+        if (odoo.restart) {
+            ignoreIfRestart.forEach { options.remove(it) }
         }
 
-        val context = MutableDslContext(
-            workspace = workspace,
-            odooOptions = proxy,
-            flags = flags,
-            options = options,
-            env = env,
-            config = config,
-        )
-
-        val queue = computes.keys.toHashSet()
-        queue.removeAll(flags)
-        queue.removeAll(options.keys)
-
-        if (context.restart) {
-            queue.removeAll(ignoreIfRestart)
-        }
+        odoo.registeredEnv
+            .mapNotNull { it.get()?.let { value -> it.name to value } }
+            .forEach { env[it.first] = it.second }
 
-        val filteredEffects: List<Effect> = if (context.dryRun || context.restart) {
+        val filteredEffects: List<() -> Unit> = if (odoo.dryRun || odoo.restart) {
             emptyList()
         } else {
-            effects
+            odoo.registeredEffects
         }
 
-        // TODO: topological sort
-        while (queue.isNotEmpty()) {
-            val iter = queue.iterator()
-            while (iter.hasNext()) {
-                val compute = iter.next()
-                val dependencies = graph[compute] ?: emptyList()
-                if (dependencies.none { it in queue }) {
-                    computes[compute]!!(context)
-                    iter.remove()
-                }
-            }
-        }
-
-        envs.forEach { (name, func) -> func(context)?.let { context.env[name] = it } }
-
-        val args = buildList(arguments.size + context.flags.size + context.options.size) {
+        val args = buildList(arguments.size + flags.size + options.size) {
             val args = arguments.toMutableList()
             if (args.remove("shell")) add("shell")
             addAll(args)
-            context.flags
+            flags
                 .filter { it !in ignores }
                 .forEach {
                     if (it == "odoo-help") {
@@ -183,11 +88,11 @@ class ContextGenerator(
                         add("--$it")
                     }
                 }
-            context.options
+            options
                 .filter { it.key !in ignores }
                 .forEach { add("--${it.key}=${it.value}") }
         }
 
-        return RunConfiguration(args, context.env, workspace.path, context, filteredEffects)
+        return RunConfiguration(args, env, workspace.path, odoo, filteredEffects)
     }
 }
diff --git a/odoo/src/Odoo.kt b/odoo/src/Odoo.kt
index 709c7cc..ec494e2 100644
--- a/odoo/src/Odoo.kt
+++ b/odoo/src/Odoo.kt
@@ -9,6 +9,8 @@ import com.github.hubvd.odootools.odoo.actions.ActionProviderImpl
 import com.github.hubvd.odootools.odoo.commands.CompleteCommand
 import com.github.hubvd.odootools.odoo.commands.LaunchCommand
 import com.github.hubvd.odootools.workspace.WORKSPACE_MODULE
+import com.github.hubvd.odootools.workspace.Workspace
+import com.github.hubvd.odootools.workspace.WorkspaceConfig
 import com.github.hubvd.odootools.workspace.WorkspaceProvider
 import com.github.pgreze.process.Redirect
 import com.github.pgreze.process.process
@@ -20,9 +22,117 @@ import kotlin.math.absoluteValue
 import kotlin.math.roundToInt
 import kotlin.system.exitProcess
 
-val computes: ContextGenerator.() -> Unit = {
-    effect {
-        if (drop && database != null) {
+@Suppress("unused")
+class Odoo(
+    val workspace: Workspace,
+    private val config: WorkspaceConfig,
+    options: Map<String, String>,
+    flags: Set<String>,
+) : CliGenerator(options, flags) {
+    val limitTimeCpu by option { "99999" }
+    val limitTimeReal by option { "99999" }
+
+    val testHoot by option()
+    val testQunit by option()
+    val mobile by flag()
+
+    val testFile by option()
+
+    val testTags by option {
+        if (testHoot != null && workspace.version < 17.2f) {
+            throw UsageError("HOOT not available before 17.2")
+        }
+        when {
+            testHoot != null && mobile -> "/qunit:WebSuiteMobile.test_hoot"
+            testHoot != null -> "/qunit:WebSuite.test_hoot"
+            testQunit != null && mobile -> "/qunit:WebSuiteMobile.test_qunit"
+            testQunit != null -> "/qunit:WebSuite.test_qunit"
+            else -> null
+        }
+    }
+
+    val testEnable by flag { testTags != null || testFile != null }
+
+    val httpPort by option {
+        when {
+            workspace.name == workspace.base && database == workspace.name -> {
+                (workspace.version * 100).roundToInt()
+            }
+
+            workspace.name == workspace.base && database == "${workspace.name}-test" -> {
+                (workspace.version * 100 + 5).roundToInt()
+            }
+
+            else -> {
+                val min = 2000
+                val max = 65535
+                (min + database.hashCode().absoluteValue % (max - min + 1))
+            }
+        }.let {
+            when (it) {
+                1720 -> 1721 // reserved port..
+                else -> it
+            }
+        }.toString()
+    }
+
+    val community by flag()
+    val themes by flag()
+    val drop by flag()
+    val watch by flag()
+    val stepDelay by option()
+    val debug by flag()
+    val dryRun by flag()
+    val restart by flag()
+    val save by option()
+    val noPatch by flag()
+
+    val database by option { if (testEnable) "${workspace.name}-test" else workspace.name }
+    val logHandler by option { if (testEnable) "werkzeug:ERROR" else null }
+    val logLevel by option { if (testEnable) "test" else null }
+    val maxCronThread by option { if (testEnable) "0" else null }
+    val stopAfterInit by flag { testEnable }
+
+    val addonsPath by option {
+        buildList {
+            add("odoo/addons")
+            if (!community) add("enterprise")
+            if (themes) add("design-themes")
+            val customAddonsPath = config.odooToolsPath / "addons"
+            val home = Path(System.getProperty("user.home"))
+            if (customAddonsPath.startsWith(home)) {
+                add("~/" + customAddonsPath.relativeTo(home))
+            } else {
+                add(customAddonsPath)
+            }
+        }.joinToString(",")
+    }
+
+    val init by option {
+        val testTags = testTags ?: return@option null
+        testTags.splitToSequence(',').filter { !it.startsWith('-') }
+            .flatMap { TestTag(it).toAddons(workspace, addonsPath) }.toHashSet().joinToString(",")
+            .takeUnless { it.isEmpty() }
+    }
+
+    val hootFilter by env {
+        val filter = testHoot ?: return@env null
+        URLEncoder.encode(filter, "utf-8")
+    }
+
+    val qunitFilter by env {
+        val testTags = testQunit ?: return@env null
+        URLEncoder.encode(testTags, "utf-8")
+    }
+
+    val qunitWatch by env { if (watch) "1" else null }
+    val stepDelayEnv by env("STEP_DELAY") { stepDelay?.toIntOrNull()?.toString() }
+    val odooWorkspace by env { workspace.path.toString() }
+    val odooDebug by env { if (debug) "1" else null }
+
+    init {
+        effect {
+            if (!drop || database == null) return@effect
             val count = runBlocking {
                 process(
                     "psql",
@@ -49,117 +159,6 @@ val computes: ContextGenerator.() -> Unit = {
             }
         }
     }
-
-    option("limit-time-cpu") { "99999" }
-    option("limit-time-real") { "99999" }
-
-    depends("database") {
-        option("http-port") {
-            when {
-                workspace.name == workspace.base && database == workspace.name -> {
-                    (workspace.version * 100).roundToInt()
-                }
-
-                workspace.name == workspace.base && database == "${workspace.name}-test" -> {
-                    (workspace.version * 100 + 5).roundToInt()
-                }
-
-                else -> {
-                    val min = 2000
-                    val max = 65535
-                    (min + database.hashCode().absoluteValue % (max - min + 1))
-                }
-            }.let {
-                when (it) {
-                    1720 -> 1721 // reserved port..
-                    else -> it
-                }
-            }.toString()
-        }
-    }
-
-    depends("test-tags", "test-file") {
-        flag("test-enable") { testTags != null || testFile != null }
-    }
-
-    depends("test-tags", "addons-path") {
-        option("init") {
-            val testTags = testTags ?: return@option null
-            testTags
-                .splitToSequence(',')
-                .filter { !it.startsWith('-') }
-                .flatMap { TestTag(it).toAddons(workspace, addonsPath) }
-                .toHashSet()
-                .joinToString(",")
-                .takeUnless { it.isEmpty() }
-        }
-    }
-
-    depends("community") {
-        option("addons-path") {
-            buildList {
-                add("odoo/addons")
-                if (!community) add("enterprise")
-                if (themes) add("design-themes")
-                val customAddonsPath = config.odooToolsPath / "addons"
-                val home = Path(System.getProperty("user.home"))
-                if (customAddonsPath.startsWith(home)) {
-                    add("~/" + customAddonsPath.relativeTo(home))
-                } else {
-                    add(customAddonsPath)
-                }
-            }.joinToString(",")
-        }
-    }
-
-    env("HOOT_FILTER") {
-        val filter = testHoot ?: return@env null
-        URLEncoder.encode(filter, "utf-8")
-    }
-
-    env("QUNIT_FILTER") {
-        val testTags = testQunit ?: return@env null
-        URLEncoder.encode(testTags, "utf-8")
-    }
-
-    env("QUNIT_WATCH") {
-        if (watch) "1" else null
-    }
-
-    env("STEP_DELAY") {
-        stepDelay?.toIntOrNull()?.toString()
-    }
-
-    env("ODOO_WORKSPACE") {
-        workspace.path.toString()
-    }
-
-    env("ODOO_DEBUG") {
-        if (debug) "1" else null
-    }
-
-    depends("test-qunit", "mobile") {
-        option("test-tags") {
-            if (testHoot != null && workspace.version < 17.2f) {
-                throw UsageError("HOOT not available before 17.2")
-            }
-            when {
-                testHoot != null && mobile -> "/qunit:WebSuiteMobile.test_hoot"
-                testHoot != null -> "/qunit:WebSuite.test_hoot"
-                testQunit != null && mobile -> "/qunit:WebSuiteMobile.test_qunit"
-                testQunit != null -> "/qunit:WebSuite.test_qunit"
-                else -> null
-            }
-        }
-    }
-
-    depends("test-enable") {
-        flag("stop-after-init") { testEnable }
-        option("log-level") { if (testEnable) "test" else null }
-        option("max-cron-thread") { if (testEnable) "0" else null }
-        option("database") { if (testEnable) "${workspace.name}-test" else workspace.name }
-        option("log-handler") { if (testEnable) "werkzeug:ERROR" else null }
-    }
 }
 
 internal val ODOO_MODULE by DI.Module {
diff --git a/odoo/src/actions/ActionProvider.kt b/odoo/src/actions/ActionProvider.kt
index 3b0ea36..a636357 100644
--- a/odoo/src/actions/ActionProvider.kt
+++ b/odoo/src/actions/ActionProvider.kt
@@ -1,8 +1,8 @@
 package com.github.hubvd.odootools.odoo.actions
 
 import com.github.ajalt.mordant.terminal.Terminal
+import com.github.hubvd.odootools.odoo.Odoo
 import com.github.hubvd.odootools.odoo.RunConfiguration
-import com.github.hubvd.odootools.odoo.commands.DslContext
 import com.github.hubvd.odootools.odoo.commands.runConfigurationWidget
 
 fun interface Action {
@@ -10,13 +10,13 @@ fun interface Action {
 }
 
 fun interface ActionProvider {
-    operator fun invoke(context: DslContext, terminal: Terminal): Action?
+    operator fun invoke(context: Odoo, terminal: Terminal): Action?
 }
 
 class ActionProviderImpl : ActionProvider {
-    override fun invoke(context: DslContext, terminal: Terminal) = when {
-        context.dryRun -> Action { terminal.println(runConfigurationWidget(it)) }
-        context.save != null -> SavePycharmConfiguration(terminal, context.save!!, context.workspace)
+    override fun invoke(odoo: Odoo, terminal: Terminal) = when {
+        odoo.dryRun -> Action { terminal.println(runConfigurationWidget(it)) }
+        odoo.save != null -> SavePycharmConfiguration(terminal, odoo.save!!, odoo.workspace)
         else -> LaunchAction(terminal)
     }
 }
diff --git a/odoo/src/actions/LaunchAction.kt b/odoo/src/actions/LaunchAction.kt
index 3b35a5a..a8e9f40 100644
--- a/odoo/src/actions/LaunchAction.kt
+++ b/odoo/src/actions/LaunchAction.kt
@@ -19,10 +19,10 @@ import kotlin.system.exitProcess
 class LaunchAction(private val terminal: Terminal) : Action {
 
     override fun run(configuration: RunConfiguration) {
-        configuration.effects.forEach { it(configuration.context) }
+        configuration.effects.forEach { it() }
 
         if (System.getenv("TERM") == "xterm-kitty") {
-            ProcessBuilder("kitty", "@", "set-window-title", "--temporary", "odoo:" + configuration.context.database)
+            ProcessBuilder("kitty", "@", "set-window-title", "--temporary", "odoo:" + configuration.odoo.database)
                 .apply {
                     redirectError(ProcessBuilder.Redirect.DISCARD)
                     redirectOutput(ProcessBuilder.Redirect.DISCARD)
@@ -33,8 +33,8 @@ class LaunchAction(private val terminal: Terminal) : Action {
 
         terminal.println(runConfigurationWidget(configuration))
 
-        val useCustomLauncher = !configuration.context.noPatch &&
-            configuration.context.workspace.version > 14
+        val useCustomLauncher = !configuration.odoo.noPatch &&
+            configuration.odoo.workspace.version > 14
 
         val main = if (!useCustomLauncher) {
             "odoo/odoo-bin"
@@ -50,7 +50,7 @@ class LaunchAction(private val terminal: Terminal) : Action {
                 .command(cmd)
                 .inheritIO()
                 .apply { environment().putAll(configuration.env) }
-                .directory(configuration.context.workspace.path.toFile())
+                .directory(configuration.odoo.workspace.path.toFile())
                 .start()
 
         Runtime.getRuntime().addShutdownHook(
@@ -62,7 +62,7 @@ class LaunchAction(private val terminal: Terminal) : Action {
 
         val code = process.waitFor()
 
-        if (configuration.context.testEnable) {
+        if (configuration.odoo.testEnable) {
             runBlocking {
                 process(
                     "notify-send",
diff --git a/odoo/src/commands/LaunchCommand.kt b/odoo/src/commands/LaunchCommand.kt
index f44a5b8..1bf0e71 100644
--- a/odoo/src/commands/LaunchCommand.kt
+++ b/odoo/src/commands/LaunchCommand.kt
@@ -6,49 +6,11 @@ import com.github.ajalt.clikt.parameters.arguments.multiple
 import com.github.ajalt.clikt.parameters.options.Option
 import com.github.hubvd.odootools.odoo.ContextGenerator
 import com.github.hubvd.odootools.odoo.actions.ActionProvider
-import com.github.hubvd.odootools.odoo.computes
-import com.github.hubvd.odootools.workspace.Workspace
 import com.github.hubvd.odootools.workspace.WorkspaceConfig
 import com.github.hubvd.odootools.workspace.Workspaces
 
-interface DslContext : OdooOptions {
-    val workspace: Workspace
-    val config: WorkspaceConfig
-}
-
-class MutableDslContext(
-    override val workspace: Workspace,
-    private val odooOptions: OdooOptions,
-    val flags: MutableSet<String>,
-    val options: MutableMap<String, String>,
-    val env: MutableMap<String, String>,
-    override val config: WorkspaceConfig,
-) : DslContext,
-    OdooOptions by odooOptions
-
 val Option.id: String get() = names.maxBy { it.length }.removePrefix("--")
 
-interface OdooOptions {
-    val community: Boolean
-    val themes: Boolean
-    val noPatch: Boolean
-    val dryRun: Boolean
-    val testQunit: String?
-    val testHoot: String?
-    val addonsPath: String?
-    val mobile: Boolean
-    val watch: Boolean
-    val stepDelay: String?
-    val drop: Boolean
-    val database: String?
-    val testTags: String?
-    val save: String?
-    val debug: Boolean
-    val testEnable: Boolean
-    val testFile: String?
-    val restart: Boolean
-}
-
 class LaunchCommand(
     private val workspaces: Workspaces,
     private val actionProvider: ActionProvider,
@@ -84,8 +46,8 @@ class LaunchCommand(
             workspace,
             ignores,
             config,
-        ).generate(computes)
+        ).generate()
 
-        actionProvider(runConfiguration.context, currentContext.terminal)?.run(runConfiguration)
+        actionProvider(runConfiguration.odoo, currentContext.terminal)?.run(runConfiguration)
     }
 }
diff --git a/odoo/src/commands/Widgets.kt b/odoo/src/commands/Widgets.kt
index e9a411e..09471fe 100644
--- a/odoo/src/commands/Widgets.kt
+++ b/odoo/src/commands/Widgets.kt
@@ -28,8 +28,8 @@ fun runConfigurationWidget(runConfiguration: RunConfiguration) = verticalLayout
 
 class EnvWidget(private val runConfiguration: RunConfiguration) : Widget {
     override fun measure(t: Terminal, width: Int): WidthRange = WidthRange(
-        "workspace=${runConfiguration.context.workspace.path}".length,
-        "workspace=${runConfiguration.context.workspace.path}".length,
+        "workspace=${runConfiguration.odoo.workspace.path}".length,
+        "workspace=${runConfiguration.odoo.workspace.path}".length,
     )
 
     override fun render(t: Terminal, width: Int) = Lines(
@@ -39,7 +39,7 @@ class EnvWidget(private val runConfiguration: RunConfiguration) : Widget {
                     listOf(
                         Span.word("workspace", TextColors.green),
                         Span.word("=", TextColors.gray),
-                        Span.word("${runConfiguration.context.workspace.path}"),
+                        Span.word("${runConfiguration.odoo.workspace.path}"),
                     ),
                 ),
             )
@@ -48,7 +48,7 @@ class EnvWidget(private val runConfiguration: RunConfiguration) : Widget {
                     listOf(
                         Span.word("version", TextColors.green),
                         Span.word("=", TextColors.gray),
-                        Span.word("${runConfiguration.context.workspace.version}"),
+                        Span.word("${runConfiguration.odoo.workspace.version}"),
                     ),
                 ),
             )