Switch programming language from Kotlin to Java #15
11 changed files with 139 additions and 163 deletions
|
@ -1,11 +1,11 @@
|
|||
# waituntil
|
||||
# de.jotoho.waituntil
|
||||
|
||||
This simple tool doubles as a programming exercise for me, as I attempt to learn Kotlin from my perspective as a Java developer and a (hopefully) useful tool for personal use. I will expand this README with details as the project evolves.
|
||||
|
||||
## Copyright / Licensing
|
||||
|
||||
```
|
||||
waituntil - a tool for delaying command execution until the specified time
|
||||
de.jotoho.waituntil - a tool for delaying command execution until the specified time
|
||||
Copyright (C) 2021 Jonas Tobias Hopusch
|
||||
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
|
|
|
@ -1,9 +1,4 @@
|
|||
import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
|
||||
|
||||
plugins {
|
||||
// Apply the org.jetbrains.kotlin.jvm Plugin to add support for Kotlin.
|
||||
kotlin("jvm") version "latest.release"
|
||||
|
||||
// Apply the application plugin to add support for building a CLI application in Java.
|
||||
application
|
||||
|
||||
|
@ -19,44 +14,22 @@ repositories {
|
|||
mavenCentral()
|
||||
}
|
||||
|
||||
dependencies {
|
||||
// Align versions of all Kotlin components
|
||||
implementation(platform(kotlin("bom", "latest.release")))
|
||||
|
||||
// Use the Kotlin standard library.
|
||||
implementation(kotlin("stdlib", "latest.release"))
|
||||
|
||||
// Use the Kotlin test library.
|
||||
testImplementation(kotlin("test", "latest.release"))
|
||||
|
||||
// Use the Kotlin JUnit integration.
|
||||
testImplementation(kotlin("test-junit", "latest.release"))
|
||||
}
|
||||
|
||||
java {
|
||||
sourceCompatibility = JavaVersion.VERSION_17
|
||||
targetCompatibility = JavaVersion.VERSION_17
|
||||
}
|
||||
|
||||
tasks.test {
|
||||
useJUnitPlatform()
|
||||
}
|
||||
|
||||
tasks.jar {
|
||||
manifest {
|
||||
attributes(
|
||||
"Implementation-Title" to "waituntil",
|
||||
"Implementation-Title" to "de.jotoho.waituntil",
|
||||
"Implementation-Version" to "${project.version}",
|
||||
"Main-Class" to "de.jotoho.waituntil.StartKt"
|
||||
"Main-Class" to "de.jotoho.waituntil.Main"
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
tasks.withType<KotlinCompile> {
|
||||
kotlinOptions.jvmTarget = "17"
|
||||
}
|
||||
|
||||
application {
|
||||
// Define the main class for the application.
|
||||
mainClass.set("de.jotoho.waituntil.StartKt")
|
||||
mainClass.set("de.jotoho.waituntil.Main")
|
||||
}
|
||||
|
|
|
@ -1,2 +1 @@
|
|||
org.gradle.daemon=false
|
||||
kotlin.code.style=official
|
||||
|
|
|
@ -7,4 +7,4 @@
|
|||
* in the user manual at https://docs.gradle.org/7.2/userguide/multi_project_builds.html
|
||||
*/
|
||||
|
||||
rootProject.name = "waituntil"
|
||||
rootProject.name = "de.jotoho.waituntil"
|
||||
|
|
10
src/main/java/de/jotoho/waituntil/GlobalConf.java
Normal file
10
src/main/java/de/jotoho/waituntil/GlobalConf.java
Normal file
|
@ -0,0 +1,10 @@
|
|||
package de.jotoho.waituntil;
|
||||
|
||||
import java.util.Locale;
|
||||
|
||||
public record GlobalConf() {
|
||||
public static final String langGerman = "de";
|
||||
public static final String applicationOutputLanguage = (Locale.getDefault().getLanguage().equals(Locale.GERMAN.getLanguage()))
|
||||
? Locale.GERMAN.getLanguage()
|
||||
: Locale.ENGLISH.getLanguage();
|
||||
}
|
51
src/main/java/de/jotoho/waituntil/Main.java
Normal file
51
src/main/java/de/jotoho/waituntil/Main.java
Normal file
|
@ -0,0 +1,51 @@
|
|||
package de.jotoho.waituntil;
|
||||
|
||||
import java.util.*;
|
||||
|
||||
import static de.jotoho.waituntil.GlobalConf.applicationOutputLanguage;
|
||||
|
||||
// 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)
|
||||
|
||||
public final class Main {
|
||||
public static void main(final String[] args) {
|
||||
final var optionDictionary = Map.of("-h", "--help", "-v", "--version");
|
||||
|
||||
final var options = new HashSet<String>();
|
||||
final var words = new HashSet<String>();
|
||||
|
||||
for (final String arg : args) {
|
||||
if (arg.startsWith("--")) {
|
||||
options.add(arg.substring(2));
|
||||
} else if (arg.startsWith("-")) {
|
||||
if (optionDictionary.containsKey(arg))
|
||||
options.add(optionDictionary.get(arg).substring(2));
|
||||
else
|
||||
System.err.println("Short-hand '$arg' does not exist. Ignoring!");
|
||||
} else {
|
||||
words.add(arg);
|
||||
}
|
||||
}
|
||||
|
||||
if (options.contains("help")) {
|
||||
switch (applicationOutputLanguage) {
|
||||
case GlobalConf.langGerman -> System.out.println("Hilfe kommt noch. (Nicht implementiert)");
|
||||
default -> System.out.println("Help is yet to come. (Not implemented)");
|
||||
}
|
||||
} else if (options.contains("version")) {
|
||||
final var thisPackage = Main.class.getPackage();
|
||||
final var appVersion = thisPackage.getImplementationVersion() != null ? thisPackage.getImplementationVersion() :"UNKNOWN";
|
||||
System.out.println("de.jotoho.waituntil version $appVersion");
|
||||
} else if (words.size() == 1) {
|
||||
final var target = TimeCalculator.calculateAndAnnounceTargetTime(words.iterator().next());
|
||||
Sleep.waitUntilTimeStamp(target);
|
||||
} else {
|
||||
switch (applicationOutputLanguage) {
|
||||
case GlobalConf.langGerman -> System.err.println("FATAL: Es wurde exact ein nicht-flag Argument erwartet. (" + words.size() + " erhalten)");
|
||||
default -> System.err.println("FATAL: Expected one non-flag argument. (Got " + words.size() + ")");
|
||||
}
|
||||
System.exit(1);
|
||||
}
|
||||
}
|
||||
}
|
32
src/main/java/de/jotoho/waituntil/Sleep.java
Normal file
32
src/main/java/de/jotoho/waituntil/Sleep.java
Normal file
|
@ -0,0 +1,32 @@
|
|||
package de.jotoho.waituntil;
|
||||
|
||||
import java.time.Instant;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.time.format.DateTimeFormatter;
|
||||
import java.time.format.FormatStyle;
|
||||
import java.time.temporal.ChronoUnit;
|
||||
import java.util.*;
|
||||
|
||||
import java.lang.Math;
|
||||
|
||||
public final class Sleep {
|
||||
public static void waitUntilTimeStamp(ZonedDateTime timestamp) {
|
||||
try {
|
||||
Thread.sleep(Math.max(0, Instant.now().until(timestamp, ChronoUnit.MILLIS)));
|
||||
} catch (final InterruptedException ignored) {
|
||||
}
|
||||
|
||||
final String formattedTimeStamp =
|
||||
DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG)
|
||||
.withZone(TimeZone.getDefault().toZoneId())
|
||||
.format(Instant.now());
|
||||
|
||||
final String msg = switch (GlobalConf.applicationOutputLanguage) {
|
||||
case GlobalConf.langGerman -> "Erfolgreich bis %s gewartet!";
|
||||
default -> "Successfully waited until %s";
|
||||
};
|
||||
|
||||
final String msgWithData = msg.formatted(formattedTimeStamp);
|
||||
System.err.println(msgWithData);
|
||||
}
|
||||
}
|
40
src/main/java/de/jotoho/waituntil/TimeCalculator.java
Normal file
40
src/main/java/de/jotoho/waituntil/TimeCalculator.java
Normal file
|
@ -0,0 +1,40 @@
|
|||
package de.jotoho.waituntil;
|
||||
|
||||
import java.time.Instant;
|
||||
import java.time.LocalDate;
|
||||
import java.time.LocalTime;
|
||||
import java.time.ZonedDateTime;
|
||||
import java.time.format.DateTimeFormatter;
|
||||
import java.time.format.FormatStyle;
|
||||
import java.util.*;
|
||||
|
||||
public final class TimeCalculator {
|
||||
|
||||
public static ZonedDateTime calculateAndAnnounceTargetTime(final String userTimeInputRaw) {
|
||||
final var userTimeInputRelative = LocalTime.parse(userTimeInputRaw);
|
||||
final var userTimeInputAbsolute =
|
||||
ZonedDateTime.of(
|
||||
LocalDate.now(),
|
||||
userTimeInputRelative,
|
||||
TimeZone.getDefault().toZoneId()
|
||||
);
|
||||
|
||||
final var userTimeInputFinal = (Instant.now().isBefore(userTimeInputAbsolute.toInstant()))
|
||||
? userTimeInputAbsolute
|
||||
: userTimeInputAbsolute.plusDays(1);
|
||||
|
||||
final var formattedTimeStamp =
|
||||
userTimeInputFinal.format(
|
||||
DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG)
|
||||
);
|
||||
|
||||
final String msg = switch (GlobalConf.applicationOutputLanguage) {
|
||||
case GlobalConf.langGerman -> "Dieses Program wird bis zum %s warten."
|
||||
.formatted(formattedTimeStamp);
|
||||
default -> "WaitUntil will suspend until %s".formatted(formattedTimeStamp);
|
||||
};
|
||||
System.out.println(msg);
|
||||
|
||||
return userTimeInputFinal;
|
||||
}
|
||||
}
|
|
@ -1,64 +0,0 @@
|
|||
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.language
|
||||
val applicationOutputLanguage: String = if (Locale.getDefault().language.equals(Locale.GERMAN.language))
|
||||
Locale.GERMAN.language
|
||||
else Locale.ENGLISH.language
|
||||
|
||||
// For accessing package information
|
||||
object DummyClass
|
||||
|
||||
fun main(args: Array<String>) {
|
||||
val optionDictionary = mapOf(Pair("-h", "--help"), Pair("-v", "--version"))
|
||||
|
||||
val options = HashSet<String>()
|
||||
val words = HashSet<String>()
|
||||
|
||||
for (arg in args) {
|
||||
if (arg.startsWith("--")) {
|
||||
options.add(arg.substring(startIndex = 2))
|
||||
} else if (arg.startsWith('-')) {
|
||||
if (optionDictionary.containsKey(arg))
|
||||
options.add(optionDictionary[arg]!!.substring(startIndex = 2))
|
||||
else
|
||||
System.err.println("Short-hand '$arg' does not exist. Ignoring!")
|
||||
} else
|
||||
words.add(arg)
|
||||
}
|
||||
|
||||
if (options.contains("help")) {
|
||||
when (applicationOutputLanguage) {
|
||||
langGerman -> println("Hilfe kommt noch. (Nicht implementiert)")
|
||||
else -> {
|
||||
println("Help is yet to come. (Not implemented)")
|
||||
}
|
||||
}
|
||||
} else if (options.contains("version")) {
|
||||
when (applicationOutputLanguage) {
|
||||
langGerman -> {
|
||||
val thisPackage = DummyClass.javaClass.`package`
|
||||
val appVersion = thisPackage.implementationVersion ?: "UNKNOWN"
|
||||
println("waituntil version $appVersion")
|
||||
}
|
||||
}
|
||||
} else if (words.size == 1) {
|
||||
val target = calculateAndAnnounceTargetTime(words.iterator().next())
|
||||
waitUntilTimeStamp(target)
|
||||
} else {
|
||||
when (applicationOutputLanguage) {
|
||||
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})")
|
||||
}
|
||||
}
|
||||
exitProcess(1)
|
||||
}
|
||||
}
|
|
@ -1,24 +0,0 @@
|
|||
package de.jotoho.waituntil
|
||||
|
||||
import java.time.Instant
|
||||
import java.time.ZonedDateTime
|
||||
import java.time.format.DateTimeFormatter
|
||||
import java.time.format.FormatStyle
|
||||
import java.time.temporal.ChronoUnit
|
||||
import java.util.*
|
||||
|
||||
fun waitUntilTimeStamp(timestamp: ZonedDateTime) {
|
||||
Thread.sleep(Instant.now().until(timestamp, ChronoUnit.MILLIS).coerceAtLeast(0))
|
||||
|
||||
val formattedTimeStamp: String =
|
||||
DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG)
|
||||
.withZone(TimeZone.getDefault().toZoneId())
|
||||
.format(Instant.now())
|
||||
|
||||
when (applicationOutputLanguage) {
|
||||
langGerman -> System.err.println("Erfolgreich bis $formattedTimeStamp gewartet!")
|
||||
else -> {
|
||||
System.err.println("Successfully waited until $formattedTimeStamp")
|
||||
}
|
||||
}
|
||||
}
|
|
@ -1,41 +0,0 @@
|
|||
package de.jotoho.waituntil
|
||||
|
||||
import java.time.Instant
|
||||
import java.time.LocalDate
|
||||
import java.time.LocalTime
|
||||
import java.time.ZonedDateTime
|
||||
import java.time.format.DateTimeFormatter
|
||||
import java.time.format.FormatStyle
|
||||
import java.util.*
|
||||
|
||||
fun calculateAndAnnounceTargetTime(userTimeInputRaw: String): ZonedDateTime {
|
||||
val userTimeInputRelative = LocalTime.parse(userTimeInputRaw)
|
||||
val userTimeInputAbsolute =
|
||||
ZonedDateTime.of(
|
||||
LocalDate.now(),
|
||||
userTimeInputRelative,
|
||||
TimeZone.getDefault().toZoneId()
|
||||
)
|
||||
|
||||
val userTimeInputFinal =
|
||||
if (Instant.now().isBefore(userTimeInputAbsolute.toInstant()))
|
||||
userTimeInputAbsolute
|
||||
else userTimeInputAbsolute.plusDays(1)
|
||||
|
||||
val formattedTimeStamp =
|
||||
userTimeInputFinal.format(
|
||||
DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG)
|
||||
)
|
||||
|
||||
when (applicationOutputLanguage) {
|
||||
langGerman ->
|
||||
System.err.println(
|
||||
"Dieses Program wird bis zum $formattedTimeStamp warten."
|
||||
)
|
||||
else -> {
|
||||
println("WaitUntil will suspend until $formattedTimeStamp")
|
||||
}
|
||||
}
|
||||
|
||||
return userTimeInputFinal
|
||||
}
|
Loading…
Reference in a new issue