Add semver support (FF-1573)

eppo/build.gradle

@@ -71,6 +71,7 @@ dependencies {
     androidTestImplementation "commons-io:commons-io:${versions.commonsio}"
     implementation("com.google.code.gson:gson:${versions.gson}")
     implementation("com.squareup.okhttp3:okhttp:${versions.okhttp}")
+    implementation("com.github.zafarkhaja:java-semver:0.10.2")
 }
 
 publishing {

eppo/src/androidTest/java/cloud/eppo/android/EppoClientTest.java

@@ -262,7 +262,7 @@ public void testCachedAssignments() {
 
             // wait for a bit since cache file is loaded asynchronously
             System.out.println("Sleeping for a bit to wait for cache population to complete");
-            Thread.sleep(5000);
+            Thread.sleep(10000);
 
             // Then reinitialize with a bad host so we know it's using the cached RAC built from the first initialization
             initClient(INVALID_HOST, false, false, false); // invalid port to force to use cache

eppo/src/main/java/cloud/eppo/android/RuleEvaluator.java

@@ -1,9 +1,10 @@
 package cloud.eppo.android;
 
+import com.github.zafarkhaja.semver.Version;
+
 import java.util.ArrayList;
 import java.util.List;
 import java.util.regex.Pattern;
-import java.util.stream.Collectors;
 
 import cloud.eppo.android.dto.EppoValue;
 import cloud.eppo.android.dto.SubjectAttributes;
@@ -15,10 +16,6 @@ interface IConditionFunc<T> {
 }
 
 class Compare {
-    public static boolean compareNumber(double a, double b, IConditionFunc<Double> conditionFunc) {
-        return conditionFunc.check(a, b);
-    }
-
     public static boolean compareRegex(String a, Pattern pattern) {
         return pattern.matcher(a).matches();
     }
@@ -48,21 +45,57 @@ private static boolean matchesRule(SubjectAttributes subjectAttributes, Targetin
         return !conditionEvaluations.contains(false);
     }
 
+
+
     private static boolean evaluateCondition(SubjectAttributes subjectAttributes, TargetingCondition condition
     ) {
         if (subjectAttributes.containsKey(condition.getAttribute())) {
             EppoValue value = subjectAttributes.get(condition.getAttribute());
+            Boolean isValueSemVer = Version.isValid(value.stringValue());
+            Boolean isConditionSemVer = Version.isValid(condition.getValue().stringValue());
+
             try {
                 switch (condition.getOperator()) {
                     case GreaterThanEqualTo:
-                        return Compare.compareNumber(value.doubleValue(), condition.getValue().doubleValue()
-                                , (a, b) -> a >= b);
+                        if (value.isNumeric() && condition.getValue().isNumeric()) {
+                            return value.doubleValue() >= condition.getValue().doubleValue();
+                        }
+
+                        if (isValueSemVer && isConditionSemVer) {
+                            return Version.parse(value.stringValue()).isHigherThanOrEquivalentTo(Version.parse(condition.getValue().stringValue()));
+                        }
+
+                        return false;
                     case GreaterThan:
-                        return Compare.compareNumber(value.doubleValue(), condition.getValue().doubleValue(), (a, b) -> a > b);
+                        if (value.isNumeric() && condition.getValue().isNumeric()) {
+                            return value.doubleValue() > condition.getValue().doubleValue();
+                        }
+
+                        if (isValueSemVer && isConditionSemVer) {
+                            return Version.parse(value.stringValue()).isHigherThan(Version.parse(condition.getValue().stringValue()));
+                        }
+
+                        return false;
                     case LessThanEqualTo:
-                        return Compare.compareNumber(value.doubleValue(), condition.getValue().doubleValue(), (a, b) -> a <= b);
+                        if (value.isNumeric() && condition.getValue().isNumeric()) {
+                            return value.doubleValue() <= condition.getValue().doubleValue();
+                        }
+
+                        if (isValueSemVer && isConditionSemVer) {
+                            return Version.parse(value.stringValue()).isLowerThanOrEquivalentTo(Version.parse(condition.getValue().stringValue()));
+                        }
+
+                        return false;
                     case LessThan:
-                        return Compare.compareNumber(value.doubleValue(), condition.getValue().doubleValue(), (a, b) -> a < b);
+                        if (value.isNumeric() && condition.getValue().isNumeric()) {
+                            return value.doubleValue() < condition.getValue().doubleValue();
+                        }
+
+                        if (isValueSemVer && isConditionSemVer) {
+                            return Version.parse(value.stringValue()).isLowerThan(Version.parse(condition.getValue().stringValue()));
+                        }
+
+                        return false;
                     case Matches:
                         return Compare.compareRegex(value.stringValue(), Pattern.compile(condition.getValue().stringValue()));
                     case OneOf:

eppo/src/main/java/cloud/eppo/android/dto/EppoValue.java

@@ -57,18 +57,10 @@ public static EppoValue valueOf() {
         return  new EppoValue(EppoValueType.Null);
     }
 
-    public int intValue() {
-        return Integer.parseInt(value, 10);
-    }
-
     public double doubleValue() {
         return Double.parseDouble(value);
     }
 
-    public long longValue() {
-        return Long.parseLong(value, 10);
-    }
-
     public String stringValue() {
         return value;
     }
@@ -87,7 +79,7 @@ public JsonElement jsonValue() {
 
     public boolean isNumeric() {
         try {
-            Long.parseLong(value, 10);
+            Double.parseDouble(value);
             return true;
         } catch (Exception e) {
             return false;

eppo/src/test/java/cloud/eppo/android/RuleEvaluatorTest.java

@@ -43,6 +43,21 @@ public void addNumericConditionToRule(TargetingRule TargetingRule) {
         addConditionToRule(TargetingRule, condition2);
     }
 
+    public void addSemVerConditionToRule(TargetingRule TargetingRule) {
+        TargetingCondition condition1 = new TargetingCondition();
+        condition1.setValue(EppoValue.valueOf("1.5.0"));
+        condition1.setAttribute("appVersion");
+        condition1.setOperator(OperatorType.GreaterThanEqualTo);
+
+        TargetingCondition condition2 = new TargetingCondition();
+        condition2.setValue(EppoValue.valueOf("2.2.0"));
+        condition2.setAttribute("appVersion");
+        condition2.setOperator(OperatorType.LessThan);
+
+        addConditionToRule(TargetingRule, condition1);
+        addConditionToRule(TargetingRule, condition2);
+    }
+
     public void addRegexConditionToRule(TargetingRule TargetingRule) {
         TargetingCondition condition = new TargetingCondition();
         condition.setValue(EppoValue.valueOf("[a-z]+"));
@@ -131,6 +146,18 @@ public void testMatchesAnyRuleWhenRuleMatches() {
         assertEquals(targetingRule, RuleEvaluator.findMatchingRule(subjectAttributes, targetingRules));
     }
 
+    @Test
+    public void testMatchesAnyRuleWhenRuleMatchesWithSemVer() {
+        List<TargetingRule> targetingRules = new ArrayList<>();
+        TargetingRule targetingRule = createRule(new ArrayList<>());
+        addSemVerConditionToRule(targetingRule);
+        targetingRules.add(targetingRule);
+
+        SubjectAttributes subjectAttributes = new SubjectAttributes();
+        subjectAttributes.put("appVersion", "1.15.5");
+
+        assertEquals(targetingRule, RuleEvaluator.findMatchingRule(subjectAttributes, targetingRules));
+    }
 
     @Test
     public void testMatchesAnyRuleWhenThrowInvalidSubjectAttribute() {