Feature/concurrency tests

project.gradle

@@ -11,20 +11,25 @@ project.ext {
     developer = "Frank Wisniewski"
     developerId = "frankwis"
     developerMail = "[email protected]"
-};
+}
+
+ext {
+    slf4jVersion = "1.7.18"
+}
 
 dependencies {
 
     compile([
-            "org.apache.avro:avro:1.8.0",
-            "org.slf4j:slf4j-api:1.7.18"
+            "org.apache.avro:avro:1.8.1",
+            "org.slf4j:slf4j-api:$slf4jVersion",
+            "com.google.code.findbugs:jsr305:3.0.1"
     ])
 
     testCompile([
             "junit:junit:4.12",
             "org.hamcrest:hamcrest-all:1.3",
             "com.google.guava:guava-testlib:19.0",
-            "org.slf4j:slf4j-simple:1.7.18"
+            "org.slf4j:slf4j-simple:$slf4jVersion"
     ])
 }
 

src/main/java/io/datanerds/avropatch/Patch.java

@@ -1,50 +1,40 @@
 package io.datanerds.avropatch;
 
+import io.datanerds.avropatch.value.DefaultSchema;
 import io.datanerds.avropatch.operation.Operation;
-import org.apache.avro.Schema;
-import org.apache.avro.io.*;
-import org.apache.avro.reflect.ReflectData;
-import org.apache.avro.reflect.ReflectDatumReader;
-import org.apache.avro.reflect.ReflectDatumWriter;
-
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-
+import org.apache.avro.reflect.AvroSchema;
+import java.util.*;
+
+/**
+ * This class represents a JSON PATCH operation holding a sequence of operations to apply to a given object.
+ *
+ * @see <a href="https://tools.ietf.org/html/rfc6902">https://tools.ietf.org/html/rfc6902</a>
+ */
 public class Patch {
 
-    public static final Schema SCHEMA = ReflectData.get().getSchema(Patch.class);
-    private static final DatumWriter<Patch> writer = new ReflectDatumWriter<>(SCHEMA);
+    @AvroSchema(DefaultSchema.HEADERS)
+    private final Map<String, ?> headers;
     private final List<Operation> operations;
 
-    public Patch() {
-        operations = new ArrayList<>();
+    @SuppressWarnings("unused") // no-arg constructor needed by Avro
+    private Patch() {
+        this(new ArrayList<>(), new HashMap<>());
     }
 
     public Patch(List<Operation> operations) {
-        this.operations = new ArrayList<>(operations);
+        this(operations, Collections.EMPTY_MAP);
     }
 
-    public boolean addOperation(Operation operation) {
-        return operations.add(operation);
+    public Patch(List<Operation> operations, Map<String, ?> headers) {
+        this.operations = new ArrayList<>(operations);
+        this.headers = new HashMap<>(headers);
     }
 
     public List<Operation> getOperations() {
         return Collections.unmodifiableList(operations);
     }
 
-    public byte[] toBytes() throws IOException {
-        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
-        Encoder binaryEncoder = EncoderFactory.get().directBinaryEncoder(outputStream, null);
-
-        writer.write(this, binaryEncoder);
-        return outputStream.toByteArray();
-    }
-
-    public static Patch of(byte[] bytes) throws IOException {
-        DatumReader<Patch> reader = new ReflectDatumReader<>(SCHEMA);
-        return reader.read(null, DecoderFactory.get().binaryDecoder(bytes, null));
+    public Map<String, ?> getHeaders() {
+        return Collections.unmodifiableMap(headers);
     }
 }

src/main/java/io/datanerds/avropatch/exception/AvroPatchException.java

@@ -1,8 +1,8 @@
 package io.datanerds.avropatch.exception;
 
-public class AvroPatchException extends RuntimeException {
+public abstract class AvroPatchException extends RuntimeException {
 
-    public AvroPatchException(String message) {
+    AvroPatchException(String message) {
         super(message);
     }
 }

src/main/java/io/datanerds/avropatch/exception/InvalidReferenceTokenException.java

@@ -0,0 +1,8 @@
+package io.datanerds.avropatch.exception;
+
+public class InvalidReferenceTokenException extends AvroPatchException {
+
+    public InvalidReferenceTokenException(String message) {
+        super(message);
+    }
+}

src/main/java/io/datanerds/avropatch/operation/Add.java

@@ -1,32 +1,30 @@
 package io.datanerds.avropatch.operation;
 
-import org.apache.avro.reflect.AvroIgnore;
+import io.datanerds.avropatch.value.DefaultSchema;
 import org.apache.avro.reflect.AvroSchema;
 
 /**
  * This class represents the "add" operation of RFC 6902 'JavaScript Object Notation (JSON) Patch'.
  *
  * @see <a href="https://tools.ietf.org/html/rfc6902#section-4.1">https://tools.ietf.org/html/rfc6902#section-4.1</a>
- * @param <T> Value type of <i>add</i> operation
+ * @param <T> DefaultSchema type of <i>add</i> operation
  */
 public final class Add<T> implements Operation {
-    @AvroIgnore
-    public static final String op = "add";
     public final Path path;
-    @AvroSchema(Value.SCHEMA)
+    @AvroSchema(DefaultSchema.VALUE)
     public final T value;
 
+    @SuppressWarnings("unused") // no-arg constructor needed by Avro
     private Add() {
-        this.path = null;
-        this.value = null;
+        this(null, null);
     }
 
     /**
      *
      * @param path Path pointing out where the JSON value should be added
      * @param value Actual value to <i>add</i> to patched object
      *
-     * @see Value
+     * @see DefaultSchema
      */
     public Add(Path path, T value) {
         this.path = path;

src/main/java/io/datanerds/avropatch/operation/Copy.java

@@ -1,21 +1,17 @@
 package io.datanerds.avropatch.operation;
 
-import org.apache.avro.reflect.AvroIgnore;
-
 /**
  * This class represents the "copy" operation of RFC 6902 'JavaScript Object Notation (JSON) Patch'.
  *
  * @see <a href="https://tools.ietf.org/html/rfc6902#section-4.5">https://tools.ietf.org/html/rfc6902#section-4.5</a>
  */
 public final class Copy implements Operation {
-    @AvroIgnore
-    public static final String op = "copy";
     public final Path from;
     public final Path path;
 
+    @SuppressWarnings("unused") // no-arg constructor needed by Avro
     private Copy() {
-        from = null;
-        path = null;
+        this(null, null);
     }
 
     /**

src/main/java/io/datanerds/avropatch/operation/Move.java

@@ -1,21 +1,17 @@
 package io.datanerds.avropatch.operation;
 
-import org.apache.avro.reflect.AvroIgnore;
-
 /**
  * This class represents the "move" operation of RFC 6902 'JavaScript Object Notation (JSON) Patch'.
  *
  * @see <a href="https://tools.ietf.org/html/rfc6902#section-4.4">https://tools.ietf.org/html/rfc6902#section-4.4</a>
  */
 public final class Move implements Operation {
-    @AvroIgnore
-    public static final String op = "move";
     public final Path from;
     public final Path path;
 
+    @SuppressWarnings("unused") // no-arg constructor needed by Avro
     private Move() {
-        this.from = null;
-        this.path = null;
+        this(null, null);
     }
 
     /**

src/main/java/io/datanerds/avropatch/operation/Path.java

@@ -1,22 +1,57 @@
 package io.datanerds.avropatch.operation;
 
-import io.datanerds.avropatch.exception.InvalidPathException;
-import org.apache.avro.reflect.AvroSchema;
+import io.datanerds.avropatch.exception.InvalidReferenceTokenException;
 
-import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 import java.util.Objects;
+import java.util.function.Function;
 import java.util.regex.Pattern;
-
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+/**
+ * This class represents a JavaScript Object Notation (JSON) Pointer object as defined in RFC 6901. {@link Path}
+ * instances identify a specific value within a JSON document by maintaining a sequence of zero or more reference
+ * tokens, each prefixed by a {@code '/'} character.
+ * <p>
+ * Assume the following JSON document:
+ * <blockquote><pre>
+ * {
+ *    "employees" : [
+ *       {
+ *          "firstName" : "John",
+ *          "lastName"  : "Doe",
+ *          "age"       : 42,
+ *          "address"   : {
+ *             "street" : "1234 Main Street",
+ *             "city"   : "San Francisco",
+ *             "zip"    : "94114"
+ *          }
+ *       },
+ *       {
+ *          "firstName" : "Jane",
+ *          "lastName"  : "Doe",
+ *          "age"       : 42,
+ *          "address"   : {
+ *             "street" : "4321 Main Street",
+ *             "city"   : "New York",
+ *             "zip"    : "10001"
+ *          }
+ *       }
+ *    ]
+ * }
+ * </pre></blockquote>
+ * <p>
+ * The JSON {@link Path} for addressing value "John" would be {@code "/employees/0/firstName"}, for the Jane's entire
+ * record {@code "/employees/1"} and to specify the street within the JSON blob representing her address
+ * {@code "/employees/1/address"}.
+ * @see <a href="https://tools.ietf.org/html/rfc6901">RFC 6901: JavaScript Object Notation (JSON) Pointer</a>
+ */
 public class Path {
-
     public static final String SLASH = "/";
     public static final Path ROOT = new Path();
-
     private static final Pattern VALID_PATTERN = Pattern.compile("[0-9a-zA-Z][0-9a-zA-Z_-]*");
-
-    @AvroSchema("{\"type\": \"array\", \"items\": \"string\"}")
     private final List<String> parts;
 
     private Path() {
@@ -27,12 +62,42 @@ private Path(List<String> parts) {
         this.parts = Collections.unmodifiableList(parts);
     }
 
-    public static Path of(String... parts) {
-        List<String> paths = Arrays.asList(parts);
-        paths.forEach(Path::validateSubPath);
+    /**
+     * Convenient method for retrieving root path {@code "/"}.
+     * @return {@link #ROOT}
+     */
+    public static Path of() {
+        return ROOT;
+    }
+
+    /**
+     * Constructs a {@link Path} object for given reference tokens.
+     * @param referenceTokens {@link String} representation of all reference tokens for {@link Path} without prefix
+     * {@code "/"}
+     * @return JSON path assembled via given reference tokens
+     */
+    public static Path of(String... referenceTokens) {
+        return new Path(validatedReferenceTokens(referenceTokens).collect(Collectors.toList()));
+    }
+
+    /**
+     * Constructs a {@link Path} object by concatenating given paths.
+     * @param subpaths paths to be concatenated for new {@link Path} object
+     * @return JSON path assembled by concatenating given paths
+     */
+    public static Path of(Path... subpaths) {
+        List<String> paths = Stream.of(subpaths)
+                .flatMap(Path.partsStream())
+                .collect(Collectors.toList());
         return new Path(paths);
     }
 
+    /**
+     * Parses a {@link String} representation of a JSON path (e.g. {@code "/employees/0/firstName"},
+     * {@code "/"} or {@code "/employees/1/address"}).
+     * @param path valid {@link String} representation of a JSON path
+     * @return JSON path instance
+     */
     public static Path parse(String path) {
         verifyParsable(path);
         if (SLASH.equals(path)) {
@@ -41,11 +106,28 @@ public static Path parse(String path) {
         return of(path.substring(1).split(SLASH));
     }
 
-    private static void verifyParsable(String path) {
-        Objects.nonNull(path);
-        if (!path.startsWith(SLASH)) {
-            throw new InvalidPathException("JSON Path has to start with a slash.");
-        }
+    /**
+     * Constructs a new {@link Path} object by appending the given subpaths to the JSON path represented by this object.
+     * @param subpaths {@link Path} objects to be appended
+     * @return concatenated {@link Path}
+     */
+    public Path append(Path... subpaths) {
+        List<String> paths = Stream.concat(this.parts().stream(), Stream.of(subpaths).flatMap(partsStream()))
+                .collect(Collectors.toList());
+        return new Path(paths);
+    }
+
+    /**
+     * Constructs a new {@link Path} object by appending the JSON path specified by the given reference tokens to the
+     * path represented by this instance.
+     * @param referenceTokens {@link String} representation of all reference tokens for {@link Path} without prefix
+     * {@code "/"}
+     * @return concatenated {@link Path}
+     */
+    public Path append(String... referenceTokens) {
+        List<String> paths = Stream.concat(this.parts().stream(), validatedReferenceTokens(referenceTokens))
+                .collect(Collectors.toList());
+        return new Path(paths);
     }
 
     public Path parent() {
@@ -59,9 +141,25 @@ public List<String> parts() {
         return parts;
     }
 
-    private static void validateSubPath(String path) {
+    private static Function<Path, Stream<String>> partsStream() {
+        return path -> path.parts().stream();
+    }
+
+    private static Stream<String> validatedReferenceTokens(String[] referenceTokens) {
+        return Stream.of(referenceTokens).map(Path::validateReferenceToken);
+    }
+
+    private static String validateReferenceToken(String path) {
         if (!VALID_PATTERN.matcher(path).matches()) {
-            throw new InvalidPathException(String.format("%s is not a valid JSON path", path));
+            throw new InvalidReferenceTokenException(String.format("%s is not a valid JSON path", path));
+        }
+        return path;
+    }
+
+    private static void verifyParsable(String path) {
+        Objects.nonNull(path);
+        if (!path.startsWith(SLASH)) {
+            throw new InvalidReferenceTokenException("JSON Path has to start with a slash.");
         }
     }