first drafts generating errors

known errors:
- does not take type parameters into account which are defined next to
  SubjecT in the kotlin expectation function
- inlining xyz(..).transform() calls does not always work
  because body of IrFunction is empty

Author: robstoll

apis/fluent/atrium-api-fluent-java/build.gradle.kts

@@ -0,0 +1,30 @@
+plugins {
+    id("build-logic.published-java-library")
+}
+
+description = "A fluent expectation function API for java with a focus on code completion"
+
+sourceSets {
+    main {
+        java {
+            srcDir(project.layout.projectDirectory.dir("src/main/generated/java").asFile)
+        }
+    }
+}
+
+dependencies {
+    api(prefixedProject("logic"))
+
+    testImplementation(prefixedProject("specs"))
+    testImplementation(libs.junit.jupiter)
+    testRuntimeOnly(libs.junit.platform.launcher)
+}
+
+
+junitjacoco {
+    additionalProjectSources.addAll(
+        prefixedProject("translations-en_GB"),
+        prefixedProject("logic"),
+        prefixedProject("core"),
+    )
+}

apis/fluent/atrium-api-fluent-java/src/main/java/ch/tutteli/atrium/api/fluent/java/AbstractAnyExpect.java

@@ -0,0 +1,30 @@
+package ch.tutteli.atrium.api.fluent.java;
+
+import ch.tutteli.atrium.creating.AssertionContainer;
+import ch.tutteli.atrium.creating.Expect;
+import ch.tutteli.atrium.logic.AnyKt;
+import ch.tutteli.atrium.logic.LogicKt;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function1;
+
+import java.util.function.Function;
+
+public abstract class AbstractAnyExpect<SubjectT, SelfT extends AbstractAnyExpect<SubjectT, SelfT>>
+    extends AbstractExpect<SubjectT, SelfT> {
+    public AbstractAnyExpect(Expect<SubjectT> expect) {
+        super(expect);
+    }
+
+    public SelfT toEqual(SubjectT expected) {
+        AssertionContainer<SubjectT> container = LogicKt.get_logic(coreExpect);
+        return switchCoreExpect(container.append(AnyKt.toBe(container, expected)));
+    }
+
+    public <NewSubjectT, NewExpectT extends AbstractExpect<NewSubjectT, NewExpectT>> NewExpectT feature(Function<SubjectT, NewExpectT> t) {}
+
+
+    public SelfT toEqualNullIfNullGivenElse(ExpectationCreator<SubjectT, SelfT> assertionCreatorOrNull) {
+        AssertionContainer<SubjectT> container = LogicKt.get_logic(coreExpect);
+        return switchCoreExpect(container.append(AnyKt.toBeNullIfNullGivenElse(container, assertionCreatorOrNull.toKotlin(this::createSelf))));
+    }
+}

apis/fluent/atrium-api-fluent-java/src/main/java/ch/tutteli/atrium/api/fluent/java/AbstractBlockExpect.java

@@ -0,0 +1,21 @@
+package ch.tutteli.atrium.api.fluent.java;
+
+import ch.tutteli.atrium.creating.Expect;
+
+public abstract class AbstractBlockExpect<SubjectT extends Block, SelfT extends AbstractBlockExpect<SubjectT, SelfT>> extends AbstractAnyExpect<SubjectT, SelfT> {
+
+    public AbstractBlockExpect(Expect<SubjectT> expect) {
+        super(expect);
+    }
+
+    public <T extends Throwable> AnyExpect<T> toThrow(Class<T> c) {
+        return null;
+    }
+
+    public <T extends Throwable> AnyExpect<T> toThrow(Class<T> c, ExpectationCreator<T, AnyExpect<T>> e) {
+        return null;
+    }
+    public <T extends Throwable> AnyExpect<T> notToThrow(Class<T> c) {
+        return null;
+    }
+}

apis/fluent/atrium-api-fluent-java/src/main/java/ch/tutteli/atrium/api/fluent/java/AbstractComparableExpect.java

@@ -0,0 +1,19 @@
+package ch.tutteli.atrium.api.fluent.java;
+
+import ch.tutteli.atrium.creating.AssertionContainer;
+import ch.tutteli.atrium.creating.Expect;
+import ch.tutteli.atrium.logic.ComparableKt;
+import ch.tutteli.atrium.logic.LogicKt;
+
+public abstract class AbstractComparableExpect<SubjectT extends Comparable<SubjectT>, SelfT extends AbstractComparableExpect<SubjectT, SelfT>>
+    extends AbstractAnyExpect<SubjectT, SelfT> {
+    public AbstractComparableExpect(Expect<SubjectT> expect) {
+        super(expect);
+    }
+
+    public SelfT toBeLessThan(SubjectT expected) {
+        AssertionContainer<SubjectT> container = LogicKt.get_logic(coreExpect);
+        return switchCoreExpect(container.append(ComparableKt.isLessThan(container, expected)));
+    }
+
+}

