jessebrault/groowt
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Helping out ssg.

Browse Source
This commit is contained in:
JesseBrault0709 2024-05-16 17:25:36 +02:00
parent 4f0f3dfb33
commit 9212d128c3
28 changed files with 453 additions and 131 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
util/di/build.gradle
View File

@ -13,6 +13,10 @@ dependencies {
implementation libs.slf4j.api, libs.groovy
}
java {
withSourcesJar()
}
jar {
archiveBaseName = 'groowt-util-di'
}

4
util/di/src/main/java/groowt/util/di/BindingUtil.java
View File

@ -27,6 +27,10 @@ public final class BindingUtil {
return bc -> {};
}
public static <T> KeyHolder<NamedRegistryExtension, String, T> named(String name, Class<T> type) {
return new SimpleKeyHolder<>(NamedRegistryExtension.class, type, name);
}
private BindingUtil() {}
}

8
util/di/src/main/java/groowt/util/di/NamedRegistryExtension.java
View File

@ -1,9 +1,3 @@
package groowt.util.di;
public interface NamedRegistryExtension extends RegistryExtension, KeyBinder<String>, QualifierHandlerContainer {
static <T> KeyHolder<NamedRegistryExtension, String, T> named(String name, Class<T> type) {
return new SimpleKeyHolder<>(NamedRegistryExtension.class, type, name);
}
}
public interface NamedRegistryExtension extends RegistryExtension, KeyBinder<String>, QualifierHandlerContainer {}

19
util/di/src/main/java/groowt/util/di/RegistryObjectFactory.java
View File

