src/main/kotlin/de/jotoho/waituntil/sleeping.kt

@@ -7,8 +7,8 @@ import java.time.format.FormatStyle
 import java.time.temporal.ChronoUnit
 import java.util.*
 
-public fun waitUntilTimeStamp(timestamp: ZonedDateTime) {
+fun waitUntilTimeStamp(timestamp: ZonedDateTime) {
-    Thread.sleep(Math.max(Instant.now().until(timestamp, ChronoUnit.MILLIS), 0))
+    Thread.sleep(Instant.now().until(timestamp, ChronoUnit.MILLIS).coerceAtLeast(0))
 
     val formattedTimeStamp: String =
             DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG)

src/main/kotlin/de/jotoho/waituntil/start.kt

@@ -1,56 +1,57 @@
 package de.jotoho.waituntil
 
 import java.util.*
+import kotlin.system.exitProcess
 
 // This file contains the main function and other utility function necessary for interpreting the terminal arguments.
 // See README.md and LICENSE.md for license information
 // Author: Jonas Tobias Hopusch (@jotoho)
 
-val langGerman: String = Locale.GERMAN.getLanguage();
+val langGerman: String = Locale.GERMAN.language
-val applicationOutputLanguage: String = if (Locale.getDefault().getLanguage().equals(Locale.GERMAN.getLanguage()))
+val applicationOutputLanguage: String = if (Locale.getDefault().language.equals(Locale.GERMAN.language))
-                                    Locale.GERMAN.getLanguage()
+                                    Locale.GERMAN.language
-                                    else Locale.ENGLISH.getLanguage();
+                                    else Locale.ENGLISH.language
 
 fun main(args: Array<String>) {
-    val optionDictionary = mapOf(Pair("-h", "--help"));
+    val optionDictionary = mapOf(Pair("-h", "--help"))
 
-    val options = HashSet<String>();
+    val options = HashSet<String>()
-    val words = HashSet<String>();
+    val words = HashSet<String>()
 
     for (arg in args) {
         if (arg.startsWith("--")) {
             options.add(arg.substring(startIndex=2))
         }
         else if (arg.startsWith('-')) {
-            val translation = optionDictionary.get(arg);
+            val translation = optionDictionary[arg]
             if (translation != null)
-                options.add(translation.substring(startIndex=2));
+                options.add(translation.substring(startIndex=2))
             else
-                System.err.println("Short-hand '$arg' does not exist. Ignoring!");
+                System.err.println("Short-hand '$arg' does not exist. Ignoring!")
         }
         else
-            words.add(arg);
+            words.add(arg)
     }
 
     if (options.contains("help")) {
         when (applicationOutputLanguage) {
-            langGerman -> println("Hilfe kommt noch. (Nicht implementiert)");
+            langGerman -> println("Hilfe kommt noch. (Nicht implementiert)")
             else -> {
-                println("Help is yet to come. (Not implemented)");
+                println("Help is yet to come. (Not implemented)")
             }
         }
     }
     else if (words.size == 1) {
-        val target = calculateAndAnnounceTargetTime(words.iterator().next());
+        val target = calculateAndAnnounceTargetTime(words.iterator().next())
-        waitUntilTimeStamp(target);
+        waitUntilTimeStamp(target)
     }
     else {
         when (applicationOutputLanguage) {
-            langGerman -> System.err.println("FATAL: Es wurde exact ein nicht-flag Argument erwartet. (${words.size} erhalten)");
+            langGerman -> System.err.println("FATAL: Es wurde exact ein nicht-flag Argument erwartet. (${words.size} erhalten)")
             else -> {
-                System.err.println("FATAL: Expected one non-flag argument. (Got ${words.size})");
+                System.err.println("FATAL: Expected one non-flag argument. (Got ${words.size})")
             }
         }
-        System.exit(1);
+        exitProcess(1)
     }
 }

src/main/kotlin/de/jotoho/waituntil/timecalc.kt

@@ -8,7 +8,7 @@ import java.time.format.DateTimeFormatter
 import java.time.format.FormatStyle
 import java.util.TimeZone
 
-public fun calculateAndAnnounceTargetTime(userTimeInputRaw: String): ZonedDateTime {
+fun calculateAndAnnounceTargetTime(userTimeInputRaw: String): ZonedDateTime {
         val userTimeInputRelative = LocalTime.parse(userTimeInputRaw)
         val userTimeInputAbsolute =
                         ZonedDateTime.of(