apis/fluent/atrium-api-fluent-java/src/main/java/ch/tutteli/atrium/api/fluent/java/AbstractExpect.java

@@ -0,0 +1,21 @@
+package ch.tutteli.atrium.api.fluent.java;
+
+import ch.tutteli.atrium.creating.Expect;
+
+public abstract class AbstractExpect<SubjectT, SelfT extends AbstractExpect<SubjectT, SelfT>> {
+    protected Expect<SubjectT> coreExpect;
+
+    public AbstractExpect(Expect<SubjectT> expect) {
+        this.coreExpect = expect;
+    }
+
+    @SuppressWarnings("unchecked")
+    final protected SelfT self() {
+        return (SelfT) this;
+    }
+
+    final protected SelfT switchCoreExpect(Expect<SubjectT> newExpect) {
+        coreExpect = newExpect;
+        return self();
+    }
+}

apis/fluent/atrium-api-fluent-java/src/main/java/ch/tutteli/atrium/api/fluent/java/AnyExpect.java

@@ -0,0 +1,16 @@
+package ch.tutteli.atrium.api.fluent.java;
+
+import ch.tutteli.atrium.creating.Expect;
+
+public class AnyExpect<SubjectT>
+    extends AbstractAnyExpect<SubjectT, AnyExpect<SubjectT>> {
+
+    public AnyExpect(Expect<SubjectT> expect) {
+        super(expect);
+    }
+
+    @Override
+    public AnyExpect<SubjectT> createSelf(Expect<SubjectT> expect) {
+        return new AnyExpect<>(expect);
+    }
+}

apis/fluent/atrium-api-fluent-java/src/main/java/ch/tutteli/atrium/api/fluent/java/Block.java

@@ -0,0 +1,5 @@
+package ch.tutteli.atrium.api.fluent.java;
+
+public interface Block {
+    void action();
+}

apis/fluent/atrium-api-fluent-java/src/main/java/ch/tutteli/atrium/api/fluent/java/BlockExpect.java

@@ -0,0 +1,15 @@
+package ch.tutteli.atrium.api.fluent.java;
+
+import ch.tutteli.atrium.creating.Expect;
+
+public class BlockExpect<SubjectT extends Block> extends AbstractBlockExpect<Block, BlockExpect<SubjectT>> {
+
+    public BlockExpect(Expect<Block> expect) {
+        super(expect);
+    }
+
+    @Override
+    public BlockExpect createSelf(Expect<Block> coreExpect) {
+        return new BlockExpect((coreExpect));
+    }
+}

apis/fluent/atrium-api-fluent-java/src/main/java/ch/tutteli/atrium/api/fluent/java/ComparableExpect.java

@@ -0,0 +1,16 @@
+package ch.tutteli.atrium.api.fluent.java;
+
+import ch.tutteli.atrium.creating.Expect;
+
+public class ComparableExpect<SubjectT extends Comparable<SubjectT>>
+    extends AbstractComparableExpect<SubjectT, ComparableExpect<SubjectT>> {
+
+    public ComparableExpect(Expect<SubjectT> expect) {
+        super(expect);
+    }
+
+    @Override
+    public ComparableExpect<SubjectT> createSelf(Expect<SubjectT> coreExpect) {
+        return new ComparableExpect<>(coreExpect);
+    }
+}

apis/fluent/atrium-api-fluent-java/src/main/java/ch/tutteli/atrium/api/fluent/java/ExpectationCreator.java

@@ -0,0 +1,16 @@
+package ch.tutteli.atrium.api.fluent.java;
+
+import ch.tutteli.atrium.creating.Expect;
+import kotlin.Unit;
+
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+public interface ExpectationCreator<SubjectT, SelfT extends AbstractExpect<SubjectT, SelfT>> extends Consumer<SelfT> {
+    default kotlin.jvm.functions.Function1<Expect<SubjectT>, kotlin.Unit> toKotlin(Function<Expect<SubjectT>, SelfT> factory) {
+        return (expect) -> {
+            accept(factory.apply(expect));
+            return Unit.INSTANCE;
+        };
+    }
+}