first draft generating code but with errors

known errors:
- does not take type parameters into account which are defined next to
  SubjectT 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,38 @@
+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"),
+    )
+}
+
+project.afterEvaluate {
+    tasks.withType<Test>().configureEach {
+        useJUnitPlatform {
+            includeEngines = setOf("junit-jupiter")
+        }
+    }
+}

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

@@ -0,0 +1,55 @@
+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.FeatureKt;
+import ch.tutteli.atrium.logic.LogicKt;
+import ch.tutteli.atrium.reporting.translating.Untranslatable;
+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(getCoreExpect());
+        return switchCoreExpect(container.append(AnyKt.toBe(container, expected)));
+    }
+
+    public <NewSubjectT> AnyExpect<NewSubjectT> feature(String description, Function<SubjectT, NewSubjectT> featureExtractor) {
+        AssertionContainer<SubjectT> container = LogicKt.get_logic(getCoreExpect());
+        var newCoreExpect = FeatureKt.<SubjectT, NewSubjectT>manualFeature(container, new Untranslatable(description), toKotlinFun(featureExtractor)).transform();
+        return ExpectFactories.expectAny(newCoreExpect);
+    }
+
+    public <NewSubjectT, NewExpectT extends AbstractExpect<NewSubjectT, NewExpectT>> SelfT feature(
+            String description,
+            Function<SubjectT, NewSubjectT> featureExtractor,
+            ExpectFactory<NewSubjectT, NewExpectT> factory,
+            ExpectationCreator<NewSubjectT, NewExpectT> creator
+    ) {
+        AssertionContainer<SubjectT> container = LogicKt.get_logic(getCoreExpect());
+        return switchCoreExpect(FeatureKt.<SubjectT, NewSubjectT>manualFeature(container, new Untranslatable(description), toKotlinFun(featureExtractor)).collectAndAppend(creator.toKotlin(factory)));
+    }
+
+    private static <T, R> Function1<T, R> toKotlinFun(Function<T, R> f) {
+        return f::apply;
+    }
+
+    public <NewExpectT extends AbstractExpect<SubjectT, NewExpectT>> NewExpectT asInstanceOf(ExpectFactory<SubjectT, NewExpectT> factory) {
+        return factory.create(getCoreExpect());
+    }
+
+
+    public SelfT toEqualNullIfNullGivenElse(ExpectationCreator<SubjectT, SelfT> assertionCreatorOrNull) {
+        AssertionContainer<SubjectT> container = LogicKt.get_logic(getCoreExpect());
+        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,44 @@
+package ch.tutteli.atrium.api.fluent.java;
+
+import ch.tutteli.atrium.creating.AssertionContainer;
+import ch.tutteli.atrium.creating.Expect;
+import ch.tutteli.atrium.logic.Fun0Kt;
+import ch.tutteli.atrium.logic.LogicKt;
+import ch.tutteli.atrium.logic.UtilsKt;
+import ch.tutteli.atrium.logic.creating.transformers.SubjectChangerBuilder;
+import kotlin.Unit;
+import kotlin.jvm.JvmClassMappingKt;
+import kotlin.jvm.functions.Function0;
+
+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> expectedType) {
+        return ExpectFactories.expectAny(toThrowInternal(expectedType).transform());
+    }
+
+    public <T extends Throwable> AnyExpect<T> toThrow(Class<T> expectedType, ExpectationCreator<T, AnyExpect<T>> expectationCreator) {
+        return ExpectFactories.expectAny(toThrowInternal(expectedType).transformAndAppend(expectationCreator.toKotlin(ExpectFactories::expectAny)));
+    }
+
+    private <T extends Throwable> SubjectChangerBuilder.ExecutionStep<?, T> toThrowInternal(Class<T> expectedType) {
+        AssertionContainer<Function0<Unit>> retypedContainer = getFunction0Container();
+        return Fun0Kt.<T>toThrow(retypedContainer, JvmClassMappingKt.getKotlinClass(expectedType));
+    }
+
+    public <T extends Throwable> AnyExpect<T> notToThrow(Class<T> c) {
+        return null;
+    }
+
+    private AssertionContainer<Function0<Unit>> getFunction0Container() {
+        AssertionContainer<SubjectT> container = LogicKt.get_logic(getCoreExpect());
+        Expect<Function0<Unit>> retypedCoreExpect = UtilsKt.getChangeSubject(container).unreported(subject -> () -> {
+            subject.action();
+            return Unit.INSTANCE;
+        });
+        return LogicKt.get_logic(retypedCoreExpect);
+    }
+}

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

@@ -0,0 +1,20 @@
+package ch.tutteli.atrium.api.fluent.java;
+
+import ch.tutteli.atrium.creating.AssertionContainer;
+import ch.tutteli.atrium.creating.Expect;
+import ch.tutteli.atrium.logic.CharSequenceKt;
+import ch.tutteli.atrium.logic.ComparableKt;
+import ch.tutteli.atrium.logic.LogicKt;
+
+public abstract class AbstractCharSequenceExpect<SubjectT extends CharSequence, SelfT extends AbstractCharSequenceExpect<SubjectT, SelfT>>
+    extends AbstractAnyExpect<SubjectT, SelfT> {
+    public AbstractCharSequenceExpect(Expect<SubjectT> expect) {
+        super(expect);
+    }
+
+    public SelfT toStartWith(CharSequence expectedStart) {
+        AssertionContainer<SubjectT> container = LogicKt.get_logic(getCoreExpect());
+        return switchCoreExpect(container.append(CharSequenceKt.startsWith(container, expectedStart)));
+    }
+
+}

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

@@ -0,0 +1,20 @@
+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(getCoreExpect());
+        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,28 @@
+package ch.tutteli.atrium.api.fluent.java;
+
+import ch.tutteli.atrium.creating.Expect;
+
+public abstract class AbstractExpect<SubjectT, SelfT extends AbstractExpect<SubjectT, SelfT>> {
+
+    private Expect<SubjectT> coreExpect;
+
+    protected Expect<SubjectT> getCoreExpect(){
+        return coreExpect;
+    }
+
+    public AbstractExpect(Expect<SubjectT> expect) {
+        this.coreExpect = expect;
+    }
+
+    public abstract  SelfT createSelf(Expect<SubjectT> coreExpect);
+
+    @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/AbstractStringExpect.java

@@ -0,0 +1,11 @@
+package ch.tutteli.atrium.api.fluent.java;
+
+import ch.tutteli.atrium.creating.Expect;
+
+public abstract class AbstractStringExpect<SelfT extends AbstractStringExpect<SelfT>>
+    extends AbstractCharSequenceExpect<String, SelfT> {
+    public AbstractStringExpect(Expect<String> expect) {
+        super(expect);
+    }
+
+}

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

@@ -0,0 +1,20 @@
+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);
+    }
+
+    static <SubjectT> AnyExpect<SubjectT> expect(Expect<SubjectT> coreExpect) {
+        return new AnyExpect<>(coreExpect);
+    }
+}

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<SubjectT, BlockExpect<SubjectT>> {
+
+    public BlockExpect(Expect<SubjectT> expect) {
+        super(expect);
+    }
+
+    @Override
+    public BlockExpect<SubjectT> createSelf(Expect<SubjectT> coreExpect) {
+        return new BlockExpect<>(coreExpect);
+    }
+}