@ -2,8 +2,6 @@ package groowt.util.di;
import groovy.lang.Closure;
import groovy.lang.DelegatesTo;
import groovy.transform.stc.ClosureParams;
import groovy.transform.stc.FromString;
import groowt.util.di.filters.FilterHandler;
import groowt.util.di.filters.IterableFilterHandler;
import jakarta.inject.Provider;
@ -20,10 +18,22 @@ import java.util.function.Consumer;
public interface RegistryObjectFactory extends ObjectFactory {
interface Builder<T extends RegistryObjectFactory> {
void configureRegistry(Consumer<? super Registry> configure);
default void configureRegistry(@DelegatesTo(Registry.class) Closure<?> configureClosure) {
this.configureRegistry(registry -> {
configureClosure.setDelegate(registry);
configureClosure.call();
});
}
void addFilterHandler(FilterHandler<?, ?> handler);
void addIterableFilterHandler(IterableFilterHandler<?, ?> handler);
T build();
}
Registry getRegistry();
@ -33,13 +43,12 @@ public interface RegistryObjectFactory extends ObjectFactory {
}
default void configureRegistry(
@DelegatesTo(Registry.class)
@ClosureParams(value = FromString.class, options = "groowt.util.di.Registry")
@DelegatesTo(value = Registry.class)
Closure<?> configureClosure
) {
final Registry registry = this.getRegistry();
configureClosure.setDelegate(registry);
configureClosure.call(registry);
configureClosure.call();
}
<A extends Annotation> @Nullable ScopeHandler<A> findScopeHandler(Class<A> scopeType);

1
util/di/src/test/java/groowt/util/di/DefaultRegistryObjectFactoryTests.java
View File

@ -5,7 +5,6 @@ import jakarta.inject.Named;
import org.junit.jupiter.api.Test;
import static groowt.util.di.BindingUtil.*;
import static groowt.util.di.NamedRegistryExtension.named;
import static org.junit.jupiter.api.Assertions.*;
public class DefaultRegistryObjectFactoryTests {

5
util/extensible/build.gradle
View File

@ -8,6 +8,10 @@ dependencies {
compileOnlyApi libs.jetbrains.anotations
}
java {
withSourcesJar()
}
jar {
archiveBaseName = 'groowt-util-extensible'
}
@ -16,6 +20,7 @@ publishing {
publications {
create('extensible', MavenPublication) {
artifactId = 'groowt-util-extensible'
from components.java
}
}
}

4
util/fp/build.gradle
View File

@ -13,6 +13,10 @@ dependencies {
compileOnlyApi libs.jetbrains.anotations
}
java {
withSourcesJar()
}
jar {
archiveBaseName = 'groowt-util-fp'
}

47
util/fp/src/main/java/groowt/util/fp/property/DefaultListProperty.java
View File

@ -1,6 +1,7 @@
package groowt.util.fp.property;
import groowt.util.fp.provider.DefaultListProvider;
import groowt.util.fp.provider.DefaultProvider;
import groowt.util.fp.provider.ListProvider;
import groowt.util.fp.provider.Provider;
@ -8,15 +9,28 @@ import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.function.Function;
import java.util.function.Predicate;
public class DefaultListProperty<T> implements ListProperty<T> {
public static <T> ListProperty<T> ofType(Class<T> type) {
return new DefaultListProperty<>(type);
}
private final Class<T> type;
private final List<Provider<T>> elementProviders = new ArrayList<>();
protected DefaultListProperty(Class<T> type) {
this.type = type;
}
@Override
public Class<T> getType() {
return this.type;
}
@Override
public void addElement(T element) {
this.elementProviders.add(Provider.of(element));
this.elementProviders.add(DefaultProvider.of(element));
}
@SuppressWarnings("unchecked")
@ -36,26 +50,31 @@ public class DefaultListProperty<T> implements ListProperty<T> {
}
@Override
public <U> ListProvider<U> mapElements(Function<? super T, ? extends U> mapper) {
return new DefaultListProvider<>(
this.elementProviders.stream()
.<Provider<U>>map(elementProvider -> elementProvider.map(mapper))
.toList()
public <U> ListProvider<U> map(Class<U> targetType, Function<? super T, ? extends U> mapper) {
return DefaultListProvider.ofElementProviders(targetType, this.elementProviders.stream()
.map(elementProvider -> elementProvider.map(targetType, mapper))
.toList()
);
}
@Override
public <U> ListProvider<U> flatMapElements(Function<? super T, ? extends Provider<? extends U>> flatMapper) {
return new DefaultListProvider<>(
this.elementProviders.stream()
.map(elementProvider -> elementProvider.flatMap(flatMapper))
.toList()
public <U> ListProvider<U> flatMap(
Class<U> targetType,
Function<? super T, ? extends Provider<? extends U>> flatMapper
) {
return DefaultListProvider.ofElementProviders(targetType, this.elementProviders.stream()
.map(elementProvider -> elementProvider.flatMap(targetType, flatMapper))
.toList()
);
}
@Override
public ListProvider<T> filterElements(Predicate<? super T> predicate) {
return new DefaultListProvider<>(this.elementProviders, List.of(predicate));
public <U extends T> ListProvider<U> withType(Class<U> desiredType) {
return DefaultListProvider.ofElementProviders(desiredType, this.elementProviders.stream()
.filter(elementProvider -> desiredType.isAssignableFrom(elementProvider.getType()))
.map(elementProvider -> elementProvider.map(desiredType, desiredType::cast))
.toList()
);
}
@Override

52
util/fp/src/main/java/groowt/util/fp/property/SimpleProperty.java → util/fp/src/main/java/groowt/util/fp/property/DefaultProperty.java
View File

@ -1,19 +1,55 @@
package groowt.util.fp.property;
import groovy.lang.Closure;
import groowt.util.fp.provider.DefaultProvider;
import groowt.util.fp.provider.Provider;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.function.Supplier;
final class SimpleProperty<T> implements Property<T> {
import static java.util.Objects.requireNonNull;
public class DefaultProperty<T> implements Property<T> {
public static <T> Property<T> empty(Class<T> type) {
return new DefaultProperty<>(type);
}
@SuppressWarnings("unchecked")
public static <T> Property<T> of(T t) {
final Property<T> property = new DefaultProperty<>((Class<T>) t.getClass());
property.set(t);
return property;
}
public static <T> Property<T> ofProvider(Class<T> type, Provider<T> tProvider) {
final Property<T> property = new DefaultProperty<>(type);
property.set(tProvider);
return property;
}
public static <T> Property<T> ofLazy(Class<T> type, Supplier<T> tSupplier) {
final Property<T> property = new DefaultProperty<>(type);
property.set(DefaultProvider.ofLazy(type, tSupplier));
return property;
}
private final Class<T> type;
private final List<Closure<?>> configureClosures = new ArrayList<>();
private Provider<? extends T> provider;
private Provider<? extends T> convention;
protected DefaultProperty(Class<T> type) {
this.type = type;
}
@Override
public Class<T> getType() {
return this.type;
}
@Override
public boolean isPresent() {
return this.provider != null || this.convention != null;
@ -26,25 +62,25 @@ final class SimpleProperty<T> implements Property<T> {
@Override
public void set(T t) {
Objects.requireNonNull(t);
this.provider = Provider.of(t);
requireNonNull(t);
this.provider = DefaultProvider.of(t);
}
@Override
public void set(Provider<? extends T> tProvider) {
Objects.requireNonNull(tProvider);
requireNonNull(tProvider);
this.provider = tProvider;
}
@Override
public void setConvention(T convention) {
Objects.requireNonNull(convention);
this.convention = Provider.of(convention);
requireNonNull(convention);
this.convention = DefaultProvider.of(convention);
}
@Override
public void setConvention(Provider<? extends T> convention) {
Objects.requireNonNull(convention);
requireNonNull(convention);
this.convention = convention;
}

23
util/fp/src/main/java/groowt/util/fp/property/ListProperty.java
View File

@ -4,10 +4,33 @@ import groowt.util.fp.provider.ListProvider;
import groowt.util.fp.provider.Provider;
import java.util.Collection;
import java.util.Objects;
public interface ListProperty<T> extends ListProvider<T> {
void addElement(T element);
void addProvider(Provider<? extends T> elementProvider);
void addAllElements(Collection<? extends T> elements);
void addAllProviders(Collection<? extends Provider<? extends T>> elementProviders);
@SuppressWarnings("unchecked")
default void leftShift(Object object) {
Objects.requireNonNull(object);
if (object instanceof Provider<?> provider) {
if (!this.getType().isAssignableFrom(provider.getType())) {
throw new IllegalArgumentException(
"The type of the given Provider (" + provider.getType().getName() + ") is not compatible with" +
"the type of this ListProperty (" + this.getType().getName() + ")."
);
}
this.addProvider((Provider<? extends T>) provider);
} else if (this.getType().isAssignableFrom(object.getClass())) {
this.addElement((T) object);
} else {
throw new IllegalArgumentException("The type of the given object (" + object.getClass().getName() +
") is not compatible with the type of this ListProperty (" + this.getType().getName() + ")."
);
}
}
}

24
util/fp/src/main/java/groowt/util/fp/property/Property.java
View File

@ -7,32 +7,8 @@ import groovy.transform.stc.FromString;
import groowt.util.fp.provider.Provider;
import org.jetbrains.annotations.Nullable;
import java.util.function.Supplier;
public interface Property<T> extends Provider<T> {
static <T> Property<T> empty() {
return new SimpleProperty<>();
}
static <T> Property<T> of(T t) {
final Property<T> property = new SimpleProperty<>();
property.set(t);
return property;
}
static <T> Property<T> ofProvider(Provider<T> tProvider) {
final Property<T> property = new SimpleProperty<>();
property.set(tProvider);
return property;
}
static <T> Property<T> ofLazy(Supplier<T> tSupplier) {
final Property<T> property = new SimpleProperty<>();
property.set(Provider.ofLazy(tSupplier));
return property;
}
void set(T t);
void set(Provider<? extends T> tProvider);
void setConvention(T t);

72
util/fp/src/main/java/groowt/util/fp/provider/DefaultListProvider.java
View File

@ -3,65 +3,71 @@ package groowt.util.fp.provider;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;
import java.util.function.Predicate;
public class DefaultListProvider<T> implements ListProvider<T> {
private final List<Provider<T>> elementProviders;
private final List<Predicate<? super T>> filters;
public DefaultListProvider(List<? extends Provider<T>> elementProviders) {
this.elementProviders = new ArrayList<>(elementProviders);
this.filters = List.of();
public static <T> ListProvider<T> ofElements(Class<T> elementType, List<? extends T> elements) {
return new DefaultListProvider<>(
elementType,
elements.stream()
.<Provider<T>>map(DefaultProvider::of)
.toList()
);
}
public DefaultListProvider(
List<? extends Provider<T>> elementProviders,
List<? extends Predicate<? super T>> filters
public static <T> ListProvider<T> ofElementProviders(
Class<T> elementType,
List<? extends Provider<T>> elementProviders
) {
return new DefaultListProvider<>(elementType, elementProviders);
}
private final Class<T> elementType;
private final List<Provider<T>> elementProviders;
private DefaultListProvider(Class<T> elementType, List<? extends Provider<T>> elementProviders) {
this.elementType = elementType;
this.elementProviders = new ArrayList<>(elementProviders);
this.filters = new ArrayList<>(filters);
}
private DefaultListProvider(DefaultListProvider<T> old, Predicate<? super T> filterToAdd) {
this.elementProviders = new ArrayList<>(old.elementProviders);
this.filters = new ArrayList<>(old.filters);
this.filters.add(filterToAdd);
}
@Override
public ListProvider<T> filterElements(Predicate<? super T> predicate) {
return new DefaultListProvider<>(this, predicate);
public Class<T> getType() {
return this.elementType;
}
@Override
public <U> ListProvider<U> mapElements(Function<? super T, ? extends U> mapper) {
public <U> ListProvider<U> map(Class<U> targetType, Function<? super T, ? extends U> mapper) {
final List<Provider<U>> uProviders = this.elementProviders.stream()
.<Provider<U>>map(elementProvider -> elementProvider.map(mapper))
.map(elementProvider -> elementProvider.map(targetType, mapper))
.toList();
return new DefaultListProvider<>(uProviders);
return new DefaultListProvider<>(targetType, uProviders);
}
@Override
public <U> ListProvider<U> flatMapElements(Function<? super T, ? extends Provider<? extends U>> flatMapper) {
public <U> ListProvider<U> flatMap(
Class<U> targetType,
Function<? super T, ? extends Provider<? extends U>> flatMapper
) {
final List<Provider<U>> uProviders = this.elementProviders.stream()
.map(elementProvider -> elementProvider.flatMap(flatMapper))
.map(elementProvider -> elementProvider.flatMap(targetType, flatMapper))
.toList();
return new DefaultListProvider<>(uProviders);
return new DefaultListProvider<>(targetType, uProviders);
}
@Override
public <U extends T> ListProvider<U> withType(Class<U> desiredType) {
return new DefaultListProvider<>(desiredType, this.elementProviders.stream()
.filter(elementProvider -> desiredType.isAssignableFrom(elementProvider.getType()))
.map(elementProvider -> elementProvider.map(desiredType, desiredType::cast))
.toList()
);
}
@Override
public List<T> get() {
final List<? extends T> filtered = this.elementProviders.stream()
.map(Provider::get)
.filter(element -> {
for (final var filter : this.filters) {
if (!filter.test(element)) {
return false;
}
}
return true;
}).toList();
.toList();
return new ArrayList<>(filtered);
}

15
util/fp/src/main/java/groowt/util/fp/provider/DefaultNamedProvider.java
View File

@ -1,20 +1,29 @@
package groowt.util.fp.provider;
public class DefaultNamedProvider<T> implements NamedProvider<T> {
class DefaultNamedProvider<T> implements NamedProvider<T> {
private final Class<T> type;
private final String name;
private final Provider<T> delegate;
@SuppressWarnings("unchecked")
public DefaultNamedProvider(String name, T element) {
this.type = (Class<T>) element.getClass();
this.name = name;
this.delegate = Provider.of(element);
this.delegate = DefaultProvider.of(element);
}
public DefaultNamedProvider(String name, Provider<T> delegate) {
public DefaultNamedProvider(Class<T> type, String name, Provider<T> delegate) {
this.type = type;
this.name = name;
this.delegate = delegate;
}
@Override
public Class<T> getType() {
return this.type;
}
@Override
public String getName() {
return this.name;

53
util/fp/src/main/java/groowt/util/fp/provider/DefaultNamedSetProvider.java Normal file
View File

@ -0,0 +1,53 @@
package groowt.util.fp.provider;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.function.Predicate;
import java.util.stream.Collectors;
class DefaultNamedSetProvider<T> extends DefaultSetProvider<T> implements NamedSetProvider<T> {
public static <T> NamedSetProvider<T> ofElementsAndNames(Class<T> type, Map<String, T> namesAndElements) {
return new DefaultNamedSetProvider<>(type, namesAndElements.entrySet().stream()
.map(entry -> new DefaultNamedProvider<>(entry.getKey(), entry.getValue()))
.collect(Collectors.toSet())
);
}
public static <T> NamedSetProvider<T> ofNamedProviders(Class<T> type, Set<? extends NamedProvider<T>> providers) {
return new DefaultNamedSetProvider<>(type, providers);
}
protected DefaultNamedSetProvider(Class<T> type, Set<? extends NamedProvider<T>> elementProviders) {
super(type, elementProviders);
}
@Override
public NamedSetProvider<T> withNames(Predicate<? super String> namePredicate) {
return new DefaultNamedSetProvider<>(this.getType(), this.getProviders().stream()
.map(provider -> (NamedProvider<T>) provider)
.filter(namedProvider -> namePredicate.test(namedProvider.getName()))
.collect(Collectors.toSet())
);
}
@Override
public NamedProvider<T> withName(String name) {
return this.getProviders().stream()
.map(provider -> (NamedProvider<T>) provider)
.filter(namedProvider -> name.equals(namedProvider.getName()))
.findFirst()
.orElseThrow(() -> new NullPointerException("There is no NamedProvider present with name " + name));
}
@SuppressWarnings("unchecked")
@Override
public NamedSetProvider<T> zipWithNames(NamedSetProvider<? extends T> other) {
final Set<NamedProvider<T>> combined = new HashSet<>();
this.getProviders().forEach(provider -> combined.add((NamedProvider<T>) provider));
other.getProviders().forEach(provider -> combined.add((NamedProvider<T>) provider));
return new DefaultNamedSetProvider<>(this.getType(), combined);
}
}

43
util/fp/src/main/java/groowt/util/fp/provider/DefaultProvider.java Normal file
View File

@ -0,0 +1,43 @@
package groowt.util.fp.provider;
import java.util.Objects;
import java.util.function.Supplier;
public class DefaultProvider<T> implements Provider<T> {
public static <T> Provider<T> of(T t) {
Objects.requireNonNull(t);
return new DefaultProvider<>(t);
}
public static <T> Provider<T> ofLazy(Class<T> type, Supplier<? extends T> tSupplier) {
Objects.requireNonNull(type);
Objects.requireNonNull(tSupplier);
return new DefaultProvider<>(type, tSupplier);
}
private final Class<T> type;
private final Supplier<T> tSupplier;
@SuppressWarnings("unchecked")
protected DefaultProvider(T t) {
this.tSupplier = () -> t;
this.type = (Class<T>) t.getClass();
}
protected DefaultProvider(Class<T> type, Supplier<? extends T> tSupplier) {
this.type = type;
this.tSupplier = tSupplier::get;
}
@Override
public Class<T> getType() {
return this.type;
}
@Override
public T get() {
return Objects.requireNonNull(this.tSupplier.get());
}
}

78
util/fp/src/main/java/groowt/util/fp/provider/DefaultSetProvider.java Normal file
View File

@ -0,0 +1,78 @@
package groowt.util.fp.provider;
import java.util.HashSet;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;
public class DefaultSetProvider<T> implements SetProvider<T> {
public static <T> SetProvider<T> ofElements(Class<T> type, Set<? extends T> elements) {
return new DefaultSetProvider<>(type, elements.stream()
.<Provider<T>>map(DefaultProvider::of)
.collect(Collectors.toSet())
);
}
public static <T> SetProvider<T> ofElementProviders(Class<T> type, Set<? extends Provider<T>> providers) {
return new DefaultSetProvider<>(type, providers);
}
private final Class<T> type;
private final Set<Provider<T>> elementProviders;
protected DefaultSetProvider(Class<T> type, Set<? extends Provider<T>> elementProviders) {
this.type = type;
this.elementProviders = new HashSet<>(elementProviders);
}
@Override
public Class<T> getType() {
return this.type;
}
@Override
public Set<Provider<T>> getProviders() {
return this.elementProviders;
}
@Override
public <U> SetProvider<U> map(Class<U> targetType, Function<? super T, ? extends U> mapper) {
return new DefaultSetProvider<>(targetType, this.elementProviders.stream()
.map(elementProvider -> elementProvider.map(targetType, mapper))
.collect(Collectors.toSet())
);
}
@Override
public <U> SetProvider<U> flatMap(Class<U> targetType, Function<? super T, ? extends Provider<U>> mapper) {
return new DefaultSetProvider<>(targetType, this.elementProviders.stream()
.map(elementProvider -> elementProvider.flatMap(targetType, mapper))
.collect(Collectors.toSet())
);
}
@Override
public <U> SetProvider<U> withType(Class<U> desiredType) {
return new DefaultSetProvider<>(desiredType, this.elementProviders.stream()
.filter(elementProvider -> desiredType.isAssignableFrom(elementProvider.getType()))
.map(elementProvider -> elementProvider.map(desiredType, desiredType::cast))
.collect(Collectors.toSet())
);
}
@SuppressWarnings("unchecked")
@Override
public SetProvider<T> zip(SetProvider<? extends T> other) {
final Set<Provider<T>> combined = new HashSet<>();
combined.addAll(this.elementProviders);
other.getProviders().forEach(provider -> combined.add((Provider<T>) provider));
return new DefaultSetProvider<>(this.getType(), combined);
}
@Override
public Set<T> get() {
return this.elementProviders.stream().map(Provider::get).collect(Collectors.toSet());
}
}

15
util/fp/src/main/java/groowt/util/fp/provider/ListProvider.java
View File

@ -2,17 +2,16 @@ package groowt.util.fp.provider;
import java.util.List;
import java.util.function.Function;
import java.util.function.Predicate;
public interface ListProvider<T> extends Provider<List<T>> {
public interface ListProvider<T> {
<U> ListProvider<U> mapElements(Function<? super T, ? extends U> mapper);
<U> ListProvider<U> flatMapElements(Function<? super T, ? extends Provider<? extends U>> flatMapper);
Class<T> getType();
ListProvider<T> filterElements(Predicate<? super T> predicate);
<U> ListProvider<U> map(Class<U> targetType, Function<? super T, ? extends U> mapper);
<U> ListProvider<U> flatMap(Class<U> targetType, Function<? super T, ? extends Provider<? extends U>> flatMapper);
default <R extends T> ListProvider<R> filterElementsByType(Class<? extends R> type) {
return this.filterElements(type::isInstance).mapElements(type::cast);
}
<U extends T> ListProvider<U> withType(Class<U> desiredType);
List<T> get();
}

3
util/fp/src/main/java/groowt/util/fp/provider/NamedProvider.java
View File

@ -12,8 +12,9 @@ public interface NamedProvider<T> extends Provider<T> {
NamedProvider<? extends T> other
) {
return new DefaultNamedProvider<>(
this.getType(),
nameSemiGroup.concat(this.getName(), other.getName()),
Provider.ofLazy(() -> tSemiGroup.concat(this.get(), other.get()))
DefaultProvider.ofLazy(this.getType(), () -> tSemiGroup.concat(this.get(), other.get()))
);
}

12
util/fp/src/main/java/groowt/util/fp/provider/NamedSetProvider.java Normal file
View File

@ -0,0 +1,12 @@
package groowt.util.fp.provider;
import java.util.function.Predicate;
public interface NamedSetProvider<T> extends SetProvider<T> {
NamedSetProvider<T> withNames(Predicate<? super String> namePredicate);
NamedProvider<T> withName(String name);
NamedSetProvider<T> zipWithNames(NamedSetProvider<? extends T> other);
}

45
util/fp/src/main/java/groowt/util/fp/provider/Provider.java
View File

@ -13,18 +13,9 @@ import java.util.function.Supplier;
*
* @param <T> The type of the value contained within.
*/
@FunctionalInterface
public interface Provider<T> {
static <T> Provider<T> of(T t) {
Objects.requireNonNull(t);
return () -> t;
}
static <T> Provider<T> ofLazy(Supplier<? extends T> tSupplier) {
Objects.requireNonNull(tSupplier);
return () -> Objects.requireNonNull(tSupplier.get(), "This Provider is empty.");
}
Class<T> getType();
/**
* @implSpec Must throw {@link NullPointerException} if the value is null.
@ -34,32 +25,48 @@ public interface Provider<T> {
*/
T get();
default T get(Supplier<RuntimeException> onEmpty) {
try {
return this.get();
} catch (NullPointerException nullPointerException) {
final RuntimeException onEmptyException = onEmpty.get();
onEmptyException.initCause(nullPointerException);
throw onEmptyException;
}
}
default Provider<T> filter(Predicate<? super T> filter) {
Objects.requireNonNull(filter);
return () -> {
return new DefaultProvider<>(this.getType(), () -> {
final T t = this.get();
if (filter.test(t)) {
return t;
} else {
throw new NullPointerException("This Provider is empty.");
throw new NullPointerException("This Provider is empty (did not pass filter).");
}
};
});
}
default <U> Provider<U> map(Function<? super T, ? extends U> mapper) {
default <U> Provider<U> map(Class<U> targetType, Function<? super T, ? extends U> mapper) {
Objects.requireNonNull(mapper);
return () -> mapper.apply(this.get());
return new DefaultProvider<>(targetType, () -> mapper.apply(this.get()));
}
default <U> Provider<U> flatMap(Function<? super T, ? extends Provider<? extends U>> flatMapper) {
default <U> Provider<U> flatMap(
Class<U> targetType,
Function<? super T, ? extends Provider<? extends U>> flatMapper
) {
Objects.requireNonNull(flatMapper);
return () -> flatMapper.apply(this.get()).get();
return new DefaultProvider<>(targetType, () -> flatMapper.apply(this.get()).get());
}
default Provider<T> zip(SemiGroup<T> semiGroup, Provider<? extends T> other) {
default Provider<T> zip(
SemiGroup<T> semiGroup,
Provider<? extends T> other
) {
Objects.requireNonNull(semiGroup);
Objects.requireNonNull(other);
return () -> semiGroup.concat(this.get(), other.get());
return new DefaultProvider<>(this.getType(), () -> semiGroup.concat(this.get(), other.get()));
}
}

22
util/fp/src/main/java/groowt/util/fp/provider/SetProvider.java Normal file
View File

@ -0,0 +1,22 @@
package groowt.util.fp.provider;
import java.util.Set;
import java.util.function.Function;
public interface SetProvider<T> {
Class<T> getType();
Set<Provider<T>> getProviders();
<U> SetProvider<U> map(Class<U> targetType, Function<? super T, ? extends U> mapper);
<U> SetProvider<U> flatMap(Class<U> targetType, Function<? super T, ? extends Provider<U>> mapper);
<U> SetProvider<U> withType(Class<U> desiredType);
Set<T> get();
SetProvider<T> zip(SetProvider<? extends T> other);
}

5
view-components/build.gradle
View File

@ -18,10 +18,15 @@ dependencies {
implementation libs.slf4j.api
}
java {
withSourcesJar()
}
publishing {
publications {
create('viewComponents', MavenPublication) {
artifactId = 'groowt-view-components'
from components.java
}
}
}

4
views/build.gradle
View File

@ -21,6 +21,10 @@ test {
testLogging.showStandardStreams = true
}
java {
withSourcesJar()
}
publishing {
publications {
create('views', MavenPublication) {

4
web-views/build.gradle
View File

@ -195,6 +195,10 @@ test {
jvmArgs '-XX:+EnableDynamicAgentLoading' // for mockito/bytebuddy
}
java {
withSourcesJar()
}
publishing {
publications {
create('webViews', MavenPublication) {

8
web-views/src/main/java/groowt/view/web/compiler/DefaultWebViewComponentTemplateCompiler.java
View File

@ -163,7 +163,13 @@ public class DefaultWebViewComponentTemplateCompiler
final var allClasses = compileUnit.getGroovyCompilationUnit().getClasses();
GroovyClass templateGroovyClass = null;
final Set<GroovyClass> otherClasses = new HashSet<>();
final String templateClassFqn = sourceUnit.getAST().getPackageName() + "." + templateClassSimpleName;
final String actualPackageName = sourceUnit.getAST().getPackageName();
final String templateClassFqn;
if (actualPackageName.endsWith(".")) {
templateClassFqn = actualPackageName + templateClassSimpleName;
} else {
templateClassFqn = actualPackageName + "." + templateClassSimpleName;
}
for (final GroovyClass groovyClass : allClasses) {
if (groovyClass.getName().equals(templateClassFqn)) {
if (templateGroovyClass != null) {

2
web-views/src/main/java/groowt/view/web/compiler/WebViewComponentTemplateCompileUnit.java
View File

@ -63,7 +63,7 @@ public class WebViewComponentTemplateCompileUnit extends AbstractComponentTempla
@Override
public @Nullable String getLine(int lineNumber, Janitor janitor) {
if (this.getSource().canReopen()) {
if (lineNumber > -1 && this.getSource().canReopen()) {
return this.getSource().getLines().get(lineNumber);
} else {
return null;

2
web-views/src/main/java/groowt/view/web/transpile/DefaultGroovyTranspiler.java
View File

@ -106,7 +106,7 @@ public class DefaultGroovyTranspiler implements GroovyTranspiler {
if (convertResult.moduleNode().hasPackage()) {
moduleNode.setPackage(convertResult.moduleNode().getPackage());
mainClassNode.setName(moduleNode.getPackageName() + "." + templateClassName);
mainClassNode.setName(moduleNode.getPackageName() + templateClassName);
}
final BlockStatement preambleBlock = convertResult.blockStatement();

10
web-views/src/main/java/groowt/view/web/transpile/DefaultTranspilerConfiguration.java
View File

@ -1,6 +1,6 @@
package groowt.view.web.transpile;
import groowt.util.fp.provider.Provider;
import groowt.util.fp.provider.DefaultProvider;
import groowt.view.web.transpile.resolve.ComponentClassNodeResolver;
public class DefaultTranspilerConfiguration implements TranspilerConfiguration {
@ -14,10 +14,10 @@ public class DefaultTranspilerConfiguration implements TranspilerConfiguration {
final var jStringTranspiler = new DefaultJStringTranspiler(positionSetter);
final var gStringTranspiler = new DefaultGStringTranspiler(positionSetter, jStringTranspiler);
final var componentTranspiler = new DefaultComponentTranspiler(
Provider.of(this.appendOrAddStatementFactory),
Provider.of(classNodeResolver),
Provider.ofLazy(this::getValueNodeTranspiler),
Provider.ofLazy(this::getBodyTranspiler)
DefaultProvider.of(this.appendOrAddStatementFactory),
DefaultProvider.of(classNodeResolver),
DefaultProvider.ofLazy(ValueNodeTranspiler.class, this::getValueNodeTranspiler),
DefaultProvider.ofLazy(BodyTranspiler.class, this::getBodyTranspiler)
);
this.valueNodeTranspiler = new DefaultValueNodeTranspiler(componentTranspiler);
this.bodyTranspiler = new DefaultBodyTranspiler(gStringTranspiler, jStringTranspiler, componentTranspiler);