Boolean entry yes/no text change

src/main/java/me/lortseam/completeconfig/api/ConfigEntry.java

@@ -66,6 +66,16 @@ public @interface ConfigEntry {
      */
     boolean requiresRestart() default false;
 
+    @Target(ElementType.FIELD)
+    @Retention(RetentionPolicy.RUNTIME)
+    @interface Boolean {
+
+        String trueTranslationKey() default "";
+
+        String falseTranslationKey() default "";
+        
+    }
+
     /**
      * Applies bounds to an entry of type Integer.
      */

src/main/java/me/lortseam/completeconfig/data/BooleanEntry.java

@@ -0,0 +1,47 @@
+package me.lortseam.completeconfig.data;
+
+import me.lortseam.completeconfig.api.ConfigEntry;
+import me.lortseam.completeconfig.data.entry.AnnotatedEntryOrigin;
+import me.lortseam.completeconfig.data.entry.EntryOrigin;
+import me.lortseam.completeconfig.data.text.TranslationIdentifier;
+import me.lortseam.completeconfig.exception.IllegalAnnotationParameterException;
+import net.minecraft.text.Text;
+import org.apache.commons.lang3.StringUtils;
+
+import java.util.function.Function;
+
+public class BooleanEntry extends Entry<Boolean> {
+
+    private final Function<Boolean, TranslationIdentifier> trueFalseTranslationSupplier;
+
+    public BooleanEntry(EntryOrigin origin, Function<Boolean, TranslationIdentifier> trueFalseTranslationSupplier) {
+        super(origin);
+        this.trueFalseTranslationSupplier = trueFalseTranslationSupplier;
+    }
+
+    BooleanEntry(AnnotatedEntryOrigin<ConfigEntry.Boolean> origin) {
+        super(origin);
+        ConfigEntry.Boolean annotation = origin.getAnnotation();
+        if (StringUtils.isBlank(annotation.trueTranslationKey()) || StringUtils.isBlank(annotation.falseTranslationKey())) {
+            throw new IllegalAnnotationParameterException("Both true key and false key must be specified");
+        }
+        trueFalseTranslationSupplier = bool -> getTranslation().root().append(bool ? annotation.trueTranslationKey() : annotation.falseTranslationKey());
+    }
+
+    BooleanEntry(EntryOrigin origin) {
+        this(origin, null);
+    }
+
+    public Function<Boolean, Text> getTrueFalseTextSupplier() {
+        if (trueFalseTranslationSupplier != null) {
+            return bool -> trueFalseTranslationSupplier.apply(bool).toText();
+        }
+        TranslationIdentifier defaultTrueTranslation = getTranslation().append("true");
+        TranslationIdentifier defaultFalseTranslation = getTranslation().append("false");
+        if (defaultTrueTranslation.exists() && defaultFalseTranslation.exists()) {
+            return bool -> (bool ? defaultTrueTranslation : defaultFalseTranslation).toText();
+        }
+        return null;
+    }
+
+}

src/main/java/me/lortseam/completeconfig/data/ColorEntry.java

@@ -1,6 +1,8 @@
 package me.lortseam.completeconfig.data;
 
 import lombok.Getter;
+import me.lortseam.completeconfig.api.ConfigEntry;
+import me.lortseam.completeconfig.data.entry.AnnotatedEntryOrigin;
 import me.lortseam.completeconfig.data.entry.EntryOrigin;
 
 public class ColorEntry<T> extends Entry<T> {
@@ -13,4 +15,8 @@ public class ColorEntry<T> extends Entry<T> {
         this.alphaMode = alphaMode;
     }
 
+    ColorEntry(AnnotatedEntryOrigin<ConfigEntry.Color> origin) {
+        this(origin, origin.getAnnotation().alphaMode());
+    }
+
 }

src/main/java/me/lortseam/completeconfig/data/Entry.java

@@ -1,13 +1,14 @@
 package me.lortseam.completeconfig.data;
 
+import com.google.common.base.Predicates;
 import com.google.common.collect.BiMap;
 import com.google.common.collect.HashBiMap;
 import com.google.common.collect.Lists;
 import lombok.*;
 import lombok.extern.log4j.Log4j2;
 import me.lortseam.completeconfig.CompleteConfig;
-import me.lortseam.completeconfig.api.ConfigEntry;
 import me.lortseam.completeconfig.api.ConfigContainer;
+import me.lortseam.completeconfig.api.ConfigEntry;
 import me.lortseam.completeconfig.data.entry.EntryOrigin;
 import me.lortseam.completeconfig.data.entry.Transformation;
 import me.lortseam.completeconfig.data.structure.DataPart;
@@ -30,26 +31,28 @@ import java.util.function.UnaryOperator;
 public class Entry<T> extends EntryBase<T> implements DataPart {
 
     private static final List<Transformation> transformations = Lists.newArrayList(
-            Transformation.ofAnnotation(ConfigEntry.BoundedInteger.class, origin -> {
+            Transformation.byAnnotation(ConfigEntry.Boolean.class).andType(boolean.class, Boolean.class).transforms(BooleanEntry::new),
+            Transformation.byType(boolean.class, Boolean.class).transforms(BooleanEntry::new),
+            Transformation.byAnnotation(ConfigEntry.BoundedInteger.class).andType(int.class, Integer.class).transforms(origin -> {
                 ConfigEntry.BoundedInteger bounds = origin.getAnnotation();
                 return new BoundedEntry<>(origin, bounds.min(), bounds.max(), bounds.slider());
-            }, int.class, Integer.class),
-            Transformation.ofAnnotation(ConfigEntry.BoundedLong.class, origin -> {
+            }),
+            Transformation.byAnnotation(ConfigEntry.BoundedLong.class).andType(long.class, Long.class).transforms(origin -> {
                 ConfigEntry.BoundedLong bounds = origin.getAnnotation();
                 return new BoundedEntry<>(origin, bounds.min(), bounds.max(), bounds.slider());
-            }, long.class, Long.class),
-            Transformation.ofAnnotation(ConfigEntry.BoundedFloat.class, origin -> {
+            }),
+            Transformation.byAnnotation(ConfigEntry.BoundedFloat.class).andType(float.class, Float.class).transforms(origin -> {
                 ConfigEntry.BoundedFloat bounds = origin.getAnnotation();
                 return new BoundedEntry<>(origin, bounds.min(), bounds.max());
-            }, float.class, Float.class),
-            Transformation.ofAnnotation(ConfigEntry.BoundedDouble.class, origin -> {
+            }),
+            Transformation.byAnnotation(ConfigEntry.BoundedDouble.class).andType(double.class, Double.class).transforms(origin -> {
                 ConfigEntry.BoundedDouble bounds = origin.getAnnotation();
                 return new BoundedEntry<>(origin, bounds.min(), bounds.max());
-            }, double.class, Double.class),
-            Transformation.of(base -> Enum.class.isAssignableFrom(base.typeClass), EnumEntry::new),
-            Transformation.ofAnnotation(ConfigEntry.Enum.class, origin -> new EnumEntry<>(origin, origin.getAnnotation().displayType()), base -> Enum.class.isAssignableFrom(base.typeClass)),
-            Transformation.ofAnnotation(ConfigEntry.Color.class, origin -> new ColorEntry<>(origin, origin.getAnnotation().alphaMode())),
-            Transformation.ofType(TextColor.class, origin -> new ColorEntry<>(origin, false))
+            }),
+            Transformation.by(base -> Enum.class.isAssignableFrom(base.typeClass)).transforms(EnumEntry::new),
+            Transformation.byAnnotation(ConfigEntry.Enum.class).and(base -> Enum.class.isAssignableFrom(base.typeClass)).transforms(origin -> new EnumEntry<>(origin, origin.getAnnotation().displayType())),
+            Transformation.byAnnotation(ConfigEntry.Color.class).transforms(ColorEntry::new),
+            Transformation.byType(TextColor.class).transforms(origin -> new ColorEntry<>(origin, false))
     );
     private static final BiMap<Key, EntryBase> entries = HashBiMap.create();
 
@@ -259,7 +262,7 @@ public class Entry<T> extends EntryBase<T> implements DataPart {
         }
 
         Entry<T> build(ConfigContainer parentObject, TranslationIdentifier parentTranslation) {
-            Entry<T> entry = transformations.stream().filter(transformation -> transformation.test(this)).findFirst().orElse(Transformation.of(base -> true, Entry::new)).transform(this, parentObject, parentTranslation);
+            Entry<T> entry = transformations.stream().filter(transformation -> transformation.test(this)).findFirst().orElse(Transformation.by(Predicates.alwaysTrue()).transforms(Entry::new)).transform(this, parentObject, parentTranslation);
             for (Consumer<Entry<T>> interaction : interactions) {
                 interaction.accept(entry);
             }

src/main/java/me/lortseam/completeconfig/data/entry/Transformation.java

@@ -6,7 +6,6 @@ import me.lortseam.completeconfig.api.ConfigContainer;
 import me.lortseam.completeconfig.data.Entry;
 import me.lortseam.completeconfig.data.EntryBase;
 import me.lortseam.completeconfig.data.text.TranslationIdentifier;
-import me.lortseam.completeconfig.exception.IllegalAnnotationTargetException;
 import org.apache.commons.lang3.ArrayUtils;
 
 import java.lang.annotation.Annotation;
@@ -17,25 +16,18 @@ import java.util.function.Predicate;
 @RequiredArgsConstructor(access = AccessLevel.PRIVATE)
 public final class Transformation<O extends EntryOrigin> {
 
-    public static Transformation<EntryOrigin> of(Predicate<EntryBase<?>> predicate, Transformer<EntryOrigin> transformer) {
-        return new Transformation<>(predicate, EntryOrigin::new, transformer);
+    public static Transformation.Builder<EntryOrigin> by(Predicate<EntryBase<?>> predicate) {
+        return new Transformation.Builder<>(EntryOrigin::new).and(predicate);
     }
 
-    public static Transformation<EntryOrigin> ofType(Type type, Transformer<EntryOrigin> transformer) {
-        return of(base -> base.getType().equals(type), transformer);
+    public static Transformation.Builder<EntryOrigin> byType(Type... types) {
+        return new Transformation.Builder<>(EntryOrigin::new).andType(types);
     }
 
-    public static <A extends Annotation> Transformation<AnnotatedEntryOrigin<A>> ofAnnotation(Class<A> annotationClass, Transformer<AnnotatedEntryOrigin<A>> transformer, Predicate<EntryBase<?>> predicate) {
-        return new Transformation<>(base -> base.getField().isAnnotationPresent(annotationClass) && predicate.test(base), (field, parentObject, parentTranslation) -> new AnnotatedEntryOrigin<>(field, parentObject, parentTranslation, field.getDeclaredAnnotation(annotationClass)), transformer);
-    }
-
-    public static <A extends Annotation> Transformation<AnnotatedEntryOrigin<A>> ofAnnotation(Class<A> annotationClass, Transformer<AnnotatedEntryOrigin<A>> transformer, Type... types) {
-        return ofAnnotation(annotationClass, transformer, base -> {
-            if (types.length > 0 && !ArrayUtils.contains(types, base.getType())) {
-                throw new IllegalAnnotationTargetException("Cannot apply annotation " + annotationClass + " to field " + base.getField());
-            }
-            return true;
-        });
+    public static <A extends Annotation> Transformation.Builder<AnnotatedEntryOrigin<A>> byAnnotation(Class<A> annotationClass) {
+        return new Transformation.Builder<>((field, parentObject, parentTranslation) -> {
+            return new AnnotatedEntryOrigin<>(field, parentObject, parentTranslation, field.getDeclaredAnnotation(annotationClass));
+        }).and(base -> base.getField().isAnnotationPresent(annotationClass));
     }
 
     private final Predicate<EntryBase<?>> predicate;
@@ -50,6 +42,34 @@ public final class Transformation<O extends EntryOrigin> {
         return transformer.transform(originCreator.create(base.getField(), parentObject, parentTranslation));
     }
 
+    @RequiredArgsConstructor(access = AccessLevel.PRIVATE)
+    public static class Builder<O extends EntryOrigin> {
+
+        private final OriginCreator<O> originCreator;
+        private Predicate<EntryBase<?>> predicate;
+
+        public Builder<O> and(Predicate<EntryBase<?>> predicate) {
+            if (this.predicate == null) {
+                this.predicate = predicate;
+            } else {
+                this.predicate = this.predicate.and(predicate);
+            }
+            return this;
+        }
+
+        public Builder<O> andType(Type... types) {
+            if (types.length == 0) {
+                throw new IllegalArgumentException("Types must not be empty");
+            }
+            return and(base -> ArrayUtils.contains(types, base.getType()));
+        }
+
+        public Transformation<O> transforms(Transformer<O> transformer) {
+            return new Transformation<>(predicate, originCreator, transformer);
+        }
+
+    }
+
     @FunctionalInterface
     private interface OriginCreator<O extends EntryOrigin> {
 

src/main/java/me/lortseam/completeconfig/extensions/clothbasicmath/ClothBasicMathExtension.java

@@ -37,7 +37,7 @@ public final class ClothBasicMathExtension implements CompleteConfigExtension {
     @Override
     public Collection<Transformation> getTransformations() {
         return ImmutableList.of(
-                Transformation.ofType(Color.class, origin -> new ColorEntry<>(origin, true))
+                Transformation.byType(Color.class).transforms(origin -> new ColorEntry<>(origin, true))
         );
     }
 

src/main/java/me/lortseam/completeconfig/gui/cloth/GuiRegistry.java

@@ -3,10 +3,7 @@ package me.lortseam.completeconfig.gui.cloth;
 import com.google.common.collect.Lists;
 import com.google.common.collect.MoreCollectors;
 import com.google.common.reflect.TypeToken;
-import me.lortseam.completeconfig.data.BoundedEntry;
-import me.lortseam.completeconfig.data.ColorEntry;
-import me.lortseam.completeconfig.data.Entry;
-import me.lortseam.completeconfig.data.EnumEntry;
+import me.lortseam.completeconfig.data.*;
 import me.shedaniel.clothconfig2.api.AbstractConfigListEntry;
 import me.shedaniel.clothconfig2.api.ConfigEntryBuilder;
 import me.shedaniel.clothconfig2.impl.builders.DropdownMenuBuilder;
@@ -77,10 +74,11 @@ public final class GuiRegistry {
     }
 
     private void registerDefaultProviders() {
-       registerProvider((Entry<Boolean> entry) -> build(
+       registerProvider((BooleanEntry entry) -> build(
                builder -> builder
                        .startBooleanToggle(entry.getText(), entry.getValue())
                        .setDefaultValue(entry.getDefaultValue())
+                       .setYesNoTextSupplier(entry.getTrueFalseTextSupplier())
                        .setTooltip(entry.getTooltip())
                        .setSaveConsumer(entry::setValue),
                entry.requiresRestart()