Create a lenient fold parser

src/main/java/fold/io/CustomFoldReader.java

@@ -1,5 +1,6 @@
 package fold.io;
 
+import com.fasterxml.jackson.jr.ob.JSON;
 import fold.model.FoldFile;
 
 import java.io.IOException;
@@ -35,9 +36,13 @@ public CustomFoldReader(Class<T> tClass, InputStream inputStream) {
      */
     public T read() throws FoldFileFormatException {
         try {
-            return json.beanFrom(tClass, inputStream);
+            return getJson().beanFrom(tClass, inputStream);
         } catch (IOException e) {
             throw new FoldFileFormatException(e);
         }
     }
+
+    protected JSON getJson() {
+        return json;
+    }
 }

src/main/java/fold/io/LenientFoldReader.java

@@ -0,0 +1,27 @@
+package fold.io;
+
+import com.fasterxml.jackson.jr.ob.JSON;
+import fold.model.FoldFile;
+
+import java.io.InputStream;
+
+import static fold.io.impl.Fold.lenient;
+
+/**
+ * Does not throw an exception when unexpected fields are encountered.
+ */
+public class LenientFoldReader  extends CustomFoldReader<FoldFile> {
+    /**
+     * Create a new FoldReader from an InputStream.
+     *
+     * @param inputStream The InputStream to read from when reading this FoldFile.
+     */
+    public LenientFoldReader(InputStream inputStream) {
+        super(FoldFile.class, inputStream);
+    }
+
+    @Override
+    protected JSON getJson() {
+        return lenient;
+    }
+}

src/main/java/fold/io/impl/Fold.java

@@ -6,6 +6,11 @@
 public class Fold {
     public static JSON json = JSON.builder()
             .register(new JrSimpleTreeExtension())
-            .register(new FoldJacksonJrExtension())
+            .register(new FoldJacksonJrExtension(true))
+            .build();
+
+    public static final JSON lenient = JSON.builder()
+            .register(new JrSimpleTreeExtension())
+            .register(new FoldJacksonJrExtension(false))
             .build();
 }

src/main/java/fold/io/impl/FoldFileValueReader.java

