workflows fix

0.7.0

.github/workflows/kdocs.yml

@@ -10,7 +10,10 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions/setup-java@v1
         with:
-          java-version: 1.8
+          java-version: 11
+      - name: Fix android 32.0.0 dx
+        continue-on-error: true
+        run: cd /usr/local/lib/android/sdk/build-tools/32.0.0/ && cp d8 dx && cd lib  && cp d8.jar dx.jar
       - name: Build
         run: ./gradlew dokkaHtml
       - name: Publish KDocs

.github/workflows/publishing_packages.yml

@@ -7,10 +7,10 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions/setup-java@v1
         with:
-          java-version: 1.8
-      - name: Fix android 31.0.0 dx
+          java-version: 11
+      - name: Fix android 32.0.0 dx
         continue-on-error: true
-        run: cd /usr/local/lib/android/sdk/build-tools/31.0.0/ && mv d8 dx && cd lib  && mv d8.jar dx.jar
+        run: cd /usr/local/lib/android/sdk/build-tools/32.0.0/ && cp d8 dx && cd lib  && cp d8.jar dx.jar
       - name: Update version
         run: |
           branch="`echo "${{ github.ref }}" | grep -o "[^/]*$"`"

CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## 0.7.1
+
+* Versions
+  * `Klock`: `2.5.2`
+
+## 0.7.0
+
+**ALL DEPRECATIONS HAVE BEEN REMOVED**
+
+* Versions
+  * `Kotlin`: `1.6.10`
+  * `Klock`: `2.4.10`
+  * `Coroutines`: `1.6.0`
+  * `Androidx Work`: `2.7.1`
+
+## 0.6.6
+
+* Versions
+  * `Klock`: `2.4.8`
+  * `Androidx Work`: `2.7.0`
+
+## 0.6.5
+
+* Flows now use `doWhile` functions
+* `doWhile` now use additional delay (for 1 ms) for cases when `block` executing too fast
+* New extensions for `KronScheduler`: `do(Once/While/Infinity)Local`/`do(Once/While/Infinity)Tz`
+
 ## 0.6.4
 
 * Versions

README.md

