feat: Add Semantic Version support (#267)

* feat: Add Semantic Version support

* feat: Add ge and le for numbers

* tests: Add invalid scenarios

* doc: Add doc strings

Co-authored-by: Tom Zurkan <thomas.zurkan@optimizely.com>

Author: oakbani

changes.patch

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 #
-#    Copyright 2019, Optimizely and contributors
+#    Copyright 2019-2020, Optimizely and contributors
 #
 #    Licensed under the Apache License, Version 2.0 (the "License");
 #    you may not use this file except in compliance with the License.
@@ -15,8 +15,10 @@
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
 #
+require_relative 'exceptions'
 require_relative 'helpers/constants'
 require_relative 'helpers/validator'
+require_relative 'semantic_version'
 
 module Optimizely
   class CustomAttributeConditionEvaluator
@@ -26,15 +28,29 @@ class CustomAttributeConditionEvaluator
     EXACT_MATCH_TYPE = 'exact'
     EXISTS_MATCH_TYPE = 'exists'
     GREATER_THAN_MATCH_TYPE = 'gt'
+    GREATER_EQUAL_MATCH_TYPE = 'ge'
     LESS_THAN_MATCH_TYPE = 'lt'
+    LESS_EQUAL_MATCH_TYPE = 'le'
     SUBSTRING_MATCH_TYPE = 'substring'
+    SEMVER_EQ = 'semver_eq'
+    SEMVER_GE = 'semver_ge'
+    SEMVER_GT = 'semver_gt'
+    SEMVER_LE = 'semver_le'
+    SEMVER_LT = 'semver_lt'
 
     EVALUATORS_BY_MATCH_TYPE = {
       EXACT_MATCH_TYPE => :exact_evaluator,
       EXISTS_MATCH_TYPE => :exists_evaluator,
       GREATER_THAN_MATCH_TYPE => :greater_than_evaluator,
+      GREATER_EQUAL_MATCH_TYPE => :greater_than_or_equal_evaluator,
       LESS_THAN_MATCH_TYPE => :less_than_evaluator,
-      SUBSTRING_MATCH_TYPE => :substring_evaluator
+      LESS_EQUAL_MATCH_TYPE => :less_than_or_equal_evaluator,
+      SUBSTRING_MATCH_TYPE => :substring_evaluator,
+      SEMVER_EQ => :semver_equal_evaluator,
+      SEMVER_GE => :semver_greater_than_or_equal_evaluator,
+      SEMVER_GT => :semver_greater_than_evaluator,
+      SEMVER_LE => :semver_less_than_or_equal_evaluator,
+      SEMVER_LT => :semver_less_than_evaluator
     }.freeze
 
     attr_reader :user_attributes
@@ -95,7 +111,35 @@ def evaluate(leaf_condition)
         return nil
       end
 
-      send(EVALUATORS_BY_MATCH_TYPE[condition_match], leaf_condition)
+      begin
+        send(EVALUATORS_BY_MATCH_TYPE[condition_match], leaf_condition)
+      rescue InvalidAttributeType
+        condition_name = leaf_condition['name']
+        user_value = @user_attributes[condition_name]
+
+        @logger.log(
+          Logger::WARN,
+          format(
+            Helpers::Constants::AUDIENCE_EVALUATION_LOGS['UNEXPECTED_TYPE'],
+            leaf_condition,
+            user_value.class,
+            condition_name
+          )
+        )
+        return nil
+      rescue InvalidSemanticVersion
+        condition_name = leaf_condition['name']
+
+        @logger.log(
+          Logger::WARN,
+          format(
+            Helpers::Constants::AUDIENCE_EVALUATION_LOGS['INVALID_SEMANTIC_VERSION'],
+            leaf_condition,
+            condition_name
+          )
+        )
+        return nil
+      end
     end
 
     def exact_evaluator(condition)
@@ -122,16 +166,7 @@ def exact_evaluator(condition)
 
       if !value_type_valid_for_exact_conditions?(user_provided_value) ||
          !Helpers::Validator.same_types?(condition_value, user_provided_value)
-        @logger.log(
-          Logger::WARN,
-          format(
-            Helpers::Constants::AUDIENCE_EVALUATION_LOGS['UNEXPECTED_TYPE'],
-            condition,
-            user_provided_value.class,
-            condition['name']
-          )
-        )
-        return nil
+        raise InvalidAttributeType
       end
 
       if user_provided_value.is_a?(Numeric) && !Helpers::Validator.finite_number?(user_provided_value)
@@ -173,6 +208,20 @@ def greater_than_evaluator(condition)
       user_provided_value > condition_value
     end
 
+    def greater_than_or_equal_evaluator(condition)
+      # Evaluate the given greater than or equal match condition for the given user attributes.
+      # Returns boolean true if the user attribute value is greater than or equal to the condition value,
+      #                 false if the user attribute value is less than the condition value,
+      #                 nil if the condition value isn't a number or the user attribute value isn't a number.
+
+      condition_value = condition['value']
+      user_provided_value = @user_attributes[condition['name']]
+
+      return nil unless valid_numeric_values?(user_provided_value, condition_value, condition)
+
+      user_provided_value >= condition_value
+    end
+
     def less_than_evaluator(condition)
       # Evaluate the given less than match condition for the given user attributes.
       # Returns boolean true if the user attribute value is less than the condition value,
@@ -187,6 +236,20 @@ def less_than_evaluator(condition)
       user_provided_value < condition_value
     end
 
+    def less_than_or_equal_evaluator(condition)
+      # Evaluate the given less than or equal match condition for the given user attributes.
+      # Returns boolean true if the user attribute value is less than or equal to the condition value,
+      #                 false if the user attribute value is greater than the condition value,
+      #                 nil if the condition value isn't a number or the user attribute value isn't a number.
+
+      condition_value = condition['value']
+      user_provided_value = @user_attributes[condition['name']]
+
+      return nil unless valid_numeric_values?(user_provided_value, condition_value, condition)
+
+      user_provided_value <= condition_value
+    end
+
     def substring_evaluator(condition)
       # Evaluate the given substring match condition for the given user attributes.
       # Returns boolean true if the condition value is a substring of the user attribute value,
@@ -204,22 +267,66 @@ def substring_evaluator(condition)
         return nil
       end
 
-      unless user_provided_value.is_a?(String)
-        @logger.log(
-          Logger::WARN,
-          format(
-            Helpers::Constants::AUDIENCE_EVALUATION_LOGS['UNEXPECTED_TYPE'],
-            condition,
-            user_provided_value.class,
-            condition['name']
-          )
-        )
-        return nil
-      end
+      raise InvalidAttributeType unless user_provided_value.is_a?(String)
 
       user_provided_value.include? condition_value
     end
 
+    def semver_equal_evaluator(condition)
+      # Evaluate the given semantic version equal match target version for the user version.
+      # Returns boolean true if the user version is equal to the target version,
+      #                 false if the user version is not equal to the target version
+
+      target_version = condition['value']
+      user_version = @user_attributes[condition['name']]
+
+      SemanticVersion.compare_user_version_with_target_version(target_version, user_version).zero?
+    end
+
+    def semver_greater_than_evaluator(condition)
+      # Evaluate the given semantic version greater than match target version for the user version.
+      # Returns boolean true if the user version is greater than the target version,
+      #                 false if the user version is less than or equal to the target version
+
+      target_version = condition['value']
+      user_version = @user_attributes[condition['name']]
+
+      SemanticVersion.compare_user_version_with_target_version(target_version, user_version).positive?
+    end
+
+    def semver_greater_than_or_equal_evaluator(condition)
+      # Evaluate the given semantic version greater than or equal to match target version for the user version.
+      # Returns boolean true if the user version is greater than or equal to the target version,
+      #                 false if the user version is less than the target version
+
+      target_version = condition['value']
+      user_version = @user_attributes[condition['name']]
+
+      SemanticVersion.compare_user_version_with_target_version(target_version, user_version) >= 0
+    end
+
+    def semver_less_than_evaluator(condition)
+      # Evaluate the given semantic version less than match target version for the user version.
+      # Returns boolean true if the user version is less than the target version,
+      #                 false if the user version is greater than or equal to the target version
+
+      target_version = condition['value']
+      user_version = @user_attributes[condition['name']]
+
+      SemanticVersion.compare_user_version_with_target_version(target_version, user_version).negative?
+    end
+
+    def semver_less_than_or_equal_evaluator(condition)
+      # Evaluate the given semantic version less than or equal to match target version for the user version.
+      # Returns boolean true if the user version is less than or equal to the target version,
+      #                 false if the user version is greater than the target version
+
+      target_version = condition['value']
+      user_version = @user_attributes[condition['name']]
+
+      SemanticVersion.compare_user_version_with_target_version(target_version, user_version) <= 0
+    end
+
     private
 
     def valid_numeric_values?(user_value, condition_value, condition)
@@ -234,18 +341,7 @@ def valid_numeric_values?(user_value, condition_value, condition)
         return false
       end
 
-      unless user_value.is_a?(Numeric)
-        @logger.log(
-          Logger::WARN,
-          format(
-            Helpers::Constants::AUDIENCE_EVALUATION_LOGS['UNEXPECTED_TYPE'],
-            condition,
-            user_value.class,
-            condition['name']
-          )
-        )
-        return false
-      end
+      raise InvalidAttributeType unless user_value.is_a?(Numeric)
 
       unless Helpers::Validator.finite_number?(user_value)
         @logger.log(

lib/optimizely/custom_attribute_condition_evaluator.rb

@@ -120,4 +120,20 @@ def initialize(aborted_method)
       super("Optimizely instance is not valid. Failing '#{aborted_method}'.")
     end
   end
+
+  class InvalidAttributeType < Error
+    # Raised when an attribute is not provided in expected type.
+
+    def initialize(msg = 'Provided attribute value is not in the expected data type.')
+      super
+    end
+  end
+
+  class InvalidSemanticVersion < Error
+    # Raised when an invalid value is provided as semantic version.
+
+    def initialize(msg = 'Provided semantic version is invalid.')
+      super
+    end
+  end
 end

lib/optimizely/exceptions.rb

@@ -338,6 +338,8 @@ module Constants
         'EVALUATING_AUDIENCE' => "Starting to evaluate audience '%s' with conditions: %s.",
         'INFINITE_ATTRIBUTE_VALUE' => 'Audience condition %s evaluated to UNKNOWN because the number value ' \
         "for user attribute '%s' is not in the range [-2^53, +2^53].",
+        'INVALID_SEMANTIC_VERSION' => 'Audience condition %s evaluated as UNKNOWN because an invalid semantic version ' \
+        "was passed for user attribute '%s'.",
         'MISSING_ATTRIBUTE_VALUE' => 'Audience condition %s evaluated as UNKNOWN because no value ' \
         "was passed for user attribute '%s'.",
         'NULL_ATTRIBUTE_VALUE' => 'Audience condition %s evaluated to UNKNOWN because a nil value was passed ' \