Feature/semver

lib/splitclient-rb.rb

@@ -90,6 +90,12 @@
 require 'splitclient-rb/engine/matchers/equal_to_boolean_matcher'
 require 'splitclient-rb/engine/matchers/equal_to_matcher'
 require 'splitclient-rb/engine/matchers/matches_string_matcher'
+require 'splitclient-rb/engine/matchers/semver'
+require 'splitclient-rb/engine/matchers/equal_to_semver_matcher'
+require 'splitclient-rb/engine/matchers/greater_than_or_equal_to_semver_matcher'
+require 'splitclient-rb/engine/matchers/less_than_or_equal_to_semver_matcher'
+require 'splitclient-rb/engine/matchers/between_semver_matcher'
+require 'splitclient-rb/engine/matchers/in_list_semver_matcher'
 require 'splitclient-rb/engine/evaluator/splitter'
 require 'splitclient-rb/engine/impressions/noop_unique_keys_tracker'
 require 'splitclient-rb/engine/impressions/unique_keys_tracker'

lib/splitclient-rb/cache/repositories/splits_repository.rb

@@ -30,7 +30,8 @@ class SplitsRepository < Repository
               }
           ],
           label: "unsupported matcher type"
-      }]
+        }]
+
         def initialize(config, flag_sets_repository, flag_set_filter)
           super(config)
           @tt_cache = {}

lib/splitclient-rb/engine/api/splits.rb

