Implement board validator

Signed-off-by: pacien <pacien.trangirard@pacien.net>

6 files changed, 198 insertions, 3 deletions

diff --git a/src/docs/user.md b/src/docs/user.md
index bb24c53..735daf5 100644
--- a/src/docs/user.md
+++ b/src/docs/user.md
@@ -1,7 +1,7 @@
 ---
 title: "BSc IN S5 / OOP with Java / Wall-J / User manual"
 author: [Pacien TRAN-GIRARD, Adam NAILI]
-date: 2018-01-03
+date: 2018-01-14
 ...
 
 # Preamble
@@ -108,6 +108,7 @@ A world is defined as valid if its blocks fulfill the following criteria:
 * The interior space formed by bounding blocks must be unique and simple.
 * Reachable blocks are either adjacent or belong to the interior space.
 * The world must contain at least one trash can and one garbage block.
+* The world must have enough free tiles to contain all droppable bombs.
 
 Only valid worlds can be loaded into the game.
 
diff --git a/src/main/java/fr/umlv/java/wallj/board/BoardParser.java b/src/main/java/fr/umlv/java/wallj/board/BoardParser.java
index c6d0cd8..001bdc8 100644
--- a/src/main/java/fr/umlv/java/wallj/board/BoardParser.java
+++ b/src/main/java/fr/umlv/java/wallj/board/BoardParser.java
@@ -59,7 +59,6 @@ public final class BoardParser {
   public static Board parse(Path filePath) throws IOException {
     return buildBoard(Files.lines(filePath)
                       .filter(s -> !s.isEmpty())
-                      .map(String::trim)
                       .map(BoardParser::parseLine)
                       .collect(Collectors.toList()));
   }
diff --git a/src/main/java/fr/umlv/java/wallj/board/BoardValidator.java b/src/main/java/fr/umlv/java/wallj/board/BoardValidator.java
index 0e51bc6..e238955 100644
--- a/src/main/java/fr/umlv/java/wallj/board/BoardValidator.java
+++ b/src/main/java/fr/umlv/java/wallj/board/BoardValidator.java
@@ -1,5 +1,145 @@
 package fr.umlv.java.wallj.board;
 
+import fr.umlv.java.wallj.model.BlockType;
+
+import java.util.*;
+import java.util.function.Predicate;
+import java.util.stream.IntStream;
+
+/**
+ * Board validity checker.
+ *
+ * @author Pacien TRAN-GIRARD
+ */
 public class BoardValidator {
-  //TODO
+
+  /**
+   * A validation exception, witness of validation error(s).
+   */
+  public static class ValidationException extends Exception {
+    ValidationException(String msg) {
+      super(msg);
+    }
+
+    ValidationException() {
+      super();
+    }
+  }
+
+  /**
+   * Constraint predicates.
+   */
+  public static final class Constraint {
+
+    public static final int NB_DROPPABLE_BOMBS = 3;
+
+    private static boolean inBoard(TileVec2 dim, TileVec2 v) {
+      return v.getRow() >= 0 && v.getRow() < dim.getRow() &&
+             v.getCol() >= 0 && v.getRow() < dim.getCol();
+    }
+
+    /**
+     * Checks that the supplied board is well-bounded.
+     */
+    public static boolean isBounded(Board b) {
+      TileVec2 dim = b.getDim();
+
+      boolean hBounded = IntStream.range(0, dim.getCol())
+                         .allMatch(col -> b.getBlockTypeAt(TileVec2.of(col, 0)).isBounding() &&
+                                          b.getBlockTypeAt(TileVec2.of(col, dim.getRow() - 1)).isBounding());
+
+      boolean vBounded = IntStream.range(0, dim.getRow())
+                         .allMatch(row -> b.getBlockTypeAt(TileVec2.of(0, row)).isBounding() &&
+                                          b.getBlockTypeAt(TileVec2.of(dim.getCol() - 1, row)).isBounding());
+
+      return hBounded && vBounded;
+    }
+
+    /**
+     * Checks that the supplied board is hollow, i.e. has a unique and simple interior.
+     */
+    public static boolean isHollow(Board b) {
+      TileVec2 dim = b.getDim();
+      Optional<TileVec2> start = b.stream().filter(e -> e.getValue().isTraversable()).findAny().map(Map.Entry::getKey);
+      if (!start.isPresent()) return false;
+
+      Set<TileVec2> reachable = new HashSet<>();
+      Queue<TileVec2> toVisit = new ArrayDeque<>();
+      reachable.add(start.get());
+      toVisit.add(start.get());
+
+      TileVec2 tile;
+      while ((tile = toVisit.poll()) != null)
+        tile.neighbors().stream()
+        .filter(neighbor -> inBoard(dim, neighbor))
+        .filter(neighbor -> b.getBlockTypeAt(neighbor) != null && b.getBlockTypeAt(neighbor).isTraversable())
+        .filter(neighbor -> !reachable.contains(neighbor))
+        .forEach(neighbor -> {
+          reachable.add(neighbor);
+          toVisit.add(neighbor);
+        });
+
+      return reachable.size() == b.stream().filter(e -> e.getValue().isTraversable()).count();
+    }
+
+    /**
+     * Checks that every block marked as reachable has at least one traversable neighbor.
+     */
+    public static boolean hasActualReachableBlocks(Board b) {
+      TileVec2 dim = b.getDim();
+      return b.stream()
+             .filter(blockEntry -> blockEntry.getValue().mustBeReachable())
+             .allMatch(blockEntry -> blockEntry.getKey().neighbors().stream()
+                                     .filter(neighbor -> inBoard(dim, neighbor))
+                                     .anyMatch(neighbor -> b.getBlockTypeAt(neighbor).isTraversable()));
+    }
+
+    /**
+     * Checks that the supplied board has all the mandatory blocks.
+     */
+    public static boolean hasMandatoryBlocks(Board b) {
+      return b.stream().anyMatch(block -> block.getValue() == BlockType.TRASH) &&
+             b.stream().anyMatch(block -> block.getValue() == BlockType.GARBAGE) &&
+             b.stream().filter(block -> block.getValue() == BlockType.FREE).count() >= NB_DROPPABLE_BOMBS;
+    }
+
+    private Constraint() {
+      // static class
+    }
+
+  }
+
+  private final Board board;
+  private final ValidationException errors = new ValidationException();
+
+  /**
+   * @param board the board to validate
+   */
+  public BoardValidator(Board board) {
+    this.board = board;
+  }
+
+  /**
+   * Tests the board against a given validator, using the supplied error message if the validation fails.
+   *
+   * @param validator a validity test
+   * @param msg       a failure message
+   * @return the board validator
+   */
+  public BoardValidator validate(Predicate<Board> validator, String msg) {
+    if (!validator.test(board)) errors.addSuppressed(new ValidationException(msg));
+    return this;
+  }
+
+  /**
+   * @return the validated board
+   * @throws ValidationException in case of failure
+   */
+  public Board get() throws ValidationException {
+    if (errors.getSuppressed().length > 0)
+      throw errors;
+    else
+      return board;
+  }
+
 }
diff --git a/src/test/java/fr/umlv/java/wallj/board/BoardValidatorTest.java b/src/test/java/fr/umlv/java/wallj/board/BoardValidatorTest.java
new file mode 100644
index 0000000..7be657d
--- /dev/null
+++ b/src/test/java/fr/umlv/java/wallj/board/BoardValidatorTest.java
@@ -0,0 +1,35 @@
+package fr.umlv.java.wallj.board;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+/**
+ * @author Pacien TRAN-GIRARD
+ */
+final class BoardValidatorTest {
+
+  private Path getResourcePath(String str) throws URISyntaxException {
+    return Paths.get(getClass().getResource(str).toURI());
+  }
+
+  @Test
+  void testConstraints() throws URISyntaxException, IOExceptio