Merge pull request #130 from preuss-adam/apreuss/reduce-dependencies

Reduce/change 3rd party dependencies

Author: Korbik

pom.xml

@@ -36,9 +36,8 @@
         <protobuf.version>3.25.5</protobuf.version>
         <protobuf-maven-plugin.version>0.6.1</protobuf-maven-plugin.version>
         <os-maven-plugin.version>1.7.1</os-maven-plugin.version>
-        <vavr.version>0.10.3</vavr.version>
         <re2j.version>1.6</re2j.version>
-        <gson.version>2.8.9</gson.version>
+        <jackson.version>2.17.3</jackson.version>
         <bcprov.version>1.80</bcprov.version>
 
         <!-- test dependencies -->
@@ -285,20 +284,15 @@
             <artifactId>protobuf-java</artifactId>
             <version>${protobuf.version}</version>
         </dependency>
-        <dependency>
-            <groupId>io.vavr</groupId>
-            <artifactId>vavr</artifactId>
-            <version>${vavr.version}</version>
-        </dependency>
         <dependency>
             <groupId>com.google.re2j</groupId>
             <artifactId>re2j</artifactId>
             <version>${re2j.version}</version>
         </dependency>
         <dependency>
-            <groupId>com.google.code.gson</groupId>
-            <artifactId>gson</artifactId>
-            <version>${gson.version}</version>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+            <version>${jackson.version}</version>
         </dependency>
         <dependency>
             <groupId>org.bouncycastle</groupId>

src/main/java/org/eclipse/biscuit/crypto/BlockSignatureBuffer.java

@@ -5,17 +5,14 @@
 
 package org.eclipse.biscuit.crypto;
 
-import static io.vavr.API.Left;
-import static io.vavr.API.Right;
-
 import biscuit.format.schema.Schema;
-import io.vavr.control.Either;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 import java.nio.charset.StandardCharsets;
 import java.util.Optional;
 import java.util.stream.Stream;
 import org.eclipse.biscuit.error.Error;
+import org.eclipse.biscuit.error.Result;
 import org.eclipse.biscuit.token.format.ExternalSignature;
 import org.eclipse.biscuit.token.format.SerializedBiscuit;
 import org.eclipse.biscuit.token.format.SignedBlock;
@@ -59,21 +56,21 @@ public static int blockSignatureVersion(
     return previousSigVersions.mapToInt(Integer::intValue).max().orElse(0);
   }
 