@@ -11,10 +11,12 @@
 
 class FoldFileValueReader<T extends FoldFile> extends ValueReader {
     private final Class<T> type;
+    private final boolean strict;
 
-    public FoldFileValueReader(Class<T> type) {
+    public FoldFileValueReader(Class<T> type, boolean strict) {
         super(FoldFile.class);
         this.type = type;
+        this.strict = strict;
     }
 
     @Override
@@ -27,7 +29,7 @@ public Object read(JSONReader reader, JsonParser p) throws IOException {
             throw new RuntimeException(e);
         }
 
-        FoldFrameValueReader.FoldFrameFactory foldFrameFactory = new FoldFrameValueReader.FoldFrameFactory(instance.getRootFrame());
+        FoldFrameValueReader.FoldFrameFactory foldFrameFactory = new FoldFrameValueReader.FoldFrameFactory(instance.getRootFrame(), strict);
 
         String fieldName;
         while ((fieldName = p.nextFieldName()) != null) {

src/main/java/fold/io/impl/FoldFrameValueReader.java

@@ -14,8 +14,11 @@
 import java.util.List;
 
 class FoldFrameValueReader extends ValueReader {
-    public FoldFrameValueReader() {
+    private final boolean strict;
+
+    public FoldFrameValueReader(boolean strict) {
         super(FoldFrame.class);
+        this.strict = strict;
     }
 
     private static <T> List<List<T>> readListListOf(Class<T> type, JSONReader reader, JsonParser p) throws IOException {
@@ -128,7 +131,7 @@ public Object read(JSONReader reader, JsonParser p) throws IOException {
 
         String fieldName;
 
-        FoldFrameFactory foldFrameFactory = new FoldFrameFactory(frame);
+        FoldFrameFactory foldFrameFactory = new FoldFrameFactory(frame, strict);
 
         while ((fieldName = p.nextFieldName()) != null) {
             foldFrameFactory.readField(fieldName, reader, p);
@@ -141,6 +144,7 @@ public Object read(JSONReader reader, JsonParser p) throws IOException {
 
     public static class FoldFrameFactory {
         private final FoldFrame instance;
+        private final boolean strict;
         List<List<Double>> vertices_coords = new ArrayList<>();
         List<List<Integer>> vertices_vertices = new ArrayList<>();
         List<List<Integer>> vertices_edges = new ArrayList<>();
@@ -159,8 +163,9 @@ public static class FoldFrameFactory {
         List<List<Integer>> edgeOrders = new ArrayList<>();
         List<List<Integer>> faceOrders = new ArrayList<>();
 
-        public FoldFrameFactory(FoldFrame instance) {
+        public FoldFrameFactory(FoldFrame instance, boolean strict) {
             this.instance = instance;
+            this.strict = strict;
         }
 
         public void readField(String fieldName, JSONReader reader, JsonParser p) throws IOException {
@@ -231,7 +236,9 @@ public void readField(String fieldName, JSONReader reader, JsonParser p) throws
                     faceOrders = readListListOf(Integer.class, reader, p);
                     break;
                 default:
-                    throw new FoldFileFormatException("Field \"" + fieldName + "\" not valid");
+                    if (strict) {
+                        throw new FoldFileFormatException("Field \"" + fieldName + "\" not valid");
+                    }
             }
         }
 

src/main/java/fold/io/impl/FoldJacksonJrExtension.java

@@ -11,19 +11,25 @@
 import fold.model.FoldFrame;
 
 class FoldJacksonJrExtension extends JacksonJrExtension {
+    private final boolean strict;
+
+    public FoldJacksonJrExtension(boolean strict) {
+        this.strict = strict;
+    }
+
     @Override
     protected void register(ExtensionContext ctx) {
         ctx.appendProvider(new FoldHandlerProvider());
     }
 
-    private static class FoldHandlerProvider extends ReaderWriterProvider {
+    private class FoldHandlerProvider extends ReaderWriterProvider {
         @SuppressWarnings("unchecked")
         public ValueReader findValueReader(JSONReader readContext, Class<?> type) {
             if (type == FoldFrame.class) {
-                return new FoldFrameValueReader();
+                return new FoldFrameValueReader(strict);
             }
             if (FoldFile.class.isAssignableFrom(type)) {
-                return new FoldFileValueReader<>((Class<FoldFile>) type);
+                return new FoldFileValueReader<>((Class<FoldFile>) type, strict);
             }
             return null;
         }

src/test/java/fold/StrictTest.java

@@ -0,0 +1,37 @@
+package fold;
+
+import fold.io.FoldFileFormatException;
+import fold.io.FoldReader;
+import fold.io.LenientFoldReader;
+import fold.model.FoldFile;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.util.Objects;
+
+public class StrictTest {
+    @Test
+    public void testReadNonStrict() throws Exception {
+        File saveFile = new File(Objects.requireNonNull(getClass().getClassLoader().getResource("fold/extra_fields.fold")).getFile());
+
+        FoldFile foldFile;
+        try (FileInputStream inputStream = new FileInputStream(saveFile)) {
+            LenientFoldReader foldReader = new LenientFoldReader(inputStream);
+            foldFile = foldReader.read();
+        }
+
+        Assertions.assertEquals(1.2, foldFile.getSpec());
+    }
+
+    @Test
+    public void testReadStrict() throws Exception {
+        File saveFile = new File(Objects.requireNonNull(getClass().getClassLoader().getResource("fold/extra_fields.fold")).getFile());
+
+        try (FileInputStream inputStream = new FileInputStream(saveFile)) {
+            FoldReader foldReader = new FoldReader(inputStream);
+            Assertions.assertThrows(FoldFileFormatException.class, foldReader::read);
+        }
+    }
+}

src/test/resources/fold/extra_fields.fold

@@ -0,0 +1,10 @@
+{
+  "file_spec": 1.2,
+  "version": 1.2,
+  "file_creator": "Crease Pattern Editor",
+  "file_classes": [
+    "singleModel"
+  ],
+  "file_author": "test",
+  "file_description": "The description"
+}