update github_release to support environment variables

2.7.2

.github/workflows/publishing_packages.yml

@@ -14,11 +14,6 @@ jobs:
           sed -i -e "s/^version=\([0-9\.]*\)/version=\1-branch_$branch-build${{ github.run_number }}/" gradle.properties
       - name: prebuild
         run: ./gradlew clean build
-      - name: Publish to Gitea
-        continue-on-error: true
-        run: ./gradlew publishAllPublicationsToGiteaRepository
-        env:
-          GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
       - name: Publish package
         continue-on-error: true
         run: ./gradlew --no-parallel publishAllPublicationsToGithubPackagesRepository

.gitignore

@@ -1,4 +1,5 @@
 .idea
+.kotlin
 out/*
 *.iml
 target

CHANGELOG.md

@@ -1,5 +1,66 @@
 # Changelog
 
+## 2.7.2
+
+* `Version`:
+  * `Kotlin`: `2.1.10`
+  * `Serialization`: `1.8.0`
+
+## 2.7.1
+
+* Fixes in parser and checker
+
+## 2.7.0
+
+* `Version`:
+  * `Kotlin`: `2.1.0`
+  * `Coroutines`: `1.10.1`
+* Add WASM support (solution of [#137](https://github.com/InsanusMokrassar/krontab/issues/137))
+
+## 2.6.1
+
+* Fixes in parsing of string parts
+
+## 2.6.0
+
+* Fix of `doOnceTz` behaviour: now it will use local time as utc time to get next waking up time
+
+## 2.5.1
+
+* Add cleaning up of incoming template, which must remove all malformed parts from string template (fix of [#126](https://github.com/InsanusMokrassar/krontab/issues/126))
+* Add support of insufficient amount of arguments (fix of [#126](https://github.com/InsanusMokrassar/krontab/issues/126))
+* `Version`:
+  * `Kotlin`: `2.0.21`
+  * `AndroidXWork`: `2.10.0`
+
+## 2.5.0
+
+* `Version`:
+  * `Kotlin`: `2.0.20`
+  * `Coroutines`: `1.9.0`
+  * `Serialization`: `1.7.3`
+
+## 2.4.0
+
+* `Version`:
+  * `Kotlin`: `2.0.10`
+  * `Coroutines`: `1.8.1`
+  * `Serialization`: `1.7.1`
+  * `Klock`: `5.4.0`
+  * `AndroidXWork`: `2.9.1`
+
+## 2.3.0
+
+* `doWhile` now will guarantee that it will not call `doOnce` more than once for time
+
+## 2.2.9
+
+* `Version`:
+  * `Kotlin`: `1.9.23`
+  * `Serialization`: `1.6.3`
+  * `Klock`: `5.3.2`
+* Fixes in build-in schedulers
+
 ## 2.2.8
 
 * `Version`:

README.md

@@ -8,6 +8,7 @@
 ![Android](https://img.shields.io/badge/Android-green?style=for-the-badge&logo=android&logoColor=white)
 ![Js](https://img.shields.io/badge/JavaScript-323330?style=for-the-badge&logo=javascript&logoColor=F7DF1E)
 ![Linux x64](https://img.shields.io/badge/Linux%20x64-white?style=for-the-badge&logo=linux&logoColor=black)
+![WASM](https://img.shields.io/badge/WASM-654FF0?style=for-the-badge&logo=webassembly&logoColor=white)
 
 [![KDocs](https://img.shields.io/badge/KDocs-323330?style=for-the-badge&logo=Kotlin&logoColor=7F52FF)](https://insanusmokrassar.github.io/krontab/)
 [![Tutorials](https://img.shields.io/badge/Tutorials-0288D1?style=for-the-badge&logo=mkdocs&logoColor=white)](https://docs.inmo.dev/krontab/index.html)

build.gradle

@@ -62,6 +62,11 @@ kotlin {
     linuxX64()
     mingwX64()
     linuxArm64()
+    wasm {
+        browser()
+        nodejs()
+        d8()
+    }
 
 
     sourceSets {
@@ -85,6 +90,7 @@ kotlin {
             dependencies {
                 implementation kotlin('test-common')
                 implementation kotlin('test-annotations-common')
+                implementation kotlin('test')
                 implementation "org.jetbrains.kotlinx:kotlinx-coroutines-test:$kotlin_coroutines_version"
             }
         }

github_release.gradle

@@ -11,12 +11,20 @@ private String getCurrentVersionChangelog(String version) {
     return changelogDataOS.toString().trim()
 }
 
-if (new File(projectDir, "secret.gradle").exists()) {
+
+def githubTokenVariableName = "GITHUB_RELEASE_TOKEN"
+def githubTokenVariableFromEnv = System.getenv(githubTokenVariableName)
+
+def secretFile = new File(projectDir, "secret.gradle")
+if (secretFile.exists() || project.hasProperty(githubTokenVariableName) || (githubTokenVariableFromEnv != "" && githubTokenVariableFromEnv != null)) {
+    if (secretFile.exists()) {
         apply from: './secret.gradle'
+    }
     apply plugin: "com.github.breadmoirai.github-release"
+    def githubReleaseToken = project.hasProperty(githubTokenVariableName) ? project.property(githubTokenVariableName).toString() : githubTokenVariableFromEnv
 
     githubRelease {
-        token "${project.property('GITHUB_RELEASE_TOKEN')}"
+        token githubReleaseToken
 
         owner = "InsanusMokrassar"
         repo = "${rootProject.name}"

gradle.properties

@@ -9,13 +9,13 @@ android.useAndroidX=true
 android.enableJetifier=false
 
 
-kotlin_version=1.9.22
+kotlin_version=2.1.10
-kotlin_coroutines_version=1.8.0
+kotlin_coroutines_version=1.10.1
-kotlin_serialization_version=1.6.2
+kotlin_serialization_version=1.8.0
 
-dokka_version=1.9.10
+dokka_version=2.0.0
 
-klockVersion=5.3.1
+klockVersion=5.4.0
 
 ## Github reease
 
@@ -23,18 +23,18 @@ github_release_plugin_version=2.5.2
 
 ## Android
 
-android_gradle_version=8.1.4
+android_gradle_version=8.7.2
 android_minSdkVersion=21
-android_compileSdkVersion=34
+android_compileSdkVersion=35
-android_buildToolsVersion=34.0.0
+android_buildToolsVersion=35.0.0
 dexcount_version=4.0.0
 junit_version=4.12
 test_ext_junit_version=1.1.3
 espresso_core=3.4.0
 
-androidx_work_version=2.9.0
+androidx_work_version=2.10.0
 
 ## Common
 
-version=2.2.8
+version=2.7.2
-android_code_version=38
+android_code_version=48

gradle/wrapper/gradle-wrapper.properties

@@ -3,4 +3,4 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.5-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.12.1-bin.zip

src/androidMain/kotlin/KronSchedulerWork.kt

@@ -139,10 +139,14 @@ abstract class KronSchedulerWork(
             }
             throw e
         }
-        when (result) {
+        result.checkResults(
-            is Result.Failure -> if (prolongOnFailure) prolong()
+            onFailure = {
-            is Result.Success -> if (prolongOnSuccess) prolong()
+                if (prolongOnFailure) prolong()
+            },
+            onSuccess = {
+                if (prolongOnSuccess) prolong()
             }
+        )
         return result
     }
 }

src/androidMain/kotlin/ResultChecker.kt

@@ -0,0 +1,15 @@
+package dev.inmo.krontab
+
+import android.annotation.SuppressLint
+import androidx.work.ListenableWorker
+
+@SuppressLint("RestrictedApi")
+internal inline fun ListenableWorker.Result.checkResults(
+    onFailure: () -> Unit,
+    onSuccess: () -> Unit
+) {
+    when (this) {
+        is ListenableWorker.Result.Failure -> onFailure()
+        is ListenableWorker.Result.Success -> onSuccess()
+    }
+}

src/commonMain/kotlin/Executes.kt

@@ -35,6 +35,8 @@ suspend inline fun <T> KronScheduler.doOnceLocal(block: (DateTime) -> T): T = do
 /**
  * Execute [block] once at the [KronScheduler.next] time and return result of [block] calculation.
  *
+ * WARNING!!! This method will use local time instead of utc
+ *
  * WARNING!!! If you want to launch it in parallel, you must do this explicitly.
  *
  * WARNING!!! In case if [KronScheduler.next] of [this] instance will return null, [block] will be called immediatelly
@@ -42,7 +44,7 @@ suspend inline fun <T> KronScheduler.doOnceLocal(block: (DateTime) -> T): T = do
 suspend inline fun <T> KronScheduler.doOnceTz(noinline block: suspend (DateTimeTz) -> T): T {
     val time = when (this) {
         is KronSchedulerTz -> nextOrNowWithOffset()
-        else -> nextOrNow().local
+        else -> nextTimeZoned() ?: DateTimeTz.nowLocal()
     }
     delay((time - DateTimeTz.nowLocal()).millisecondsLong)
     return block(time)
@@ -71,9 +73,18 @@ suspend inline fun <T> doOnceTz(
  * Will execute [block] while it will return true as a result of its calculation
  */
 suspend inline fun KronScheduler.doWhile(block: (DateTime) -> Boolean) {
+    var latest: DateTime? = null
     do {
         delay(1L)
-    } while (doOnce(block))
+        val result = doOnce {
+            if (latest != it) {
+                latest = it
+                block(it)
+            } else {
+                null
+            }
+        }
+    } while (result == null || result)
 }
 /**
  * Will execute [block] while it will return true as a result of its calculation
@@ -85,9 +96,18 @@ suspend inline fun KronScheduler.doWhileLocal(block: (DateTime) -> Boolean) = do
  * Will execute [block] while it will return true as a result of its calculation
  */
 suspend inline fun KronScheduler.doWhileTz(noinline block: suspend (DateTimeTz) -> Boolean) {
+    var latest: DateTimeTz? = null
     do {
         delay(1L)
-    } while (doOnceTz(block))
+        val result = doOnceTz {
+            if (latest != it) {
+                latest = it
+                block(it)
+            } else {
+                null
+            }
+        }
+    } while (result == null || result)
 }
 
 /**

src/commonMain/kotlin/KrontabConfig.kt

@@ -1,5 +1,6 @@
 package dev.inmo.krontab
 
+import dev.inmo.krontab.internal.*
 import dev.inmo.krontab.internal.CronDateTimeScheduler
 import dev.inmo.krontab.internal.CronDateTimeSchedulerTz
 import dev.inmo.krontab.internal.createKronScheduler
@@ -94,7 +95,17 @@ value class KrontabConfig(
         var dayOfWeekParsed: Array<Byte>? = null
         var yearParsed: Array<Int>? = null
         var millisecondsParsed: Array<Short>? = null
-        val (secondsSource, minutesSource, hoursSource, dayOfMonthSource, monthSource) = template.split(" ").also {
+        val (secondsSource, minutesSource, hoursSource, dayOfMonthSource, monthSource) = template
+            .split(" ")
+            .filter { checkIncomingPart(it) } // filter garbage from string
+            .let {
+                if (it.size < 5) { // reconstruction in case of insufficient arguments; 5 is amount of required arguments out of latest also code
+                    it + (it.size until 5).map { "*" }
+                } else {
+                    it
+                }
+            }
+            .also {
                 listOfNotNull(
                     it.getOrNull(5),
                     it.getOrNull(6),

src/commonMain/kotlin/SchedulerShortcuts.kt

@@ -34,35 +34,60 @@ val EverySecondScheduler: KronScheduler by lazy {
  * [KronScheduler.next] will always return [korlibs.time.DateTime.now] + one minute
  */
 val EveryMinuteScheduler: KronScheduler by lazy {
-    buildSchedule { minutes { 0 every 1 } }
+    buildSchedule {
+        seconds { at(0) }
+        minutes { 0 every 1 }
+    }
 }
 
 /**
  * [KronScheduler.next] will always return [korlibs.time.DateTime.now] + one hour
  */
 val EveryHourScheduler: KronScheduler by lazy {
-    buildSchedule { hours { 0 every 1 } }
+    buildSchedule {
+        seconds { at(0) }
+        minutes { at(0) }
+        hours { 0 every 1 }
+    }
 }
 
 /**
  * [KronScheduler.next] will always return [korlibs.time.DateTime.now] + one day
  */
 val EveryDayOfMonthScheduler: KronScheduler by lazy {
-    buildSchedule { dayOfMonth { 0 every 1 } }
+    buildSchedule {
+        seconds { at(0) }
+        minutes { at(0) }
+        hours { at(0) }
+        dayOfMonth { 0 every 1 }
+    }
 }
 
 /**
  * [KronScheduler.next] will always return [korlibs.time.DateTime.now] + one month
  */
 val EveryMonthScheduler: KronScheduler by lazy {
-    buildSchedule { months { 0 every 1 } }
+    buildSchedule {
+        seconds { at(0) }
+        minutes { at(0) }
+        hours { at(0) }
+        dayOfMonth { at(0) }
+        months { 0 every 1 }
+    }
 }
 
 /**
  * [KronScheduler.next] will always return [korlibs.time.DateTime.now] + one year
  */
 val EveryYearScheduler: KronScheduler by lazy {
-    buildSchedule { years { 0 every 1 } }
+    buildSchedule {
+        seconds { at(0) }
+        minutes { at(0) }
+        hours { at(0) }
+        dayOfMonth { at(0) }
+        months { at(0) }
+        years { 0 every 1 }
+    }
 }
 
 /**

src/commonMain/kotlin/builder/SchedulerBuilder.kt

@@ -182,15 +182,24 @@ class SchedulerBuilder(
      */
     fun build(): KronScheduler = offset ?.let {
         createKronSchedulerWithOffset(
-            seconds,
+            seconds = seconds,
-            minutes,
+            minutes = minutes,
-            hours,
+            hours = hours,
-            dayOfMonth,
+            dayOfMonth = dayOfMonth,
-            month,
+            month = month,
-            year,
+            years = year,
-            dayOfWeek,
+            weekDays = dayOfWeek,
-            TimezoneOffset(it.minutes),
+            offset = TimezoneOffset(it.minutes),
-            milliseconds ?: millisecondsArrayDefault
+            milliseconds = milliseconds ?: millisecondsArrayDefault
+        )
+    } ?: createKronScheduler(
+        seconds = seconds,
+        minutes = minutes,
+        hours = hours,
+        dayOfMonth = dayOfMonth,
+        month = month,
+        years = year,
+        weekDays = dayOfWeek,
+        milliseconds = milliseconds ?: millisecondsArrayDefault
     )
