Mapper backend refactor and texture deco improvements

src/main/java/com/cleanroommc/groovyscript/GroovyScript.java

@@ -15,7 +15,7 @@
 import com.cleanroommc.groovyscript.event.EventHandler;
 import com.cleanroommc.groovyscript.helper.JsonHelper;
 import com.cleanroommc.groovyscript.helper.StyleConstant;
-import com.cleanroommc.groovyscript.mapper.ObjectMapper;
+import com.cleanroommc.groovyscript.mapper.AbstractObjectMapper;
 import com.cleanroommc.groovyscript.mapper.ObjectMapperManager;
 import com.cleanroommc.groovyscript.network.CReload;
 import com.cleanroommc.groovyscript.network.NetworkHandler;
@@ -166,7 +166,7 @@ public static void initializeGroovyPreInit() {
         ObjectMapperManager.init();
         StandardInfoParserRegistry.init();
         ModSupport.init();
-        for (ObjectMapper<?> goh : ObjectMapperManager.getObjectMappers()) {
+        for (AbstractObjectMapper<?> goh : ObjectMapperManager.getObjectMappers()) {
             getSandbox().registerBinding(goh);
         }
         if (FMLLaunchHandler.isDeobfuscatedEnvironment()) Documentation.generate();

src/main/java/com/cleanroommc/groovyscript/compat/mods/betterwithaddons/BetterWithAddons.java

@@ -27,13 +27,19 @@ public BetterWithAddons() {
     }
 
     /**
-     * Because Better With Addons checks if the ingredient is an instanceof {@link betterwithaddons.util.IHasSize IHasSize}
-     * to determine if the Ingredient has an amount, we have to use their custom Ingredient.
-     * <p>
-     * If this isn't used, then the recipe may appear correctly in JEI but will actually only consume 1 when done in-game.
+     * This is required for grs to not crash when bwm is not loaded for some reason.
      */
-    public static Ingredient fromIIngredient(IIngredient ingredient) {
-        return new IngredientSized(ingredient.toMcIngredient(), ingredient.getAmount());
+    public static class FromIngredient {
+
+        /**
+         * Because Better With Addons checks if the ingredient is an instanceof {@link betterwithaddons.util.IHasSize IHasSize}
+         * to determine if the Ingredient has an amount, we have to use their custom Ingredient.
+         * <p>
+         * If this isn't used, then the recipe may appear correctly in JEI but will actually only consume 1 when done in-game.
+         */
+        public static Ingredient fromIIngredient(IIngredient ingredient) {
+            return new IngredientSized(ingredient.toMcIngredient(), ingredient.getAmount());
+        }
     }
 
     public static boolean isBetterWithEverything() {

src/main/java/com/cleanroommc/groovyscript/compat/mods/betterwithaddons/DryingBox.java

@@ -77,7 +77,7 @@ public void validate(GroovyLog.Msg msg) {
         @RecipeBuilderRegistrationMethod
         public @Nullable CherryBoxRecipe register() {
             if (!validate()) return null;
-            CherryBoxRecipe recipe = new CherryBoxRecipe(BlockCherryBox.CherryBoxType.DRYING, BetterWithAddons.fromIIngredient(input.get(0)), output.get(0));
+            CherryBoxRecipe recipe = new CherryBoxRecipe(BlockCherryBox.CherryBoxType.DRYING, BetterWithAddons.FromIngredient.fromIIngredient(input.get(0)), output.get(0));
             ModSupport.BETTER_WITH_ADDONS.get().dryingBox.add(recipe);
             return recipe;
         }

src/main/java/com/cleanroommc/groovyscript/compat/mods/betterwithaddons/FireNet.java

@@ -78,7 +78,7 @@ public void validate(GroovyLog.Msg msg) {
         @RecipeBuilderRegistrationMethod
         public @Nullable NetRecipe register() {
             if (!validate()) return null;
-            NetRecipe recipe = new NetRecipe(BlockNettedScreen.SifterType.FIRE, BetterWithAddons.fromIIngredient(input.get(0)), 0, output.toArray(new ItemStack[0]));
+            NetRecipe recipe = new NetRecipe(BlockNettedScreen.SifterType.FIRE, BetterWithAddons.FromIngredient.fromIIngredient(input.get(0)), 0, output.toArray(new ItemStack[0]));
             ModSupport.BETTER_WITH_ADDONS.get().fireNet.add(recipe);
             return recipe;
         }

src/main/java/com/cleanroommc/groovyscript/compat/mods/betterwithaddons/Packing.java

@@ -85,7 +85,7 @@ public void validate(GroovyLog.Msg msg) {
         @RecipeBuilderRegistrationMethod
         public @Nullable PackingRecipe register() {
             if (!validate()) return null;
-            PackingRecipe recipe = new PackingRecipe(BetterWithAddons.fromIIngredient(input.get(0)), compress);
+            PackingRecipe recipe = new PackingRecipe(BetterWithAddons.FromIngredient.fromIIngredient(input.get(0)), compress);
             recipe.setJeiOutput(IngredientHelper.isEmpty(jeiOutput) ? IngredientHelper.toItemStack(compress) : jeiOutput);
             ModSupport.BETTER_WITH_ADDONS.get().packing.add(recipe);
             return recipe;

src/main/java/com/cleanroommc/groovyscript/compat/mods/betterwithaddons/SandNet.java

@@ -91,7 +91,7 @@ public void validate(GroovyLog.Msg msg) {
         @RecipeBuilderRegistrationMethod
         public @Nullable NetRecipe register() {
             if (!validate()) return null;
-            NetRecipe recipe = new NetRecipe(BlockNettedScreen.SifterType.SAND, BetterWithAddons.fromIIngredient(input.get(0)), sand, output.toArray(new ItemStack[0]));
+            NetRecipe recipe = new NetRecipe(BlockNettedScreen.SifterType.SAND, BetterWithAddons.FromIngredient.fromIIngredient(input.get(0)), sand, output.toArray(new ItemStack[0]));
             ModSupport.BETTER_WITH_ADDONS.get().sandNet.add(recipe);
             return recipe;
         }

src/main/java/com/cleanroommc/groovyscript/compat/mods/betterwithaddons/SoakingBox.java

@@ -77,7 +77,7 @@ public void validate(GroovyLog.Msg msg) {
         @RecipeBuilderRegistrationMethod
         public @Nullable CherryBoxRecipe register() {
             if (!validate()) return null;
-            CherryBoxRecipe recipe = new CherryBoxRecipe(BlockCherryBox.CherryBoxType.SOAKING, BetterWithAddons.fromIIngredient(input.get(0)), output.get(0));
+            CherryBoxRecipe recipe = new CherryBoxRecipe(BlockCherryBox.CherryBoxType.SOAKING, BetterWithAddons.FromIngredient.fromIIngredient(input.get(0)), output.get(0));
             ModSupport.BETTER_WITH_ADDONS.get().soakingBox.add(recipe);
             return recipe;
         }

src/main/java/com/cleanroommc/groovyscript/compat/mods/betterwithaddons/Spindle.java

@@ -87,7 +87,7 @@ public void validate(GroovyLog.Msg msg) {
         @RecipeBuilderRegistrationMethod
         public @Nullable SpindleRecipe register() {
             if (!validate()) return null;
-            SpindleRecipe recipe = new SpindleRecipe(popoff, BetterWithAddons.fromIIngredient(input.get(0)), output.toArray(new ItemStack[0]));
+            SpindleRecipe recipe = new SpindleRecipe(popoff, BetterWithAddons.FromIngredient.fromIIngredient(input.get(0)), output.toArray(new ItemStack[0]));
             ModSupport.BETTER_WITH_ADDONS.get().spindle.add(recipe);
             return recipe;
         }

src/main/java/com/cleanroommc/groovyscript/compat/mods/betterwithaddons/Tatara.java

@@ -76,7 +76,7 @@ public void validate(GroovyLog.Msg msg) {
         @RecipeBuilderRegistrationMethod
         public @Nullable SmeltingRecipe register() {
             if (!validate()) return null;
-            SmeltingRecipe recipe = new SmeltingRecipe(BetterWithAddons.fromIIngredient(input.get(0)), output.get(0));
+            SmeltingRecipe recipe = new SmeltingRecipe(BetterWithAddons.FromIngredient.fromIIngredient(input.get(0)), output.get(0));
             ModSupport.BETTER_WITH_ADDONS.get().tatara.add(recipe);
             return recipe;
         }

src/main/java/com/cleanroommc/groovyscript/compat/mods/betterwithaddons/Transmutation.java

@@ -86,7 +86,7 @@ public void validate(GroovyLog.Msg msg) {
         @RecipeBuilderRegistrationMethod
         public @Nullable TransmutationRecipe register() {
             if (!validate()) return null;
-            TransmutationRecipe recipe = new TransmutationRecipe(BetterWithAddons.fromIIngredient(input.get(0)), spirits, output.get(0));
+            TransmutationRecipe recipe = new TransmutationRecipe(BetterWithAddons.FromIngredient.fromIIngredient(input.get(0)), spirits, output.get(0));
             ModSupport.BETTER_WITH_ADDONS.get().transmutation.add(recipe);
             return recipe;
         }

src/main/java/com/cleanroommc/groovyscript/compat/mods/betterwithaddons/WaterNet.java

@@ -80,7 +80,7 @@ public void validate(GroovyLog.Msg msg) {
         @RecipeBuilderRegistrationMethod
         public @Nullable NetRecipe register() {
             if (!validate()) return null;
-            NetRecipe recipe = new NetRecipe(BlockNettedScreen.SifterType.WATER, BetterWithAddons.fromIIngredient(input.get(0)), 0, output.toArray(new ItemStack[0]));
+            NetRecipe recipe = new NetRecipe(BlockNettedScreen.SifterType.WATER, BetterWithAddons.FromIngredient.fromIIngredient(input.get(0)), 0, output.toArray(new ItemStack[0]));
             ModSupport.BETTER_WITH_ADDONS.get().waterNet.add(recipe);
             return recipe;
         }

src/main/java/com/cleanroommc/groovyscript/mapper/AbstractObjectMapper.java

@@ -0,0 +1,190 @@
+package com.cleanroommc.groovyscript.mapper;
+
+import com.cleanroommc.groovyscript.api.GroovyLog;
+import com.cleanroommc.groovyscript.api.INamed;
+import com.cleanroommc.groovyscript.api.IObjectParser;
+import com.cleanroommc.groovyscript.api.Result;
+import com.cleanroommc.groovyscript.compat.mods.GroovyContainer;
+import com.cleanroommc.groovyscript.helper.ArrayUtils;
+import com.cleanroommc.groovyscript.sandbox.expand.IDocumented;
+import com.cleanroommc.groovyscript.server.CompletionParams;
+import com.cleanroommc.groovyscript.server.Completions;
+import groovy.lang.Closure;
+import groovy.lang.groovydoc.Groovydoc;
+import groovy.lang.groovydoc.GroovydocHolder;
+import org.apache.commons.lang3.StringUtils;
+import org.codehaus.groovy.ast.ClassHelper;
+import org.codehaus.groovy.ast.MethodNode;
+import org.codehaus.groovy.ast.Parameter;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.lang.reflect.Modifier;
+import java.util.*;
+
+public abstract class AbstractObjectMapper<T> extends Closure<T> implements INamed, IDocumented, IObjectParser<T>, TextureBinder<T> {
+
+    private final String name;
+    private final GroovyContainer<?> mod;
+    private final Class<T> returnType;
+    private final List<Class<?>[]> paramTypes;
+    protected String documentation = StringUtils.EMPTY;
+    private List<MethodNode> methodNodes;
+
+    protected AbstractObjectMapper(String name, GroovyContainer<?> mod, Class<T> returnType) {
+        super(null);
+        this.name = name;
+        this.mod = mod;
+        this.returnType = returnType;
+        this.paramTypes = new ArrayList<>();
+        addSignature(String.class);
+    }
+
+    /**
+     * Call in ctor to configure signatures
+     */
+    protected final void clearSignatures() {
+        this.paramTypes.clear();
+        this.methodNodes = null;
+    }
+
+    /**
+     * Call in ctor to configure signatures.
+     * By default, only `name(String)` exists.
+     */
+    protected final void addSignature(Class<?>... types) {
+        this.paramTypes.add(types);
+        this.methodNodes = null;
+    }
+
+    public final T doCall(String s, Object... args) {
+        return invokeWithDefault(false, s, args);
+    }
+
+    public final T doCall() {
+        return invokeDefault();
+    }
+
+    @Nullable
+    public final T invoke(boolean silent, String s, Object... args) {
+        Result<T> t = Objects.requireNonNull(parse(s, args), "Object mapper must return a non null result!");
+        if (t.hasError()) {
+            if (!silent) {
+                if (this.mod == null) {
+                    GroovyLog.get().error("Can't find {} for name {}!", name, s);
+                } else {
+                    GroovyLog.get().error("Can't find {} {} for name {}!", mod, name, s);
+                }
+                if (t.getError() != null && !t.getError().isEmpty()) {
+                    GroovyLog.get().error(" - reason: {}", t.getError());
+                }
+            }
+            return null;
+        }
+        return Objects.requireNonNull(t.getValue(), "Object mapper result must contain a non-null value!");
+    }
+
+    public final T invokeWithDefault(boolean silent, String s, Object... args) {
+        T t = invoke(silent, s, args);
+        return t != null ? t : invokeDefault();
+    }
+
+    public final T invokeDefault() {
+        Result<T> t = getDefaultValue();
+        return t == null || t.hasError() ? null : t.getValue();
+    }
+
+    /**
+     * Returns a default value for this mapper. This is called every time the parser returns an errored result.
+     *
+     * @return default value of this mapper. May be null
+     */
+    public abstract Result<T> getDefaultValue();
+
+    /**
+     * Adds all possible values this mapper can have at a param position.
+     * For example the `item()` mapper adds all item registry names when the index is 0.
+     *
+     * @param index the index of the param to complete
+     * @param params the values of all current (constant) params of the mapper
+     * @param items a list of completion items
+     */
+    public void provideCompletion(int index, CompletionParams params, Completions items) {}
+
+    /**
+     * Draws an image representation of the given object. This is used for lsp.
+     * The icon will show up in VSC or other code editors with compat.
+     * If this is implemented, {@link #hasTextureBinder()} must return true. Otherwise, this will not be used.
+     *
+     * @param t object for which a texture should be drawn.
+     */
+    public void bindTexture(T t) {}
+
+    /**
+     * Determines if {@link #bindTexture(Object)} is implemented and should be used.
+     *
+     * @return true if this mapper can bind textures
+     */
+    public abstract boolean hasTextureBinder();
+
+    @NotNull
+    public List<String> getTooltip(T t) {
+        return Collections.emptyList();
+    }
+
+    public List<MethodNode> getMethodNodes() {
+        if (methodNodes == null) {
+            this.methodNodes = new ArrayList<>();
+            for (Class<?>[] paramType : this.paramTypes) {
+                Parameter[] params = ArrayUtils.map(
+                        paramType,
+                        c -> new Parameter(ClassHelper.makeCached(c), ""),
+                        new Parameter[paramType.length]);
+                MethodNode node = new MethodNode(
+                        this.name,
+                        Modifier.PUBLIC | Modifier.FINAL,
+                        ClassHelper.makeCached(this.returnType),
+                        params,
+                        null,
+                        null);
+                node.setDeclaringClass(
+                        this.mod != null ? ClassHelper.makeCached(this.mod.get().getClass()) : ClassHelper.makeCached(ObjectMapperManager.class));
+                node.setNodeMetaData(GroovydocHolder.DOC_COMMENT, new Groovydoc(getDocumentation(), node));
+                this.methodNodes.add(node);
+            }
+        }
+        return methodNodes;
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public Collection<String> getAliases() {
+        return Collections.singleton(this.name);
+    }
+
+    public GroovyContainer<?> getMod() {
+        return mod;
+    }
+
+    public Class<T> getReturnType() {
+        return returnType;
+    }
+
+    public List<Class<?>[]> getParamTypes() {
+        return paramTypes;
+    }
+
+    @Override
+    public final String getDocumentation() {
+        return documentation;
+    }
+
+    protected final String docOfType(String type) {
+        String mod = this.mod == null ? StringUtils.EMPTY : this.mod.getContainerName() + ' ';
+        return "returns a " + mod + type;
+    }
+}

src/main/java/com/cleanroommc/groovyscript/mapper/BlockStateMapper.java

@@ -0,0 +1,79 @@
+package com.cleanroommc.groovyscript.mapper;
+
+import com.cleanroommc.groovyscript.api.Result;
+import com.cleanroommc.groovyscript.compat.mods.GroovyContainer;
+import com.cleanroommc.groovyscript.server.CompletionParams;
+import com.cleanroommc.groovyscript.server.Completions;
+import net.minecraft.block.Block;
+import net.minecraft.block.properties.IProperty;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.fml.common.registry.ForgeRegistries;
+import net.prominic.groovyls.util.CompletionItemFactory;
+import org.eclipse.lsp4j.CompletionItem;
+import org.eclipse.lsp4j.CompletionItemKind;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collections;
+import java.util.List;
+
+public class BlockStateMapper extends AbstractObjectMapper<IBlockState> {
+
+    public static final BlockStateMapper INSTANCE = new BlockStateMapper("blockstate", null);
+
+    protected BlockStateMapper(String name, GroovyContainer<?> mod) {
+        super(name, mod, IBlockState.class);
+        addSignature(String.class, int.class);
+        addSignature(String.class, String[].class);
+        this.documentation = docOfType("block state");
+    }
+
+    @Override
+    public Result<IBlockState> getDefaultValue() {
+        return Result.some(Blocks.AIR.getDefaultState());
+    }
+
+    @Override
+    public @NotNull Result<IBlockState> parse(String mainArg, Object[] args) {
+        return ObjectMappers.parseBlockState(mainArg, args);
+    }
+
+    @Override
+    public void provideCompletion(int index, CompletionParams params, Completions items) {
+        if (index == 0) items.addAllOfRegistry(ForgeRegistries.BLOCKS);
+        if (index >= 1 && params.isParamType(0, String.class)) {
+            Block block = ForgeRegistries.BLOCKS.getValue(new ResourceLocation(params.getParamAsType(0, String.class)));
+            if (block != null) {
+                // TODO completions for ints doesnt work properly
+                /*items.addAll(block.getBlockState().getValidStates(), state -> {
+                    return CompletionItemFactory.createCompletion(CompletionItemKind.Value, String.valueOf(state.getBlock().getMetaFromState(state)));
+                });*/
+                for (IProperty property : block.getBlockState().getProperties()) {
+                    items.addAll(property.getAllowedValues(), val -> {
+                        CompletionItem item = CompletionItemFactory.createCompletion(CompletionItemKind.Constant, property.getName() + "=" + property.getName((Comparable) val));
+                        return item;
+                    });
+                }
+            }
+        }
+    }
+
+    @Override
+    public void bindTexture(IBlockState iBlockState) {
+        ItemStack itemStack = new ItemStack(iBlockState.getBlock(), 1, iBlockState.getBlock().getMetaFromState(iBlockState));
+        TextureBinder.ofItem().bindTexture(itemStack);
+    }
+
+    @Override
+    public @NotNull List<String> getTooltip(IBlockState iBlockState) {
+        ItemStack itemStack = new ItemStack(iBlockState.getBlock(), 1, iBlockState.getBlock().getMetaFromState(iBlockState));
+        return Collections.singletonList(itemStack.getDisplayName());
+    }
+
+    @Override
+    public boolean hasTextureBinder() {
+        return true;
+    }
+}