-  public static Either<Error.FormatError, byte[]> generateBlockSignaturePayload(
+  public static Result<byte[], Error.FormatError> generateBlockSignaturePayload(
       byte[] payload,
       PublicKey nextKey,
       Optional<ExternalSignature> externalSignature,
       Optional<byte[]> previousSignature,
       int version) {
     switch (version) {
       case 0:
-        return Right(generateBlockSignaturePayloadV0(payload, nextKey, externalSignature));
+        return Result.ok(generateBlockSignaturePayloadV0(payload, nextKey, externalSignature));
       case 1:
-        return Right(
+        return Result.ok(
             generateBlockSignaturePayloadV1(
                 payload, nextKey, externalSignature, previousSignature, version));
       default:
-        return Left(
+        return Result.err(
             new Error.FormatError.DeserializationError("unsupported block version " + version));
     }
   }

src/main/java/org/eclipse/biscuit/crypto/KeyDelegate.java

@@ -5,7 +5,7 @@
 
 package org.eclipse.biscuit.crypto;
 
-import io.vavr.control.Option;
+import java.util.Optional;
 
 /**
  * Used to find the key associated with a key id
@@ -14,5 +14,5 @@
  * time. Tokens can carry a root key id, that can be used to indicate which key will verify it.
  */
 public interface KeyDelegate {
-  Option<PublicKey> getRootKey(Option<Integer> keyId);
+  Optional<PublicKey> getRootKey(Optional<Integer> keyId);
 }

src/main/java/org/eclipse/biscuit/crypto/Token.java

@@ -5,16 +5,13 @@
 
 package org.eclipse.biscuit.crypto;
 
-import static io.vavr.API.Left;
-import static io.vavr.API.Right;
-
-import io.vavr.control.Either;
 import java.security.InvalidKeyException;
 import java.security.NoSuchAlgorithmException;
 import java.security.SignatureException;
 import java.util.ArrayList;
 import java.util.Optional;
 import org.eclipse.biscuit.error.Error;
+import org.eclipse.biscuit.error.Result;
 
 class Token {
   private final ArrayList<byte[]> blocks;
@@ -65,7 +62,7 @@ Token append(KeyPair keyPair, byte[] message)
   }
 
   // FIXME: rust version returns a Result<(), error::Signature>
-  public Either<Error, Void> verify(PublicKey root)
+  public Result<Void, Error> verify(PublicKey root)
       throws NoSuchAlgorithmException, InvalidKeyException, SignatureException {
     PublicKey currentKey = root;
     for (int i = 0; i < this.blocks.size(); i++) {
@@ -78,16 +75,16 @@ public Either<Error, Void> verify(PublicKey root)
       if (currentKey.verify(payload, signature)) {
         currentKey = nextKey;
       } else {
-        return Left(
+        return Result.err(
             new Error.FormatError.Signature.InvalidSignature(
                 "signature error: Verification equation was not satisfied"));
       }
     }
 
     if (this.next.getPublicKey().equals(currentKey)) {
-      return Right(null);
+      return Result.ok(null);
     } else {
-      return Left(
+      return Result.err(
           new Error.FormatError.Signature.InvalidSignature(
               "signature error: Verification equation was not satisfied"));
     }

src/main/java/org/eclipse/biscuit/datalog/Check.java

@@ -6,15 +6,13 @@
 package org.eclipse.biscuit.datalog;
 
 import static biscuit.format.schema.Schema.CheckV2.Kind.All;
-import static io.vavr.API.Left;
-import static io.vavr.API.Right;
 
 import biscuit.format.schema.Schema;
-import io.vavr.control.Either;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
 import org.eclipse.biscuit.error.Error;
+import org.eclipse.biscuit.error.Result;
 
 public final class Check {
   public enum Kind {
@@ -59,7 +57,7 @@ public Schema.CheckV2 serialize() {
     return b.build();
   }
 
-  public static Either<Error.FormatError, Check> deserializeV2(Schema.CheckV2 check) {
+  public static Result<Check, Error.FormatError> deserializeV2(Schema.CheckV2 check) {
     ArrayList<Rule> queries = new ArrayList<>();
 
     Kind kind;
@@ -76,16 +74,15 @@ public static Either<Error.FormatError, Check> deserializeV2(Schema.CheckV2 chec
     }
 
     for (Schema.RuleV2 query : check.getQueriesList()) {
-      Either<Error.FormatError, Rule> res = Rule.deserializeV2(query);
-      if (res.isLeft()) {
-        Error.FormatError e = res.getLeft();
-        return Left(e);
+      var res = Rule.deserializeV2(query);
+      if (res.isErr()) {
+        return Result.err(res.getErr());
       } else {
-        queries.add(res.get());
+        queries.add(res.getOk());
       }
     }
 
-    return Right(new Check(kind, queries));
+    return Result.ok(new Check(kind, queries));
   }
 
   @Override

src/main/java/org/eclipse/biscuit/datalog/Combinator.java

@@ -5,58 +5,57 @@
 
 package org.eclipse.biscuit.datalog;
 
-import io.vavr.Tuple2;
-import io.vavr.control.Option;
 import java.io.Serializable;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.NoSuchElementException;
+import java.util.Optional;
 import java.util.Set;
 import java.util.function.Supplier;
 import java.util.stream.Stream;
 
-public final class Combinator implements Serializable, Iterator<Tuple2<Origin, Map<Long, Term>>> {
+public final class Combinator implements Serializable, Iterator<Pair<Origin, Map<Long, Term>>> {
   private MatchedVariables variables;
-  private final Supplier<Stream<Tuple2<Origin, Fact>>> allFacts;
+  private final Supplier<Stream<Pair<Origin, Fact>>> allFacts;
   private final List<Predicate> predicates;
-  private final Iterator<Tuple2<Origin, Fact>> currentFacts;
+  private final Iterator<Pair<Origin, Fact>> currentFacts;
   private Combinator currentIt;
   private final SymbolTable symbolTable;
 
   private Origin currentOrigin;
 
-  private Option<Tuple2<Origin, Map<Long, Term>>> nextElement;
+  private Optional<Pair<Origin, Map<Long, Term>>> nextElement;
 
   @Override
   public boolean hasNext() {
-    if (this.nextElement != null && this.nextElement.isDefined()) {
+    if (this.nextElement != null && this.nextElement.isPresent()) {
       return true;
     }
     this.nextElement = getNext();
-    return this.nextElement.isDefined();
+    return this.nextElement.isPresent();
   }
 
   @Override
-  public Tuple2<Origin, Map<Long, Term>> next() {
-    if (this.nextElement == null || !this.nextElement.isDefined()) {
+  public Pair<Origin, Map<Long, Term>> next() {
+    if (this.nextElement == null || !this.nextElement.isPresent()) {
       this.nextElement = getNext();
     }
-    if (this.nextElement == null || !this.nextElement.isDefined()) {
+    if (this.nextElement == null || !this.nextElement.isPresent()) {
       throw new NoSuchElementException();
     } else {
-      Tuple2<Origin, Map<Long, Term>> t = this.nextElement.get();
-      this.nextElement = Option.none();
+      Pair<Origin, Map<Long, Term>> t = this.nextElement.get();
+      this.nextElement = Optional.empty();
       return t;
     }
   }
 
-  public Option<Tuple2<Origin, Map<Long, Term>>> getNext() {
+  public Optional<Pair<Origin, Map<Long, Term>>> getNext() {
     if (this.predicates.isEmpty()) {
-      final Option<Map<Long, Term>> vOpt = this.variables.complete();
+      final Optional<Map<Long, Term>> vOpt = this.variables.complete();
       if (vOpt.isEmpty()) {
-        return Option.none();
+        return Optional.empty();
       } else {
         Map<Long, Term> variables = vOpt.get();
         // if there were no predicates,
@@ -67,7 +66,7 @@ public Option<Tuple2<Origin, Map<Long, Term>>> getNext() {
         set.add((long) 0);
 
         this.variables = new MatchedVariables(set);
-        return Option.some(new Tuple2<>(new Origin(), variables));
+        return Optional.of(new Pair<>(new Origin(), variables));
       }
     }
 
@@ -78,7 +77,7 @@ public Option<Tuple2<Origin, Map<Long, Term>>> getNext() {
         while (true) {
           // we iterate over the facts that match the current predicate
           if (this.currentFacts.hasNext()) {
-            final Tuple2<Origin, Fact> t = this.currentFacts.next();
+            final Pair<Origin, Fact> t = this.currentFacts.next();
             Origin currentOrigin = t._1.clone();
             Fact fact = t._2;
 
@@ -111,11 +110,11 @@ public Option<Tuple2<Origin, Map<Long, Term>>> getNext() {
 
             // there are no more predicates to check
             if (this.predicates.size() == 1) {
-              final Option<Map<Long, Term>> vOpt = vars.complete();
+              final Optional<Map<Long, Term>> vOpt = vars.complete();
               if (vOpt.isEmpty()) {
                 continue;
               } else {
-                return Option.some(new Tuple2<>(currentOrigin, vOpt.get()));
+                return Optional.of(new Pair<>(currentOrigin, vOpt.get()));
               }
             } else {
               this.currentOrigin = currentOrigin;
@@ -132,20 +131,20 @@ public Option<Tuple2<Origin, Map<Long, Term>>> getNext() {
             break;
 
           } else {
-            return Option.none();
+            return Optional.empty();
           }
         }
       }
 
       if (this.currentIt == null) {
-        return Option.none();
+        return Optional.empty();
       }
 
-      Option<Tuple2<Origin, Map<Long, Term>>> opt = this.currentIt.getNext();
+      Optional<Pair<Origin, Map<Long, Term>>> opt = this.currentIt.getNext();
 
-      if (opt.isDefined()) {
-        Tuple2<Origin, Map<Long, Term>> t = opt.get();
-        return Option.some(new Tuple2<>(t._1.union(currentOrigin), t._2));
+      if (opt.isPresent()) {
+        Pair<Origin, Map<Long, Term>> t = opt.get();
+        return Optional.of(new Pair<>(t._1.union(currentOrigin), t._2));
       } else {
         currentOrigin = null;
         currentIt = null;
@@ -156,7 +155,7 @@ public Option<Tuple2<Origin, Map<Long, Term>>> getNext() {
   public Combinator(
       final MatchedVariables variables,
       final List<Predicate> predicates,
-      Supplier<Stream<Tuple2<Origin, Fact>>> allFacts,
+      Supplier<Stream<Pair<Origin, Fact>>> allFacts,
       final SymbolTable symbolTable) {
     this.variables = variables;
     this.allFacts = allFacts;

src/main/java/org/eclipse/biscuit/datalog/Fact.java

@@ -5,15 +5,12 @@
 
 package org.eclipse.biscuit.datalog;
 
-import static io.vavr.API.Left;
-import static io.vavr.API.Right;
-
 import biscuit.format.schema.Schema;
-import io.vavr.control.Either;
 import java.io.Serializable;
 import java.util.List;
 import java.util.Objects;
 import org.eclipse.biscuit.error.Error;
+import org.eclipse.biscuit.error.Result;
 
 public final class Fact implements Serializable {
   private final Predicate predicate;
@@ -60,13 +57,12 @@ public Schema.FactV2 serialize() {
     return Schema.FactV2.newBuilder().setPredicate(this.predicate.serialize()).build();
   }
 
-  public static Either<Error.FormatError, Fact> deserializeV2(Schema.FactV2 fact) {
-    Either<Error.FormatError, Predicate> res = Predicate.deserializeV2(fact.getPredicate());
-    if (res.isLeft()) {
-      Error.FormatError e = res.getLeft();
-      return Left(e);
+  public static Result<Fact, Error.FormatError> deserializeV2(Schema.FactV2 fact) {
+    var res = Predicate.deserializeV2(fact.getPredicate());
+    if (res.isErr()) {
+      return Result.err(res.getErr());
     } else {
-      return Right(new Fact(res.get()));
+      return Result.ok(new Fact(res.getOk()));
     }
   }
 }

src/main/java/org/eclipse/biscuit/datalog/FactSet.java

@@ -5,7 +5,6 @@
 
 package org.eclipse.biscuit.datalog;
 
-import io.vavr.Tuple2;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
@@ -71,8 +70,7 @@ public Stream stream(TrustedOrigins blockIds) {
               Origin o = entry.getKey();
               return blockIds.contains(o);
             })
-        .flatMap(
-            entry -> entry.getValue().stream().map(fact -> new Tuple2<>(entry.getKey(), fact)));
+        .flatMap(entry -> entry.getValue().stream().map(fact -> new Pair<>(entry.getKey(), fact)));
   }
 
   public Stream<Fact> stream() {