-    } ?: createKronScheduler(seconds, minutes, hours, dayOfMonth, month, year, dayOfWeek, milliseconds ?: millisecondsArrayDefault)
 }

src/commonMain/kotlin/internal/Parser.kt

@@ -37,6 +37,106 @@ private fun <T> createSimpleScheduler(from: String, dataRange: IntRange, dataCon
     return results.map(dataConverter)
 }
 
+/**
+ * FSM for parsing of incoming data. If at the end of parsing it have non-null state and string is not empty, data passed check
+ *
+ * 1.
+ *     * "\\d" -> 2
+ *     * "\\*" -> 4
+ *     * "F" -> 7
+ *     * "f" -> 7
+ *     * "L" -> 7
+ *     * "l" -> 7
+ *     * "/" -> 6
+ * 2.
+ *     * "\\d" -> 2
+ *     * "/" -> 6
+ *     * "," -> 1
+ *     * "-" -> 3
+ *     * "m" -> 9
+ *     * "o" -> 10
+ *     * "w" -> 10
+ * 3.
+ *     * "L" -> 7
+ *     * "l" -> 7
+ *     * "\\d" -> 8
+ * 4.
+ *     * "/" -> 6
+ *     * "," -> 1
+ * 5.
+ *     * "/" -> 6
+ * 6.
+ *     * "\\d" -> 8
+ *     * "\\*" -> 7
+ * 7.
+ *     * "," -> 1
+ * 8.
+ *     * "\\d" -> 8
+ *     * "," -> 1
+ * 9.
+ *     * "s" -> 10 // end of ms
+ * 10. Empty, end of parse
+ */
+private val checkIncomingPartTransitionsMap = listOf(
+    listOf( // 0
+        Regex("\\d") to 1,
+        Regex("\\*") to 3,
+        Regex("[Ff]") to 6,
+        Regex("[Ll]") to 6,
+        Regex("/") to 5,
+    ),
+    listOf( // 1
+        Regex("\\d") to 1,
+        Regex("/") to 5,
+        Regex(",") to 0,
+        Regex("-") to 2,
+        Regex("m") to 8,
+        Regex("o") to 9,
+        Regex("w") to 9,
+    ),
+    listOf( // 2
+        Regex("[Ll]") to 6,
+        Regex("\\d") to 7,
+    ),
+    listOf( // 3
+        Regex("/") to 5,
+        Regex(",") to 0,
+    ),
+    listOf( // 4
+        Regex("/") to 5,
+    ),
+    listOf( // 5
+        Regex("\\d") to 7,
+        Regex("\\*") to 6,
+    ),
+    listOf( // 6
+        Regex(",") to 0,
+    ),
+    listOf( // 7
+        Regex("\\d") to 7,
+        Regex(",") to 0,
+    ),
+    listOf( // 8
+        Regex("s") to 9, // end of ms
+    ),
+    listOf(), // empty state, end of parsing
+)
+internal fun checkIncomingPart(part: String): Boolean {
+    var i = 0
+    var state = checkIncomingPartTransitionsMap[0]
+    while (i < part.length) {
+        val char = part[i]
+        val nextState = state.firstNotNullOfOrNull {
+            it.second.takeIf { _ -> it.first.matches("$char") }
+        }
+        if (nextState == null) return false
+        state = checkIncomingPartTransitionsMap[nextState]
+        i++
+    }
+
+    return part.isNotEmpty()
+}
+
 internal fun parseWeekDay(from: String?) = from ?.let { if (it.endsWith("w")) createSimpleScheduler(it.removeSuffix("w"), dayOfWeekRange, intToByteConverter) ?.toTypedArray() else null }
 internal fun parseOffset(from: String?) = from ?.let { if (it.endsWith("o")) it.removeSuffix("o").toIntOrNull() else null }
 internal fun parseYears(from: String?) = from ?.let { createSimpleScheduler(from, yearRange, intToIntConverter) ?.toTypedArray() }

