add new preference service

src/main/kotlin/dartzee/preferences/DefaultPreferenceService.kt

@@ -0,0 +1,35 @@
+package dartzee.preferences
+
+import dartzee.utils.NODE_PREFERENCES
+import java.util.prefs.Preferences
+
+class DefaultPreferenceService : IPreferenceService {
+    private val preferences = Preferences.userRoot().node(NODE_PREFERENCES)
+
+    override fun <T : Any> delete(preference: Preference<T>) {
+        preferences.remove(preference.name)
+    }
+
+    override fun <T : Any> save(preference: Preference<T>, value: T) {
+        preferences.put(preference.name, value.toString())
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    override fun <T : Any> get(preference: Preference<T>, useDefault: Boolean): T {
+        if (useDefault) {
+            return preference.default
+        }
+
+        val raw = preferences.get(preference.name, preference.default.toString())
+        return when (val desiredType = preference.default::class) {
+            Boolean::class -> raw.toBoolean() as T
+            Double::class -> raw.toDouble() as T
+            Int::class -> raw.toInt() as T
+            String::class -> raw as T
+            else ->
+                throw TypeCastException(
+                    "Unhandled type [${desiredType}] for preference ${preference.name}"
+                )
+        }
+    }
+}

src/main/kotlin/dartzee/preferences/IPreferenceService.kt

@@ -0,0 +1,9 @@
+package dartzee.preferences
+
+interface IPreferenceService {
+    fun <T : Any> delete(preference: Preference<T>)
+
+    fun <T : Any> save(preference: Preference<T>, value: T)
+
+    fun <T : Any> get(preference: Preference<T>, useDefault: Boolean = false): T
+}

src/main/kotlin/dartzee/preferences/Preference.kt

@@ -0,0 +1,3 @@
+package dartzee.preferences
+
+data class Preference<T>(val name: String, val default: T)

src/main/kotlin/dartzee/preferences/Preferences.kt

@@ -0,0 +1,26 @@
+package dartzee.preferences
+
+import dartzee.utils.DartsColour.DARTBOARD_BLACK_STR
+import dartzee.utils.DartsColour.DARTBOARD_GREEN_STR
+import dartzee.utils.DartsColour.DARTBOARD_RED_STR
+import dartzee.utils.DartsColour.DARTBOARD_WHITE_STR
+
+object Preferences {
+    val oddSingleColour = Preference("oddsing", DARTBOARD_WHITE_STR)
+    val oddDoubleColour = Preference("odddoub", DARTBOARD_GREEN_STR)
+    val oddTrebleColour = Preference("oddtreb", DARTBOARD_GREEN_STR)
+    val eventSingleColour = Preference("evensing", DARTBOARD_BLACK_STR)
+    val evenDoubleColour = Preference("evendoub", DARTBOARD_RED_STR)
+    val evenTrebleColour = Preference("eventreb", DARTBOARD_RED_STR)
+
+    val aiAutoContinue = Preference("aiauto", true)
+    val checkForUpdates = Preference("chkupd", true)
+    val showAnimations = Preference("anim", true)
+
+    val aiSpeed = Preference("aispd", 1000)
+    val leaderboardSize = Preference("ldbrdsz", 50)
+
+    val hueFactor = Preference("huefactor", 0.8)
+    val fgBrightness = Preference("fgbri", 0.5)
+    val bgBrightness = Preference("bgbri", 1)
+}

src/test/kotlin/dartzee/preferences/PreferenceServiceTest.kt

@@ -0,0 +1,89 @@
+package dartzee.preferences
+
+import dartzee.helper.AbstractTest
+import io.kotest.assertions.throwables.shouldNotThrowAny
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.matchers.shouldBe
+import kotlin.reflect.full.memberProperties
+import org.junit.jupiter.api.AfterEach
+import org.junit.jupiter.api.Test
+
+private val STRING_PREF = Preference("fake_string", "foo")
+private val INT_PREF = Preference("fake_int", 20)
+private val DOUBLE_PREF = Preference("fake_double", 2.5)
+private val BOOLEAN_PREF = Preference("fake_boolean", false)
+
+class DefaultPreferenceServiceTest : AbstractTest(), PreferenceServiceTest {
+    override val implementation = DefaultPreferenceService()
+}
+
+interface PreferenceServiceTest {
+    val implementation: IPreferenceService
+
+    @AfterEach
+    fun afterEach() {
+        implementation.delete(STRING_PREF)
+        implementation.delete(INT_PREF)
+        implementation.delete(DOUBLE_PREF)
+        implementation.delete(BOOLEAN_PREF)
+    }
+
+    @Test
+    @Suppress("UNCHECKED_CAST")
+    fun `Should be able to get defaults for all preferences`() {
+        Preferences::class.memberProperties.forEach { member ->
+            val pref = member.get(Preferences) as Preference<Any>
+
+            shouldNotThrowAny { implementation.get(pref, true) }
+        }
+    }
+
+    @Test
+    fun `Getting and setting strings`() {
+        implementation.get(STRING_PREF) shouldBe "foo"
+
+        implementation.save(STRING_PREF, "bar")
+
+        implementation.get(STRING_PREF) shouldBe "bar"
+        implementation.get(STRING_PREF, true) shouldBe "foo"
+    }
+
+    @Test
+    fun `Getting and setting booleans`() {
+        implementation.get(BOOLEAN_PREF) shouldBe false
+
+        implementation.save(BOOLEAN_PREF, true)
+
+        implementation.get(BOOLEAN_PREF) shouldBe true
+        implementation.get(BOOLEAN_PREF, true) shouldBe false
+    }
+
+    @Test
+    fun `Getting and setting ints`() {
+        implementation.get(INT_PREF) shouldBe 20
+
+        implementation.save(INT_PREF, 5000)
+
+        implementation.get(INT_PREF) shouldBe 5000
+        implementation.get(INT_PREF, true) shouldBe 20
+    }
+
+    @Test
+    fun `Getting and setting doubles`() {
+        implementation.get(DOUBLE_PREF) shouldBe 2.5
+
+        implementation.save(DOUBLE_PREF, 0.00017)
+
+        implementation.get(DOUBLE_PREF) shouldBe 0.00017
+        implementation.get(DOUBLE_PREF, true) shouldBe 2.5
+    }
+
+    @Test
+    fun `Unsupported type`() {
+        val pref = Preference("listPreference", listOf(5))
+
+        val t = shouldThrow<TypeCastException> { implementation.get(pref) }
+        t.message shouldBe
+            "Unhandled type [class java.util.Collections\$SingletonList] for preference listPreference"
+    }
+}