@@ -16,8 +16,8 @@ def since(since, fetch_options = { cache_control_headers: false, till: nil, sets
         start = Time.now
 
         params = { s: SplitIoClient::Spec::FeatureFlags::SPEC_VERSION, since: since }
-        params[:till] = fetch_options[:till] unless fetch_options[:till].nil?
         params[:sets] = @flag_sets_filter.join(",") unless @flag_sets_filter.empty?
+        params[:till] = fetch_options[:till] unless fetch_options[:till].nil?
         @config.logger.debug("Fetching from splitChanges with #{params}: ")
         response = get_api("#{@config.base_uri}/splitChanges", @api_key, params, fetch_options[:cache_control_headers])
         if response.status == 414

lib/splitclient-rb/engine/matchers/between_semver_matcher.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  class BetweenSemverMatcher < Matcher
+    MATCHER_TYPE = 'BETWEEN_SEMVER'
+
+    attr_reader :attribute
+
+    def initialize(attribute, start_value, end_value, logger, validator)
+      super(logger)
+      @validator = validator
+      @attribute = attribute
+      @semver_start = SplitIoClient::Semver.build(start_value, logger)
+      @semver_end = SplitIoClient::Semver.build(end_value, logger)
+      @logger = logger
+    end
+
+    def match?(args)
+      return false unless verify_semver_arg?(args, 'BetweenSemverMatcher')
+
+      value_to_match = SplitIoClient::Semver.build(args[:attributes][@attribute.to_sym], @logger)
+      unless !value_to_match.nil? && !@semver_start.nil? && !@semver_end.nil?
+        @logger.error('betweenStringMatcherData is required for BETWEEN_SEMVER matcher type')
+        return false
+
+      end
+      matches = ([0, -1].include?(@semver_start.compare(value_to_match)) &&
+                 [0, 1].include?(@semver_end.compare(value_to_match)))
+      @logger.debug("[BetweenMatcher] #{value_to_match} matches -> #{matches}")
+      matches
+    end
+  end
+end

lib/splitclient-rb/engine/matchers/equal_to_semver_matcher.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  class EqualToSemverMatcher < Matcher
+    MATCHER_TYPE = 'EQUAL_TO_SEMVER'
+
+    attr_reader :attribute
+
+    def initialize(attribute, string_value, logger, validator)
+      super(logger)
+      @validator = validator
+      @attribute = attribute
+      @semver = SplitIoClient::Semver.build(string_value, logger)
+      @logger = logger
+    end
+
+    def match?(args)
+      return false unless verify_semver_arg?(args, 'EqualsToSemverMatcher')
+
+      value_to_match = SplitIoClient::Semver.build(args[:attributes][@attribute.to_sym], @logger)
+      return false unless check_semver_value_to_match(value_to_match, MATCHER_TYPE)
+
+      matches = (@semver.version == value_to_match.version)
+      @logger.debug("[EqualsToSemverMatcher] #{value_to_match} matches -> #{matches}")
+      matches
+    end
+  end
+end

lib/splitclient-rb/engine/matchers/greater_than_or_equal_to_semver_matcher.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  class GreaterThanOrEqualToSemverMatcher < Matcher
+    MATCHER_TYPE = 'GREATER_THAN_OR_EQUAL_TO_SEMVER'
+
+    attr_reader :attribute
+
+    def initialize(attribute, string_value, logger, validator)
+      super(logger)
+      @validator = validator
+      @attribute = attribute
+      @semver = SplitIoClient::Semver.build(string_value, logger)
+      @logger = logger
+    end
+
+    def match?(args)
+      return false unless verify_semver_arg?(args, 'GreaterThanOrEqualsToSemverMatcher')
+
+      value_to_match = SplitIoClient::Semver.build(args[:attributes][@attribute.to_sym], @logger)
+      return false unless check_semver_value_to_match(value_to_match, MATCHER_TYPE)
+
+      matches = [0, 1].include?(value_to_match.compare(@semver))
+      @logger.debug("[GreaterThanOrEqualsToSemverMatcher] #{value_to_match} matches -> #{matches}")
+      matches
+    end
+  end
+end

lib/splitclient-rb/engine/matchers/in_list_semver_matcher.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  class InListSemverMatcher < Matcher
+    MATCHER_TYPE = 'IN_LIST_SEMVER'
+
+    attr_reader :attribute
+
+    def initialize(attribute, list_value, logger, validator)
+      super(logger)
+      @validator = validator
+      @attribute = attribute
+      @semver_list = list_value.map { |item| SplitIoClient::Semver.build(item, logger) }
+      @logger = logger
+    end
+
+    def match?(args)
+      return false unless verify_semver_arg?(args, 'InListSemverMatcher')
+
+      value_to_match = SplitIoClient::Semver.build(args[:attributes][@attribute.to_sym], @logger)
+      unless !value_to_match.nil? && @semver_list.all? { |n| !n.nil? }
+        @logger.error('whitelistMatcherData is required for IN_LIST_SEMVER matcher type')
+        return false
+      end
+      matches = (@semver_list.map { |item| item.version == value_to_match.version }).any? { |item| item == true }
+      @logger.debug("[InListSemverMatcher] #{value_to_match} matches -> #{matches}")
+      matches
+    end
+  end
+end

lib/splitclient-rb/engine/matchers/less_than_or_equal_to_semver_matcher.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  class LessThanOrEqualToSemverMatcher < Matcher
+    MATCHER_TYPE = 'LESS_THAN_OR_EQUAL_TO_SEMVER'
+
+    attr_reader :attribute
+
+    def initialize(attribute, string_value, logger, validator)
+      super(logger)
+      @validator = validator
+      @attribute = attribute
+      @semver = SplitIoClient::Semver.build(string_value, logger)
+      @logger = logger
+    end
+
+    def match?(args)
+      return false unless verify_semver_arg?(args, 'LessThanOrEqualsToSemverMatcher')
+
+      value_to_match = SplitIoClient::Semver.build(args[:attributes][@attribute.to_sym], @logger)
+      return false unless check_semver_value_to_match(value_to_match, MATCHER_TYPE)
+
+      matches = [0, -1].include?(value_to_match.compare(@semver))
+      @logger.debug("[LessThanOrEqualsToSemverMatcher] #{value_to_match} matches -> #{matches}")
+      matches
+    end
+  end
+end

lib/splitclient-rb/engine/matchers/matcher.rb

@@ -30,5 +30,23 @@ def equals?(obj)
     def string_type?
       false
     end
+
+    private
+
+    def verify_semver_arg?(args, matcher_name)
+      @logger.debug("[#{matcher_name}] evaluating value and attributes.")
+      return false unless @validator.valid_matcher_arguments(args)
+
+      true
+    end
+
+    def check_semver_value_to_match(value_to_match, matcher_spec_name)
+      unless !value_to_match.nil? && [email protected]?
+        @logger.error("stringMatcherData is required for #{matcher_spec_name} matcher type")
+        return false
+
+      end
+      true
+    end
   end
 end

lib/splitclient-rb/engine/matchers/semver.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  class Semver
+    METADATA_DELIMITER = '+'
+    PRE_RELEASE_DELIMITER = '-'
+    VALUE_DELIMITER = '.'
+
+    attr_reader :major, :minor, :patch, :pre_release, :is_stable, :version
+
+    def initialize(version)
+      @major = 0
+      @minor = 0
+      @patch = 0
+      @pre_release = []
+      @is_stable = false
+      @version = ''
+      @metadata = ''
+      parse(version)
+    end
+
+    #
+    # Class builder
+    #
+    # @param version [String] raw version as read from splitChanges response.
+    #
+    # @return [type] Semver instance
+    def self.build(version, logger)
+      new(version)
+    rescue NoMethodError => e
+      logger.error("Failed to parse Semver data, incorrect data type:  #{e}")
+      nil
+    rescue StandardError => e
+      logger.error("Failed to parse Semver data:  #{e}")
+      nil
+    end
+
+    #
+    # Check if there is any metadata characters in version.
+    #
+    # @return [type] String semver without the metadata
+    #
+    def remove_metadata_if_exists(old_version)
+      index = old_version.index(METADATA_DELIMITER)
+      return old_version if index.nil?
+
+      @metadata = old_version[index + 1, old_version.length]
+      old_version[0, index]
+    end
+
+    # Compare the current Semver object to a given Semver object, return:
+    #      0: if self == passed
+    #      1: if self > passed
+    #      -1: if self < passed
+    #
+    # @param to_compare [trype] splitio.models.grammar.matchers.semver.Semver object
+    #
+    # @returns [Integer] based on comparison
+    def compare(to_compare)
+      return 0 if @version == to_compare.version
+
+      # Compare major, minor, and patch versions numerically
+      return compare_attributes(to_compare) if compare_attributes(to_compare) != 0
+
+      # Compare pre-release versions lexically
+      compare_pre_release(to_compare)
+    end
+
+    private
+
+    def integer?(value)
+      value.to_i.to_s == value
+    end
+
+    #
+    # Parse the string in version to update the other internal variables
+    #
+    def parse(old_version)
+      without_metadata = remove_metadata_if_exists(old_version)
+
+      index = without_metadata.index(PRE_RELEASE_DELIMITER)
+      if index.nil?
+        @is_stable = true
+      else
+        pre_release_data = without_metadata[index + 1..-1]
+        without_metadata = without_metadata[0, index]
+        @pre_release = pre_release_data.split(VALUE_DELIMITER)
+      end
+      assign_major_minor_and_patch(without_metadata)
+    end
+
+    #
+    # Set the major, minor and patch internal variables based on string passed.
+    #
+    # @param version [String] raw version containing major.minor.patch numbers.
+    def assign_major_minor_and_patch(version)
+      parts = version.split(VALUE_DELIMITER)
+      if parts.length != 3 ||
+         !(integer?(parts[0]) &&
+           integer?(parts[1]) &&
+           integer?(parts[2]))
+        raise "Unable to convert to Semver, incorrect format: #{version}"
+      end
+
+      @major = parts[0].to_i
+      @minor = parts[1].to_i
+      @patch = parts[2].to_i
+      @version = "#{@major}#{VALUE_DELIMITER}#{@minor}#{VALUE_DELIMITER}#{@patch}"
+      @version += "#{PRE_RELEASE_DELIMITER}#{@pre_release.join('.')}" unless @pre_release.empty?
+      @version += "#{METADATA_DELIMITER}#{@metadata}" unless @metadata.empty?
+    end
+
+    #
+    # Compare 2 variables and return int as follows:
+    #    0: if var1 == var2
+    #    1: if var1 > var2
+    #    -1: if var1 < var2
+    #
+    # @param var1 [type] String/Integer object that accept ==, < or > operators
+    # @param var2 [type] String/Integer object that accept ==, < or > operators
+    #
+    # @returns [Integer] based on comparison
+    def compare_vars(var1, var2)
+      return 0 if var1 == var2
+
+      return 1 if var1 > var2
+
+      -1
+    end
+
+    # Compare the current Semver object's major, minor, patch and is_stable attributes to a given Semver object, return:
+    #      0: if self == passed
+    #      1: if self > passed
+    #      -1: if self < passed
+    #
+    # @param to_compare [trype] splitio.models.grammar.matchers.semver.Semver object
+    #
+    # @returns [Integer] based on comparison
+    def compare_attributes(to_compare)
+      result = compare_vars(@major, to_compare.major)
+      return result if result != 0
+
+      result = compare_vars(@minor, to_compare.minor)
+      return result if result != 0
+
+      result = compare_vars(@patch, to_compare.patch)
+      return result if result != 0
+
+      return -1 if !@is_stable && to_compare.is_stable
+
+      return 1 if @is_stable && !to_compare.is_stable
+
+      0
+    end
+
+    # Compare the current Semver object's pre_release attribute to a given Semver object, return:
+    #      0: if self == passed
+    #      1: if self > passed
+    #      -1: if self < passed
+    #
+    # @param to_compare [trype] splitio.models.grammar.matchers.semver.Semver object
+    #
+    # @returns [Integer] based on comparison
+    def compare_pre_release(to_compare)
+      min_length = get_pre_min_length(to_compare)
+      0.upto(min_length - 1) do |i|
+        next if @pre_release[i] == to_compare.pre_release[i]
+
+        if integer?(@pre_release[i]) && integer?(to_compare.pre_release[i])
+          return compare_vars(@pre_release[i].to_i, to_compare.pre_release[i].to_i)
+        end
+
+        return compare_vars(@pre_release[i], to_compare.pre_release[i])
+      end
+      # Compare lengths of pre-release versions
+      compare_vars(@pre_release.length, to_compare.pre_release.length)
+    end
+
+    # Get minimum of current Semver object's pre_release attributes length to a given Semver object
+    #
+    # @param to_compare [trype] splitio.models.grammar.matchers.semver.Semver object
+    #
+    # @returns [Integer]
+    def get_pre_min_length(to_compare)
+      [@pre_release.length, to_compare.pre_release.length].min
+    end
+  end
+end