Add default values to Construct fields

It makes more sense to put the default values in the Construct definitions rather than nested deep in the sentences compiler plugin.

Author: Stypox

sentences-compiler-plugin/src/main/kotlin/org/stypox/dicio/sentencesCompilerPlugin/gen/GenerateConstruct.kt

@@ -31,23 +31,23 @@ fun generateConstruct(construct: Construct): CodeBlock {
 
 fun generateWord(word: Word): CodeBlock {
     return CodeBlock.of(
-        "%T(%S, %L, %L, %Lf)",
+        "%T(%S, %L, %L)",
         ClassName("org.dicio.skill.standard.construct", "WordConstruct"),
         word.normalizedValue,
         /* isRegex = */ false,
         word.isDiacriticsSensitive,
-        1.0f // TODO allow specifying weight
+        // TODO allow specifying weight
     )
 }
 
 fun generateWordWithVariations(word: WordWithVariations): CodeBlock {
     return CodeBlock.of(
-        "%T(%S, %L, %L, %Lf)",
+        "%T(%S, %L, %L)",
         ClassName("org.dicio.skill.standard.construct", "WordConstruct"),
         word.toJavaRegex(),
         /* isRegex = */ true,
         word.isDiacriticsSensitive,
-        1.0f // TODO allow specifying weight
+        // TODO allow specifying weight
     )
 }
 
@@ -68,10 +68,10 @@ fun generateOptionalConstruct(): CodeBlock {
 
 fun generateCapturingGroup(capturingGroup: CapturingGroup): CodeBlock {
     return CodeBlock.of(
-        "%T(%S, %Lf)",
+        "%T(%S)",
         ClassName("org.dicio.skill.standard.construct", "CapturingConstruct"),
         capturingGroup.name,
-        0.0f // TODO allow specifying weight
+        // TODO allow specifying weight
     )
 }
 

skill/src/main/java/org/dicio/skill/standard/construct/CapturingConstruct.kt

@@ -7,7 +7,12 @@ import org.dicio.skill.standard.util.normalizeMemToEnd
 
 data class CapturingConstruct(
     private val name: String,
-    private val weight: Float
+    // By default, don't assign extra points for having matched a capturing group: the fact that the
+    // capturing group can match any part of the input already gives enough points from the words
+    // that were actually matched. Also, if there is an optional word next to a capturing group that
+    // matches with an input word, this will ensure that it is not included in the capturing group
+    // but is instead matched.
+    private val weight: Float = 0.0f,
 ) : Construct {
     override fun matchToEnd(memToEnd: Array<StandardScore>, helper: MatchHelper) {
         val cumulativeWeight = helper.cumulativeWeight

skill/src/main/java/org/dicio/skill/standard/construct/DateTimeConstruct.kt

@@ -10,11 +10,11 @@ import org.dicio.skill.standard.util.MatchHelper
  */
 class DateTimeConstruct(
     name: String,
-    weight: Float,
-    bonusIfLargestPossible: Float,
-    private val now: () -> LocalDateTime,
-    private val shortScale: Boolean,
-    private val preferMonthBeforeDay: Boolean,
+    weight: Float = DEFAULT_WEIGHT,
+    bonusIfLargestPossible: Float = DEFAULT_BONUS_IF_LARGEST_POSSIBLE,
+    private val now: () -> LocalDateTime = { LocalDateTime.now() },
+    private val shortScale: Boolean = true,
+    private val preferMonthBeforeDay: Boolean = false,
 ) : RangesConstruct<LocalDateTime>(name, weight, bonusIfLargestPossible) {
 
     override fun parserParams(helper: MatchHelper): ParserParams<LocalDateTime>? {

skill/src/main/java/org/dicio/skill/standard/construct/DurationConstruct.kt

@@ -10,9 +10,9 @@ import org.dicio.skill.standard.util.MatchHelper
  */
 class DurationConstruct(
     name: String,
-    weight: Float,
-    bonusIfLargestPossible: Float,
-    private val shortScale: Boolean,
+    weight: Float = DEFAULT_WEIGHT,
+    bonusIfLargestPossible: Float = DEFAULT_BONUS_IF_LARGEST_POSSIBLE,
+    private val shortScale: Boolean = true,
 ) : RangesConstruct<Duration>(name, weight, bonusIfLargestPossible) {
 
     override fun parserParams(helper: MatchHelper): ParserParams<Duration>? {

skill/src/main/java/org/dicio/skill/standard/construct/NumberConstruct.kt

@@ -10,11 +10,11 @@ import org.dicio.skill.standard.util.MatchHelper
  */
 class NumberConstruct(
     name: String,
-    weight: Float,
-    bonusIfLargestPossible: Float,
-    private val shortScale: Boolean,
-    private val preferOrdinal: Boolean,
-    private val integerOnly: Boolean,
+    weight: Float = DEFAULT_WEIGHT,
+    bonusIfLargestPossible: Float = DEFAULT_BONUS_IF_LARGEST_POSSIBLE,
+    private val shortScale: Boolean = true,
+    private val preferOrdinal: Boolean = false,
+    private val integerOnly: Boolean = false,
 ) : RangesConstruct<Number>(name, weight, bonusIfLargestPossible) {
 
     override fun parserParams(helper: MatchHelper): ParserParams<Number>? {

skill/src/main/java/org/dicio/skill/standard/construct/RangesConstruct.kt

@@ -15,8 +15,8 @@ import org.dicio.skill.standard.util.normalizeMemToEnd
  */
 abstract class RangesConstruct<T>(
     private val name: String,
-    private val weight: Float,
-    private val bonusIfLargestPossible: Float,
+    private val weight: Float = DEFAULT_WEIGHT,
+    private val bonusIfLargestPossible: Float = DEFAULT_BONUS_IF_LARGEST_POSSIBLE,
 ) : Construct {
 
     /**
@@ -75,4 +75,11 @@ abstract class RangesConstruct<T>(
     override fun toString(): String {
         return ".$name:${this::class.simpleName?.removeSuffix("Construct")}."
     }
+
+    companion object {
+        // TODO these seem sensible default values after playing around a bit, but they haven't been
+        //  fine-tuned very well
+        protected const val DEFAULT_WEIGHT = 1.0f
+        protected const val DEFAULT_BONUS_IF_LARGEST_POSSIBLE = 0.5f
+    }
 }

skill/src/main/java/org/dicio/skill/standard/construct/WordConstruct.kt

@@ -9,7 +9,7 @@ data class WordConstruct(
     private val text: String,
     private val isRegex: Boolean,
     private val isDiacriticsSensitive: Boolean,
-    private val weight: Float,
+    private val weight: Float = 1.0f,
 ) : Construct {
     private val compiledRegex = if (isRegex) Regex(text) else null