Move valuetypes API here temporarily

build.gradle.kts

@@ -27,7 +27,13 @@ repositories {
     mavenCentral()
 }
 
+val detag by configurations.creating {
+    isCanBeConsumed = false
+    isCanBeResolved = true
+}
+
 dependencies {
+    detag("com.r35157.tools:detag-impl_ref:0.1-dev")
     compileOnly("org.jetbrains:annotations:26.1.0")
 }
 
@@ -39,6 +45,75 @@ tasks.withType<JavaCompile>().configureEach {
     options.release.set(25)
 }
 
+val generatedDetagMain = layout.buildDirectory.dir("generated/sources/detag/main/java")
+
+val cleanGeneratedDetagMain by tasks.registering(Delete::class) {
+    delete(generatedDetagMain)
+}
+
+val detagMain by tasks.registering(JavaExec::class) {
+    group = "build"
+    description = "Generates Java sources from .tjava files"
+
+    classpath = detag
+    mainClass.set("com.r35157.tools.detag.impl.ref.Main")
+
+    val configFile = layout.projectDirectory.file("../detag.conf")
+    val sourceRoot = layout.projectDirectory.dir("src/main/tjava")
+
+    inputs.file(configFile)
+    inputs.dir(sourceRoot)
+    outputs.dir(generatedDetagMain)
+
+    dependsOn(cleanGeneratedDetagMain)
+
+    args(
+        "--config", configFile.asFile.absolutePath,
+        "--source-root", sourceRoot.asFile.absolutePath,
+        "--out", generatedDetagMain.get().asFile.absolutePath
+    )
+}
+
+sourceSets {
+    main {
+        // Human-written Detag source files. IntelliJ should treat this as a source root.
+        // Gradle's Java compiler will still only compile .java files directly from sourceSets,
+        // so the .tjava files are not compiled directly.
+        java.srcDir("src/main/tjava")
+    }
+}
+
+tasks.named<JavaCompile>("compileJava") {
+    dependsOn(detagMain)
+
+    // Compiler input generated from src/main/tjava.
+    // Do not add this directory to sourceSets, or IntelliJ will see duplicate classes:
+    // MyClass.tjava + build/generated/.../MyClass.java.
+    source(generatedDetagMain)
+}
+
+val libsDir = layout.buildDirectory.dir("libs")
+
+tasks.register<Sync>("prepareLibs") {
+    group = "distribution"
+    description = "Copies runtime deps to build/libs without deleting the app jar"
+
+    val jarTask = tasks.named<Jar>("jar")
+    dependsOn(jarTask)
+
+    into(libsDir)
+
+    // Kun deps (transitivt)
+    from(configurations.runtimeClasspath)
+
+    // Bevar jar-filen som jar-tasken allerede har lagt i build/libs
+    preserve {
+        include(jarTask.get().archiveFileName.get())
+    }
+
+    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+}
+
 publishing {
     publications {
         create<MavenPublication>("mavenJava") {

build.sh

@@ -5,5 +5,11 @@ export VERSION=$(git describe --tags --exact-match 2>/dev/null \
   || git symbolic-ref --short -q HEAD \
   || git rev-parse --short HEAD)
 
-echo "Building $VERSION..."
+GITHASH=$(git rev-parse --short=8 HEAD)
+
+export VERSION_LONG=${VERSION}_${GITHASH}
+
+# Build this artifact
+echo "Building 'NenjimHub API v${VERSION_LONG}'..."
+
 ./gradlew -Pversion=$VERSION jar

src/main/java/com/r35157/libs/valuetypes/basic/CurrencyType.java

@@ -0,0 +1,16 @@
+package com.r35157.libs.valuetypes.basic;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.UUID;
+
+public record CurrencyType(
+        UUID id,
+        String name,
+        String symbol
+) {
+    @Override
+    public @NotNull String toString() {
+        return symbol;
+    }
+}

src/main/java/com/r35157/libs/valuetypes/basic/SemanticVersion.java

@@ -0,0 +1,70 @@
+package com.r35157.libs.valuetypes.basic;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Semantic Versioning (SemVer):
+ * A version number has the form MAJOR.MINOR.PATCH.
+ * - Increment MAJOR for incompatible API changes,
+ * - Increment MINOR for added functionality in a backward-compatible way,
+ * - Increment PATCH for backward-compatible bug fixes or improvements.
+ * TODO: Not the whole specification is implemented yet!
+ */
+public record SemanticVersion(int major, int minor, int patch) {
+    /**
+     * Creates a SemanticVersion and validates that all components are valid.
+     *
+     * @throws IllegalArgumentException if any of {@code major}, {@code minor}, or {@code patch} is negative
+     */
+    public SemanticVersion {
+        initializationGuardClause(major, minor, patch);
+    }
+
+    public static SemanticVersion of(int major, int minor, int patch) {
+        return new SemanticVersion(major, minor, patch);
+    }
+
+    public static SemanticVersion of(int major, int minor) {
+        return of(major, minor, 0);
+    }
+
+    public static SemanticVersion of(int major) {
+        return of(major, 0);
+    }
+
+    public static SemanticVersion of(@NotNull String versionStr) {
+        final String s = versionStr.trim();
+
+        final Matcher m = SEMVER_REGEX.matcher(s);
+        if (!m.matches()) {
+            throw new IllegalArgumentException("Invalid semantic version: '" + versionStr + "'!");
+        }
+
+        try {
+            final int major = Integer.parseInt(m.group(1));
+            final int minor = m.group(2) != null ? Integer.parseInt(m.group(2)) : 0;
+            final int patch = m.group(3) != null ? Integer.parseInt(m.group(3)) : 0;
+            return of(major, minor, patch);
+        } catch (NumberFormatException e) {
+            // Happens only with overruns
+            throw new IllegalArgumentException("Invalid semantic version: '" + versionStr + "'!", e);
+        }
+    }
+
+    @Override
+    public @NotNull String toString() {
+        return "%d.%d.%d".formatted(major, minor, patch);
+    }
+
+    private void initializationGuardClause(int major, int minor, int patch) throws IllegalArgumentException {
+        if (major < 0) throw new IllegalArgumentException("Version element 'major' cannot be negative - was '" + major + "'!");
+        if (minor < 0) throw new IllegalArgumentException("Version element 'minor' cannot be negative - was '" + minor + "'!");
+        if (patch < 0) throw new IllegalArgumentException("Version element 'patch' cannot be negative - was '" + patch + "'!");
+    }
+
+    private static final Pattern SEMVER_REGEX =
+            Pattern.compile("^(\\d+)(?:\\.(\\d+)(?:\\.(\\d+))?)?$");
+}

src/main/java/com/r35157/libs/valuetypes/basic/SmtpConfiguration.java

@@ -0,0 +1,7 @@
+package com.r35157.libs.valuetypes.basic;
+
+public record SmtpConfiguration(
+        NetworkEndPoint networkEndPoint,
+        Credentials credentials
+) {
+}

src/main/java/com/r35157/libs/valuetypes/basic/TradingPair.java

@@ -0,0 +1,6 @@
+package com.r35157.libs.valuetypes.basic;
+
+public record TradingPair(
+        CurrencyType base,  // The thing you are buying or selling.
+        CurrencyType quote  // The currency/unit used to price the base asset.
+) { }

src/main/tjava/com/r35157/libs/valuetypes/basic/Credentials.tjava

@@ -0,0 +1,6 @@
+package com.r35157.libs.valuetypes.basic;
+
+public record Credentials(
+        ΩUserNameΩ userName,
+        ΩPasswordΩ password
+) {}

src/main/tjava/com/r35157/libs/valuetypes/basic/MoneyAmount.tjava

@@ -0,0 +1,15 @@
+package com.r35157.libs.valuetypes.basic;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.math.BigDecimal;
+
+public record MoneyAmount(
+        ΩAmountΩ amount,
+        CurrencyType currencyType
+) {
+    @Override
+    public @NotNull String toString() {
+        return amount + " " + currencyType();
+    }
+}

src/main/tjava/com/r35157/libs/valuetypes/basic/MoneyPrice.tjava

@@ -0,0 +1,8 @@
+package com.r35157.libs.valuetypes.basic;
+
+import java.math.BigDecimal;
+
+public record MoneyPrice(
+        ΩPriceΩ price,
+        CurrencyType currencyType
+) { }

src/main/tjava/com/r35157/libs/valuetypes/basic/NetworkEndPoint.tjava

@@ -0,0 +1,7 @@
+package com.r35157.libs.valuetypes.basic;
+
+public record NetworkEndPoint(
+        ΩHostnameΩ hostName,
+        ΩportNumberΩ portNumber
+) {
+}

src/main/tjava/com/r35157/libs/valuetypes/basic/Range.tjava

@@ -0,0 +1,43 @@
+package com.r35157.libs.valuetypes.basic;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Objects;
+
+public record Range<T extends Comparable<T>>(
+        T from,
+        boolean fromIncluding,
+        T to,
+        boolean toIncluding
+) {
+    public Range {
+        Objects.requireNonNull(from, "from");
+        Objects.requireNonNull(to, "to");
+
+        if (from.compareTo(to) > 0) {
+            throw new IllegalArgumentException("Range from-value must not be greater than to-value.");
+        }
+    }
+
+    public boolean contains(T value) {
+        Objects.requireNonNull(value, "value");
+
+        int fromComparison = value.compareTo(from);
+        int toComparison = value.compareTo(to);
+
+        boolean afterFrom = fromIncluding
+                ? fromComparison >= 0
+                : fromComparison > 0;
+
+        boolean beforeTo = toIncluding
+                ? toComparison <= 0
+                : toComparison < 0;
+
+        return afterFrom && beforeTo;
+    }
+
+    @Override
+    public @NotNull String toString() {
+        return (fromIncluding() ? "[" : "(") + from + "," + to + (toIncluding() ? "]" : ")");
+    }
+}