Sonar fixes

2025-07-19 00:04:19 +02:00
parent 1527ab0cb0
commit 6d58b93477
15 changed files with 339 additions and 335 deletions
--- a/commonUI/src/androidMain/kotlin/ch/dissem/yaep/ui/common/App.android.kt
+++ b/commonUI/src/androidMain/kotlin/ch/dissem/yaep/ui/common/App.android.kt
@@ -3,9 +3,13 @@ package ch.dissem.yaep.ui.common
 import ch.dissem.yaep.domain.Game
 import io.github.oshai.kotlinlogging.KotlinLogging
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+import kotlin.coroutines.CoroutineContext

 private val log = KotlinLogging.logger {}

-actual fun CoroutineScope.logGame(game: Game) {
-    log.debug { "Game: $game" }
+actual fun CoroutineScope.logGame(game: Game, dispatcher: CoroutineContext) {
+    launch(dispatcher) {
+        log.debug { "Game: $game" }
+    }
 }
--- a/commonUI/src/commonMain/kotlin/ch/dissem/yaep/ui/common/App.kt
+++ b/commonUI/src/commonMain/kotlin/ch/dissem/yaep/ui/common/App.kt
@@ -31,17 +31,23 @@ import androidx.compose.ui.unit.TextUnitType
 import androidx.compose.ui.unit.dp
 import ch.dissem.yaep.domain.Clue
 import ch.dissem.yaep.domain.Game
+import ch.dissem.yaep.domain.GameCell
+import ch.dissem.yaep.domain.GameRow
 import ch.dissem.yaep.domain.Grid
 import ch.dissem.yaep.domain.HorizontalClue
+import ch.dissem.yaep.domain.Item
+import ch.dissem.yaep.domain.ItemClass
 import ch.dissem.yaep.domain.NeighbourClue
 import ch.dissem.yaep.domain.OrderClue
 import ch.dissem.yaep.domain.SameColumnClue
 import ch.dissem.yaep.domain.TripletClue
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
 import org.jetbrains.compose.resources.painterResource
 import yaep.commonui.generated.resources.Res
 import yaep.commonui.generated.resources.neighbour
 import yaep.commonui.generated.resources.order
+import kotlin.coroutines.CoroutineContext
 import kotlin.time.ExperimentalTime

 class DisplayClue<C : Clue>(val clue: C) {
@@ -144,59 +150,89 @@ fun PuzzleGrid(
 ) {
    Column(modifier = modifier) {
        for (row in grid) {
-            Row(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .wrapContentHeight()
-            ) {
-                val allOptions = row.options
-                for (item in row) {
-                    var selection by remember(item) { mutableStateOf(item.selection) }
-                    val options = remember(item) {
-                        allOptions.map { Toggleable(it, item.options.contains(it)) }
-                    }
-                    LaunchedEffect(item) {
-                        item.optionsChangedListeners.add { enabled ->
-                            options.forEach { it.enabled = enabled.contains(it.item) }
-                        }
-                        item.selectionChangedListeners.add {
-                            selection = it
-                            onUpdate()
-                        }
-                    }
-                    Selector(
-                        modifier = Modifier
-                            .padding(spacing)
-                            .weight(1f),
-                        spacing,
-                        selectDirectly = selectDirectly,
-                        options = options,
-                        onOptionRemoved = {
-                            grid.snapshot()
-                            item.options.remove(it)
-                            row.cleanupOptions()
-                        },
-                        onOptionAdded = {
-                            item.options.add(it)
-                        },
-                        selectedItem = selection,
-                        onSelectItem = { selectedItem ->
-                            if (selectedItem != null) {
-                                grid.snapshot()
-                                item.selection = selectedItem
-                                row.cleanupOptions()
-                            } else {
-                                while (item.selection != null) {
-                                    if (!grid.undo()) break
-                                }
-                                options.forEach { option ->
-                                    option.enabled = item.options.contains(option.item)
-                                }
-                            }
-                        }
-                    )
+            PuzzleRow(
+                row = row,
+                onUpdate = onUpdate,
+                onSnapshot = { grid.snapshot() },
+                onUndo = { grid.undo() },
+                spacing = spacing,
+                selectDirectly = selectDirectly
+            )
+        }
+    }
+}
+
+@Composable
+private fun PuzzleRow(
+    row: GameRow<ItemClass<*>>,
+    onUpdate: () -> Unit,
+    onSnapshot: () -> Unit,
+    onUndo: () -> Boolean,
+    spacing: Dp,
+    selectDirectly: Boolean
+) {
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .wrapContentHeight()
+    ) {
+        val allOptions = row.options
+        for (cell in row) {
+            var selection by remember(cell) { mutableStateOf(cell.selection) }
+            val options = remember(cell) {
+                allOptions.map { Toggleable(it, cell.options.contains(it)) }
+            }
+            LaunchedEffect(cell) {
+                cell.optionsChangedListeners.add { enabled ->
+                    options.forEach { it.enabled = enabled.contains(it.item) }
+                }
+                cell.selectionChangedListeners.add {
+                    selection = it
+                    onUpdate()
                }
            }
+            Selector(
+                modifier = Modifier
+                    .padding(spacing)
+                    .weight(1f),
+                spacing,
+                selectDirectly = selectDirectly,
+                options = options,
+                onOptionRemoved = {
+                    onSnapshot()
+                    cell.options.remove(it)
+                    row.cleanupOptions()
+                },
+                onOptionAdded = {
+                    cell.options.add(it)
+                },
+                selectedItem = selection,
+                onSelectItem = { selectedItem ->
+                    onSelectItem(row, cell, options, selectedItem, onSnapshot, onUndo)
+                }
+            )
+        }
+    }
+}
+
+private fun onSelectItem(
+    row: GameRow<ItemClass<*>>,
+    cell: GameCell<ItemClass<*>>,
+    options: List<Toggleable<Item<ItemClass<*>>>>,
+    selectedItem: Item<ItemClass<*>>?,
+    onSnapshot: () -> Unit,
+    onUndo: () -> Boolean
+) {
+    if (selectedItem != null) {
+        onSnapshot()
+        cell.selection = selectedItem
+        row.cleanupOptions()
+    } else {
+        while (cell.selection != null) {
+            if (!onUndo()) break
+        }
+        options.forEach { option ->
+            option.enabled = cell.options.contains(option.item)
        }
    }
 }
@@ -269,7 +305,7 @@ fun VerticalClue(
    }
 }

-expect fun CoroutineScope.logGame(game: Game)
+expect fun CoroutineScope.logGame(game: Game, dispatcher: CoroutineContext = Dispatchers.IO)

@Composable
 fun ClueCard(
--- a/commonUI/src/commonMain/kotlin/ch/dissem/yaep/ui/common/theme/Theme.kt
+++ b/commonUI/src/commonMain/kotlin/ch/dissem/yaep/ui/common/theme/Theme.kt
@@ -1,11 +1,10 @@
 package ch.dissem.yaep.ui.common.theme
+
 import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.darkColorScheme
 import androidx.compose.material3.lightColorScheme
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.Immutable
-import androidx.compose.ui.graphics.Color

 private val lightScheme = lightColorScheme(
    primary = primaryLight,
@@ -83,192 +82,19 @@ private val darkScheme = darkColorScheme(
    surfaceContainerHighest = surfaceContainerHighestDark,
 )

-private val mediumContrastLightColorScheme = lightColorScheme(
-    primary = primaryLightMediumContrast,
-    onPrimary = onPrimaryLightMediumContrast,
-    primaryContainer = primaryContainerLightMediumContrast,
-    onPrimaryContainer = onPrimaryContainerLightMediumContrast,
-    secondary = secondaryLightMediumContrast,
-    onSecondary = onSecondaryLightMediumContrast,
-    secondaryContainer = secondaryContainerLightMediumContrast,
-    onSecondaryContainer = onSecondaryContainerLightMediumContrast,
-    tertiary = tertiaryLightMediumContrast,
-    onTertiary = onTertiaryLightMediumContrast,
-    tertiaryContainer = tertiaryContainerLightMediumContrast,
-    onTertiaryContainer = onTertiaryContainerLightMediumContrast,
-    error = errorLightMediumContrast,
-    onError = onErrorLightMediumContrast,
-    errorContainer = errorContainerLightMediumContrast,
-    onErrorContainer = onErrorContainerLightMediumContrast,
-    background = backgroundLightMediumContrast,
-    onBackground = onBackgroundLightMediumContrast,
-    surface = surfaceLightMediumContrast,
-    onSurface = onSurfaceLightMediumContrast,
-    surfaceVariant = surfaceVariantLightMediumContrast,
-    onSurfaceVariant = onSurfaceVariantLightMediumContrast,
-    outline = outlineLightMediumContrast,
-    outlineVariant = outlineVariantLightMediumContrast,
-    scrim = scrimLightMediumContrast,
-    inverseSurface = inverseSurfaceLightMediumContrast,
-    inverseOnSurface = inverseOnSurfaceLightMediumContrast,
-    inversePrimary = inversePrimaryLightMediumContrast,
-    surfaceDim = surfaceDimLightMediumContrast,
-    surfaceBright = surfaceBrightLightMediumContrast,
-    surfaceContainerLowest = surfaceContainerLowestLightMediumContrast,
-    surfaceContainerLow = surfaceContainerLowLightMediumContrast,
-    surfaceContainer = surfaceContainerLightMediumContrast,
-    surfaceContainerHigh = surfaceContainerHighLightMediumContrast,
-    surfaceContainerHighest = surfaceContainerHighestLightMediumContrast,
-)
-
-private val highContrastLightColorScheme = lightColorScheme(
-    primary = primaryLightHighContrast,
-    onPrimary = onPrimaryLightHighContrast,
-    primaryContainer = primaryContainerLightHighContrast,
-    onPrimaryContainer = onPrimaryContainerLightHighContrast,
-    secondary = secondaryLightHighContrast,
-    onSecondary = onSecondaryLightHighContrast,
-    secondaryContainer = secondaryContainerLightHighContrast,
-    onSecondaryContainer = onSecondaryContainerLightHighContrast,
-    tertiary = tertiaryLightHighContrast,
-    onTertiary = onTertiaryLightHighContrast,
-    tertiaryContainer = tertiaryContainerLightHighContrast,
-    onTertiaryContainer = onTertiaryContainerLightHighContrast,
-    error = errorLightHighContrast,
-    onError = onErrorLightHighContrast,
-    errorContainer = errorContainerLightHighContrast,
-    onErrorContainer = onErrorContainerLightHighContrast,
-    background = backgroundLightHighContrast,
-    onBackground = onBackgroundLightHighContrast,
-    surface = surfaceLightHighContrast,
-    onSurface = onSurfaceLightHighContrast,
-    surfaceVariant = surfaceVariantLightHighContrast,
-    onSurfaceVariant = onSurfaceVariantLightHighContrast,
-    outline = outlineLightHighContrast,
-    outlineVariant = outlineVariantLightHighContrast,
-    scrim = scrimLightHighContrast,
-    inverseSurface = inverseSurfaceLightHighContrast,
-    inverseOnSurface = inverseOnSurfaceLightHighContrast,
-    inversePrimary = inversePrimaryLightHighContrast,
-    surfaceDim = surfaceDimLightHighContrast,
-    surfaceBright = surfaceBrightLightHighContrast,
-    surfaceContainerLowest = surfaceContainerLowestLightHighContrast,
-    surfaceContainerLow = surfaceContainerLowLightHighContrast,
-    surfaceContainer = surfaceContainerLightHighContrast,
-    surfaceContainerHigh = surfaceContainerHighLightHighContrast,
-    surfaceContainerHighest = surfaceContainerHighestLightHighContrast,
-)
-
-private val mediumContrastDarkColorScheme = darkColorScheme(
-    primary = primaryDarkMediumContrast,
-    onPrimary = onPrimaryDarkMediumContrast,
-    primaryContainer = primaryContainerDarkMediumContrast,
-    onPrimaryContainer = onPrimaryContainerDarkMediumContrast,
-    secondary = secondaryDarkMediumContrast,
-    onSecondary = onSecondaryDarkMediumContrast,
-    secondaryContainer = secondaryContainerDarkMediumContrast,
-    onSecondaryContainer = onSecondaryContainerDarkMediumContrast,
-    tertiary = tertiaryDarkMediumContrast,
-    onTertiary = onTertiaryDarkMediumContrast,
-    tertiaryContainer = tertiaryContainerDarkMediumContrast,
-    onTertiaryContainer = onTertiaryContainerDarkMediumContrast,
-    error = errorDarkMediumContrast,
-    onError = onErrorDarkMediumContrast,
-    errorContainer = errorContainerDarkMediumContrast,
-    onErrorContainer = onErrorContainerDarkMediumContrast,
-    background = backgroundDarkMediumContrast,
-    onBackground = onBackgroundDarkMediumContrast,
-    surface = surfaceDarkMediumContrast,
-    onSurface = onSurfaceDarkMediumContrast,
-    surfaceVariant = surfaceVariantDarkMediumContrast,
-    onSurfaceVariant = onSurfaceVariantDarkMediumContrast,
-    outline = outlineDarkMediumContrast,
-    outlineVariant = outlineVariantDarkMediumContrast,
-    scrim = scrimDarkMediumContrast,
-    inverseSurface = inverseSurfaceDarkMediumContrast,
-    inverseOnSurface = inverseOnSurfaceDarkMediumContrast,
-    inversePrimary = inversePrimaryDarkMediumContrast,
-    surfaceDim = surfaceDimDarkMediumContrast,
-    surfaceBright = surfaceBrightDarkMediumContrast,
-    surfaceContainerLowest = surfaceContainerLowestDarkMediumContrast,
-    surfaceContainerLow = surfaceContainerLowDarkMediumContrast,
-    surfaceContainer = surfaceContainerDarkMediumContrast,
-    surfaceContainerHigh = surfaceContainerHighDarkMediumContrast,
-    surfaceContainerHighest = surfaceContainerHighestDarkMediumContrast,
-)
-
-private val highContrastDarkColorScheme = darkColorScheme(
-    primary = primaryDarkHighContrast,
-    onPrimary = onPrimaryDarkHighContrast,
-    primaryContainer = primaryContainerDarkHighContrast,
-    onPrimaryContainer = onPrimaryContainerDarkHighContrast,
-    secondary = secondaryDarkHighContrast,
-    onSecondary = onSecondaryDarkHighContrast,
-    secondaryContainer = secondaryContainerDarkHighContrast,
-    onSecondaryContainer = onSecondaryContainerDarkHighContrast,
-    tertiary = tertiaryDarkHighContrast,
-    onTertiary = onTertiaryDarkHighContrast,
-    tertiaryContainer = tertiaryContainerDarkHighContrast,
-    onTertiaryContainer = onTertiaryContainerDarkHighContrast,
-    error = errorDarkHighContrast,
-    onError = onErrorDarkHighContrast,
-    errorContainer = errorContainerDarkHighContrast,
-    onErrorContainer = onErrorContainerDarkHighContrast,
-    background = backgroundDarkHighContrast,
-    onBackground = onBackgroundDarkHighContrast,
-    surface = surfaceDarkHighContrast,
-    onSurface = onSurfaceDarkHighContrast,
-    surfaceVariant = surfaceVariantDarkHighContrast,
-    onSurfaceVariant = onSurfaceVariantDarkHighContrast,
-    outline = outlineDarkHighContrast,
-    outlineVariant = outlineVariantDarkHighContrast,
-    scrim = scrimDarkHighContrast,
-    inverseSurface = inverseSurfaceDarkHighContrast,
-    inverseOnSurface = inverseOnSurfaceDarkHighContrast,
-    inversePrimary = inversePrimaryDarkHighContrast,
-    surfaceDim = surfaceDimDarkHighContrast,
-    surfaceBright = surfaceBrightDarkHighContrast,
-    surfaceContainerLowest = surfaceContainerLowestDarkHighContrast,
-    surfaceContainerLow = surfaceContainerLowDarkHighContrast,
-    surfaceContainer = surfaceContainerDarkHighContrast,
-    surfaceContainerHigh = surfaceContainerHighDarkHighContrast,
-    surfaceContainerHighest = surfaceContainerHighestDarkHighContrast,
-)
-
-@Immutable
-data class ColorFamily(
-    val color: Color,
-    val onColor: Color,
-    val colorContainer: Color,
-    val onColorContainer: Color
-)
-
-val unspecified_scheme = ColorFamily(
-    Color.Unspecified, Color.Unspecified, Color.Unspecified, Color.Unspecified
-)
-
@Composable
 fun AppTheme(
    darkTheme: Boolean = isSystemInDarkTheme(),
    content: @Composable() () -> Unit
 ) {
-  val colorScheme = when {
-      darkTheme -> darkScheme
-      else -> lightScheme
-  }
-//  val view = LocalView.current
-//  if (!view.isInEditMode) {
-//    SideEffect {
-//      val window = (view.context as Activity).window
-//      window.statusBarColor = colorScheme.primary.toArgb()
-//      WindowCompat.getInsetsController(window, view).isAppearanceLightStatusBars = darkTheme
-//    }
-//  }
+    val colorScheme = when {
+        darkTheme -> darkScheme
+        else -> lightScheme
+    }

-  MaterialTheme(
-    colorScheme = colorScheme,
-//    typography = AppTypography,
-    content = content
-  )
+    MaterialTheme(
+        colorScheme = colorScheme,
+        content = content
+    )
 }

--- a/commonUI/src/jvmMain/kotlin/ch/dissem/yaep/ui/common/App.jvm.kt
+++ b/commonUI/src/jvmMain/kotlin/ch/dissem/yaep/ui/common/App.jvm.kt
@@ -3,8 +3,8 @@ package ch.dissem.yaep.ui.common
 import ch.dissem.yaep.domain.Game
 import io.github.oshai.kotlinlogging.KotlinLogging
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
+import kotlin.coroutines.CoroutineContext
 import kotlin.io.path.Path
 import kotlin.io.path.createFile
 import kotlin.io.path.isDirectory
@@ -15,8 +15,8 @@ import kotlin.time.ExperimentalTime
 private val log = KotlinLogging.logger {}

@OptIn(ExperimentalTime::class)
-actual fun CoroutineScope.logGame(game: Game) {
-    launch(Dispatchers.IO) {
+actual fun CoroutineScope.logGame(game: Game, dispatcher: CoroutineContext) {
+    launch(dispatcher) {
        val dirName = """${System.getProperty("user.home")}/.yaep"""
        val dir = Path(dirName)
        if (dir.isDirectory()) {