src/commonTest/kotlin/BuildersTest.kt

@@ -0,0 +1,38 @@
+package dev.inmo.krontab.utils
+
+import dev.inmo.krontab.*
+import korlibs.time.*
+import kotlinx.coroutines.test.runTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.time.Duration.Companion.milliseconds
+import kotlin.time.Duration.Companion.minutes
+import kotlin.time.Duration.Companion.seconds
+
+class BuildersTest {
+    @Test
+    fun presetsWorksCorrectly() {
+        val data = mapOf(
+            EverySecondScheduler to { it: DateTime -> if (it.milliseconds > 0 ) it + 1.seconds - it.milliseconds.milliseconds else it },
+            EveryMinuteScheduler to { it: DateTime -> if (it.seconds > 0 || it.milliseconds > 0 ) it + 1.minutes - it.seconds.seconds - it.milliseconds.milliseconds else it },
+            EveryHourScheduler to { it: DateTime -> if (it.minutes > 0 || it.seconds > 0 || it.milliseconds > 0 ) it + 1.hours - it.minutes.minutes - it.seconds.seconds - it.milliseconds.milliseconds else it },
+            EveryDayOfMonthScheduler to { it: DateTime -> if (it.hours > 0 || it.minutes > 0 || it.seconds > 0 || it.milliseconds > 0 ) it + 1.days - it.hours.hours - it.minutes.minutes - it.seconds.seconds - it.milliseconds.milliseconds else it },
+            EveryMonthScheduler to { it: DateTime -> if (it.dayOfMonth > 1 || it.hours > 0 || it.minutes > 0 || it.seconds > 0 || it.milliseconds > 0 ) (it + 1.months).copy(dayOfMonth = 1, hour = 0, minute = 0, second = 0, milliseconds = 0) else it },
+        )
+        val samples = 10000
+
+        runTest {
+            var now = DateTime.now()
+            for (i in 0 until samples) {
+                data.forEach { (scheduler, expectCalculator) ->
+                    val expectValue = expectCalculator(now)
+                    val newNow = scheduler.nextOrRelative(now)
+
+                    assertEquals(expectValue, newNow, "For time ${now.toStringDefault()} calculated wrong value: ${newNow.toStringDefault()} is not equal to ${expectValue.toStringDefault()}")
+
+                    now = newNow
+                }
+            }
+        }
+    }
+}

