Generify filter utils

src/main/java/io/gitlab/jfronny/respackopts/filters/FileFilterEventImpl.java

@@ -11,8 +11,6 @@ import io.gitlab.jfronny.respackopts.filters.util.FileFallbackProvider;
 import net.minecraft.resource.AbstractFileResourcePack;
 import net.minecraft.util.Identifier;
 
-import java.io.FileNotFoundException;
-import java.io.IOException;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 public class FileFilterEventImpl {
@@ -21,13 +19,12 @@ public class FileFilterEventImpl {
         UserResourceEvents.OPEN.register((type, id, previous, pack) -> {
             if (skip(pack)) return previous;
             String name = new ResourcePath(type, id).getName();
-            IOException ex = new FileNotFoundException();
             if (pack.contains(type, id)) {
                 if (containsFileWasFallback.get())
-                    return FileFallbackProvider.getReplacement(pack, name, ex);
+                    return FileFallbackProvider.getReplacement(pack, name);
-                return FileExpansionProvider.replace(previous, pack, name, ex);
+                return FileExpansionProvider.replace(previous, pack, name);
             }
-            throw ex;
+            return previous;
         });
         UserResourceEvents.FIND_RESOURCE.register((type, namespace, prefix, maxDepth, pathFilter, previous, pack) -> {
             // Warning: the Identifiers here DON'T CONTAIN THE TYPE!

src/main/java/io/gitlab/jfronny/respackopts/filters/util/FileExclusionProvider.java

@@ -1,36 +1,20 @@
 package io.gitlab.jfronny.respackopts.filters.util;
 
-import io.gitlab.jfronny.libjf.data.ResourcePath;
 import io.gitlab.jfronny.libjf.data.WrappedPack;
 import io.gitlab.jfronny.respackopts.Respackopts;
-import io.gitlab.jfronny.respackopts.data.FileRpo;
+import io.gitlab.jfronny.respackopts.util.RpoFormatException;
-
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.io.Reader;
 
 public class FileExclusionProvider {
     public static boolean fileHidden(WrappedPack pack, String name) {
-        if (name.endsWith(Respackopts.FILE_EXTENSION))
+        return FileRpoSearchProvider.modifyWithRpo(name, pack, rpo -> {
-            return false;
-        ResourcePath rpoPath;
-        try {
-            rpoPath = new ResourcePath(name + Respackopts.FILE_EXTENSION);
-            if (!pack.contains(rpoPath.getType(), rpoPath.getId()))
-                return false;
-        } catch (Throwable e) {
-            Respackopts.LOGGER.error("Could not check file filter status", e);
-            return false;
-        }
-        try (InputStream stream = pack.open(rpoPath.getType(), rpoPath.getId()); Reader w = new InputStreamReader(stream)) {
-            FileRpo rpo = Respackopts.GSON.fromJson(w, FileRpo.class);
             if (rpo.conditions == null)
                 return false;
-            return !rpo.conditions.evaluate(Respackopts.getId(pack));
+            try {
-        }
+                return !rpo.conditions.evaluate(Respackopts.getId(pack));
-        catch (Throwable e) {
+            } catch (RpoFormatException e) {
-            Respackopts.LOGGER.error("Could not load RPO file " + name, e);
+                Respackopts.LOGGER.error("Could not evaluate condition " + name, e);
-            return false;
+                return false;
-        }
+            }
+        }, false);
     }
 }

src/main/java/io/gitlab/jfronny/respackopts/filters/util/FileExpansionProvider.java

@@ -1,9 +1,7 @@
 package io.gitlab.jfronny.respackopts.filters.util;
 
-import io.gitlab.jfronny.libjf.data.ResourcePath;
 import io.gitlab.jfronny.libjf.data.WrappedPack;
 import io.gitlab.jfronny.respackopts.Respackopts;
-import io.gitlab.jfronny.respackopts.data.FileRpo;
 import meteordevelopment.starscript.Script;
 
 import java.io.*;
@@ -18,28 +16,16 @@ public class FileExpansionProvider {
         return new ByteArrayInputStream(s.getBytes());
     }
 
-    //TODO move check to see if file has rpo (and parse it if it does) to shared location
+    public static InputStream replace(InputStream inputStream, WrappedPack pack, String name) {
-    public static InputStream replace(InputStream inputStream, WrappedPack pack, String name, IOException ex) throws IOException {
+        return FileRpoSearchProvider.modifyWithRpo(name, pack, rpo -> {
-        if (name.endsWith(Respackopts.FILE_EXTENSION))
-            return inputStream;
-        ResourcePath rpoPath;
-        try {
-            rpoPath = new ResourcePath(name + Respackopts.FILE_EXTENSION);
-            if (!pack.contains(rpoPath.getType(), rpoPath.getId()))
-                return inputStream;
-        } catch (Throwable e) {
-            Respackopts.LOGGER.error("Could not check file filter status", e);
-            return inputStream;
-        }
-        try (InputStream stream = pack.open(rpoPath.getType(), rpoPath.getId()); Reader w = new InputStreamReader(stream)) {
-            FileRpo rpo = Respackopts.GSON.fromJson(w, FileRpo.class);
             if (rpo.expansions == null || rpo.expansions.isEmpty())
                 return inputStream;
-            return replace(inputStream, rpo.expansions);
+            try {
-        }
+                return replace(inputStream, rpo.expansions);
-        catch (Exception e) {
+            } catch (IOException e) {
-            Respackopts.LOGGER.error("Could not generate replacement for " + name + " in " + pack.getName(), e);
+                Respackopts.LOGGER.error("Could not perform file expansion on " + name, e);
-        }
+                return inputStream;
-        throw ex;
+            }
+        }, inputStream);
     }
 }

src/main/java/io/gitlab/jfronny/respackopts/filters/util/FileFallbackProvider.java

@@ -3,63 +3,53 @@ package io.gitlab.jfronny.respackopts.filters.util;
 import io.gitlab.jfronny.libjf.data.ResourcePath;
 import io.gitlab.jfronny.libjf.data.WrappedPack;
 import io.gitlab.jfronny.respackopts.Respackopts;
-import io.gitlab.jfronny.respackopts.data.FileRpo;
 import net.minecraft.resource.ResourceType;
 import net.minecraft.util.Identifier;
 
-import java.io.IOException;
 import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.io.Reader;
 import java.util.Collection;
 import java.util.List;
 
 public class FileFallbackProvider {
     public static boolean fileVisible(WrappedPack pack, String name) {
-        if (name.endsWith(Respackopts.FILE_EXTENSION))
+        return FileRpoSearchProvider.modifyWithRpo(name, pack, rpo -> {
-            return false;
-        try (ResourcePath fbt = new ResourcePath(name + Respackopts.FILE_EXTENSION); InputStream stream = pack.open(fbt.getType(), fbt.getId()); Reader w = new InputStreamReader(stream)) {
-            if (pack.contains(fbt.getType(), fbt.getId())) {
-                FileRpo rpo = Respackopts.GSON.fromJson(w, FileRpo.class);
-                if (rpo.fallbacks != null) {
-                    List<String> arr = rpo.fallbacks;
-                    for (String s : arr) {
-                        ResourcePath tmp = new ResourcePath(s);
-                        if (pack.contains(tmp.getType(), tmp.getId()))
-                            return true;
-                    }
-                }
-            }
-        }
-        catch (Exception e) {
-            Respackopts.LOGGER.error("Could not determine visibility of " + name, e);
-        }
-        return false;
-    }
-
-    public static InputStream getReplacement(WrappedPack pack, String name, IOException ex) throws IOException {
-        try (ResourcePath fbt = new ResourcePath(name + Respackopts.FILE_EXTENSION); InputStream stream = pack.open(fbt.getType(), fbt.getId()); Reader w = new InputStreamReader(stream)) {
-            FileRpo rpo = Respackopts.GSON.fromJson(w, FileRpo.class);
             if (rpo.fallbacks != null) {
                 List<String> arr = rpo.fallbacks;
                 for (String s : arr) {
                     ResourcePath tmp = new ResourcePath(s);
                     if (pack.contains(tmp.getType(), tmp.getId()))
-                        return pack.open(tmp.getType(), tmp.getId());
+                        return true;
                 }
             }
-        }
+            return false;
-        catch (Exception e) {
+        }, false);
-            Respackopts.LOGGER.error("Could not determine replacement for " + name, e);
+    }
-        }
+
-        throw ex;
+    public static InputStream getReplacement(WrappedPack pack, String name) {
+        return FileRpoSearchProvider.modifyWithRpo(name, pack, rpo -> {
+            try {
+                if (rpo.fallbacks != null) {
+                    List<String> arr = rpo.fallbacks;
+                    for (String s : arr) {
+                        ResourcePath tmp = new ResourcePath(s);
+                        if (pack.contains(tmp.getType(), tmp.getId()))
+                            return pack.open(tmp.getType(), tmp.getId());
+                    }
+                }
+                Respackopts.LOGGER.error("Could not determine replacement for " + name);
+            }
+            catch (Exception e) {
+                Respackopts.LOGGER.error("Could not determine replacement for " + name, e);
+            }
+            return null;
+        }, null);
     }
 
     public static void addFallbackResources(WrappedPack pack, Collection<Identifier> ret, String namespace, ResourceType type) {
         // Warning: the Identifiers here DON'T CONTAIN THE TYPE! Therefore, it needs to be added when calling a method that generates a ResourcePath!
         for (Identifier identifier : ret) {
             String path = identifier.getPath();
-            if (path.endsWith(Respackopts.FILE_EXTENSION)) {
+            if (FileRpoSearchProvider.isRpo(path)) {
                 String expectedTarget = path.substring(0, path.length() - Respackopts.FILE_EXTENSION.length());
                 if (ret.stream().noneMatch(s -> s.getPath().equals(expectedTarget)) && fileVisible(pack, type.getDirectory() + "/" + expectedTarget)) {
                     ret.add(new Identifier(namespace, expectedTarget));

src/main/java/io/gitlab/jfronny/respackopts/filters/util/FileRpoSearchProvider.java

@@ -0,0 +1,41 @@
+package io.gitlab.jfronny.respackopts.filters.util;
+
+import io.gitlab.jfronny.libjf.data.ResourcePath;
+import io.gitlab.jfronny.libjf.data.WrappedPack;
+import io.gitlab.jfronny.respackopts.Respackopts;
+import io.gitlab.jfronny.respackopts.data.FileRpo;
+
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.Reader;
+
+public class FileRpoSearchProvider {
+    public static boolean isRpo(String fileName) {
+        return fileName.endsWith(Respackopts.FILE_EXTENSION);
+    }
+
+    public static <T> T modifyWithRpo(String fileName, WrappedPack pack, ModifiedGenerator<T> getModified, T defaultValue) {
+        if (FileRpoSearchProvider.isRpo(fileName))
+            return defaultValue;
+        ResourcePath rpoPath;
+        try {
+            rpoPath = new ResourcePath(fileName + Respackopts.FILE_EXTENSION);
+            if (!pack.contains(rpoPath.getType(), rpoPath.getId()))
+                return defaultValue;
+        } catch (Throwable e) {
+            Respackopts.LOGGER.error("Could not check file filter status", e);
+            return defaultValue;
+        }
+        try (InputStream stream = pack.open(rpoPath.getType(), rpoPath.getId()); Reader w = new InputStreamReader(stream)) {
+            return getModified.getModified(Respackopts.GSON.fromJson(w, FileRpo.class));
+        }
+        catch (Exception e) {
+            Respackopts.LOGGER.error("Could not generate replacement for " + rpoPath.getName() + " in " + pack.getName(), e);
+            return defaultValue;
+        }
+    }
+
+    public interface ModifiedGenerator<T> {
+        T getModified(FileRpo rpo);
+    }
+}