@@ -1,22 +1,12 @@
 # krontab
 
  [![Maven Central](https://maven-badges.herokuapp.com/maven-central/dev.inmo/krontab/badge.svg)](https://maven-badges.herokuapp.com/maven-central/dev.inmo/krontab)
- [![Build Status](https://github.com/InsanusMokrassar/krontab/actions/workflows/regular_build.yml/badge.svg)](https://github.com/InsanusMokrassar/krontab/actions/workflows/regular_build.yml)
+ [![Build Status](https://github.com/InsanusMokrassar/krontab/actions/workflows/publishing_packages.yml/badge.svg)](https://github.com/InsanusMokrassar/krontab/actions/workflows/publishing_packages.yml)
  [![KDocs](https://raw.githubusercontent.com/InsanusMokrassar/badges/master/kdocs.svg)](https://krontab.inmo.dev/index.html)
  
 Library was created to give oppotunity to launch some things from time to time according to some schedule in
 runtime of applications.
 
-| Table of content |
-|---|
-| [ How to use ](#how-to-use) |
-| [ How to use: Including in project ](#including-in-project) |
-| [ How to use: Config from string ](#config-from-string) |
-| [ How to use: Config via builder (DSL preview) ](#config-via-builder) |
-| [ How to use: KronScheduler as a Flow ](#KronScheduler-as-a-Flow) |
-| [ How to use: Offsets ](#Offsets) |
-| [ How to use: Note about week days ](#Note-about-week-days) |
-
 ## How to use
 
 There are several ways to configure and use this library:
@@ -133,6 +123,38 @@ kronScheduler.doInfinity {
 
 All of these examples will do the same things: print `Called` message every five seconds.
 
+### do\* functions
+
+With regular `doOnce`/`doWhile`/`doInfinity` there are two types of their variations: **local** and **timezoned**. Local
+variations (`doOnceLocal`/`doWhileLocal`/`doInfinityLocal`) will pass `DateTime` as an argument into the block:
+
+```kotlin
+doInfinityLocal("/5 * * * *") {
+    println(it) // will print current date time
+}
+```
+
+Timezoned variations (`doOnceTz`/`doWhileTz`/`doInfinityTz`) will do the same thing but pass as an argument `DateTimeTz`:
+
+```kotlin
+doInfinityTz("/5 * * * * 0o") {
+    println(it) // will print current date time in UTC
+}
+```
+
+It is useful in cases when you need to get the time of calling and avoid extra calls to system time.
+
+#### Helpful table for 
+
+|  | No args | Local `DateTime` | Local `DateTimeTz` with offset of `KronScheduler` |
+|---| ------- | ---------------- | ------------------------------------------------- |
+| **Call only near time** | doOnce | doOnceLocal | doOnceTz |
+| **Call while condition is true** | doWhile | doWhileLocal | doWhileTz |
+| **Work infinity*** | doInfinity | doInfinityLocal | doInfinityTz |
+
+*Here there is an important notice, that `Work infinity` is not exactly `infinity`. Actually, that means that `do while
+coroutine is alive` and in fact executing will be stopped when coroutine became cancelled.
+
 ### KronScheduler as a Flow
 
 Any `KronScheduler`can e converted to a `Flow<DateTime` using extension `asFlow`:
@@ -163,7 +185,7 @@ flow.takeWhile {
 Offsets in this library works via passing parameter ending with `o` in any place after `month` config. Currently
 there is only one format supported for offsets: minutes of offsets. To use time zones you will need to call `next`
 method with `DateTimeTz` argument or `nextTimeZoned` method with any `KronScheduler` instance, but in case if this
-scheduler is not instance of `KronSchedulerTz` it will works like you passed just `DateTime`.
+scheduler is not instance of `KronSchedulerTz` it will work like you passed just `DateTime`.
 
 Besides, in case you wish to use time zones explicitly, you will need to get `KronSchedulerTz`. It is possible by:
 

build.gradle

@@ -10,7 +10,7 @@ buildscript {
         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
         classpath "com.github.breadmoirai:github-release:$github_release_plugin_version"
         classpath "com.getkeepsafe.dexcount:dexcount-gradle-plugin:$dexcount_version"
-        classpath 'com.android.tools.build:gradle:4.2.2'
+        classpath 'com.android.tools.build:gradle:7.0.4'
     }
 }
 
@@ -132,3 +132,8 @@ android {
         }
     }
 }
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}

gradle.properties

@@ -8,12 +8,12 @@ android.useAndroidX=true
 android.enableJetifier=false
 
 
-kotlin_version=1.5.31
-kotlin_coroutines_version=1.5.2
+kotlin_version=1.6.10
+kotlin_coroutines_version=1.6.0
 
-dokka_version=1.5.30
+dokka_version=1.6.10
 
-klockVersion=2.4.2
+klockVersion=2.5.2
 
 ## Github reease
 
@@ -22,16 +22,16 @@ github_release_plugin_version=2.2.12
 ## Android
 
 android_minSdkVersion=19
-android_compileSdkVersion=31
-android_buildToolsVersion=31.0.0
+android_compileSdkVersion=32
+android_buildToolsVersion=32.0.0
 dexcount_version=3.0.0
 junit_version=4.12
 test_ext_junit_version=1.1.2
 espresso_core=3.3.0
 
-androidx_work_version=2.6.0
+androidx_work_version=2.7.1
 
 ## Common
 
-version=0.6.4
-android_code_version=8
+version=0.7.1
+android_code_version=12

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-7.2-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.4-bin.zip

src/commonMain/kotlin/dev/inmo/krontab/Executes.kt

@@ -1,7 +1,10 @@
 package dev.inmo.krontab
 
 import com.soywiz.klock.DateTime
+import com.soywiz.klock.DateTimeTz
 import kotlinx.coroutines.delay
+import kotlinx.coroutines.isActive
+import kotlin.coroutines.coroutineContext
 
 /**
  * Execute [block] once at the [KronScheduler.next] time and return result of [block] calculation.
@@ -10,29 +13,109 @@ import kotlinx.coroutines.delay
  *
  * WARNING!!! In case if [KronScheduler.next] of [this] instance will return null, [block] will be called immediately
  */
-suspend inline fun <T> KronScheduler.doOnce(noinline block: suspend () -> T): T {
-    next() ?.let {
+suspend inline fun <T> KronScheduler.doOnceLocal(noinline block: suspend (DateTime) -> T): T {
+    val time = nextOrNow().also {
         delay((it - DateTime.now()).millisecondsLong)
     }
-    return block()
+    return block(time)
 }
 
 /**
- * Will [buildSchedule] using [scheduleConfig] and call [doOnce] on it
+ * Execute [block] once at the [KronScheduler.next] time and return result of [block] calculation.
+ *
+ * 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
+ */
+suspend inline fun <T> KronScheduler.doOnceTz(noinline block: suspend (DateTimeTz) -> T): T {
+    val time = when (this) {
+        is KronSchedulerTz -> nextOrNowWithOffset()
+        else -> nextOrNow().local
+    }
+    delay((time - DateTimeTz.nowLocal()).millisecondsLong)
+    return block(time)
+}
+
+/**
+ * Execute [block] once at the [KronScheduler.next] time and return result of [block] calculation.
+ *
+ * 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 immediately
+ */
+suspend inline fun <T> KronScheduler.doOnce(noinline block: suspend () -> T): T = doOnceLocal { _ -> block() }
+
+/**
+ * Will [buildSchedule] using [scheduleConfig] and call [doOnceLocal] on it
+ * @see buildSchedule
+ */
+suspend inline fun <T> doOnce(
+    scheduleConfig: String,
+    noinline block: suspend (DateTime) -> T
+) = buildSchedule(scheduleConfig).doOnceLocal(block)
+
+/**
+ * Will [buildSchedule] using [scheduleConfig] and call [doOnceLocal] on it
+ * @see buildSchedule
+ */
+suspend inline fun <T> doOnceTz(
+    scheduleConfig: String,
+    noinline block: suspend (DateTimeTz) -> T
+) = buildSchedule(scheduleConfig).doOnceTz(block)
+
+/**
+ * Will [buildSchedule] using [scheduleConfig] and call [doOnceLocal] on it
  * @see buildSchedule
  */
 suspend inline fun <T> doOnce(
     scheduleConfig: String,
     noinline block: suspend () -> T
-) = buildSchedule(scheduleConfig).doOnce(block)
+) = doOnce(scheduleConfig) { _ -> block() }
+
 
 /**
  * Will execute [block] while it will return true as a result of its calculation
  */
-suspend inline fun KronScheduler.doWhile(noinline block: suspend () -> Boolean) {
-    do { val doNext = doOnce(block) } while (doNext)
+suspend inline fun KronScheduler.doWhileLocal(noinline block: suspend (DateTime) -> Boolean) {
+    do {
+        delay(1L)
+    } while (doOnceLocal(block))
 }
 
+/**
+ * Will execute [block] while it will return true as a result of its calculation
+ */
+suspend inline fun KronScheduler.doWhileTz(noinline block: suspend (DateTimeTz) -> Boolean) {
+    do {
+        delay(1L)
+    } while (doOnceTz(block))
+}
+
+/**
+ * Will execute [block] while it will return true as a result of its calculation
+ */
+suspend inline fun KronScheduler.doWhile(noinline block: suspend () -> Boolean) = doWhileLocal { block() }
+
+/**
+ * Will [buildSchedule] using [scheduleConfig] and call [doWhile] with [block]
+ *
+ * @see buildSchedule
+ */
+suspend inline fun doWhileLocal(
+    scheduleConfig: String,
+    noinline block: suspend (DateTime) -> Boolean
+) = buildSchedule(scheduleConfig).doWhileLocal(block)
+
+/**
+ * Will [buildSchedule] using [scheduleConfig] and call [doWhile] with [block]
+ *
+ * @see buildSchedule
+ */
+suspend inline fun doWhileTz(
+    scheduleConfig: String,
+    noinline block: suspend (DateTimeTz) -> Boolean
+) = buildSchedule(scheduleConfig).doWhileTz(block)
+
 /**
  * Will [buildSchedule] using [scheduleConfig] and call [doWhile] with [block]
  *
@@ -41,15 +124,53 @@ suspend inline fun KronScheduler.doWhile(noinline block: suspend () -> Boolean)
 suspend inline fun doWhile(
     scheduleConfig: String,
     noinline block: suspend () -> Boolean
-) = buildSchedule(scheduleConfig).doWhile(block)
+) = doWhileLocal(scheduleConfig) { block() }
+
+
+/**
+ * Will execute [block] without any checking of result
+ */
+suspend inline fun KronScheduler.doInfinityLocal(noinline block: suspend (DateTime) -> Unit) = doWhileLocal {
+    block(it)
+    coroutineContext.isActive
+}
+
+/**
+ * Will execute [block] without any checking of result
+ */
+suspend inline fun KronScheduler.doInfinityTz(noinline block: suspend (DateTimeTz) -> Unit) = doWhileTz {
+    block(it)
+    coroutineContext.isActive
+}
 
 /**
  * Will execute [block] without any checking of result
  */
 suspend inline fun KronScheduler.doInfinity(noinline block: suspend () -> Unit) = doWhile {
     block()
-    true
+    coroutineContext.isActive
 }
+
+/**
+ * Will [buildSchedule] using [scheduleConfig] and call [doInfinity] with [block]
+ *
+ * @see buildSchedule
+ */
+suspend inline fun doInfinityLocal(
+    scheduleConfig: String,
+    noinline block: suspend (DateTime) -> Unit
+) = buildSchedule(scheduleConfig).doInfinityLocal(block)
+
+/**
+ * Will [buildSchedule] using [scheduleConfig] and call [doInfinity] with [block]
+ *
+ * @see buildSchedule
+ */
+suspend inline fun doInfinityTz(
+    scheduleConfig: String,
+    noinline block: suspend (DateTimeTz) -> Unit
+) = buildSchedule(scheduleConfig).doInfinityTz(block)
+
 /**
  * Will [buildSchedule] using [scheduleConfig] and call [doInfinity] with [block]
  *

src/commonMain/kotlin/dev/inmo/krontab/internal/CronDateTime.kt

@@ -1,8 +1,8 @@
 package dev.inmo.krontab.internal
 
-import com.soywiz.klock.*
+import com.soywiz.klock.DateTime
+import com.soywiz.klock.TimezoneOffset
 import dev.inmo.krontab.KronScheduler
-import dev.inmo.krontab.utils.copy
 
 /**
  * @param daysOfWeek 0-6

src/commonMain/kotlin/dev/inmo/krontab/internal/CronDateTimeScheduler.kt

@@ -2,7 +2,6 @@ package dev.inmo.krontab.internal
 
 import com.soywiz.klock.DateTime
 import dev.inmo.krontab.KronScheduler
-import dev.inmo.krontab.collection.plus
 
 /**
  * Cron-oriented realisation of [KronScheduler]
@@ -36,23 +35,3 @@ internal fun mergeCronDateTimeSchedulers(
 ): CronDateTimeScheduler = CronDateTimeScheduler(
     schedulers.map { it.cronDateTime }.merge()
 )
-
-/**
- * @return New instance of [CronDateTimeScheduler] with all unique [CronDateTimeScheduler.cronDateTimes] of
- * [kronSchedulers] included
- */
-@Deprecated("Will be removed in next major release", ReplaceWith("merge", "dev.inmo.krontab"))
-fun merge(kronSchedulers: List<KronScheduler>) = kronSchedulers.apply { dev.inmo.krontab.merge() }
-
-/**
- * @return Vararg shortcut for [dev.inmo.krontab.merge]
- */
-@Suppress("NOTHING_TO_INLINE")
-@Deprecated("Will be removed in next major release", ReplaceWith("merge", "dev.inmo.krontab"))
-inline fun merge(vararg kronDateTimeSchedulers: KronScheduler) = kronDateTimeSchedulers.apply { dev.inmo.krontab.merge() }
-/**
- * @return Vararg shortcut for [dev.inmo.krontab.merge]
- */
-@Suppress("NOTHING_TO_INLINE")
-@Deprecated("Will be removed in next major release", ReplaceWith("merge", "dev.inmo.krontab"))
-inline fun KronScheduler.plus(other: KronScheduler) = this + other

src/commonMain/kotlin/dev/inmo/krontab/utils/DateTimeCopy.kt

@@ -1,6 +1,7 @@
 package dev.inmo.krontab.utils
 
-import com.soywiz.klock.*
+import com.soywiz.klock.DateTime
+import com.soywiz.klock.Month
 import kotlin.math.min
 
 fun DateTime.copy(

src/commonMain/kotlin/dev/inmo/krontab/utils/SchedulerFlow.kt

@@ -2,57 +2,34 @@ package dev.inmo.krontab.utils
 
 import com.soywiz.klock.DateTime
 import com.soywiz.klock.DateTimeTz
-import dev.inmo.krontab.KronScheduler
-import dev.inmo.krontab.next
-import kotlinx.coroutines.*
-import kotlinx.coroutines.flow.*
+import dev.inmo.krontab.*
+import kotlinx.coroutines.FlowPreview
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.channelFlow
 
 /**
  * This [Flow] will trigger emitting each near time which will be returned from [this] [KronScheduler] with attention to
  * time zones
  *
  * @see channelFlow
+ * @see KronSchedulerTz.doInfinityTz
  */
 @FlowPreview
 fun KronScheduler.asTzFlow(): Flow<DateTimeTz> = channelFlow {
-    var previousTime = DateTime.nowLocal()
-    while (isActive) {
-        val now = DateTime.nowLocal()
-        val nextTime = next(now) ?: break
-        if (previousTime == nextTime) {
-            delay(1L) // skip 1ms
-            continue
-        } else {
-            previousTime = nextTime
-        }
-        val sleepDelay = (nextTime - DateTime.now().local).millisecondsLong
-        delay(sleepDelay)
-        send(nextTime)
+    doInfinityTz {
+        send(it)
     }
 }
 
 /**
  * This method is a map for [asTzFlow] and will works the same but return flow with [DateTime]s
+ *
+ * @see channelFlow
+ * @see KronScheduler.doInfinityLocal
  */
 @FlowPreview
-fun KronScheduler.asFlow(): Flow<DateTime> = asTzFlow().map { it.local }
-
-@Deprecated(
-    "It is not recommended to use this class in future. This functionality will be removed soon",
-    ReplaceWith("asFlow", "dev.inmo.krontab.utils.asFlow")
-)
-@FlowPreview
-class SchedulerFlow(
-    private val scheduler: KronScheduler
-) : AbstractFlow<DateTime>() {
-    @FlowPreview
-    override suspend fun collectSafely(collector: FlowCollector<DateTime>) {
-        while (true) {
-            val now = DateTime.now()
-            val nextTime = scheduler.next(now) ?: break
-            val sleepDelay = (nextTime - now).millisecondsLong
-            delay(sleepDelay)
-            collector.emit(nextTime)
-        }
+fun KronScheduler.asFlow(): Flow<DateTime> = channelFlow {
+    doInfinityLocal {
+        send(it)
     }
 }