src/commonTest/kotlin/StringParseTest.kt

@@ -2,6 +2,7 @@ package dev.inmo.krontab.utils
 
 import korlibs.time.*
 import dev.inmo.krontab.KronSchedulerTz
+import dev.inmo.krontab.KrontabTemplate
 import dev.inmo.krontab.buildSchedule
 import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.takeWhile
@@ -11,23 +12,52 @@ import kotlin.test.*
 @ExperimentalCoroutinesApi
 @FlowPreview
 class StringParseTest {
-    @Test
+    private fun makeSimpleEverySecondTest(template: KrontabTemplate) {
-    fun testThatFlowIsCorrectlyWorkEverySecondBuiltOnString() {
+        val kronScheduler = buildSchedule(template)
-        val kronScheduler = buildSchedule("*/1 * * * *")
 
         val flow = kronScheduler.asFlowWithoutDelays()
 
         runTest {
             val mustBeCollected = 10
             var collected = 0
+            var previousTime: DateTime? = null
             flow.takeWhile {
                 collected < mustBeCollected
             }.collect {
+                previousTime ?.let { previousTime ->
+                    assertEquals(previousTime + 1.seconds, it)
+                }
+                previousTime = it
                 collected++
             }
             assertEquals(mustBeCollected, collected)
         }
     }
+
+    @Test
+    fun testThatFlowIsCorrectlyWorkEverySecondBuiltOnString() {
+        makeSimpleEverySecondTest("*/1 * * * *")
+    }
+    @Test
+    fun testThatFlowIsCorrectlyWorkEverySecondBuiltOnStringWithWrongAmountOfSpaces() {
+        val templatesFirstReplacers = listOf(
+            "*/1",
+            "*",
+            "/1",
+            "f,/1",
+        )
+        templatesFirstReplacers.forEach { replacer ->
+            makeSimpleEverySecondTest("$replacer  *  * *  * ")
+        }
+    }
+    @Test
+    fun testThatFlowIsCorrectlyWorkEverySecondBuiltOnStringWithGarbageInTemplate() {
+        makeSimpleEverySecondTest(" sdf */1  *  * *  oo * ")
+    }
+    @Test
+    fun testThatFlowIsCorrectlyWorkEverySecondBuiltOnStringWithInsufficientArgsInTemplate() {
+        makeSimpleEverySecondTest(" sdf */1  ")
+    }
     @Test
     fun testThatFlowIsCorrectlyWorkEverySecondWhenMillisIsHalfOfSecondBuiltOnString() {
         val kronScheduler = buildSchedule("*/1 * * * * 500ms")
@@ -37,9 +67,14 @@ class StringParseTest {
         runTest {
             val mustBeCollected = 10
             var collected = 0
+            var previousTime: DateTime? = null
             flow.takeWhile {
                 collected < mustBeCollected
             }.collect {
+                previousTime ?.let { previousTime ->
+                    assertEquals(previousTime.copy(milliseconds = 500) + 1.seconds, it)
+                }
+                previousTime = it
                 collected++
             }
             assertEquals(mustBeCollected, collected)