splitclient-rb 6.3.0 → 8.11.0

data/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

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

@@ -0,0 +1,36 @@
+# 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 do |item|
+        version = SplitIoClient::Semver.build(item, logger)
+        @semver_list << version unless version.nil?
+      end
+      @logger = logger
+    end
+
+    def match?(args)
+      return false if @semver_list.empty? || !verify_semver_arg?(args, 'InListSemverMatcher')
+
+      value_to_match = SplitIoClient::Semver.build(args[:attributes][@attribute.to_sym], @logger)
+      if value_to_match.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

data/lib/splitclient-rb/engine/matchers/less_than_or_equal_to_matcher.rb

@@ -6,21 +6,23 @@ module SplitIoClient
 
     attr_reader :attribute
 
-    def initialize(attribute_hash)
+    def initialize(attribute_hash, logger, validator)
+      super(logger)
+      @validator = validator
       @attribute = attribute_hash[:attribute]
       @data_type = attribute_hash[:data_type]
       @value = formatted_value(attribute_hash[:value], true)
     end
 
     def match?(args)
-      SplitLogger.log_if_debug('[LessThanOrEqualToMatcher] evaluating value and attributes.')
+      @logger.log_if_debug('[LessThanOrEqualToMatcher] evaluating value and attributes.')
 
-      return false unless SplitIoClient::Validators.valid_matcher_arguments(args)
+      return false unless @validator.valid_matcher_arguments(args)
 
       value = formatted_value(args[:value] || args[:attributes][@attribute.to_sym])
 
       matches = value.is_a?(Integer) ? (value <= @value) : false
-      SplitLogger.log_if_debug("[LessThanOrEqualToMatcher] #{value} less than or equal to #{@value} -> #{matches}")
+      @logger.log_if_debug("[LessThanOrEqualToMatcher] #{value} less than or equal to #{@value} -> #{matches}")
       matches
     end
 

data/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

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

@@ -5,6 +5,10 @@ module SplitIoClient
   # class to implement the all keys matcher
   #
   class Matcher
+    def initialize(logger)
+      @logger = logger
+    end
+
     #
     # evaluates if the given object equals the matcher
     #
@@ -26,5 +30,23 @@ module SplitIoClient
     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)
+      if value_to_match.nil? || @semver.nil?
+        @logger.error("stringMatcherData is required for #{matcher_spec_name} matcher type")
+        return false
+
+      end
+      true
+    end
   end
 end

data/lib/splitclient-rb/engine/matchers/matches_string_matcher.rb

@@ -6,9 +6,10 @@ module SplitIoClient
 
     attr_reader :attribute
 
-    def initialize(attribute, regexp_string)
+    def initialize(attribute, regexp_string, logger)
       @attribute = attribute
       @regexp_string = @regexp_string.is_a?(Regexp) ? regexp_string : Regexp.new(regexp_string)
+      @logger = logger
     end
 
     def match?(args)
@@ -17,7 +18,7 @@ module SplitIoClient
       end
 
       matches = !(value =~ @regexp_string).nil?
-      SplitLogger.log_if_debug("[MatchesStringMatcher] #{value} matches #{@regexp_string} -> #{matches}")
+      @logger.log_if_debug("[MatchesStringMatcher] #{value} matches #{@regexp_string} -> #{matches}")
       matches
     end
 

data/lib/splitclient-rb/engine/matchers/negation_matcher.rb

@@ -7,7 +7,8 @@ module SplitIoClient
   class NegationMatcher < Matcher
     MATCHER_TYPE = 'NEGATION_MATCHER'
 
-    def initialize(matcher = nil)
+    def initialize(logger, matcher = nil)
+      super(logger)
       @matcher = matcher
     end
 
@@ -19,7 +20,7 @@ module SplitIoClient
     # @return [boolean] evaluation of the negation matcher
     def match?(args)
       matches = !@matcher.match?(args)
-      SplitLogger.log_if_debug("[NegationMatcherMatcher] Matcher #{@matcher} Arguments #{args} -> #{matches}")
+      @logger.log_if_debug("[NegationMatcherMatcher] Matcher #{@matcher} Arguments #{args} -> #{matches}")
       matches
     end
 

data/lib/splitclient-rb/engine/matchers/part_of_set_matcher.rb

@@ -6,20 +6,16 @@ module SplitIoClient
 
     attr_reader :attribute
 
-    def initialize(attribute, remote_array)
-      super(attribute, remote_array)
-    end
-
     def match?(args)
       @local_set = local_set(args[:attributes], @attribute)
 
       if @local_set.empty?
-        SplitLogger.log_if_debug('[PartOfSetMatcher] Local Set is empty.')
+        @logger.log_if_debug('[PartOfSetMatcher] Local Set is empty.')
         return false
       end
 
       matches = @local_set.subset? @remote_set
-      SplitLogger.log_if_debug("[PartOfSetMatcher] Local Set #{@local_set} is a subset of #{@remote_set} -> #{matches}")
+      @logger.log_if_debug("[PartOfSetMatcher] Local Set #{@local_set} is a subset of #{@remote_set} -> #{matches}")
       matches
     end
   end

data/lib/splitclient-rb/engine/matchers/prerequisites_matcher.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  class PrerequisitesMatcher
+    def initialize(prerequisites, logger)
+      @prerequisites = prerequisites
+      @logger = logger
+    end
+
+    def match?(args)
+      keys = { matching_key: args[:matching_key], bucketing_key: args[:bucketing_key] }
+
+      match = true
+      @prerequisites.each do |prerequisite|
+        evaluate = args[:evaluator].evaluate_feature_flag(keys, prerequisite[:n], args[:attributes])
+        next if prerequisite[:ts].include?(evaluate[:treatment])
+
+        @logger.log_if_debug("[PrerequisitesMatcher] feature flag #{prerequisite[:n]} evaluated to #{evaluate[:treatment]} \
+          that does not exist in prerequisited treatments.")
+        match = false
+        break
+      end
+
+      match
+    end
+
+    def string_type?
+      false
+    end
+  end
+end

data/lib/splitclient-rb/engine/matchers/rule_based_segment_matcher.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  #
+  # class to implement the user defined matcher
+  #
+  class RuleBasedSegmentMatcher < Matcher
+    MATCHER_TYPE = 'IN_RULE_BASED_SEGMENT'
+
+    def initialize(segments_repository, rule_based_segments_repository, segment_name, config)
+      super(config.logger)
+      @rule_based_segments_repository = rule_based_segments_repository
+      @segments_repository = segments_repository
+      @segment_name = segment_name
+      @config = config
+    end
+
+    #
+    # evaluates if the key matches the matcher
+    #
+    # @param key [string] key value to be matched
+    #
+    # @return [boolean] evaluation of the key against the segment
+    def match?(args)
+      rule_based_segment = @rule_based_segments_repository.get_rule_based_segment(@segment_name)
+      return false if rule_based_segment.nil?
+
+      key = update_key(args)
+      return false if rule_based_segment[:excluded][:keys].include?(key)
+
+      return false unless check_excluded_segments(rule_based_segment, key, args)
+
+      matched = false
+      rule_based_segment[:conditions].each do |c|
+        condition = SplitIoClient::Condition.new(c, @config)
+        next if condition.empty?
+
+        matched = Helpers::EvaluatorHelper.matcher_type(condition, @segments_repository, @rule_based_segments_repository).match?(args)
+
+        break if matched
+      end
+
+      @logger.debug("[InRuleSegmentMatcher] #{@segment_name} is in rule based segment -> #{matched}")
+      matched
+    end
+
+    private
+
+    def check_excluded_segments(rule_based_segment, key, args)
+      rule_based_segment[:excluded][:segments].each do |segment|
+        if segment[:type] == SplitIoClient::Engine::Models::SegmentType::STANDARD &&
+           @segments_repository.in_segment?(segment[:name], key)
+          return false
+        end
+        return false if segment[:type] == SplitIoClient::Engine::Models::SegmentType::RULE_BASED_SEGMENT && match_rbs(
+          @rule_based_segments_repository.get_rule_based_segment(segment[:name]), args
+        )
+      end
+      true
+    end
+
+    def update_key(args)
+      if args[:value].nil? || args[:value].empty?
+        args[:matching_key]
+      else
+        args[:value]
+      end
+    end
+
+    def match_rbs(rule_based_segment, args)
+      rbs_matcher = RuleBasedSegmentMatcher.new(@segments_repository, @rule_based_segments_repository,
+                                                rule_based_segment[:name], @config)
+      rbs_matcher.match?(matching_key: args[:matching_key],
+                         bucketing_key: args[:value],
+                         attributes: args[:attributes])
+    end
+  end
+end

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

@@ -0,0 +1,201 @@
+# 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
+      result = compare_attributes(to_compare)
+      return result if result != 0
+
+      # Compare pre-release versions lexically
+      compare_pre_release(to_compare)
+    end
+
+    private
+
+    def integer?(value)
+      !!value.match(/^(\d)+$/)
+    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 += parse_pre_release
+      @version += "#{METADATA_DELIMITER}#{@metadata}" unless @metadata.empty?
+    end
+
+    def parse_pre_release
+      return '' if @pre_release.empty?
+
+      pre_parsed = []
+      @pre_release.each do |pre_digit|
+        pre_digit = pre_digit.to_i if integer?(pre_digit)
+        pre_parsed << pre_digit
+      end
+      "#{PRE_RELEASE_DELIMITER}#{pre_parsed.join('.')}"
+    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

data/lib/splitclient-rb/engine/matchers/set_matcher.rb

@@ -10,9 +10,10 @@ module SplitIoClient
 
     protected
 
-    def initialize(attribute, remote_array)
+    def initialize(attribute, remote_array, logger)
       @attribute = attribute
       @remote_set = remote_array.to_set
+      @logger = logger
     end
 
     def local_set(data, attribute)

data/lib/splitclient-rb/engine/matchers/starts_with_matcher.rb

@@ -6,21 +6,22 @@ module SplitIoClient
 
     attr_reader :attribute
 
-    def initialize(attribute, prefix_list)
+    def initialize(attribute, prefix_list, logger)
       @attribute = attribute
       @prefix_list = prefix_list
+      @logger = logger
     end
 
     def match?(args)
       if @prefix_list.empty?
-        SplitLogger.log_if_debug('[StartsWithMatcher] Prefix List is empty.')
+        @logger.log_if_debug('[StartsWithMatcher] Prefix List is empty.')
         return false
       end
 
       value = get_value(args)
 
       matches = @prefix_list.any? { |prefix| value.to_s.start_with? prefix }
-      SplitLogger.log_if_debug("[StartsWithMatcher] #{value} matches any of #{@prefix_list} -> #{matches}")
+      @logger.log_if_debug("[StartsWithMatcher] #{value} matches any of #{@prefix_list} -> #{matches}")
       matches
     end
 

data/lib/splitclient-rb/engine/matchers/user_defined_segment_matcher.rb

@@ -7,7 +7,8 @@ module SplitIoClient
   class UserDefinedSegmentMatcher < Matcher
     MATCHER_TYPE = 'IN_SEGMENT'
 
-    def initialize(segments_repository, segment_name)
+    def initialize(segments_repository, segment_name, logger)
+      super(logger)
       @segments_repository = segments_repository
       @segment_name = segment_name
     end
@@ -20,7 +21,7 @@ module SplitIoClient
     # @return [boolean] evaluation of the key against the segment
     def match?(args)
       matches = @segments_repository.in_segment?(@segment_name, args[:value] || args[:matching_key])
-      SplitLogger.log_if_debug("[InSegmentMatcher] #{@segment_name} is in segment -> #{matches}")
+      @logger.log_if_debug("[InSegmentMatcher] #{@segment_name} is in segment -> #{matches}")
       matches
     end
   end

data/lib/splitclient-rb/engine/matchers/whitelist_matcher.rb

@@ -9,7 +9,9 @@ module SplitIoClient
 
     attr_reader :attribute
 
-    def initialize(whitelist_data)
+    def initialize(whitelist_data, logger, validator)
+      super(logger)
+      @validator = validator
       @whitelist = case whitelist_data
                    when Array
                      whitelist_data
@@ -26,9 +28,9 @@ module SplitIoClient
     def match?(args)
       return matches_user_whitelist(args) unless @matcher_type == 'ATTR_WHITELIST'
 
-      SplitLogger.log_if_debug('[WhitelistMatcher] evaluating value and attributes.')
+      @logger.log_if_debug('[WhitelistMatcher] evaluating value and attributes.')
 
-      return false unless SplitIoClient::Validators.valid_matcher_arguments(args)
+      return false unless @validator.valid_matcher_arguments(args)
 
       matches_attr_whitelist(args)
     end
@@ -49,14 +51,14 @@ module SplitIoClient
 
     def matches_user_whitelist(args)
       matches = @whitelist.include?(args[:value] || args[:matching_key])
-      SplitLogger.log_if_debug("[WhitelistMatcher] #{@whitelist} include \
+      @logger.log_if_debug("[WhitelistMatcher] #{@whitelist} include \
         #{args[:value] || args[:matching_key]} -> #{matches}")
       matches
     end
 
     def matches_attr_whitelist(args)
       matches = @whitelist.include?(args[:value] || args[:attributes][@attribute.to_sym])
-      SplitLogger.log_if_debug("[WhitelistMatcher] #{@whitelist} include \
+      @logger.log_if_debug("[WhitelistMatcher] #{@whitelist} include \
         #{args[:value] || args[:attributes][@attribute.to_sym]} -> #{matches}")
       matches
     end